Status of Pascal

[CP/M User]

It's true. Over at Gaby's site, I think she has a very early (<1.0) bunch of CP/M source code. Remember that it was DRI who rolled out a PL//I compiler for their ISV program. It was considerably more powerful than PL/M. Not the complete PL/M language, but a good part of it. Not shabby for an 8080-based compiler.

It's very impressive considering it was written on a 8080 computer, I came across the Manual for it here and at one time I was interested in writing something for it, but at the time was on Dial-up Internet and had to download some Monster Library of CP/M goodies in order to get PL/M, which was unfortunate.
These days it wouldn't be a hassle downloading, though I seem to have less time to learn something new, and just seem to poke around with my Z80 Amstrad. PL/M is obviously Intels Language, so Zilog probably would of being Sued had they written one for Z80 and I'm guessing that would explain why you don't see languages like PL/I or PL/M for Z80?

 

[Chuck(G)]

Zilog offered PLZ/SYS for their language set--not to be confused with PLZ/ASM, which was a Z80 assembly program. I haven't looked on bitsavers, but perhaps AK has preserved a copy. Note that we're not talking about a CP/M tool (nor was PL/M--it ran under ISIS). There was an independently-developed version of PL/M for CP/M, but it wasn't an official Intel product.

 

[CP/M User]

Zilog offered PLZ/SYS for their language set--not to be confused with PLZ/ASM, which was a Z80 assembly program. I haven't looked on bitsavers, but perhaps AK has preserved a copy. Note that we're not talking about a CP/M tool (nor was PL/M--it ran under ISIS). There was an independently-developed version of PL/M for CP/M, but it wasn't an official Intel product.

I didn't even know about those Languages, I could only seem to find some documentation about it, like here, seems to be much harder to find the Tools which perform the work, Zilog doesn't even seem to have anything about it on their website, perhaps like PL/M for CP/M, it wasn't made my Zilog perhaps?

 

[BigAlUK]

Wow - this talk of PL/M brings back memories. I wrote a shed load of embedded code back in the early 1980s in PL/M using an Intel MDS.

The Intel MDS was an 8-bit 8080-based embedded systems development station using the ISIS II operating system. So the PL/M was an ISIS-hosted cross-compiler for the Intel range of plug-in 16-bit 8086 embedded system cards.

Some years later, I found I needed to revisit some of that old PL/M code. But there was no Intel MDS no-more. It had long been consigned to some scrap heap or other.

So this is where it gets interesting: We had an Olivetti M24 (8086 machine running MSDOS 3.3). We also had a Z80 card for it that would run CP/M-80. This Z80 card was part of a 68000 embedded systems development station that we happened to have at the time, but we were going to 'abuse' it here. The CP/M-80 on this card would transparently use the MS/DOS of its host to read and write to the host drive. And we had an ISIS II soft emulator that would run on CP/M. This would then run the Intel MDS PL/M cross compiler under ISIS, under CP/M, on the Z80 card, hosted on the 8086 machine, making its OS-calls to MS/DOS. Bear in mind that all these different hardware and software products span a decade of elapsed time and none of them were specifically developed to work with each other.

So.. with this I was able to access my PL/M source and so quickly and flawlessly redesign and compile it as an 8086 program to run stand-alone under MSDOS. I was writing late-1980s MSDOS programs using a mid-1970s Intel-MDS ISIS II PL/M compiler. And it worked as if the whole PL/M environment had been designed for MSDOS! Big wow!

I've been an evangelist for emulations and virtual machines ever since.

 

[BigAlUK]

But back to the main theme of the thread:

As an embedded systems programmer of some 35+ years, I obviously have had to write a lot of code in machine code and later in 'C'. Because some of this was military-grade stuff for the US, I also had to spend some time with Ada. For me, these represent the extremes of the programming language spectrum.

ASM and 'C' do very little to protect the programmer from mistakes. At the point of first software delivery, there will usually be a heck of a lot of bugs that escape testing. This is because of the natural time pressure to deliver. There is a curve you can draw on a graph that demonstrates an exponential decay in discovery of bugs with time. At some point you make the decision to deliver because the bugs-detected-per-buck-spent-testing makes the decision more-or-less a given.

