Didn’t have a free commercial grade compiler. Made it hard for hobbyist to learn.

Nobody did back then though. Getting a free C compiler before GCC wasn't easy. Even commercial Unix systems shipped with licensing restrictions on their C compilers.

I bought Pascal, and then Modula-2, for my Atari ST. They were cheaper or the same price as a C compiler. Though C was a better choice for that system, since the OS was written in it and the calling conventions, etc. were all C.

On the Macintosh (and Lisa before it), by contrast, Pascal was the way to go.

So I think part of the reason C won out over Wirth languages back in the late 80s was because it just "fit" better with the systems that were emergent then. The swing towards Unix/Posix or Unix-like machines meant that the syscall interface for most things was defined with C calling conventions, and most example code was done that way.

And C++ also became quite popular, while the various object oriented Wirth / Wirth-like languages were not well standardized or available.

I appreciate your comment. I think it proves the idea how important free compilers and run times are. The web took off not due to C, but Perl. It was free and came with many servers that people rented. After that came the 90s with languages like Java and other free higher level languages. At the same time free OSes like Linux allowed people to be more technical without cost.

By the time this came around, universities taught C++ or Java in their intro to programming. Students used those. Then found the free version from discussion with peers.

It really is interesting just how much tooling plays a part in a language's success. It has to "just work" without any kind of crazy build steps. Rust with cargo handles this well, as does ReasonML with esy, Elm, and so on.

One might ask how NPM succeeded and well, it was the only way to write code on the Web, so people had to use it, one way or another.

npm did a fantastic job. Before it JS "dependency management" has been copying other people's scripts from random websites, embedding them in countless performance-degrading <script> tags, and never updating the code ever.

On the other hand, the tedium of manually copying <script> tags onto each page of an application naturally encourages developers to try to limit the total number of them.

Nowadays, no-one blinks an eyelid when `npm install foo` drops 1000 packages in your node_modules directory.

Pricing is the major reason that Delphi is not selling. The version of Delphi which can actually connect to a "client-server" database across the network costs $3,999 and the $999 for annual renewals..

https://www.embarcadero.com/products/delphi/product-editions

Otherwise Delphi is an excellent product.

However, since Delphi doesn't sell well we have the classic catch-22 situation - there aren't enough developers and the existing ones are retiring and hardly any new developers are using Delphi. So naturally companies are reluctant to commit to Delphi for new development.... further reducing the chance of bringing in more developers.

At the time, Borland and Watcom C++ just blew Turbo Pascal out of the water. There was no competition, feature and performance-wise. Also OO, which became another things..

um. Turbo Pascal was owned by Borland at that time. They did buy the company that invented it for sure.

TP executables were fast. Compared favorably to C++. The compile-time was also very fast.

I think parent meant "Borland c++ blew away Borland turbo pascal". I can confirm this, as in highschool I (painfully) ported my science fair project from tp to Borland c++ specifically for this reason and saw a ~2x speedup.

can confirm.

It caught on during the 80 and mid-90s, Object Pascal was originally designed for Lisa and MacOS OS development, before Borland, TMT and others adopted it.

But then Borland decided selling Lifecycle tooling to Fortune 500 was more interesting than small developers.

Delphi and C++ Builder are still around, unmatched in several of their RAD capabilities, but a couple of generations were lost, even if now they try with the community editions.

Standard Pascal couldn't handle variable-length items (e.g. strings without a compile-time maximum length), so only toy programs could be portable.

Even opening a file with a given path wasn't in the Pascal standard. Different implementations did this completely differently.

And didn't standard pascal also store the runtime length inline as a single byte, limiting strings to 255 bytes?

Now, in hindsight, thinking about it:

It might have had to do with:

- Turbo Pascal difficulty in dealing with 32-bits x86. Turbo C++ had different memory models (but I think it was still on the 640k limit) and then DJGPP came with protected memory

Ok then we got Delphi. But to talk to Windows you needed the C/C++ interface. And don't get me wrong, Borland C++ libraries were much, much better than the MS VC 6.0 MFC. Really.

But for the times where you needed a "direct line" with Windows, C was the way to go, so maybe that was it.

DJGPP was amazing, I remember programming games on it with Allegro when I was a kid.

I suspect the reason is that Proprietary for too long. Why use pascal by shelling out $500 to Borland when you could use c for free?

And you could shell out $500 to visual studio and the C++ MFC or the borderland C++ components if you wanted to do some fancy stuff like in delphi.

I believe Ada was supposed to be a better Pascal in some sense.

But I don't know why Ada didn't take off either.

The compilers were dead slow.

Ada was ahead of c++ by years, but it was unusably slow in compile debug cycles compared to c++.

http://archive.adaic.com/intro/ada-vs-c/ada-vs-c.html

> The compilers were dead slow.

And also expensive.

Nvidia recently chose Spark/Ada for some of their safety critical software.

https://blogs.nvidia.com/blog/2019/02/05/adacore-secure-auto...

It's still used in defense and aerospace. Last talking to people who were making inertial navigation units (the movement sensors like in your phone but much better and for a plane), all the software was done Ada, millions of lines of Ada.

AT&T monopoly, thus Unix and C.