Very nice article. We must not loose from sight that actual learning requires some sort of effort. Even better when it's coupled to using your hands (definitely why I still take notes written by hands for some things).

I'm not necessarily convinced this is as much a silver bullet as it is presented here. Still there are benefits to such a structured approach for reviews in community projects.

I mostly agree with this. I'd just complete it a bit: it's probably a good idea to have at least one language where you went really deep in (emphasis on at least). A kind of strategy to aim at "T shaped skills" (or better "paint drip shaped skills").

In praise of property based testing. This definitely completes well the tests you write by hand.

This is a welcome consequence of the CJUE ruling. Be warned, think twice before reaching for Google Analytics.

Remote work is clearly the best way for smaller companies to compete to attract talent. This greatly increases the size of the pool of potential hires.

Interesting optimization on this somewhat common data structure.

This often overlooked indeed... and to make it worse it can be hard to optimize.

Interesting proof of concept. I wonder how far this will go. There is definitely a need in any case.

Excellent piece from an excellent artist. I really thought this through and I think he's going in the right direction.

This would be an interesting extension to the Java Stream API. Maybe one day it'll make its way to the standard...

This is a neat example of what programming languages could check at compile time. This clearly brings way more safety when you get such contract validation at build time.

I always felt uneasy around this "law" as well. It's a good deconstruction of it and proposes proper alternatives. It's all about dependencies really.

Interesting to see what gets confirmed (slow compiler, nice compiler error messages, code quality) or debunked (steep learning curve, interoperability).

Very comprehensive (didn't read it all yet) guide about self-supervised learning. It'll likely become good reference material.

Good piece about the hype cycles our industry constantly fall into. So much undue complexity for nothing in some projects... and then we'll complain about technical debt. It would have been much easier to pick the right tool instead of wanting to use whatever new got released by some big tech company.

It smells a bit like hypocrisy isn't it? On one hand they claim it can make developers more productive on the other they think they shouldn't use it.

Nice set of advises when dealing with concurrency. Don't fall into some of the anti-patterns which are pointed out.

Especially important in the context of tests indeed. As soon as you depend on some form of elapsed time you get into the territory of flaky tests.

Long but fascinating article on a blend of guidelines which could be statically checked to enforce a memory-safe subset of C++.