ldlework

Unironically, yes. That's exactly how anarcho-capitalists see it. To them, Anarchy just means "no coercion/state", it doesn't mean a lack of structure, delegation or coordination.

This is quite cool.

Created this short visual narrative with Dall-E in the style of H.R. Giger.

Human figures live their lives in a surreal dystopian world, until they find a hole leading to an even stranger one.

Video was made with React Remotion which was pretty cool. If anything, check that out.

All you've done is push the burden of constructing the dependency to whomever is calling an passing that dependency to __init__

Consistently applied, all construction gets pushed to the entry-point of the program. Congratulations, you've just discovered the so-called "composition root".

Now that all construction is taking place at once, the order matters as you can't pass a dependency to its dependent until the dependency has been constructed. But it may have its own dependencies. So now there is a topological sorting problem.

Turns out computers are really good at topological sorting. So, someone made the computer do it, and we call that a dependency injection container. Tada.

When this was first being presented at the Hackathon where it was created, I joined a few seconds late due to some camera trouble. My first thoughts where "Wow, they really went above and beyond, so tightly choreographing their presentation to their slides." Then it slowly dawned on me what was happening. Funny stuff.

Try http://type-tetris.ldlework.com :)

I'm still having this issue.

If the code is implementing against interfaces, why would late binding mess up your IDE experience at all?

In my opinion, you probably don't have good reasons.

> I have a hard time seeing anything new here. > Just .. [a] new perspective...

okie dokie

I have recently started looking into Nix to solve the problem of dotfile deployment to new OSX workstations. When you get a new laptop, you clone your dotfiles, maybe symlink them to your home directory -- and then what? Nix solves this problem for me by coupling my dotfile deployment with the installation of the related software.

The learning curve has been absolutely tremendous, however. That said, the support on Freenode has been some of the best I've encountered in more than a decade.

https://nixos.org/nix/manual/#chap-package-management https://rycee.net/posts/2017-07-02-manage-your-home-with-nix...

ITM

This is by far the best podcast Ive personally enjoyed besides maybe Waking Up with Sam Harris. The "old friends" chemistry the hosts have cannot be understated. In the morning!

...and user type-classes, compile-time AST macros, and GC-as-an-API

Would really appreciate some kind of link to the discussion you mentioned..

Oh sure. I'm asking specifically, given that I'm writing software happily in Nim, what potential pitfalls am I blind to? My software is compiling to C and it shouldn't be so I'm wondering what can I expect to actually experience using Nim, outside of Hacker News posts about Nim.

Oh, I've been writing software in Nim pretty happily for a months now. What problems am I blind to?

Huh, I keep hearing more and more about it in places I'd never suspect.

I'll go ahead and plug my own introduction video which gives a light introduction to the core grammar concepts in lojban: https://www.youtube.com/watch?v=yZjSTUK3hFI

If you can absorb what's in this video, you could probably pick up lojban with little effort on the grammar side. Alas, vocabulary is just something you have to get through.

You were down-voted but I actually agree. I did conclude the article by saying that templates seem really nice for closing the gap on refactoring code that not even generics could wrap up. So the intention was to convey that templates are really a last resort secret weapon. They just also seem to be pretty easy to understand :)

You were down-voted but I secretly agree.

wait - oops. :)

These are definitely exciting times for container networking!

Thank you. My mouth was literally agape.

Hey I am just curious as to what you see as the dark corners of Nim?

I certainly agree.

Hey I come from Python too and I just want to put out there both that Nim is a normal language - you can use it without templates or macros (you might end up using someone else's macro because some stdlib or library is implemented as one, but you don't have to write them yourself) - but also that Nim's macros are quite easy to understand!

They are just functions that take an AST tree, modify that AST or produce a new AST and return it. Its just normal Nim code working on an AST object. That's it! I wrote a small blog article about them when I first learned about them: http://blog.ldlework.com/a-cursory-look-at-meta-programming-...

I encourage you to conquer your fears!