Rust GCC Code Generator "rustc_codegen_gcc" Can Now Bootstrap Rustc

[oiaohm]

I didn't realize "first class citizen" needed clarifying at all - and it didn't, until oiaohm did what oiaohm does, which is to take a piece of someone's comment and twist it into something that was never said so that they can argue with themselves about how the newly-fabricated statement was wrong. I generally find it's best to just leave them to it.

No read what I quoted and note what was in bold.

Seriously though, this entire premise is simply not even "real". There have already been periods where numerous languages all held "first class citizen" positions: there was a time when BASIC and Pascal were in far more common use than C was, and BASIC even remained so for 20 years after Windows took over the world.

The problem was not "first class citizen". The reality is that Basic and Pascal in history never gets to be in more common usage than C was. Only two languages that can claim that they are in more common usage than C at any point in history is Python and Java.

Being "first class citizen" does not magically create market share in fact the Apple Macintosh is a good demo of that case because pascal was first class citizen but the dominate programing language still end up being C due to legacy code bases and cross platform.

arQon you wrote that Basic and Pascal out numbered C by the words "far more common use". "Far more known than C" by general population would be true for BASIC and Pascal at their peeks of popularity but "far more common use than C" for Basic and Pascal is in fact false because that never happens.

Like it or not you made a statement that is historically false arQon.

[arQon]

sigh...

"Microsoft surveys in the late 1990s showed that nearly two thirds of all business application programming on Windows PCs was done in Visual Basic".
https://www.devtopics.com/the-rise-a...-visual-basic/

Since there will doubtless be another response along the lines of "that's not what I meant", or "that doesn't count", etc, and there's a grain of truth in that which will suddenly be transformed into the new focus of talking point, I might as well waste some time on it now...

By the late 90s, most VB work was hosted in Excel, which continues to be the case today. It's the time *before* that that we're interested in, back when it was a language in its own right.

People generally think of BASIC as an interpreted language, which made it almost worthless for any non-interactive use - but Borland's Turbo Basic was compiled, and as a result was performant enough even for games, albeit with asm for the 20% of the code that did 80% of the work, i.e. sprites etc.
Pascal was never as successful, but the family as a whole was still big business in the 90s, especially once Delphi came along.

Aside from incorporating RAD, which was essentially v1.0 of what later became known as Agile, both of these languages had full development environments, real debuggers, and other groundbreaking tools (like in-IDE debugging) for the time. Since they not only bypassed most of the footguns of C, but were also languages either learned by hobbyists or being taught to the droves of new college graduates, in far larger numbers than the handful of courses that included C at the time, they were far more readily adopted and gained huge market share. (It probably helped that the minicomputer era was coming to a close, so there was a secondary source of programmers from VAXes etc as well).

C developers were a tiny minority, and while competent ones were very productive they were an even smaller subset, just as they are today. With the PC market exploding, and demand for software growing exponentially on top of that, there simply weren't enough C devs to go around - and most of the new companies being formed by people leaving the titans of the mini era to start their own businesses were older and didn't even know the language. The financial markets and a few other star industries got the C developers, but everyone else - which made up the overwhelming majority of the PC space - had to either make do with whatever they could get, or hire people with no experience and train them up, which is difficult to do when you don't have anyone to teach them in a language in the first place.

So the BASIC and Pascal shops thrived, and since they outnumbered C devs and didn't have to spend half their day dealing with code that used void*** and risked buffer overruns and memory leaks every dozen or two lines, *and* could produce *anything with a UI* at least 100x more quickly than anyone working in pure C could, they released a lot more software as a result.

C was always the preferred language for Unix, but that was never the case for Windows. Since DOS/Windows outnumbered *nix even more then than it does now though, those systems weren't even a rounding error as far as software goes. C was something like 8-12% of the developer population, and that pretty easily counts as making the sum of the other groups "far more common".

None of which is on-topic, but, meh.

[oiaohm]

"Microsoft surveys in the late 1990s showed that nearly two thirds of all business application programming on Windows PCs was done in Visual Basic".
https://www.devtopics.com/the-rise-a...-visual-basic/

The bad news here this is truth lies and statistics. "all business application programming" pays to find the survey to see how Microsoft defined that. Please note accountancy software that business software right the answer is not Microsoft survey define. There is a lot of software that by Microsoft define was excluded.

What Microsoft had one with truth lies and statistics here is make marketing material to sell more basic licenses and training materials.

C was always the preferred language for Unix, but that was never the case for Windows. Since DOS/Windows outnumbered *nix even more then than it does now though, those systems weren't even a rounding error as far as software goes. C was something like 8-12% of the developer population, and that pretty easily counts as making the sum of the other groups "far more common".

8 to 12 percent is a huge number but its also not correct.

https://www.tiobe.com/tiobe-index/

Other problem you run into is the sizes of particular surveys. Like Evans Data one at the end of the write up had was only 430 developers yet it still had C and C++ programs making up 40% when java was in the lead. Before Java beats C we are not looking at C developer market share being 8-12% we are looking at C + C++ market share being over 50%,

That 8 to 12% lines up with something else.

http://petesqbsite.com/sections/tutorials/tuts/c_in_qb.html

Notice here people adding C to quick basic program for performance. This is repeating trend that keeps on going. From the first time basic could be complied into binary right into .net. What happened here is where people have need high performance code they have used C or C++ and if it C++ normally C++ limited to only C features.

So it works out 8-12% of your .net program, java program, basic programs any language that is not C or C++ that is complied into a binary program turns out to be custom C or C++. on average. So you still need people who know C or C++ to maintain this code you also need people who know C/C++ and the language you are using to make the interface between.

Basic and Pascal shops were not pure Basic or Pascal Shops because they still had C developers for the high performance code. Reality here is there have been pure C and C++ shops because they don't run into the performance problem.

So the BASIC and Pascal shops thrived, and since they outnumbered C devs and didn't have to spend half their day dealing with code that used void*** and risked buffer overruns and memory leaks every dozen or two lines, *and* could produce *anything with a UI* at least 100x more quickly than anyone working in pure C could, they released a lot more software as a result.

This makes a set of presumes that has key flaws two key facts.
1) Basic and Pascal shops required at least some C developers to make productive programs due to the limitations of the compilers/language.
2) The ideal that code problem you point to was fixed by using Basic and Pascal is wrong.

https://wiki.freepascal.org/Secure_programming#Buffer_Overflow

Pascal can buffer overflow and all the other stupid things C can. There is one problem here C had lint tools the early static analysis tools to find lot of errors Pascal particularly you were without these tools.

There is a reason why Pascal shops die out almost completely and it not because borland and others stopped making compilers. Pascal shop developers need to know C for high performance code and C code when using static analysis tools works out safer than using Pascal. C might be horrible but Pascal is not much better. Every flaw you can have in C program you can code in pure Pascal program but the problem here is the tools to locate those flaws in pascal source code effectively never developed. Basic does have some advantages here. There some flaws you simply cannot code in pure basic with way basic languages have prevented these problems have caused their own forms of problems with performance and compatibility leading to the C work around so needing c developers.

arQon this is history rust developed do need to beware of this. C has had developer dominance because even when people attempt to create projects without using C they end up having to use C in places for performance and other reasons. Rust is on the right track building in good static analysis tools off the start line.these will be required to compete with C.

Want Rust win over C you want to get it that a C developer need to know Rust to be effective. Having rust metadata able to be added to C and run rust static analysis would make C developer have to know rust stuff.