At the other extreme is Ada. The whole language and its development tools was specifically designed to make code robust and readable. That is why Ada exists at all as a language. Consequently, you have to spend a lot of your time interpreting the messages it gives you as to why it will not even compile your code. It wants EVERYTHING explained to it. You want me to add these two entities? Ok, how do I do that? What about overflow? What about storage size? How would you like me to deliver the result? Yada Yada Yada. By the time you get it to actually compile your code, however, it will be almost guaranteed to work first time!

So the Ada debug-curve is strange: It flat-lines for a while at a high value and then decays sharply. However, the decision to deliver is much more straight-forward, because of that sharp decline. And you WILL have less bugs in the delivered code.

So. This is why I like Pascal best: It sits somewhere in the middle between the 'laissez faire' lack of protection of ASM and C and the overbearing interfering and sometimes downright annoying interventionism of Ada.

And it gets fairly bug-free results. Fast.

That is what 35+ years experience tells me.



Pascal is the middle-ground 'liberal' language that sits between 'conservative' C and 'socialist' Ada. And Pascal programmers continue to this day to quietly produce good, simple, legible, effective code, whilst C-programmers whinge about efficiency and Ada-programmers whine about safety and integrity.

 

[retrogear]

Sorry to go off topic again but ...

BigAlUK - if you want to relive your past there is a full Intel MDS emulation running ISIS native os. It requires Windows running the ZEMU emulator here:
http://www.z80.info/z80emu.htm
Then search for Intellec on that page. I've run the plm80 compiler on it to assemble PL/M source code

AND

since PL/M was brought up, the Fortran source for the compiler exists which can be compiled with gfortran on Windows to develop a PL/M cross compiler for DOS which can compile the cp/m source code.
ok I'm done ...

Larry G

 

[retrogear]

Back on topic.

There is a Pascal compiler for the MDS environment running ISIS. I just never experimented with it.

DIRECTORY OF :F0ASCAL
NAME .EXT BLKS LENGTH ATTR NAME .EXT BLKS LENGTH ATTR
ISIS .DIR 26 3200 IF ISIS .MAP 5 512 IF
ISIS .T0 24 2944 IF ISIS .LAB 54 6784 IF
ISIS .BIN 94 11756 SIF ISIS .CLI 25 2984 SIF
ISIS .OV0 11 1279 SIF DLOAD 3 190
ULOAD 5 430 COPY 70 8582
DIR 55 6908 RENAME 21 2439
LINK 105 13184 LOCATE 120 15104
DELETE 40 4917 LINK .OVL 37 4608
OBJHEX 45 5632 SYSTEM.LIB 28 3456
BUFFER.PAS 8 878 COMP .COD 293 36864
GENOBJ.COD 61 7680 JOIN .COD 29 3584
P80EXT.LIB 2 127 P80ISS.LIB 77 9482
P80RAR.LIB 45 5590 P80RUN.LIB 70 8648
PASCAL 81 10083 PASCAL.RES 106 13312
1540
1540/4004 BLOCKS USED

Fun stuff !!

Larry G

 

[CP/M User]

But back to the main theme of the thread:

As an embedded systems programmer of some 35+ years, I obviously have had to write a lot of code in machine code and later in 'C'. Because some of this was military-grade stuff for the US, I also had to spend some time with Ada. For me, these represent the extremes of the programming language spectrum.

ASM and 'C' do very little to protect the programmer from mistakes. At the point of first software delivery, there will usually be a heck of a lot of bugs that escape testing. This is because of the natural time pressure to deliver. There is a curve you can draw on a graph that demonstrates an exponential decay in discovery of bugs with time. At some point you make the decision to deliver because the bugs-detected-per-buck-spent-testing makes the decision more-or-less a given.

At the other extreme is Ada. The whole language and its development tools was specifically designed to make code robust and readable. That is why Ada exists at all as a language. Consequently, you have to spend a lot of your time interpreting the messages it gives you as to why it will not even compile your code. It wants EVERYTHING explained to it. You want me to add these two entities? Ok, how do I do that? What about overflow? What about storage size? How would you like me to deliver the result? Yada Yada Yada. By the time you get it to actually compile your code, however, it will be almost guaranteed to work first time!

