Hacker News Reader

Comment by aninteger | Hacker News Reader

I always wonder what the early c++ compilers looked like. Something that targeted AT&T 2.0 or 2.1 C++, so predating C++98.

I guess all we really have to go on is cfront or early gcc (1.15.3 was the first version with a c++ front end). We also have Walter Bright's Digital Mars compiler but how different is this from Zortech?

View on HN

> I always wonder what the early c++ compilers looked like.

Pretty horrible. I attempted to use the E (education) release of cfront, and failed miserably (couldn't install it).

I then was forced to use the Glockenspiel compiler (based on cfront) and running on OS/2 (eek!) who's favourite error message was a core dump - this was at a training company, and the combination of very bad error messages and OS/2 was not popular with our clients.

The Zortech compiler was the first good one, and then Microsofts. Then IBM came out with a very good one on AIX.

I may well have got the sequencing wrong here - so long ago and far away :-)

Borland turbo c++ was pretty good, and v4 came with a ton of printed docs on the standard library.

Indeed - completely forgot about that. Though Borland really dropped the ball later, with horrible non-standard extensions to the language.

And of course many people in SE Asia are still being damaged by still being taught using Turbo C++ when they could be usefully using GCC or clang.

> And of course many people in SE Asia are still being damaged by still being taught using Turbo C++ when they could be usefully using GCC or clang.

Reason number X for someone to work on semi-faithfully cloning that MS-DOS-era TUI interface so that it can work as an IDE on modern systems and compilers, piggibacking on things like LSP servers. It was done already for the Pascal version ("fp" ide), and we also have things like QB64. Hopefully it's just a matter of someone being inspired to do the work.

I forgot, until now, that once upon a time I was building & packaging xwpe for sco osr5 for a while.

https://web.archive.org/web/20160321050842/http://www.aljex....

It's like an X11 rendition of the Borland tui.

It didn't have a logo or icon so I made one. (several crap ones actually)

Now the modern system I was using that emulated-old-thing on is itself even older than turboc was at the time.

Nice. Software homepage is still up at http://identicalsoftware.com/xwpe/ (with self-signed https), screenshots at http://identicalsoftware.com/xwpe/screenshots.html . FAQ about the original software preserved at https://web.archive.org/web/20030402074122/http://www.astro.... (from 2003(!), later versions are 404s). Ironically enough, the homepage itself describes this as a fork aiming to continue maintenance since the previous author of the software had stopped responding to inquiries about it. A perfect example, if perhaps a regrettably short-lived one, of how ensuring the Right to Fork can help address concerns about FLOSS maintainership.

I agree. All the arguments about the difficulty or practicality of maintaining things in the open world where there's too much stuff, none of that matters at all. How difficult or likely or realistic or useful-today something is doesn't matter at all. The only thing that matters is the difference between possible and not-possible.

What anyone does or doesn't do with that which is possible is no excuse to tolerate, let alone advocate, things being not-possible.

A couple of months ago I started to convert xwpe to use wide charachters as a means to dust of my ancient c skills. I should finish it.

Borland came out much later than Zortech C++. Borland abandoned their own OOP extensions to C when they saw how well ZTC++ was selling.

In my not-so-humble opinion, it is ZTC++ that cemented C++ as the leading OOP successor to C. Before ZTC++, ObjectiveC and C++ were neck and neck (judging by traffic on newsgroups). Borland and Microsoft were both investigating their own C-derived OOP languages.

ZTC++ came out, and a ton of magazine articles came out about C++ using Zortech C++. ObjectiveC fell away, and most of the C++ programming was in ZTC++.

Well (as of course you well know) you are right. But people have all sorts of reasons for making the success of a product - my boss at the BBC bought a copy of ZTC++ because he liked the text editor that came with it (it did, didn't it, or am I finally going Deolali?) - he never wrote a line of C++ himself.

Yeah, it had ZED the text editor. I still used microEmacs myself :-) My partner liked ZED, so it was all good.

I remember reading hints of prior extensions in BC++. I remember they kept their message dispatch hacks for windows. E.g. virtual void foo() =[WM_USER+11].

All versions came like that.

Microsoft was the very MS-DOS compiler vendor to support C++.

Zortech, Borland, Watcom, Metaware all beat Microsoft to it, which released their first support on Microsoft C/C++ 7.0, their very last MS-DOS compiler.

> Walter Bright's Digital Mars compiler but how different is this from Zortech?

It's the same compiler, but upgraded for C++98. It's Open Source now.

https://github.com/DigitalMars/dmc

In 1991, I began using C++, with both the Microsoft C++ compiler and the Borland Turbo C++ compiler (on a PC/AT clone with a 386DX-25).

In the end, I have used mostly the Microsoft C++ compiler, but not because I had noticed any problem with the Borland compiler, but because the library delivered by Microsoft happened to include some functions that I needed frequently, and which were missing in the Borland library.

Because at that time there was no standard, even if the language accepted by the two compilers was mostly the same, the libraries were quite different.

I do not know how well templates worked in those early compilers, because I did not attempt to use templates in any program written during those years.

Except for templates and for multiple inheritance, which I have used only seldom, I had exercised all other language features in some complex programs, which simulated some physical models.

In general using C++ at that stage was, at least for me, a pleasant experience in comparison with the earlier use of languages like C, Fortran, Pascal or Basic. Because my programs included a lot of complicated formulae whose operands were matrices or vectors of complex numbers, I have especially appreciated using overloaded operators to reduce dramatically the size of the formulae, making them much more easy to read than in my earlier programs.

In my opinion, the Java creators had some weird mental problems, because they believed that it is better to write and read something like:

cplx_vector_add(A, cplx_vector_sub(cplx_mat_vec_mul(B, C), cplx_mat_vec_mul(D, cplx_mat_vec_mul(E, F))))

instead of writing and reading something like:

A + B * C - D * E * F

(The formulae that I had to use were much more complicated than in the example above, so the reduction in text size was much larger)

I did not have any complaints about the performance of the compilation or execution of the programs.

I have found once a bug in a certain version of the Microsoft C++ compiler, where depending on the order of some declarations, for which there was no reason to be significant, either correct or buggy code was generated. However the next compiler version no longer had the bug.

Both the Microsoft C++ compiler and the Borland Turbo C++ compiler had superb documentation.

Even without knowing anything about C++ and without any other books or publications on the subject (and obviously without Internet), just reading carefully the set of manuals provided with the compiler was enough for becoming a good C++ programmer (assuming that you were familiar with programming in any other language).

I think that actually the largest difference that I feel when I compare now an early C++ compiler with a current C++ compiler, is not that the current C++ language has 5 times more features than early C++, but that the early compilers were paired with a huge quantity of documentation, which seemed to have required about as much writing effort as writing the compiler.

Reply on news.ycombinator.com