Paradox

Recently I had to do an update to the underlying environment a codebase ran on. This was a somewhat involved upgrade and took a longer period of time than most of our work usually does. I did it in a separate worktree, so I didn’t have to constantly rejuggle the installed dependencies in the project, and could work on two features relatively concurrently

It also provides some utility for comparing the two versions. Nothing you couldn’t do other ways, but still useful

And in elixir/erlang we’re spoiled with loads of options, from ETS to mnesia

I’ve only ever worked in one codebase that didn’t need feature flags, and even then we could have used them.

Graphite is ok, but honestly it’s a solution in search of a problem

Maybe if you have a massive pr, splitting it up like this works, but that’s really a planning failure. Stories should be smaller, and if you need to keep them separate for a long time, use feature branches

This is actually built into vsc

An ad hoc sorting system for a grid of tiles on an enterprise app

Instead of sorting across row wise, it sorted columnar. So it was

A E I M
B F J N
C G K O
D H L P

Instead of

A B C D
E F G H
I J K L
M N O P

This was a requirement from the CEO. Since we used this project (dogfooding) we stuck a secret search box/command palette in, which you could hit . and then type the name of the thing you wanted and click it

JetBrains users kind of live in their own weird bubble. Of the ones I’ve worked with, a decent number didn’t even know how to use git, they just relied on the built in vcs tools

Check out Elixir’s Ecto. You basically do write SQL for querying, it’s just lightly wrapped in a functional approach.

Python belongs in docker for exactly thus reason

In theory yes, but it becomes a problem of ergonomics. The transpiled library feels like a transpiled library, it doesn’t match the conventions of Nim/Zig. The best ports/wrappers/whatever typically use the C lib for all the heavy lifting and unique things, and build their own interface, that matches conventions of the calling language

Its a neat language, very simple. Has a somewhat simple approach to codegen at compile time, which is both a boon and a curse; you can do a lot with it, and not get too deep into footgun territory, but once you hit the limits of what you can do, you’re pretty much stuck there.

The syntax and other features are very nice, and it makes rather small binaries. I’d say its comparable to Nim in this area.

Sadly, it also suffers the same problems Nim suffers: dearth of libraries.

Nesting is now in native CSS, so it’s even easier

My approach for variants is to use attribute selectors. You don’t get massive class names and it becomes more obvious what things are doing. Discover ability gets hurt a bit, but that was never BEMs strength either

https://pdx.su/blog/2023-07-27-use-css-attributes

Only system I’ve used that loves processes more than Unix is Erlang

Would you use them when building things for a client? If yes, then yes. No one gets mad at a carpenter for buying nails.

For most projects or tools that I find on GitHub these days, I run them all in docker. Node, at least, is somewhat of a good guest. All it’s crap lives in node_modules, and so when I’m done, rm the directory and it’s all clean. Python seems to love leaving relics across my system

Well, one major difference between nim and zig is that nim has codegen features built in, and the ergonomics are so simple around them you’ll wind up using them without knowing.

Nim, if you just start calling functions in your code, will evaluate them at compile time. This means you can use loops and other constructs to generate bits of code. This is similar to how it works in Ruby and Elixir (and python too IIRC).

So you can do this contrived example:

for i in [a, b, c]:
  proc i =
    echo "Generated proc"

That code probably wont work, but you can see the utility on being able to generate stuff inside your source code.

Zig explicitly has chosen to not have codegen features. The reasoning is that it keeps the language simpler, and is inline with Zigs efforts to stay away from macros and templates. The closest you can get is the comptime keyword, which evaluates it’s right at compile, but it’s very limited

All of them are lawful

The author chose to host on a platform that does that. So it is their fault

Best way to learn is to dive in and try to accomplish something you want to do

https://github.com/mreid/feed-bag

Not sure if it does all you want, but the basics are there, and it wouldn’t be beyond the pale to make something like this do what you want. The code is pretty clean