What's with the avalanche of new things to learn - has it always been that bad?

Heh, Hector Martin is that guy with that cartoon character alter-ego right? Asahi Lima or something. He is a very much an exhibitionist. I wonder how many on that mailing list cringe when he opens his mouth.

These Rust "abstractions" (bindings) seem to be absorbing all of the developers time. It has been over a year already and they are still developing them! Just wait until maintenance needs to happen; they are going to be very fragile.

Hopefully some of the skilled developers from Linux will move over to FreeBSD as an end result :)
I just saw on LKML that he posted a MAINTAINERS patch on which he resigns from his role.
 
How is this relevant here? If you want to play in the C++ field, you've got to update your knowledge & skill of C++. If you have to use containers and kubernetes, you'd better keep your skills uptodate. And so on.

The (continued) complaint here is that containers and kubernetes change at a normal rate that a human can keep up with while having time to do the actual job. But that C++ exceeds that limit.

Unless you are in a position to change things (& have the necessary energy level to keep at it), it is no use complaining. One option is to try to simplify your life, to change the playing field, so that you have to maintain fewer and hopefully more enjoyable things. It is true that changes are speeding up and there is more and more complicated (and badly designed) systems so simplifying is harder but not impossible. An additional issue is that as we get older at least some people get less tolerant of newfangled changes that don't add to their quality of life!

You can't change potential employer's technical environment. It is hard enough to simplify things when you are inside.
 
It is hard enough to simplify things when you are inside.
It may be easier to just organize your own workflow to adapt to what's inside. The employer's job is to support what they have. If that support is unsustainable, there will be changes.
 
If you ever needed a reason to skip Rust:


"they know they're going to be on the losing side of history sooner or later. No amount of sabotage from old entrenched maintainers is going to stop the world from moving forward towards memory-safe languages."

It's not just the language that needs maturing, but the members of this cult.
That guy sounds like Fidel Castro. What's next? "Viva la revolución"?
 
You can't change potential employer's technical environment. It is hard enough to simplify things when you are inside.
When I joined a well-known very large company, my first task was to fix (a long list of) bugs in a critical program written in C++. I studied it for a while and asked them if it was ok to rewrite it in Go. I was quite prepared to argue my case but then I was pleasantly surprised when colleagues told me they were hoping I would rewrite it in Go! Rewrite took a while since it had to interface with all sorts of external programs and APIs which were in constant flux & their internal systems were highly complicated. May be I have been lucky but my experience over the years is that by taking some initiative & hard work & persuasion changes are possible. Though often people don't do this (or they give up assuming they won't be allowed). It is like they are not aware of their own power.

But I do agree that simplifying is harder and harder as "technical debt" (bad design/impl. decisions) accrues. One other phenomenon I saw at this company is that their "smart" programmers were the type who could keep a lot of complexity in their heads so they didn't seem to mind all that complexity but over time there is an increasing cost. Especially as "smart" programmers move on to other projects.
 
But I do agree that simplifying is harder and harder as "technical debt" (bad design/impl. decisions) accrues.
This is the thing that tends to kill a lot of companies/products. I'm probably not alone in "there is never enough time to rewrite the 15yr old code to make it easier to maintain because we are too busy fixing bugs that are obscure corner cases from the old code that we hacked yet another layer on top to make it do something it was never supposed to".
 
I've managed to do rewrites, more than a few times. Once you've done it successfully a couple of times they learn to trust you (more or less! 😁) . Of couse much of the time its "we need to ship it it in 3 days we don't have time for a re-write". But sometimes it's worked out. Sometimes you can do it by stealth, and you have it done before they realise what you're doing.😁

One occasion was a bunch of build packaging shell scripts, part of a multi-phase build system, these things had grown over the years, there was one script for each hardware type supported and as each new machine type was added someone (usually a different person each time, some of whom inevitably left) would copy the entire script, bodge some changes in and check it in as a new script, and they ended up with a couple of thousand lines of terrible code that no-one understood or knew the history of, and it became unmaintainable. I'm sure everyone here is familiar with this kind of story. They asked me to look at it, I designed some xml to describe the targets and reduced the thousands of lines to about 300 lines of perl based around an xml parser, and deleted all of the original code. Thereafter the replacement perl script remained unchanged and each new machine type merely added a new descriptor to the xml, which radically simplified and speeded up the whole process of adding a new hardware type. So sometimes doing a rewrite works out really well. Of course in that instance it helped that it was a fairly self-contained piece of work without a lot of linkage to other code.

