Where I work we tend to write RFCs for fundamental design decisions. Deciding what counts as a "fundamental design decision" is sometimes self-moderated in the moment but we also account for it when making long term plans. For example when initially creating epics in Jira we might find it hard to flesh out as we don't really know how we're going to approach it, so we just start it off with a task to write an RFC.
These can be written either for just our team or for the eyes of all other software teams. In the latter case we put these forward as RFCs for discussion in a fortnightly meeting, which is announced well in advance so people can read them, leave comments beforehand, and only need to attend the meeting if there's an RFC of interest to them up for discussion.
This has gone pretty well for us! It can feel like a pain to write some of these, and at times I think we overuse them somewhat, but I much prefer our approach to any other place I've worked where we didn't have any sort of collaborative design process in place at all.
I would like to see improvements in the speed of feedback - particularly from language servers - but the value of those 'basic' guarantees is more than worth the current cost. Unexpected side effects are responsible for almost every trip I've taken with a debugger in any large Java or C++ project I've ever worked on.
Nushell is quite nice. Tables are nice to work with and look at, and the cross-platform support is top notch. It feels like what Powershell would have been, had it been designed by people who have actually used a command-line before. The main issues I have are bugs. Most recently, I find that it can't properly handle files with square brackets in the name, which isn't really all that uncommon.
I wouldn't recommend it for day-to-day, production usage just yet, but definitely worth keeping an eye on if you're not a huge fan of the typical stringly-typed shells.
Where have you seen a service describing something posted less than 12 hours ago as being "posted last week" rather than "posted yesterday"/"posted today"?
I got quite annoyed with Neovim config at some point and tried out Kakoune, and ended up contributing some window splitting code to the main repo for Sway. I liked it quite a lot, but it's not built with Windows in mind so I ended up crawling back to Neovim. I'd be interested to hear of any Kakoune-like editors with better cross-platform support/design.
I'm mostly indifferent to it because it doesn't really harm readability, and it's not hard to know when to use it, but I can seem why it might be more strongly disliked. You can't entirely rely on it to know a dereference is happening because references (e.g. `int&`) aren't subject to the `->` requirement. It's also annoying if you find that you can refactor `func(T*)` to `func(T&)` and now you have to replace all `->`s with `.`s.
Is writing a simple CSS file and some HTML code really too much effort for a personal blog? Clicking around this site the only non-trivial things are the RSS feed and the paginated scrolling (which seems wholly unnecessary) on the homepage.
Anyone got other useful tools for debugging within (neo)vim? Just seamlessly putting down breakpoints, stepping through code execution, and getting a fully fledged debugging UI experience (a la Visual Studio or Remedy BG)? This is possibly the only thing I miss from developing on Windows, and it's a shame!
EDIT: I specified 'within vim' but actually I'd be down for standalone Linux app recommendations too.
I think the official Zig website already does a good enough job at expressing what the the language has to offer, to the extent C devs can read a couple of pages and know whether or not they vibe with the language. The only thing it's missing is quoted praise from its users.
I can't really comment on the nuances of the sound, but a digital piano will allow you to plug in headphones which is - in my opinion - invaluable in a home environment.
I missed UO's hayday, but when I've played the big modern MMOs I find myself instead attracted to the idea that individual characters shouldn't be able to do everything. I feel like forcing players to interact if they want to gather specific resources or craft vital items would really help a game feel "massively multiplayer".
Are there any modern MMOs with mechanics like this, e.g. life-skill limits or some other source of dependence on other players?
This is my perspective too. Whenever I find myself having to use Windows (which these days is just for games with Windows-only anti-cheat), the annoyances feel so much more pronounced.
Most likely you specifically don't have much reason to care about Zig. Meanwhile, C can still often be found in areas where high performance and precise control over memory are important - such as in small embedded systems and game engine development - and Zig is a great fit as a replacement.
While you can technically use Rust in these domains you'll find yourself jumping through hoops and fighting against quirks that come with it being fairly high-level and very opinionated on how to enforce memory safety.
One such scenario I've encountered is implementing my own memcpy with a loop like `for i in 0..len`. This works in release builds, but without optimisations this gets a deeeeep callstack that eventually also calls memcpy, so you get a stack overflow. Note how memcpy is implemented in rlibc to avoid this issue:
https://docs.rs/rlibc/latest/src/rlibc/lib.rs.html#30-38
It's a strange sentence for sure. Organising your programs around data and its transformation happens to mean you are aware of how hardware organises, represents, and transforms data, and accommodate that to keep things running smoothly.
I would say the purpose of DoD is most certainly to make fast programs, but guess the point of that quote is just to further emphasise that this is all about data.
It's seems clear to my family and friends that they have some sort of checklist for writers that includes garbage like mandatory regular sex scenes. In my case, they have _finished_ a tiny tiny percentage of their shows. They tend to string viewers along with contrived new-but-very-similar problems each season, and then just cancel once viewership gets bored. No thanks, give me a show that has an ending.
I think Disney has been better with their series in this regard. I've been watching a few shows that were planned with many seasons in mind, but instead of abruptly pulling the plug when viewership was lower than expected they gave them a final season that writers have been using to wrap things up really well. I can start a new show from them with a bit more confidence it'll get finished.
This shouldn't detract too much from your point, but for fighting games the situation is slightly different from most other genres:
Modern fighting games, as well as older ones that have been modded to included this (such as Melee), have a netcode model called "rollback" that can negate network-induced latency on local inputs. The trade-off is that what you see is usually inaccurate until you receive inputs from the remote player's machine.
Despite fighters often requiring fast reaction speeds, this downside is not a big deal granted that the ping is low. The first few frames of many actions are generally quite subtle, enough that they are quite hard to distinguish from each other; it's usually specific keyframes/poses that people will actually be reacting to.
Melee is probably hurt the most though, as movement is extremely fast and very important, and the difference between wavedashing left or right is not masked by subtle animations.
I feel like they should probably advertise this fact somewhere, as I couldn't find it in their docs, website, or readme, and it is quite a significant detail.