23,650 karma · joined October 15, 2013
1999 is exactly right for the start of the XML hype, everything had to be XML, it would single handedly solve the software crisis (after OOP failed to do that) because everything would be able to talk to everything!
(also let's be honest, building yet another CRUD app - eg what 99% of software devs actually do, is not "creating value" - with or without AI)
LLMs can be very useful for all sorts of things, but large scale code generation is IMHO the least interesting use case. And even when LLMs are successfully used for code generation, I feel like progress has been reset to the early 60s and people are now rediscovering all the failed software development approaches (eg "spec-driven" is pretty much the equivalent of "waterfall", I'm now waiting for UML diagrams to make a comeback as the next big thing with an "agentic engineering" label slapped on ;)
Classic interactive "vibecoding" with quick turnaround times (but much quicker than now please, don't make me wait and let me slip out of the flow) might actually turn out to be the most useful way to build software with LLMs (or let's better say "prototypes"). Because everything else currently looks like we're building up too much bureaucracy around the software development process again, and just in time when we finally got rid of that shit (now we have that absurd amount of .md files in pseudo-human-language as "skills", "rules", "context", "memory", ...) like it was common in the 70s when the work was split between "software architects" who only do the high level design, and "implementers" who only bake that design into code. This was obviously a stupid idea and I don't know why the "AI bros" seem to be so keen on repeating that mistake.
Every approach that builds a "human language specification" that's separate from source code written in a much more precise programming language is doomed to fail (eg the code is the spec!), and that's nothing new, we've known this for decades, but that brain virus of "upfront software architecture" always keeps creeping back into the minds of people at the first opportunity.
It's not that the private sector gave up entirely though (e.g. see https://isaraerospace.com/), but of course it's incredibly hard to enter a market that's dominated by a handful heavily subsidized and state/military-sponsored companies (and that includes SpaceX).
But I have a feeling that at least the braindrain from Europe towards the US will not be quite as extreme in the future as it was in the last 90 years.
Also:
> I really wish German industry had a little more willpower
I think it's less about company willpower but about (investment) money, and of course every idea must make business sense. That whole balancing act between 'must quickly become a viable business' versus 'how much investment money is available to burn on failed experiments' happens on a much smaller scale in Europe compared to the US (and a lot of European investment money is being burned in the US instead of Europe, and this clearly would need to change first).
These are Cold War terms (post WW2). And for the Cold War era it makes sense to use the original meaning.
IMHO the term "3rd world country" shouldn't be used in the first place when talking about the time after the early 1990s though. It's misleading and the "modern" meaning comes with a hefty whiff of implied racism/colonialism.
https://en.wikipedia.org/wiki/Third_World
Do you think the Soviets would have called the US aligned countries "First World"? ;)
The more 'correct' term for that modern/popular meaning of 3rd world is 'developing countries' (or in German "Entwicklungslaender"). But tbh, I have no idea when, how and why the transition from 'politically unaligned country' to 'underdeveloped country' happened in the modern popular opinion - the Wikipedia article has some ideas though - but tbh I would never have considered Cold Ware era Cuba or Vietnam to be "3rd world countries", and after 1990 the whole idea behind those "three worlds" has lost all meaning anyway, and especially after China had entered the chat.
Yugoslavia and Albania are more interesting cases though indeed, at least Yugoslavia tried to play both sides during the cold war, while Albania started as a very close Soviet ally but then moved towards China and then eventually ending up as completely isolationist.
Also as a clear example for a '2nd world despot' look at Romania's Ceausescu, and for examples of '1st world despots' look at Spain under Franco (easy to forget that Spain was a fascist dictatorship until the 1970s), or Chile under Pinochet.
Scott Manley has a video about them, and that's also available in Germany ;)
https://www.youtube.com/watch?v=ed4w4Cz5ccU
PS: GP probably meant this one (this is just the trailer of a German documentary from 2018):
Back in the Cold War the 'division' of the world into power blocs was quite simple:
- 1st world: countries aligned with the USA
- 2nd world: countries aligned with the USSR
- 3rd world: independent countries that were neither aligned with the US nor USSR
E.g. in its actual meaning, 3rd world doesn't say anything about how rich or poor a country is, or about its form of government.
https://en.wikipedia.org/wiki/Gerald_Bull
I wonder how many similar but unknown cases there are involving former Soviet scientists and engineers trying their luck with 3rd world despots after the Soviet Union collapsed.
PS: just remembered that Willy Messerschmitt also ended up building a jet fighter for Egypt after the project was abandondend by Spain. Egypt then also eventually cancelled the project in 1969 though and instead decided to become close buddies with the Soviet Union - I wonder if that decision saved Messerschmitt from the same fate as Krug and Bull:
My guess is that the implicit declaration was a leftover from a C predecessor (B?) and kept in C to simplify programming in hybrid B/C environments. Just a guess though.
One silly side effect of compiling C in C++ mode is that it forces you to cast from void pointers. E.g. the famous example of:
bla_t* bla = (bla_t*)malloc(sizeof(bla_t));
That extra cast is just a silly and completely pointless C++-ism. It's only the tip of the iceberg though (another difference was zero-initialization with `{}` vs `{0}`, but that's harmonized now in C23 so that `{}` is also valid in C, but as soon as you want to use C99 designated init, the 'harmonization' ends).One critical missing piece of C compilation mode was usually that the compiler didn't warn when using a wrong enum type, but that's also fixed by now (assuming `-Wall -Wextra`, but that should always be enabled anyway, otherwise you're just flying blind), e.g.:
That's not possible for 'standard C' though, only for the separate language that's called "the common subset of C and C++". E.g. it works more or less by accident for some specific C code that predates C99, but even that is built with C++ semantics (which has many subtle and some not-so-subtle differences to C semantics).
Instead of trying to build C in C++ mode, turn all the warnings to 11 (and also include warnings that aren't in -Wall -Wextra, like -Wsign-conversion).
There's at least a dozen local German dialects missing which are just as 'weird' as Bavarian though (PS: ok, all the main dialects spoken in the northern parts of Germany seem to be there, just in their own 'heritage node'), I guess Bavarian earned its own spot because it has the most speakers.
As terrible as the influencer scourge is for society, I somehow doubt that it was a 3 day social media fad a couple of weeks or months ago caused the collapse of ocean wildlife.
For areas like application plugins via DLLs it's the OS ABI that matters.
Ultimately any ABI discussions need to happen between CPU and OS vendors, compiler toolchains implement whatever comes out of those discussions.
And to be honest, this sort of compiler-specific ABI interoperability is a non-problem that doesn't need solving, it's at most relevant for software developers of closed source libraries who distribute the libraries as precompiled blobs. But those must be stamped out for different target-triples anyway.
Also IIRC it was really only UNIX which had this "whatever our C compiler does" mishmash. On most other operating systems it was the other way around, C compilers had to implement whatever calling convention the OS already had defined before there even was a C compiler for that OS (for instance early Windows version used a PASCAL calling conventions, and others (CP/M, DOS, AmigaOS...) some random rules that were most convenient for handwritten assembly code).
PS: and yeah I know that other article (or rather: incoherent rant). It's basically a lot of barking up the wrong tree.
ABIs are defined by CPU and operating system vendors. Those ABIs usually happen to be quite 'C friendly', but that's not a requirement (for instance the AmigaOS ABI was primarily meant to be used from handwritten assembly code, and Amiga C compilers had to adapt to those ABI rules or they wouldn't be able to call into the operating system DLLs).
In the end, OS/CPU combinations define ABIs, compiler toolchains (no matter what language) can't do much more then follow (if they want to be able to talk to the operating system at least). E.g. if one day operating systems implement stable Rust-friendly ABIs, then C compilers will have to adapt to those conventions instead.
Vulkan was released after both Metal and D3D12 btw.