klauserc

Was my first thought as well, but this is an open weights model. You can run it on your own hardware.

I definitely am. Haven't touched git in over a year. If there was just a single feature to point at where jj meaningfully improves on git, I think it's: `jj undo`.

It is a universal undo command. It works for every change in your repository. You don't need to memorize/google/ask claude how to revert each individual kind of operation (commit, rebase, delete branch, etc.). You try a jj command, look at your repo, and if you don't like what you see, you `jj undo`.

The biggest downside for me is that no longer have the necessary expertise to help coworkers who get themselves into trouble with git.

jj automatically hides "uninteresting" changes. Most of the time, this is good.

Occasionally, I need to see more changes. It is not obvious to me how I get jj to show me elided changes. I mean, sure, I can explicitly ask jj to show me the one ancestor of the last visible change, and then show me the ancestor of that one, etc. Is some flag to say: "just show me 15 more changes that you would otherwise elide"?

The best way to get an LLM to follow style is to make sure that this style is evident in the codebase. Excessive instructions (whether through memories or AGENT.md) do not help as much.

Personally, I absolutely hate instructing agents to make corrections. It's like pushing a wet noodle. If there is lots to correct, fix one or two cases manually and tell the LLM to follow that pattern.

https://www.humanlayer.dev/blog/writing-a-good-claude-md

Isn't that example the exact opposite of mixing content and presentation? The * notation applies the strong [emphasis] tag, the show rule (re-)defines the presentation. Ideally you would of course separate the two into separate files (template + content).

In my time using Typst, I found that Typst makes it possible/easy to make content even more abstract: write the content as a "data structure" and then present parts of it in various places around your document. For instance to list quantity/weight of a parts description in a parts index at the end.

Was using vim for a decade, discovered Helix, installed it on all my systems and haven't looked back (at least not voluntarily; I'm always bewildered by the old-school CAD-like command-then-subject paradigm when I get thrown into vi on a random machine)

Yes! One of the worst bugs to debug in my entire career boiled down to a piece of Java mutating a HashSet that it received from another component. That other component had independently made the decision to cache these HashSet instances. Boom! Spooky failure scenarios where requests only start to fail if you previously made an unrelated request that happened to mutate the cached object.

This is an example where ownership semantics would have prevented that bug. (references to the cached HashSets could have only been handed out as shared/immutable references; the mutation of the cached HashSet could not have happened).

The ownership model is about much more than just memory safety. This is why I tell people: spending a weekend to learn rust will make you a better programmer in any language (because you will start thinking about proper ownership even in GC-ed languages).

Using gen AI for anything artistic (illustrations, music, video, creative writing) is a dead end. The results are soulless and bland. People notice immediately.

Code completions are fine. Driving code through chat is a complete waste of time (never saves time for me; always ends up taking longer). Agentic coding (where the LLM works autonomously for half an hour) still holds some promise, but my employer isn't ready for that.

Research/queries only for very low stakes/established things (e.g., how do I achieve X in git).

I found Helix much easier to get into than vim because you can see and experiment with the selection before committing to an action. It's also much more familiar to users of modern software (where you generally first select an object and then apply an action).

Yes, all the time. For reference-level information, I don't trust AI summaries. If I need to know facts, I cannot have even the possibility of a lying auto-complete machine between me and the facts.

Exploratory/introductory/surface-level queries are the ones that get handed to auto-complete.

I like how Kagi lets me control whether AI should be involved by adding or omitting a question mark from my search query. Best of both worlds.

As someone responsible for login/registration at a large online retailer, I see so much bot traffic and attacks. Attackers try to enumerate registered users, try to mass-login with credentials from password dumps, try to register accounts controlled by bots.

Login forms are a war zone. Looking for patterns that indicate the other party is a bot and serve them (and only them) a captcha is a technique that is quite effective. But it is not perfect. Especially business customers often get forced to solve captchas in our system.

