Reading these old Linus exchanges always has me in two minds. On the one hand, it's great to peer into the mind of a genius and see the thought process, but on the other - and in light of his stepping back after recognising his own highly unprofessional behaviour over the years - I wonder if we should repost and idolise these emails.
Are people - especially young and impressionable developers - able to separate the two sides of the coin, or does it serve to plant a seed of normalisation for this kind of communication?
> Are people - especially young and impressionable developers - able to separate the two sides of the coin
As a young coder, I remember reading these linus oldtime posts as an exhilarating breath of fresh air. Everyone around me was all-in about "object orientation" and similar bullshit. When I say everyone I mean it: there was not a single person that suggested even a hint of hypothetical disagreement on software engineering mantra. Thus, it was refreshing to read these posts and realize that there existed, after all, another side of the coin.
We should not be afraid that young and impressionable people see "all sides of the coin". We should be afraid that they only get to see one side.
I almost always find myself agreeing with Linus (I don't super agree with his thoughts on debuggers, but I can see the merits), but I think you can be skeptical about technology (OOP, C++, exceptions, debuggers) without declaring to the world you have no empathy for other humans. I'm glad to see Linus taking stock of his behavior and starting to consider how he makes others feel. I think that's really hard for anyone to do, but especially someone who's been as successful as he has been. It's a huge personal leap, and I think we should be proud of him.
I don't really know if 33 is young or old but I really cannot agree more about the mantra thing. And it's not only the OOP craze that completely ate the industry at some point..! NoSQL-related discussions, all UIs and CLIs, the big enterprise influences vs open source approaches, etc.
It's easy to echo who you perceive as smart people; it's harder to have your own opinions, and be at a level where you can defend them in a satisfactory way.
Somehow, the Go language is doing it, eschewing traditional OOP in favor of a get shit done fast and a little dirty approach. It's not even because of the charm of an individual either.
Then again, before Go there was JS as the big opponent to rigid OOP. I still don't understand why they felt like they had to add half-baked classes / OOP to it.
I always strongly disliked the OOP school of program design, even though I learned to parrot everything required by one's typical interview process.
Keeping data and functions together can be nice. In some rare cases inheritance is almost OK. But still don't understand how it all went nuts and they started writing, say, parsers in that style...
But it's always nice to hear that there are other people having similar opinions. Especially if it's people like Linus.
yeah but people hate writing Go. It’s like using the dullest possible knife. It doesn’t have objects, it doesn’t have generics (so you can’t really do Functional Programming) and it doesn’t really let you do C-style machine work either. Its basic assumption is that you’ll have an endless supply of human beings to
implement everything, because the computer isn’t going to let you abstract anything
Bit of a blanket statement. I enjoy it much more than the little Node I investigated for work.
The lack of functional programming though, yeah. I feel like it might be due to GC optimisations as well, however. From what I understand, the reason the GC is so fast is because such a style of programming is heavily discouraged.
>and in light of his stepping back after recognising his own highly unprofessional behaviour over the years - I wonder if we should repost and idolise these emails.
I'd say we should. For me his apologizing was more cringe worthy than anything in these emails.
Basically caving in to the American (and some Europeans by mimicry) culture of and "shame! shame! shame!"-style demand for public apologies.
We need more people standing up to what they see as BS in tech. And if the use strong language doing it, that's in a great tradition too.
>Are people - especially young and impressionable developers - able to separate the two sides of the coin, or does it serve to plant a seed of normalisation for this kind of communication?
Yeah, as if we suffer from too much candor and strong words in today's tech landscape.
I will admit that I didn’t take the time to read through those articles, but I doubt any of them mention the positive effects of using profanity to deride others…
Because there has never been any positive effect from deriding others?
From social change (e.g. "look at these backwards bigots"), to running a tight crew ("wtf Kowalski, you stupid! You nearly got us all killed"), deriding others can just as well have positive effects.
Then there's the fact that some things naturally and inevitable deserve derision.
Not all ideas are derision proof.
Let's have Theranos or Fyre festival or non-vaccination as an example that we all agree on.
A healthy society should include a healthy dose of derision for derision worthy ideas.
(And if you think my argument above is stupid and deserves derision, then you've just made my point!)
They are less likely to offend others and discourage people from contributing to the project.
>Of course, I'd also suggest that whoever was the genius who thought it
>was a good idea to read things ONE FCKING BYTE AT A TIME with system
>calls for each byte should be retroactively aborted. Who the fck does
>idiotic things like that? How did they noty die as babies, considering
>that they were likely too stupid to find a tit to suck on?
Surely there are better ways to express a point without going at great length attempting to offend someone else. If you believe this sort of abusive attitude is acceptable, then why shouldn't people provide feedback with their fists as well? It can carry a similar degree of persuasion.
It also dissuades other people who may not make mistakes from contributing. I’m certainly not getting involved with a community run by someone who mirrors past abuse I’ve experienced, for example.
Then it's an inefficient method to do so, because along with discouraging these particular people, it may also discourage many other productive and competent developers who don't wish to condone this sort of abusive leadership.
Unless there's some demonstrated correlation that this subset of people is likely to be less productive contributing to a project like Linux, then this would just be bad leadership on behalf of Linus who'd exclude potential contributors based on personal whims.
You might consider simply emailing back with "please don't make mistakes contributing to the project". That works really well with me and everyone else I know. I don't need to be bullied to be convinced.
Then that’s not a particularly nice thing to do. People naturally make mistakes, and I’m pretty sure that the consensus is that belittling them when they do doesn’t really help.
Yes, let us hide old posts from public until candidness and frankness (driving forces of innovation and self-correction) is completely obliterated from the corporate world.
And let us also gently place everyone's thumbs into their mouths while they are asleep because it feels cute and cuddly.
What's wrong with Linus communication in this post ? Someone asked for his opinion. Not only did he respond with his opinion, he also clearly communicated why he holds that opinion. Sure he has written some abusive stuff, but that doesn't make everything else abusive, or can you point out the abusive parts in this post ?
Does your comment also apply to this specific e-mail?
I just read it and it seems pretty tame to me. It's direct but if people get offended by this these days, by gods, we have a problem. Sometimes growing a thicker skin is the answer, one can't put the burden all on the messenger.
I mean, there's some Linus e-mails (and also Erik Naggum posts on Usenet) that I thought were awesome when I was young and impressionable but that I now think are over the line. But this specific example, if that's not possible... phew.)
(I also get the impression some commenters here do not realize what "fsck" refers to.)
When you say "genius" you mean his technical abilities, by "unprofessional" you probably mean those moments when he pointed out other people's technical mistakes in a... straightforward manner.
Some people are offended by this other side of his style, yes. TBH, I don't understand why was it such a big deal. He never spoke about non-technical things in that way. Meanwhile, his technical opinions always were clear, sound and to the point.
> This is a much better email. It has 43% as many words, but loses none of the meaning. It's still forceful and unambiguous. With fewer words, it's easier for someone to absorb the core message about unthinking deference to standards.
> It also doesn't berate anyone, building a needlessly antagonistic culture around the project. Writing this email instead of the original email doesn't require any extra work, and will save mileage on Linus' (or your) fingers besides.
> If you read apologists commenting about this email, they often completely miss Linus' actual point. He's fine with the change; he doesn't like the justification, which uses an appeal to authority. The very people who apologize for the useless bloat miss this because of the bloat!
> These people missed the signal because it was buried in noise. But most of them go on to argue that the noise is boosting the signal; that ranting is good because it drives the point home. But they didn't even detect the signal because they were so focused on defending the noise!
I say make the world more interesting not less... People are adults and they can decide. To the extent that I agree that society 'needs to change' the most serious problems (abuse) are all things which have happened in private. It someone wants to be borish in public, everyone is aware, everyone can deal with it.
I don't think anyone else is idolising this kind of toxic behaviour. You're the one calling it 'genius'! I think it's an absolutely terrible way to speak to people and I hope I never have to interact with him to get something done in my job. I don't know how a professional person can be happy with knowing there are people who would avoid them like that.
>I don't know how a professional person can be happy with knowing there are people who would avoid them like that.
Well, they know there are hundreds of millions of others who use their work, thousands who worked with them, and a trillion dollar industry built on their labor and effort, and that they have spoken their mind, with no BS, and no fake niceties like it's the norm.
Some don't want to be people pleasers in general. They'd rather break bridges that censor themselves and be less blunt.
Others don't want certain kinds of people to "want to talk to them" in the first place, so they are non-polite towards their kind on purpose.
And a final similar case is wanting people to talk to you only if they can stand that level of discussion/no BS talk/bluntness/sense of humor/profanity/etc. So that you can be yourself among them, and they can be themselves with you, with no facades.
> I think it's an absolutely terrible way to speak to people
I, for one, pretty much prefer being spoken to that way, instead of a sanitized corporate newspeak that means exactly the same thing but uses "professional" words.
I agree. Corporate speak is the worst combination of ass-covering and abdication of responsibility.
I think people mean well when they talk about empathy and kindness, but those concepts assume that the only reality is how we feel and speak about things, when generally it's the underlying reality that is painful or harsh. And when you have to deliver a product, you can't avoid that reality.
I try to address it by frequently talking about my own fuckups and thus making it easier for junior devs to understand that failing is something we all go through.
But nothing can change the fact that it hurts to invest deeply in something and see it fail. We can't make pain go away, so it's better to just get it over with and learn to adapt to it and be resilient.
I read quite a lot of Linus emails, and honestly, he was harsh, but he was always constructive.
As a younger developer - what matters to me most is the constructive criticism. I don't want to have it phrased nicer(nor harsher) than needed - i just want it to be down to earth and constructive.
construct-js uses DataView under the hood. I wrote construct-js to ease working with binary data by allowing you to name and reference sections, and handle things like endianess easily in one place. With a DataView, I still need to calculate offsets into a structure manually, whereas construct-js has .getOffset(name) and .getDeepOffset(path). If performance is key however, use the lowest level of course.
Map wouldn't have really brought a lot of clarity or control. You'd have to specify an array of array-pairs, which is noisy IMO, and then you wouldn't have the benefit of being able to programatically/conditionally add fields.
I might consider a static `Struct.fromMap(name, mapObject)`, but as a complimentary API.
Thanks! When it comes to performance I can understand choosing a more low level approach. construct-js trades performance for declarativeness (though I suspsect that I can do a lot of optimising under the hood).
As for DEFLATE, I'm working on an automatic bit level structure at the moment which would allow for unaligned structures. Should be in the lib in a couple of days.
IIRC, when I last checked this (admittedly this was years ago) a single TypedArray object had 200 bytes of overhead - not counting the backing buffer for the array itself - due to the complexity of the one backing buffer being potentially used by multiple arrays and so on. By comparison regular object had about a dozen bytes of overhead. Because of this, tiny typed arrays are almost always worse in terms of performance than objects or plain arrays. Especially if we are talking about "type stable" objects, that is: prototypical objects with a hidden class that does not change.
Things have probably improved in Buffer/DataView/TypedArray land thanks to the push for WASM, but the allocation overhead still will be a lot higher and involve a lot more work to allocate them.
Hey - author here. You're completely right, but I hope the basic understanding will whet peoples appetites to try some more exotic stuff! Really I was just trying to lift the veil of what can be a quite intimidating subject if you haven't grazed past it before. Thanks for checking it out!
Are people - especially young and impressionable developers - able to separate the two sides of the coin, or does it serve to plant a seed of normalisation for this kind of communication?