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
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
Not only that, but with toolchains like deno, it’s almost enjoyable
I wrote some telegram bots in deno and it’s got one of the cleanest deploy chains around, just compile to an executable for the target architecture, and SCP it over. Exec is statically linked, and so it just works