So the Ada debug-curve is strange: It flat-lines for a while at a high value and then decays sharply. However, the decision to deliver is much more straight-forward, because of that sharp decline. And you WILL have less bugs in the delivered code.

So. This is why I like Pascal best: It sits somewhere in the middle between the 'laissez faire' lack of protection of ASM and C and the overbearing interfering and sometimes downright annoying interventionism of Ada.

And it gets fairly bug-free results. Fast.

That is what 35+ years experience tells me.



Pascal is the middle-ground 'liberal' language that sits between 'conservative' C and 'socialist' Ada. And Pascal programmers continue to this day to quietly produce good, simple, legible, effective code, whilst C-programmers whinge about efficiency and Ada-programmers whine about safety and integrity.

Reading that just reminded back when I was a Student in a Class entering a COBOL program. The teacher simply gave us a program to enter without telling us to follow the Structure of the program, just so a whole Class Room would look confused when they compiled it.

 

[vol.litwr]

Pascal and Modula-2 in one kit - https://en.wikipedia.org/wiki/Amsterdam_Compiler_Kit

Reading that just reminded back when I was a Student in a Class entering a COBOL program. The teacher simply gave us a program to enter without telling us to follow the Structure of the program, just so a whole Class Room would look confused when they compiled it.

What was this program about? COBOL has right assignment, it is from left to right.

 

[Chuck(G)]

COBOL has right assignment, it is from left to right.

Well, it depends on what you mean by "COBOL":

ADD ALPHA TO BETA GIVING DELTA.
COMPUTE DELTA = ALPHA+BETA.

are, IIRC, equally valid COBOL statements.

 

[CP/M User]

What was this program about? COBOL has right assignment, it is from left to right.

Naturally, but it's a very old language which goes back to the 1950s. Fortran was also around then and like COBOL those languages used Punch cards were used for the programs. But by the time I was using COBOL in the late 90s, punch cards weren't being used, instead you would write your program into a Text Editor and save a file. But the COBOL we were using (RM COBOL from the mid-80s), required every Statement to begin on a certain row of each line (I cannot remember which row it had to be), and if a line was a comment you had to put a "C" on a particular row number (7 I think), if you didn't do this, there would be trouble.
I also found the same sort of thing with a Fortran DOS Compiler, though I never did learn where everything had to start on each line, fortunately I was able to bypass that in that particular DOS Compiler, but I don't think the RM COBOL we had allowed that.

This site might be able to explain more about Punch Cards.

 

[KC9UDX]

Either you call a column a row or I'm just severely confused.

 

[CP/M User]

Either you call a column a row or I'm just severely confused.

Yeah could be Columns, always getting them mixed up, since a row is across and Columns of a Coliseum goes down.

 

[Chuck(G)]

Both COBOL and FORTRAN had reasons for the hard assignment of columns;

For example: FORTRAN column 1 = C, was a comment, non-blank/zero in column 6 = continuation, columns 73-80 = sequence/ignored. There were some version-depend things also, such as IBM 7090 FORTRAN II used a "B" in column 1 to signify a boolean expression. If you had the right drum card in your keypunch, it was very logical.

COBOL used columns to denote separation between divisions, sections and paragraphs.

For what it's worth, the use/ignoring of columns 73-80 on a card had its beginning in the IBM 704, with its 36-bit words. The cards were read in row-binary with two words per row, making only 72 columns. The system did not read the rest of the card.

 

[vol.litwr]

I never used COBOL but I read about it. I find some its features very attractive, e.g., the left to right assignment, build-in database, ...
This thread is about Pascal and I dare to publish several my notes about this language. It make me confused that the modern and in a way very good languages still miss some convenient features of Pascal.
1. I am fond of Pascal's type hierarchy. This hierarchy in Wirth's Modulas, Oberon, Zonnon is more poor and IMHO this makes them less attractive.
2. Pascal has limited but very fast set type. I can write

S*[Robert,John]

and get the intersection or

if (i in [1,3,7]) or (i > 9) then ...

