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.
Good tips on how to create some slack and prevent burnout.
Long but fascinating article on a blend of guidelines which could be statically checked to enforce a memory-safe subset of C++.
Basically the wording allows them to feed whatever system they want with your code... even in private repositories.
Interesting way to look at our profession... I wonder if this is the core reason of why we have a hard time to turn into a proper engineering discipline, is it even possible at all then?
Facebook getting interested in the fediverse indeed looks like XMPP or OOXML all over again. Beware of those old tactics, they are very efficient against communities.
A reminder of what's going on in France... and it's bleak. Lots of things can turn you into a suspect at this point.
You encrypt your communications or data? You try to avoid surveillance from the GAFAM? You use Tor or a VPN?
If anything bad happens around you, then you'll turn into a suspect, this is due to the "clandestine behavior" you entertain... so for sure you are part of some "conspiracy".
This is very worrying.
The title of the post is not the best. Still it nicely lists and explains common mistakes around the use of std::shared_ptr.
Is the graphics community warming up to the JVM? Or is it the other way around? Let's see if it makes progress in any case.
Definitely this, what matters most is being able to change previous decisions. In comparison each decision itself is less important.
Great article. We know that the projections we use can't give a proper picture of the world. We often don't realize by how much it distort our views and what we miss. This is a good summary of the various biases in our maps.
Interesting deep dive in Rust and C++23 string formatting features. This shows the differences quite well. It also does a good job at highlighting the pros and cons for each approach.
Oh the bad feedback loop this introduces... this clearly poison the well of AI training when it goes through such platforms.