DixieDev

This line of thought works for storage in isolation, but does not hold up if write speed is a concern.

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.

Your comment is far too reasonable. Go directly to jail. Do not pass ⅄OR.

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 feel genuinely insane trying to parse this site. It's a miracle that there's no mention of Web3.

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.

https://ziglang.org/learn/overview/

https://ziglang.org/learn/why_zig_rust_d_cpp/

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.

"Rust has mature and production ready frameworks in Actix Web and Rocket"

Why is Rocket considered production ready when it's only just at version 0.5? Similar <1.0 stories can be found on crates for sqlx, rusqlite, and postgres. Am I wrong in assuming the API must be quite stable before it can receive the 'production ready' label?

Ok, sure, there are a whole bunch of reasons that my function might not actually finish. In this case, though, it's specifically not finishing due to invisible compile-time additions Zig is making to the function I've written.

They could instead require me to explicitly write `await bar();` within foo(), and I could find comfort in the "no hidden control flow" tenet of the language once more. I recognise now that this would break the colour-blindness of their async implementation and that this is a pretty significant trade-off, but my perspective remains that this breaks one of the rules they've laid out on their homepage.

Within main(), your snippet will give you an error at compile time "function with calling convention 'Inline' cannot be async". In my snippet foo() is invoked in an async context using the async keyword, and when foo() suspends (due to it awaiting bar()) control will be returned to main(). If you change your first line from

  foo();

to

  _ = async foo();

Then your program will compile and your log is not going to be prevented by Zig's async shenanigans.

My original reply is kind of sloppy, here's a snippet to better illustrate my confusion: https://gitlab.com/-/snippets/2290425

Specifically, examine this:

  fn foo() void {
    bar();
    std.log.info("foo() is finished", .{});
  }

It looks dead simple, but it's a pain in the butt to use because it's actually async, and you can know neither that nor how to get this function to actually finish without looking inside of bar().

This article was my first exposure to async in Zig, and I find it rather at odds with the "No hidden control flow" selling point of the language.

  fn foo() void {
    bar();
    std.log.info("bar is finished");
    baz();
    std.log.info("baz is finished");
  }

I cannot just look at this function and know what it's doing and how to use it. If bar()'s implementation contains a suspend or await keyword then this won't compile when called from main() unless its call is prefixed with async, and even if I do so then I also have to make sure I resume foo enough times for bar (or baz) to finish too. Am I missing some key detail here? It seems out of place compared to many other language features.

Not everyone uses social media to watch anonymous users screeching their opinions at each other. It is a nice tool to cut down on encountering content you don't necessarily care for.

PoW also favors those who are already rich it's just abstracted by one layer of them having to buy rigs for mining farms, instead of being hard-coded in the same way as PoS.

I've been running Lineage OS without any Google Play Services and it's been pretty rough. A lot of apps from various APK mirrors just straight up don't work, even when they seem like they shouldn't be affected at alll.

F-Droid has been a great source for apps, especially when I'm seeking a particular need without a specific app in mind. Most recently that's been wanting a file browser and a PDF reader. The open-source focus is a nice bonus, but more importantly I consider its stability to be the best of all Play Store alternatives I've tried.

Yeah, if you click too many links without an account it'll bring up a sign-up pop-up that takes you to the previous page when you close it. You can get around it by opening the link in a new tab, or save yourself constant hassle by disabling cookies on twitter altogether.

While we're here, take another pro-tip: Set yourself up with an RSS/Atom reader and "Follow" accounts you are interested in through Nitter. No account, no random "We thought you might like", and no ads, just posts and retweets from the accounts you're interested in.

Personally I haven't found Stack Overflow useful for anything in a looong time. At work, usually my problems are specific to whatever proejct I'm working on and my peers are the only real source of answers regarding that. At home, if I want to work on some cool new thing then a Wikipedia page or good write-up on someone's blog is the goto source for useful, structured information.

The few times I have seen SO recently have been from friends trying to do Linux things, looking for answers on SO, and finding some ludicrous answer that is either just wrong or an extremely roundabout (and overcomplicated) approach to solving it.