Where else can I find such convenient syntax?
3. How to define variable which value should be limited to the fixed range without subrange types? Pascal provides them, I can plainly write

var i: 2..5;

.
4. Pascal has true enumeration types. it is possible to use the abstract type

(Mo, Tu, We, Th, Fri, Sa, Su)

C++ uses hidden integer type for this. The languages like Ruby use lists for this...
5. The Pascal's record may have variant part - this is more convenient than to use union in C. A lot of good languages missed the idea of the record variant part or the union completely.
Pascal was the first popular PL with the OOP support. Turbo Pascal 5.5 appeared earlier than the polished C++ distributions. It is the mystery for me why Borland Pascal was so easy moved away by Java which was not so mature as today?

 

[lowen]

...
5. The Pascal's record may have variant part - this is more convenient than to use union in C. A lot of good languages missed the idea of the record variant part or the union completely.

I took a couple of college Pascal classes in the '80's on a VAX 11/750, and the textbook we used was 'Oh, Pascal!' (2nd Edition, Doug Cooper). So I wrote a poem about halfway through the 'data structures' section:

Oh Pascal, you make me mad
your syntax is so weird.
When record variants hit my code
I really scratch my beard.

Having said that, we used them in linked lists of records, and we heavily used the enumerated types.

 

[CP/M User]

I never used COBOL but I read about it. I find some its features very attractive, e.g., the left to right assignment, build-in database, ...
This thread is about Pascal and I dare to publish several my notes about this language. It make me confused that the modern and in a way very good languages still miss some convenient features of Pascal.

Well I started this thread as a way of looking into how Pascal is coping with the likes of C, but discussing other languages are by no means off-topic. I briefly recall a time in the late 90s when people were talking about COBOL making a comeback and I think even Microsoft had released something along those lines, but people were talking about it being a replacement for the likes of Java or Javascript for Web-based pages, but I guess Java had too much of a stronghold and Freely accessible made it an attractive language?

1. I am fond of Pascal's type hierarchy. This hierarchy in Wirth's Modulas, Oberon, Zonnon is more poor and IMHO this makes them less attractive.

Unfortunately I underuse the TYPE hierarchy, I used it more when I was coding in Turbo Pascal because I was setting up a type record for the Assembly registers and this was then used by the INTR command. I've used Type more recently to setup a String like Array, my compiler doesn't support Strings as such, so I need to define an Array of type Char, though I need to ensure the Size remains constant (one of the irritating things about my compiler). Turbo Pascal had some flexibility when it came to Strings, as long as they weren’t longer than what was defined, though since I moved to a different Compiler, a size defined needs to match what was defined, even if it’s smaller, which I think is something people have criticised about when it came to it. Though I’d presume a modern Pascal compiler has worked out those problems and even allow Variable Sized Arrays.

2. Pascal has limited but very fast set type. I can write

S*[Robert,John]

and get the intersection or

if (i in [1,3,7]) or (i > 9) then ...

Where else can I find such convenient syntax?

I’m confused, your saying Pascal has a limited SET type, but then go on to say where else can i find such convenient syntax? I’m not sure if C has an equivalent, in BASIC it’s equivalent would be to have a variable with a designated value and then

on <Var> gosub line1,line2,line3

the BASIC dialect I know uses Line Numbers, if certain values weren’t used, I think the no line numbers are used so line1 might represent 1 followed by a gap and then line2 to represent 3. My BASIC also has ON <var> GOTO, but I just think that’s asking for trouble (spaghetti programming).

3. How to define variable which value should be limited to the fixed range without subrange types? Pascal provides them, I can plainly write

var i: 2..5;

.

I fairly sure my Pascal doesn’t support that, but it allows a defined TYPE have a value assigned to it, so

TYPE i = 2..5;

is valid, and then I can say

var num : i;

, which will allow numbers between 2 & 5.

4. Pascal has true enumeration types. it is possible to use the abstract type

(Mo, Tu, We, Th, Fri, Sa, Su)

C++ uses hidden integer type for this. The languages like Ruby use lists for this…

No argument here. :D