Other re-writes I've done, like one that was a multi-threaded client-server IPC library that had to be redesigned, was highly embedded in other system code and took more time and care to achieve so as not to break the rest of the product.
 
  • Like
Reactions: mer
I haven't watched the video but "Memory leak" and "Memory safe" are completely unrelated things.
Quite right of course. However, the story shows that its perfectly possible to screw things up badly in rust, just like any other language. That story makes me wonder if they did any more than a cursory test before shipping it too. It wouldn't be the first time! 😁
 
Quite right or course. However, the story shows that its perfectly possible to screw things up badly in rust, just like any other language. That story makes me wonder if they did any more than a cursory test before shipping it too. It wouldn't be the first time! 😁
I would also add that the false sense of security is often the cause of the worse mistakes.
 
When I joined a well-known very large company, my first task was to fix (a long list of) bugs in a critical program written in C++. I studied it for a while and asked them if it was ok to rewrite it in Go. I was quite prepared to argue my case but then I was pleasantly surprised when colleagues told me they were hoping I would rewrite it in Go! Rewrite took a while since it had to interface with all sorts of external programs and APIs which were in constant flux & their internal systems were highly complicated. May be I have been lucky but my experience over the years is that by taking some initiative & hard work & persuasion changes are possible. Though often people don't do this (or they give up assuming they won't be allowed). It is like they are not aware of their own power.

The reluctance to re-write is that many organizations did encounter the "second system effect" in the past:

You case was special in that you are competent (obviously, otherwise the rewrite wouldn't have succeeded), you were alone (greatly simplifying things) and you seem to have limited functionality to what has been there before (hence avoiding the second system effect). Any of these can be missing in other projects.

Now your company is better off not just because they have a better codebase, but they also learned that rewrites can work and they might allow their people to do it again. An important lesson as long as their realize the factors that made it work.
 
One occasion was a bunch of build packaging shell scripts, part of a multi-phase build system, these things had grown over the years, there was one script for each hardware type supported and as each new machine type was added someone (usually a different person each time, some of whom inevitably left) would copy the entire script, bodge some changes in and check it in, and they ended up with a couple of thousand lines of terrible code that no-one understood or knew the history of, and it became unmaintainable. I'm sure everyone here is familiar with this kind of story. They asked me to look at it, I designed some xml to describe the targets and reduced the thousands of lines to about 300 lines of perl based around an xml parser, and deleted all of the original code. Thereafter the replacement perl script remained unchanged and each new machine type merely added a new descriptor to the xml, which radically simplified and speeded up the whole process of adding a new hardware type. So sometimes doing a rewrite works out really well. Of course in that instance it helped that it was a fairly self-contained piece of work without a lot of linkage to other code.

You replaced a bunch of similar codepieces (aka copy'n'paste programming) with compile-time computing. I am a big fan of that. Sadly languages who offer compile-time computing directly are out of fashion :( So the next best thing is a scripting language somewhere in the build process.
 
You replaced a bunch of similar codepieces (aka copy'n'paste programming) with compile-time computing. I am a big fan of that. Sadly languages who offer compile-time computing directly are out of fashion :( So the next best thing is a scripting language somewhere in the build process.
Perl has a bunch of useful cpan modules for xml parsing, merging hashes, the map operator and of course regex matching that made it a natural fit for this kind of job. I expect you could do something similar in python (yuk) if you tried really hard. I thought of it more as replacing a bunch of duplicated linear code with something table driven (the table being the xml file). I use to work in forth many eons ago on 8-bit and remember using compiling words in forth :)
 
Perl has a bunch of useful cpan modules for xml parsing, merging hashes, the map operator and of course regex matching that made it a natural fit for this kind of job. I expect you could do something similar in python (yuk) if you tried really hard. I thought of it more as replacing a bunch of duplicated linear code with something table driven (the table being the xml file). I use to work in forth many eons ago on 8-bit and remember using compiling words in forth :)

I was more thinking about doing it in Lisp with the table directly in the source code (and not in a string)...
 
Back
Top