If you know of a better solution (other than: don't be a big online shop), I'm all ears.

Fantastically beautiful keyboard!

Keyboards are such a good hobby project. The scope is comparatively small, yet within that scope you get in contact with many different and highly interesting subjects and challenges. And you can more or less pick and choose, which ones you engage with (wireless vs wired, soldering vs hand-wired, custom firmware vs. ZMK/QMK, split vs. traditional).

You can buy ZSA split keyboards with labels on the keycaps. Its great while you are still learning to type on these rather exotic keyboards. As you get more proficient, you start to rely more and more on the "central" keys (using layers toggles to put, say arrow keys on the home row). Muscle-memory is often more than enough.

That said, I have kept the number row labelled. These keys are not obscured by your hands and they can give you the necessary frame of reference. The ideal trade-off for me.

I've been running Fedora on top of the excellent ZFSBootMenu[1] for about a year. You need to pay attention to the kernel versions supported by OpenZFS and might have to wait for support for a couple of weeks. The setup works fine otherwise.

[1] https://docs.zfsbootmenu.org

I use it on my work laptop. Reasons:

- a single solution that covers the entire storage domain (I don't have to learn multiple layers, like logical volume manager vs. ext4 vs. physical partitions) - cheap/free snapshots. I have been glad to have been able to revert individual files or entire file systems to an earlier state. E.g., create a snapshot before doing a major distro update. - easy to configure/well documented

Like others have said, at this point I would need a good reason, NOT to use ZFS on a system.

You have to set the C# language version to 'preview'.

    <PropertyGroup>
       <LangVersion>preview</LangVersion>
    </PropertyGroup>

Still fascinating how a computing device that used to cost upwards of 10k a couple of years ago is now not even considered a "workstation".

On a more serious note, I'm not sure that ECC RAM should be an important distinguishing factor. If your workstation actually produces an artifact that is used further down the line (a model, a binary or even just a number, a decision based on a simulation), then yes, definitely, it should run ECC RAM.

I feel like it's a different story for software engineers. What they use their "workstations" for is not what will eventually get shipped. That artifact is (hopefully) getting built on dedicated build machines (and those better have ECC RAM). ECC RAM won't have much impact on running IDEs and local compile-test-run cycles, right?

Would `Vec::into_boxed_slice` [1] be the answer here? It gives you a `Box<[Foo]>`, which doesn't have a capacity (it still knows its own length).

1: https://doc.rust-lang.org/std/vec/struct.Vec.html#method.int...

C# pattern matching gets very close. I think C# can do everything except for their last example ("splitting conditional prefixes in arbitrary places"). One of the things I miss when switching to Rust.

    if foo(args)
        == 0 then "null"
        |> abs
            > 100 then "large"
            < 10 then "small"
            else "medium"

Been using jj at work for months now. In colocated mode, JetBrains IDEs even retain some if their VCS integration.

The ability to easily work on top of an octopus merge and then push changes "down" into the contributing branches has been a live saver when my team had to do a big refactoring in a mono repo and split the changes into small PRs for individual teams (code owners).

The auto committing behavior is a bit weird at first, but now I don't want to go back to git. It feels a bit like the step from SVN to git back in the the day. ("this feels weird" -> "how did people ever tolerate the old way?")

I prefer Asciidoc over markdown for documents where chapters, cross references, call outs, etc are valuable. For things that one might want to turn into a PDF.

The tooling is a bit of a pain, but the Java world has pretty good integration (gradle, intellij)

Oh my! That's an amazing list. I used to perform many of these changes by hand on every new windows installation. It's such a slog.

And while some of my systems now run linux, as the post says: "Sometimes using Windows is inevitable."

In defense of the much maligned Windows registry, I'll say: isn't it amazing that you can make such a wide array of changes via a single tool (regedit)? If you had to automate such changes on Linux, you would probably need a whole suite of tools. In some cases, you'd write a file into a `.d` directory. In other cases, you can `echo '...' >> subsystem.cfg`. In yet other cases, you'll need `sed -i`. Maybe `awk` gets the job done where `sed` is too simple. Maybe there are more complex cases, where you'd need the power of `perl` (or python or ...) to make the edit. And some subsystems come with their own suite of manipulation tools (ZFS, systemd, etc.) where editing text files would be the more difficult option.

I once had the questionable pleasure to write code in an environment where "at most one method call per statement" was strictly enforced. Had to constantly come up with names for intermediate values that would only get used once, in the very next statement.

It has kind of radicalized me against "pointless names". Names take up valuable space in the working memory of the reader. They need to carry their weight.

Hm... difficult question. I got a Pixel Fold at half price second hand. What MKBHD says about the Pixel Fold is absolutely true: it has the best outer screen/folded experience of all the foldables. Most of the time, I use it closed. And, apart from the abysmal screen brightness, it's a perfectly fine phone when folded.

There are still very few apps that support the full screen properly and while you can force apps to run full screen on the big screen, their automatic UI layout will simply blow up the lower and upper portions of their interface so that you don't see that much more.

Most Google app, obviously, have proper support and YouTube is definitely the primary use case for the big screen. Insanely, Google Maps loses features when viewed unfolded (WTF?). But even among the Google apps, though, most don't really use the space in a useful way. They often just put some hamburger menu permanently on the screen. Nice, I guess, but you won't bother unfolding the phone just for that.

Web browsing/reading is great on the unfolded screen. That's where the near-rectangular aspect ratio works best.

Honestly though, while I'm keeping an eye on what's happening in the foldable space, I think my next phone will be a boring old slab phone again.

They present this like a smart solution for some sort of fundamental problem. It's really not a fundamental problem. Advertisement has worked and still works perfectly fine without attribution in TV, in magazines, on billboards.

Adtech gaslights everyone into accepting that just because it is technically possible to perfectly track and personalize ads in digital media, that they have some sort of moral right to do it.

I built a crappy scripting language. The language itself is nothing special. Vaguely ECMAScript. But it was a ton of fun to _evolve_ the language and runtime system over the span of ten or so years.

I have my collection of scripts in that language, some of which were in regular use for a time, and I wanted the changes I made to be as backwards-compatible as possible. Those were some really fun design challenges. Like: "how do you retro-fit a module system into a language that essentially started out with PHP-style source transclusion for re-use?".

I'm super torn about type erasure in Java.

On the one hand, it is super hacky and requires ugly workarounds (passing Class<T> references around). At the same time, it also made creative abuses of the type system possible (e.g., heterogeneous lists). All while remaining type safe (albeit with runtime type checks).

It is also very noticeable how Java can iterate more quickly on its type system (only partially embedded in its VM) whereas C# generics are more or less set in stone (deeply embedded in its runtime).

Totally agree about the "removing a misbehaving" feature part.

The frustration I was trying to express is more related to "perfect being the enemy of good". JEP-430 was introduced 3 years ago. By that point C# has already had string interpolation in place for 6 years and the C# solution achieves 90% of what JEP-430 set out to do. Java users could have benefited from 90% of that feature for 9 years by now.

It sounds a bit dramatic when we are talking about string interpolation, I realize that.

There is Windows S Mode where you can only run Windows Store apps and only use Microsoft Edge. That should qualify for "proper sandboxing", shouldn't it?

Then again, no one who needs an actually useful computer runs Windows in S mode.

I find GitHub Copilot close to useless for production code. The worst, most obscure bugs I've had to debug in the last year were all in Copilot-written code. It _looks_ plausible, but it makes extremely subtle mistakes. Occasionally, you have repetitive sections of code where it can copy&adapt lines from the context, but that's about it.

It's a different story for test code. Test code is often formulaic and "standardized" (given/when/then). For instance, I find myself writing the first test case and Copilot can come up with additional test cases. Or I might write the method name ( FeatureUnderTest_Scenario_ExpectedOutcome) and Copilot provides the implementation.

I have not found any value in Copilot chat.