5. The Pascal's record may have variant part - this is more convenient than to use union in C. A lot of good languages missed the idea of the record variant part or the union completely.
Pascal was the first popular PL with the OOP support. Turbo Pascal 5.5 appeared earlier than the polished C++ distributions. It is the mystery for me why Borland Pascal was so easy moved away by Java which was not so mature as today?

When I used to use Turbo Pascal 3 for CP/M-86 around 2000, most people were using Turbo Pascal 7 on the Forum I was on, but at some point people moved away from that, it might of happened after other Pascal languages were showing up with the likes of Free Pascal, there was also another Pascal compiler which was also Free. Though Free Pascal had offered what Turbo Pascal could do, but be a 32-bit Compiler & allowed development for a number of 32-bit Operating Systems or even DOS in 32-bit mode. I don’t think Turbo Pascal or Borland made a 32-bit Compiler with their Pascal programs, which might of explained why people moved to the likes of 32-bit based Languages. It’s just a thought though.

 

[krebizfan]

When I used to use Turbo Pascal 3 for CP/M-86 around 2000, most people were using Turbo Pascal 7 on the Forum I was on, but at some point people moved away from that, it might of happened after other Pascal languages were showing up with the likes of Free Pascal, there was also another Pascal compiler which was also Free. Though Free Pascal had offered what Turbo Pascal could do, but be a 32-bit Compiler & allowed development for a number of 32-bit Operating Systems or even DOS in 32-bit mode. I don’t think Turbo Pascal or Borland made a 32-bit Compiler with their Pascal programs, which might of explained why people moved to the likes of 32-bit based Languages. It’s just a thought though.

Borland Pascal 7 and Turbo Pascal 7 had 32-bit extensions. Delphi is a modified and extended Turbo Pascal which went 32-bit and even 64-bit. Made by Borland and had early success.

Pascal's problem has been the change in academia switching over to Unix and therefore C (and variants thereof). The sizable pool of Pascal programmers available in the early 80s thanks to UCSD Pascal dominating computer science departments have mostly retired. Cheaper to buy the language programmers know instead of retraining them to a different language.

 

[CP/M User]

Borland Pascal 7 and Turbo Pascal 7 had 32-bit extensions.

Ok, I didn't know that, or had forgotten.

Delphi is a modified and extended Turbo Pascal which went 32-bit and even 64-bit. Made by Borland and had early success.

Knew that since I did some programming with that in Windows 95 back in '96.

Pascal's problem has been the change in academia switching over to Unix and therefore C (and variants thereof). The sizable pool of Pascal programmers available in the early 80s thanks to UCSD Pascal dominating computer science departments have mostly retired. Cheaper to buy the language programmers know instead of retraining them to a different language.

Would explain where a good deal of Pascal people have gone, though I suppose a few of them would have moved to C/C++ ?

 

[krebizfan]

There are still enough Pascal programmers to keep Embarcedo offering Delphi upgrades. https://www.embarcadero.com/products/delphi
Parts of Delphi descended from the UCSD/Blue Label/Turbo line with the addition of object oriented elements from Whitewater's Actor (similar to Smalltalk with Pascal inspired pieces). Borland licensed Actor's object library as the basis for Object Windows Library and also acquired a number of Whitewater staff who assisted in the Delphi development.

Scott Moore has been working on getting a Pascal compiler that implements the ISO standard instead of the UCSD/Borland language. http://moorecad.com/ippas/index.html Scott Moore also has a lot of other pages discussing the Pascal standard. The issues of the newsletter from the Pascal User's Group are stored on one of his websites and are a great source for the early history of Pascal.

Some of the other Pascal companies also worked on Modula-2. Stony Brook software phased out their Pascal compiler but kept the Modula-2 compiler running for a long time which after ownership changes is now free. http://www.modula2.org/adwm2/

Of course, there was also Wirth's team and their Pascal variant of the month club what with Modula and Oberon and all those other languages.

The primary reason UCSD Pascal faded was UCSD could not handle the volume of sales so they handed the product line to Sof-tech, a defense contractor that decided to charge defense contractor prices while letting the language languish. That included no work on Unix versions as cheap Unix systems started popping up all over campuses. Later owners Pecan and then Cabot returned to more reasonable prices and did some development but it was a bit too late.