Hartmut Behrens

Likes to flip bits, push pixels and ride bikes.

[Hartmut Behrens @HartmutBehrens]

@blume_im_revier Alles Gute zum Geburtstag !

[John Crickett @johncrickett]

In April he said AI was a multiplier and everyone has to use it.

If they're now facing a slop problem, that start's at the top.

AI is a multiplier. If it's being used to create slop grenades it's multiplying the things the leadership rewards.

[Paul Calcraft @paul_cal]

"You don't see four clusters?"

[じゃがりきん @jagarikin]

なんと動いてません

[Hartmut Behrens @HartmutBehrens]

@ElizeRiley Sorry to hear this @ElizeRiley 😢

[Rockport @RockportAI]

Einstein spent 10 years on one idea. The idea: gravity isn't a force. It's what you feel when you pretend spacetime is flat and it isn't.
We compressed a 1.5-hour podcast into a 9-minute summary.
Adam Brown, who leads BlueShift at Google DeepMind, derived general relativity from scratch on Dwarkesh.

[Hartmut Behrens @HartmutBehrens]

@RyanCoetzee I agree that Musk's documented behaviour is problematic, but I don't follow how that makes Starlink use a national security issue ? It's not like they would be the only game in town for internet access, and there's regulation if they don't hold up their end of the agreement ?

[Hartmut Behrens @HartmutBehrens]

@MichaelJordaan I think the best time to escape this trap is before you've walked into it. I'm planning to tell the kids to try building something people want right after studies, while they have no mortgage, no dependants, and a home to fall back on.

[Alexander Stubb @alexstubb]

Today, Suzanne and I hosted the annual dinner for the diplomatic corps in Helsinki.

I’m delighted to carry on this fine tradition as President. Over 100 countries were represented at the Presidential palace this evening.

[John Carmack @ID_AA_Carmack]

Space launch was a clear case where there was a large difference in efficiency between what was possible and what was done in practice before SpaceX. A large part of that was due to everything being locked in to what (just barely) already worked, with huge risk aversion. WIth national prestige or a half billion dollar geosync satellite on the line, speculative engineering ideas that might result in a public debacle were not welcome.

When failure is not an option, success can stay very expensive. You need to experiment to improve, and that fundamentally means being comfortable with failure. If you know it is going to work, it isn’t an experiment.

I have long believed that nuclear power today is in precisely the same state as space launch two decades ago, but the even more pressing question now is if semiconductor fabrication might also be.

On the one hand, Moore’s Law has been a sequence of heroic miracles of technology at the wafer fabrication level, grinding out hundreds of compounding small improvements.

On the other hand, fabs are “too big to fail”, and there are elements of extreme conservatism at play. Intel’s “Copy exactly!” fab development exemplifies that mindset – instead of every new building being an opportunity to explore and optimize processes, it was deemed more valuable to just replicate.

While each individual machine may be straining against physical limits of technology, it is possible that the systems orchestrating them all together could be far from optimal.

The explore / exploit axis is fundamental to all decision making, but human risk avoidance probably biases away from optimal exploration.

[John Watches Horror @Y2John84]

This was made in 1979.

[Ramin Nasibov @RaminNasibov]

Programmers were asked to make the worst volume control for a contest https://t.co/uafe4aPMgS

[🎸 Rock History 🎸 @historyrock_]

Tina Turner's most iconic concert entrance (1999)

[Cédric Devoyon @Cdevoyon]

Le « problème médical »

[Austin Hill @austinhill]

It simply amazes me that mechanized Lego courses aren’t mandatory in early STEM schooling.

[Turbine Traveller @Turbinetraveler]

At first I thought it was a toy plane!

[Jonathan Blow @Jonathan_Blow]

Some people might read this and think, that's just not my world, I am stuck in this world where software breaks all the time and everything I build is disposable.

Even if that is kind of the case for you, there is still good news, because this isn't an all-or-nothing problem. It's a dial that can be turned; you can turn that dial in a direction that reduces flailing and results in more-stable long-term progress.

You don't have to remove all the dependencies, because every dependency you remove contributes to stability. Even getting rid of 1/3 of your dependencies can do amazing things.

You can look at all the things you depend on and divide them into two categories: major and minor. Major dependencies are things that, realistically, you are never going to have your own version of. I am never going to make my own graphics API, so those count as major dependencies for me (DirectX12, Vulkan, Metal, etc). I am not going to write my own CPU-side font rasterization, so anything I choose to use there (FreeType, stb_truetype) goes in that category.

With Major Dependencies, you limit your contact surface with them: You call only the functions you really need, and you do this only from the surface of your program -- you don't build data structures deep into your program that propagate the particular data structures or API decisions of any of these systems. A good API author will help you do this (stb_truetype), a bad API author will be trying as hard as they can to screw you up and force you to become tied to their system forever (anything from Microsoft or Apple).

Understanding that many API authors are hostile can cause a big change of perspective here, and once you see it, the correct tactics become much more obvious.

So, that's the major dependencies. Minor dependencies are things that are smaller, and that you want to use much more thoroughly throughout your program: for systems programmers this might be a data structure like an expanding array or hash table, for Web, maybe there are some string or file operations that you like to do.

Minor dependencies can be eliminated and it's not even hard. You just do one at a time: hey, I need this data structure, I have been importing this other code to provide that functionality, I have suffered X, Y and Z problems because of this, how about if I just implement my own simple version of this one thing?

People can get scared of implementing core stuff like this, because they look at the implementation they are using now, and it looks huge and complicated and hard to reproduce. But the thing to realize is most of this implementation is spam. It is mostly doing things for people who are not you, for reasons you don't necessarily agree with, chosen by a decision-making method that is deeply flawed. Your own implementation can be cleaner and smaller, and it can give you good feelings when you go look at it. You don't need all the functionality of the thing you are importing; you only need 8% of the functionality. Implementing that is easy.

Once you do this a few times, you have your own stable body of code that you bring with you from project to project. It won't break unless you mess with it. You can keep improving it if you want, incrementally over time, but the cost of this is small because this code represents stable algorithms that don't change with fashion, so work on this is never forced.

Every big company has their own internal version of this, but the problem in that scenario is that a big company is full of people who want different things, and have varying levels of decision-making skill, so these usually end up not so good. But when it's your own personal thing, it can in fact be very good, and help make you happy on a daily basis.

And, your software will break much less often. Which is great.

@NotAShelf
@ThePrimeagen

https://t.co/p77DWbDx0X

[James Melville 🚜 @JamesMelville]

This is off the scale brilliant.
♥️🎶

[Massimo @Rainmaker1973]

Filming the speed of light at 1,000,000,000,000 frames per second

[Hartmut Behrens @HartmutBehrens]

@XorDev Slang?