It drips as what he views as maximally efficient for his particular project. He isn’t the only one thinking along those same lines, either.

Yes, the delivery of the message sounds vane.

***

Most languages have evolved techniques so that they can be used efficiently today (at least for various purposes). Usually when you improve the language a dash you give something up that would be of value in some areas.

FOSS is not like a typical business in-house project. It has the potential of having a lot of key code will be built with distributed costs while accessing overall a greater amount of resources (like eyeballs), eventually be refined by devs with a higher average level of skill, and be used/leveraged by a much larger group.

Not every app benefits from X and Y runtime support overhead.

Perhaps we should all program in some universal and extensible xml-based language system that has virtually unlimited room to add attributes, hints, nonprogramming metadata, inline speedups useful under some cases, etc. With suitable translators/viewers, that same file can be seen in and compiled from many different languages/frameworks (losing some capabilities depending on the mapping target chosen). Future improved frameworks can very easily use the same old source code (though work best after new tuning/tagging is created). We can all program using very high level concepts with lower level hints/implementations as we find time/need. Testing can be worked into the system as can almost anything one can think of (after designing the suitable xml tags/rules). Such an xml framework would not be designed without thought and be workable well into the future, but someone could probably do a good enough job. The xml “file format” can be grown at a different rate as the tools that support it/map from it. Eg, some hints may not be used my any framework for years.

Why not allow yourself maximal room for design and creativity?

Of course, even this will not be ideal for all cases.

FWIW, I’ve never agreed with that view of Linus. It also drips vanity.

Whenever you use a “context” struct in C, you are effectively using OOP.

http://thread.gmane.org/gmane.comp.version-control.git/57643/focus=57918

*YOU* are full of bullshit.

C++ is a horrible language. It's made more horrible by the fact that a lot
of substandard programmers use it, to the point where it's much much
easier to generate total and utter crap with it. Quite frankly, even if
the choice of C were to do *nothing* but keep the C++ programmers out,
that in itself would be a huge reason to use C.

In other words: the choice of C is the only sane choice. I know Miles
Bader jokingly said "to piss you off", but it's actually true. I've come
to the conclusion that any programmer that would prefer the project to be
in C++ over C is likely a programmer that I really *would* prefer to piss
off, so that he doesn't come and screw up any project I'm involved with.

C++ leads to really really bad design choices. You invariably start using
the "nice" library features of the language like STL and Boost and other
total and utter crap, that may "help" you program, but causes:

 - infinite amounts of pain when they don't work (and anybody who tells me
   that STL and especially Boost are stable and portable is just so full
   of BS that it's not even funny)

 - inefficient abstracted programming models where two years down the road
   you notice that some abstraction wasn't very efficient, but now all
   your code depends on all the nice object models around it, and you
   cannot fix it without rewriting your app.

In other words, the only way to do good, efficient, and system-level and
portable C++ ends up to limit yourself to all the things that are
basically available in C. And limiting your project to C means that people
don't screw that up, and also means that you get a lot of programmers that
do actually understand low-level issues and don't screw things up with any
idiotic "object model" crap.

So I'm sorry, but for something like git, where efficiency was a primary
objective, the "advantages" of C++ is just a huge mistake. The fact that
we also piss off people who cannot see that is just a big additional
advantage.

If you want a VCS that is written in C++, go play with Monotone. Really.
They use a "real database". They use "nice object-oriented libraries".
They use "nice C++ abstractions". And quite frankly, as a result of all
these design decisions that sound so appealing to some CS people, the end
result is a horrible and unmaintainable mess.

But I'm sure you'd like it more than git.

			Linus

Also note that w/ Mono, Mono will at runtime detect if the bytecode can be optimized using SIMD on the current architecture and use that instead of the less efficient instructions that GCC would have compiled the same logic to.

Horse manure. If it’s not as efficient as machine language or straight Compiled C Code, it’s not efficient, and shouldn’t be used.

Ah, another canonical example of the type of “fan” this blog attracts.

“Programming is hard for me, it should be hard for everyone! And anyone who disagrees is an idiot!!”

I’ll keep this in mind the next time I get a proposal for a J2EE inventory control app at my company. I’ll send it back with a recommendation to code it entirely in x86 assembler.

Note: writer of this comment adds absolutely nothing but stalking and personal attacks against readers, as documented here.

@aeshna23
I didn’t mention alcoholism – where did you get that from? As to jaywalking, the point is that you have to be consistent. Think about it. The small shit counts.

@AlexH
Really? You don’t think that the lack of a superb Java/C# compiler is an issue? Think back to the early days of Micros – the lack of a good C compiler held off general adoption of C as a programming language for years/

@Roy Schestowitz
If it’s a run once application, I agree. If it’s going to be run by millions of people daily, I disagree completely.

It’s simply mad to compare FOSS development to alcoholism–even for those few who are addicted to programming.

For me, it’s just not OK to allow jaywalking on residential streets and forbid it on highways. I feel intense loathing for people who want to forbid jaywalking on residential streets. I hate them for all the utterly pointless, anal things that we are forced to do because of them. Rules should be applied reasonably and not with insane fanaticism.