Pascal dying out?
Galvin Paul
Hello,
This my first message, so please be nice to me....
I am at Lafayette College as a sophomore and there is a certain
element that seems to think that Pascal is dying out. They say that
in 20 years, it will be long gone.
Is there any basis for this? I hardly see anyone who is in the
business of writing programs or such and I would not be able to
determine the truth of this.
Thanx --Paul J. Galvin
Sean Brunnock
>
> I am at Lafayette College as a sophomore and there is a certain
> element that seems to think that Pascal is dying out. They say that
> in 20 years, it will be long gone.
I don't believe that Pascal is used much by serious programmers
developers anymore, thank/blame C for that.
But Pascal is still perfect for its originally intended purpose:
teaching the elements of computer programming to students. It is
still my language of choice for school assignments or professional
programming.
Sean Brunnock
Richard Marks
>there is a certain element that seems to think that Pascal is dying out.
>They say that in 20 years, it will be long gone.
>
>Is there any basis for this? I hardly see anyone who is in the
>business of writing programs or such and I would not be able to
>determine the truth of this.
Boy will this start a discussion. I want to put in my 2 cents. Before
I turn flames on let me say that I Pascal is my language of preference and
I do a lot of coding in it.
Note however that there is a factor of ten more messages in the "c" newsgroup
as compared to the "pascal" group. But when I look at the "c" group I keep
laughing at the semantic and syntactic bullshit the questions are about.
Most of the crap they ask about is covered transparently in pascal. Honestly
who wants to get involved in if a declaration should be func (**int(*char)) or
not?
But face it guys, pascal is really not portable. How many lines of Turbo P do
we have that will never get to Unix. I think pascal was really little used,
except in college courses, until Borland gave us TurboP. Now that we also have
Turbo C and since "c" will run on almost any box, "c" will swamp pascal.
Now what will happen if Borland gives us pascal on Unix ??
Richard Marks
rma...@KSP.unisys.COM
Denny Kolb - Professor of Existential Metaphysics
>
>element that seems to think that Pascal is dying out. They say that
>in 20 years, it will be long gone.
>
>Is there any basis for this?
I don't really see anything that would justify that kind of pessimism.
I have been hearing for at least 10 years now, that FORTRAN is destined for
the 'scrap heap of computerdom', but at last report, it is comming along quite
well.
Granted, as a 'real world', production language, Pascal leaves much to be
desired. However, Pascal was never intended for an environment such as that.
Pascal is first and formost, a teaching language, and as such it has no equal.
(Would you REALLY want to learn 'C' as a First Language???)
I am currently teaching the Intro Pascal course here at CSU, and as a
first language Pascal does remarkably well. Pascal enables the student to learn
the various laguage constructs, such as Looping, Selection, Arrays, Data
Abstraction, etc. Without having to learn all of the extraneous garbage that
generally go along with them in a more conventional language.
>I hardly see anyone who is in the
>business of writing programs or such and I would not be able to
>determine the truth of this.
I am a little confused as to what you mean by 'in the business', but I assume
that you are refering to the more 'real world' sorts of programming here.
If this is true, then in this area, I think Pascal is already gone. I doubt
that many, if any, companies involved in large programming projects are actively
using Pascal in their Day-to-Day programming activities. There are several
reasons for this, but primarily, Pascal lacks most of the file handling
capabilities that are essential for any kind of realistic software package.
There is a language called Modula-II which was also written by N. Wirth, that
does have these file-handling routines, and other such stuff. I have never
written in M-II, but people who have tell me that it has a syntax that is
very similar to Pascal. Modula-II still tends to be somewhat obscure, so I
have no idea if it has an industial following or not.
Well, I've rambled on for long enough. Hope this clears up your confusion.
Regards,
Denny
Garrett Mcauliffe
>The Borland manuals were better (thinner, but still thick paperbacks, 5 volumes
>taking about 6 or 7 inches of shelf space.)
Except, their new manual for Turbo Assembler--the example programs they
list are filled with little bugs. It would make learning assembler for
the novice a REAL nuisance. I wish Borland got on the ball with this!!!
>But what I want to know is, what's this about Turbo Technix being cancelled?
>I subscribe, and I didn't see any mention in the latest issue (the latest
>issue I have is the one describing the directory search engine in TP5 and
>announcing the new languages). That would be a truly sad thing if true, for
....
Yes, it's true. I've heard Borland's been cutting back on its staff, and
the staff of Turbo Technix was one of their cuts... Very unfortunate, for
I haven't seen such a quality magazine out in years (and never one for the
IBM programming languages). I called Borland, and they confirmed that they
no longer publish the magazine. I think everyone should write them and
try to get them to put it back together....
Garrett
Eliot Lear
Pascal to LISP for their introductory CS courses. I don't know if
this typifies other universities.
--
Eliot Lear
[le...@net.bio.net]
Usenet file owner
(rma...@ksp.unisys.com) writes:
>In article <2...@lafcol.UUCP> gal...@lafcol.UUCP (Galvin Paul ) writes:
>>there is a certain element that seems to think that Pascal is dying out.
>>They say that in 20 years, it will be long gone.
>
>
>But face it guys, pascal is really not portable. How many lines of
>Turbo P do we have that will never get to Unix. I think pascal was
>really little used, except in college courses, until Borland gave us
>TurboP. Now that we also have Turbo C and since "c" will run on
>almost any box, "c" will swamp pascal.
I think there's a point here which should be clarified. C, as a
*language*, is relatively portable; i.e., if you avoid things like
assuming ints and pointers are the same size, your program will
probably compile correctly on another machine.
However, no real program is useful without making lots of operating
system calls. C and UNIX are pretty much inseparable, because they're
both have totally obscure syntax and weird semantics (:-). However,
the semantics of UNIX system calls differ enough from machine to
machine (and even OS release to OS release) that it's unlikely you can
write a reasonable C application with a nice user interface without
using non-standard features (thus rendering it non-portable).
You might as well use Pascal with non-standard features (VAX Pascal
is excellent, and UCSD isn't too bad--I haven't used Turbo much, but
some of my friends like it).
A good article on this is in IEEE CompCon '86, called "The
Portability of UNIX Application Programs And Other Modern Folk Tales."
It isn't even UNIX-bashing! (Not that there's anything wrong with
that!)
Just my thoughts....
+----------------------------------+------------------------+
| Anton Rang (grad student) | "UNIX: Just Say No!" |
| Michigan State University | ra...@cpswh.cps.msu.edu |
+----------------------------------+------------------------+
Thomas Cervera
such garbage source codes. Pascal is too restrictive. In my opinion, this is
a great feature of Pascal, but how to tell this a UNIX/C programmer ?
So, because UNIX will spread out over the world like a cancerous tumor, even
MODULA II (much better than Pascal) won't have a chance ...
--
alderaan
OP RKOpdp (RSTS/E)
FB Mathematik/Informatik
RKO Berlin
Dieffenbachstrasze 60-61
1000 Berlin 61
UNIX -- just say NO ! (remke)
Tom Gilstrap
in Pascal vs. C or ??. As far as "real world" uses, Hewlett Packard's
MPE XL operating system is written in Pascal. I guess if Pascal dies in
20 years, I'll have plenty to do resurecting all of my "dead" code.
[ job security ;-) ]
A. R. Thompson
>I do note that my own alma mater has been considering switching from
>Pascal to LISP for their introductory CS courses. I don't know if
>this typifies other universities.
>--
Here at the College of Engineering we teach Pascal as the student's
introduction to computation on the grounds that it provides a better basis
for understanding the solution of problems than do languages that have too
many machine dependencies and other vagaries.
I have advocated (so far unsuccessfully) that our students should learn
LISP as the second course in computing. Now we follow the introductory
Pascal with a semester of numerical analysis using Pascal. This is
important knowlege for engineers, I admit, but my rationale for following
up Pascal with LISP is that the students will immediately learn a method
of programming that is based on a different paradigm (functional vs Von
Neumann). I relly think that the beginning students will benefit
enormaously from this different view.
James Mork
--
UUCP Bitnet Internet
uunet!ndsuvax!numork numork@ndsuvax num...@plains.nodak.edu
Thomas Cervera
>
> [...] I doubt
> that many, if any, companies involved in large programming projects are actively
> using Pascal in their Day-to-Day programming activities. There are several
> reasons for this, but primarily, Pascal lacks most of the file handling
> capabilities that are essential for any kind of realistic software package.
But for what do you use external procedure libraries ? Powerful File handling
is nearly not existant in Pascal, but this is not the reason why nobody uses
this language. Hand on heart, would change to C for such a reason ? For my
person, I extended an RT11/OMSI-Pascal with such procedures as lookup, copy,
delete, seek, .. So, Pascal now is quite useable, also for data base projects
(as we're currently working on).
On Technical University Berlin, they use Pascal to teach timesharing program-
ming.
>
> There is a language called Modula-II which was also written by N. Wirth, that
> does have these file-handling routines, and other such stuff. I have never
> written in M-II, but people who have tell me that it has a syntax that is
> very similar to Pascal. Modula-II still tends to be somewhat obscure, so I
> have no idea if it has an industial following or not.
>
MII is much more than a new version of Pascal. Especially the modularity
of this language (where the name comes from), helps you to just enjoy this
language. BTW, it is even better for big projects (industrial programming).
Thomas Cervera
> I do note that my own alma mater has been considering switching from
Yes, and then, (here in Berlin), they changed to MODULA II. So, you should
read books about MII before it's too late :-)
Carl Ellison
> Yes, I think pascal will die out, because unlike in C, you cannot produce
> such garbage source codes. Pascal is too restrictive. In my opinion, this is
> a great feature of Pascal, but how to tell this a UNIX/C programmer ?
I agree that this is a great feature -- and not just for novice programmers.
When my code gets big enough (eg., 30000 lines or more), I need to be
protected from myself.
I'm careful -- but as the professor in my first system programming class
pointed out: the first 20 minutes of coding on a new project are creation;
everything after that is modification -- so design your code to be easy to
modify!
Unfortunately, it's not just UNIX/C programmers who are afraid of being
accused of being sub-human if they use a language which does anything to
try to keep them out of trouble. I've heard it from many sources --
including a system programmer who codes in PL/I (of all things).
As far as I can tell, this is a psychological problem -- akin to the need
to be macho -- and probably unsolvable. :-(
--Carl Ellison ...!harvard!anvil!es!cme (normal mail address)
...!ulowell!cloud9!cme (usenet news reading)
Roger Pick
>
> Hello,
>
> This my first message, so please be nice to me....
>
> I am at Lafayette College as a sophomore and there is a certain
> element that seems to think that Pascal is dying out. They say that
> in 20 years, it will be long gone.
>
The faculty of the Information Systems Group at the University of
Cincinnati are switching from Pascal to Modula 2 in our first
programming course for majors. In more advanced courses, we are
phasing out programming using von Neumann languages altogether in
favor of more modern tools: 4GLs like Focus or Nomad, application
generators, report generators, and techniques for evaluation of
software for purchase.
As to the non-academic world, the employers who hire our students
*never* used Pascal. They use COBOL, PL/1, or C, but they are
writing fewer and fewer programs.
--
Roger Alan Pick - QA & Information Systems Department, University of Cincinnati
UUCP: {decuac,psuvax1!gatech!mit-eddie,philabs!phri,pyramid}!uccba!ucqais!rpick
ARPA or BITNET: rpick%ucq...@uccba.uc.edu PHONE: (513) 556-7158
POST: QAIS - Lindner Hall, Univ. Cincinnati, Cincinnati, Ohio 45221-0130 USA
David Collett ext 1648
I sent in my registration card over a year ago. Since then, I received
one issue of Technix magazine. ONE! It was the issue about how to
use the mouse in Pascal. It was a 2-part article. Of course, I never
received the second part!
Would ANYONE be willing to send me a copy of that article? It was the
one about using the mouse in hi-res. I will happily reimburse you for
mailing and Xerox fees. Thank you very much!
David S. Collett
6830 S.W. 192nd Avenue
Beaverton, OR. 97007
Daniel F. Conway
I haven't seen such a quality magazine out in years (and never one for the
IBM programming languages). I called Borland, and they confirmed that they
no longer publish the magazine. I think everyone should write them and
try to get them to put it back together....
I'll second the motion.
Does Phillipe Kahn read notes?
Dan Conway
Hewlett-Packard
Palo Alto, CA
dan_c...@hplabs.hp.com
tr...@peora.uucp
At the University of Central Florida, introduction courses (Programming I,II)
are taught using Modula-2 for more than a year now.
Dennis Cohen
>
> I am at Lafayette College as a sophomore and there is a certain
> element that seems to think that Pascal is dying out. They say that
> in 20 years, it will be long gone.
Others have replied to the effect that this might be the case in the "real"
world; however, I have seen enough evidence to the contrary to doubt their
accuracy. The following are among "best-selling" software packages written
in Pascal:
4th Dimension
dBASE Mac
FullWrite Professional
MacDraw
MacDraw II
MacPaint
MacProject
MacinTax
MacMoney
FileMaker II
NutShell
Turbo Pascal
HyperCard
ReflexPlus
There are a lot of others, but those are the ones that come quickly to mind.
The thing that you will note about most/all of them is that they are written
with "industrial-strength" (significantly extended) dialects of Pascal. This
is particularly true of the Macintosh products. Sales reports indicate that
in the Macintosh market, C and Pascal are essentially tied in popularity and
sales.
Dennis Cohen
Claris Corp.
------------
Disclaimer: Any opinions expressed above are _MINE_!
Sean Brunnock
> The following are among "best-selling" software packages written
> in Pascal:
> Turbo Pascal
I know that the libraries Borland writes for Turbo Pascal are
written in Pascal, but Borland is proud to point out that the
compiler itself is written purely in assembly (both Z80 and 8086).
Sean Brunnock
A. R. Thompson
>In article <2...@lafcol.UUCP> gal...@lafcol.UUCP (Galvin Paul ) writes:
>>
>>.....there is a certain
>>element that seems to think that Pascal is dying out. They say that
>>in 20 years, it will be long gone.
>>
>>Is there any basis for this?
>
> I don't really see anything that would justify that kind of pessimism.
>
> I have been hearing for at least 10 years now, that FORTRAN is destined for
>the 'scrap heap of computerdom', but at last report, it is comming along quite
>well.
>
> Granted, as a 'real world', production language, Pascal leaves much to be
>desired. However, Pascal was never intended for an environment such as that.
>Pascal is first and formost, a teaching language, and as such it has no equal.
>(Would you REALLY want to learn 'C' as a First Language???)
The newly proposed Pascal standard fixes up a lot of the problems
associated with "production" programming. The major extensions are:
Separate compilation (modules), functions that return structured results,
direct access files, schemata (replacing the troublesome cantankerous
[conformant] array extension of the British Standard and dynamic strings.
There are also a number of minor extensions, e.g. "otherwise" clause in
case statement, built in imaginary type and more. With the new extended
Pascal it should be far more suitable for industrial strength work.
Pascal is alive and quite healthy in Europe.
The major problem with Pascal, at least as I see it, is the lack of
publicity of the standards work. I believe that if more public attention
were drawn to the new version we would be seeing a resurgence of interest
in what is really a very fine language, far superior to C in my humble
opinion (at least once the "teaching only" drawbacks are eliminated). Can
somebody on the Pascal committee please bring us up to date on the status
of things (Yoo hoo, Bob Dietrich are you listening?)
>
> I am currently teaching the Intro Pascal course here at CSU, and as a
>first language Pascal does remarkably well. Pascal enables the student to learn
>the various laguage constructs, such as Looping, Selection, Arrays, Data
>Abstraction, etc. Without having to learn all of the extraneous garbage that
>generally go along with them in a more conventional language.
Here in the College of Engineering at BU we do the same thing and are
quite happy with the results.
>
>>I hardly see anyone who is in the
>>business of writing programs or such and I would not be able to
>>determine the truth of this.
>
> I am a little confused as to what you mean by 'in the business', but I assume
>that you are refering to the more 'real world' sorts of programming here.
>
> If this is true, then in this area, I think Pascal is already gone. I doubt
>that many, if any, companies involved in large programming projects are actively
>using Pascal in their Day-to-Day programming activities. There are several
>reasons for this, but primarily, Pascal lacks most of the file handling
>capabilities that are essential for any kind of realistic software package.
It's quite widely used in Europe. But the limitations of "pure" Pascal
are well known and are inhibitory in the context of "real" programming,
not just file handling e.g. no real time support, no separate compilation,
static arrays etc. With luck the new standard will have eliminated these
objections and will lead to a wider use of the language.
>
> There is a language called Modula-II which was also written by N. Wirth, that
>does have these file-handling routines, and other such stuff. I have never
>written in M-II, but people who have tell me that it has a syntax that is
>very similar to Pascal. Modula-II still tends to be somewhat obscure, so I
>have no idea if it has an industial following or not.
Modula-II has some drawbacks. I haven't looked at it for a while, so what
follows is a bit shaky. MII defines a "word", a sixteen bit pattern of
bits. This is unfortunate since in a very real sense it welds a bias
toward sixteen bit architectures into the language. It allows structural
compatibility of types, which we all "know" is immoral. The biggest sin
MII commits is, however, its definition of "modules" inside of procedures.
This is unfortunate since it makes modules subject to the dynamic comings
and goings of procedures. That is, given the definition of the lifetime
of a procedure, a module exists while its defining procedure is active and
ceases to exist when that procedure is exited. If you view a module (as
most do) as a fixed component, analogous to a transistor, this makes no
sense. The transistor is always there even if it's not being used, it
doesn't come into existence when needed and then disappear. So modules
should always exist, even if they are only used inside of one or more
procedures. A better way is to define modules that define procedures as
their components instead of the other way around. This allows the
language to define "abstract data types", a collection of values (types)
and the operations valid over those values. An example would be a module
that defines a type "stack", (a linear data structure with insertions and
deletions allowed only at one end), the operations "push" and "pop" and
the boolean variables "full" and "empty" plus whatever other housekeeping
is deemed necessary.
The interested readers are referred to DeRemer and Kron's classic paper
"Programming in the Large Versus Programming in the Small" 1976 IEEE
Transactions on Software Engineering (exact vol, pages etc not at hand,
sorry) for a thorough discussion of the differences between static and
dynamic objects in programs and the need for different languages to
express these very different concepts. It turns out that it is possible
to define a static structure definition language that (when coupled with
Pascal as the language for programming in the small) allows Pascal to be
used as an object oriented language. Neat huh?
Dave Seaman
>Modula-II has some drawbacks. I haven't looked at it for a while, so what
>follows is a bit shaky. MII defines a "word", a sixteen bit pattern of
>bits.
>This is unfortunate since in a very real sense it welds a bias
>toward sixteen bit architectures into the language.
I have crossposted to comp.lang.modula2 and redirected the followups to that
group.
First of all, MII does not define a "word". I believe the system module
may define a word, but its size is implementation-defined. There is
nothing in the MII language itself that is "biased" toward 16-bit
architectures.
>The biggest sin
>MII commits is, however, its definition of "modules" inside of procedures.
>This is unfortunate since it makes modules subject to the dynamic comings
>and goings of procedures.
[long tirade deleted]
Only if you choose to do it that way. You can have modules inside
procedures, or you can have procedures inside modules. You can even have
both at once, if it pleases you.
Actually, I believe the concept of "local modules" is being removed or
already has been removed, though it was present in the last implementation
of MII that I actually used. It seems that few people were making use of
local modules. If all modules are required to be separate compilation
units, then it is no longer possible to have modules inside procedures.
Does that make you happy?
--
Dave Seaman
a...@j.cc.purdue.edu
jo...@wsl.dec.com
A. R. Thompson has a few misconceptions about Modula-2. The language certainly
has some problems, but none that he describes.
First, the type WORD is imported from a machine-dependent module SYSTEM. Using
WORD is therefore not portable to all other implementations, but is the right
thing for the machine at hand. In particular, on a VAX the type WORD is 32
bits long.
I have been convinced that structural compatibility of types is not bad in all
cases, particularly if you are dealing with data structures residing on remote
machines. In this case it is hard to maintain name compatibility. But in any
case, Modula-2 uses name compatibility.
Modula-2 allows the declaration of modules inside of procedures, but hardly
anyone uses them this way. Most modules are declared as compilation units, and
data declared in these modules exists for the life of the module. In most
systems, this is synonymous with the life of the program, but in systems that
support dynamic loading the module data may live longer.
Modula-2 modules allow the definition of ``abstract data types'' in the original
sense of the word. It does not support subtyping or object-oriented programming
directly, though many have kludged around this by embedding procedure fields
inside of records. You do give up type-safety if you want to subclass using
this technique.
Modula-2 is a much nicer language than Pascal, with none of the problems
attributed to it by A. R. Thompsen. I can't speak for the extended Pascal
proposal.
- Joel McCormack
Graham Wills
>
> I don't believe that Pascal is used much by serious programmers
>developers anymore, thank/blame C for that.
You are wrong. Pascal is still very much used by serious programmers.
I am a Postgrad at Trinity College Dublin, Ireland, and a lot of my research
is associated with programming. I use the Macintosh family of computers,
especially the Mac II ( and if you are talking about *serious* PCs, then the
Mac II beats most others hollow - especially for easy, speedy graphics, which
is essential for my area of research; Spatial population motion analysis )
I have written a time series package which works with graphic representations,
which uses binary and text data files, can import/export to Excel, multi-
windows, etc., etc. . I have also written simulations, and have acces to a wide
variety of packages written in Pascal.
I have written a Kermit for an obscure Mini in a mixture of C and Fortran, demo
Forth applications, Object-oriented Pascal programs, and as a young and free
hacker, games in Basic, 6502 and Z80 machine code.
Whoops - reading back that reads like a job application letter. It's meant to
demonstrate that I do know what I'm talking about, which is :
1) Pascal is a nice language. It is (and I don't think anyone disagrees with
this) an ideal language to learn programming with.
2) It is not easy or quick to work with standard Pascal filing methods -
If you need to do serious work, get libraries. I use the standard Mac
routines, so I can load in records, windows, arrays as binary files with
two or three lines of code, and very quickly. This (and rigorous typing -
which is annoying) is its worst defect for the serious programmer.
3) C is a much more flexible language (hopefully this is indisputable).
This is both good and bad. It is good in that more compact, subtle code
is possible, and bad in that you can write overly subtle, unreadable code.
For a well-disciplined programmer this is no problem. For most of us, it is.
In summary, I use Pascal happily all the time, hate doing filing using it, but
prefer it because it is very readable, simple and keeps me on the rails as
regards readability, modifiability and structuredness. With C I tend to hack.
These are my personal opinions, and I just threw it in to show that serious
Pascal is alive and well.
All replies welcome. I wear asbestos suits while reading News
-------------------------------------------------------------------------------
"The secret is to bang the rocks together"
-------------------------------------------------------------------------------
James Vasil
> element that seems to think that Pascal is dying out. They say that
> in 20 years, it will be long gone.
>
> Is there any basis for this? I hardly see anyone who is in the
> business of writing programs or such and I would not be able to
> determine the truth of this.
>
> Thanx --Paul J. Galvin
20 years is an awfully long time in this business. My guess would
be that yes, that far in the future Pascal will no longer be used
too much. The same statement may be made for each of the other
programming languages currently in vogue (if this doesn't come
about then CS will have not progressed much beyond today's state
of the art, and I don't think that will be the case).
If you come out of school knowing Pascal, C, Ada (at least some),
and Lisp (at least some) you should be employable and able to learn
new languages as they come into existance.
Regards,
James
/* As always, these opinions are mine, not my employer's. */
Bob Dietrich
going out of town in about 9 hours.]
I think the conclusions you've reached based on your limited sample are
wrong. I work for a company that sells Pascal, have regular contact with
many other Pascal vendors, and I think it's far from dying out in the near
term.
Certainly one factor that may have tinged the response to your question is
the forum you asked it in: usenet. The majority of machines on usenet are
running some flavor of Unix. With C being the implementation language of
Unix, and with Unix needing to be worked on constantly, there's certainly
going to be a much higher percentage of C devotees on usenet. Also, often
(note I'm not saying always!) these Unix machines are not in a department
doing product development work. Even though Unix is a popular bandwagon, it
does not come close to controlling a majority of the computers in the field.
Now that I've stirred up the hornets's nest (he he), on to other points. I
think if you simply take a look at the languages offered by vendors that are
in the business of selling languages or computer systems, you'll see that
Pascal is almost always listed. Unless it's trying to be a tax write-off, a
company simply cannot afford to support a language unless there's demand for
it. And frankly, educational institutions don't have enough clout with
industry to force a manufacturer to support a language solely for teaching.
Successful languages, like many things, go through a life-cycle. At
first, there's just a small band of missionaries spreading the word.
Then, if the word has any merit, it catches on. Articles and books are
written, further spreading the enthusiasm. The word becomes widely
discussed, and some people even go so far as to actually use the
language. The language becomes more commonplace, a better vehicle of
communication, and it enters its workhorse phase. Since the word is now
common knowledge, there's no sense writing about it so much anymore, so
editors and publishers jump on the next bandwagon that rolls along. The
workhorse continues to plod along, creating excitement only if it's not
there to do its job. It gets replaced only when there's a workhorse that's so
much better that it's economical to forget how much you invested in the older
workhorse. Pascal is in the workhorse stage, and there hasn't been a suitable
replacement come by yet. [Yeah, I know I switched metaphors in midstream; so
what.]
In the relatively short time people have been seriously using programming
languages, only a handful have made it to workhorse status: COBOL, FORTRAN,
ALGOL, BASIC, Pascal, LISP, and C. Others faded before they got there, and
ALGOL and BASIC have pretty much reached the end of their useful life. The
others that have survived have gradually changed over the years, and Pascal
is about to undergo such a change with Extended Pascal. Extended Pascal
should offer enough of what users want (modularity, strings, random I/O,
flexible arrays, standardization, etc.) that it should renew interest in
the language. All this without screwing up sets like Modula-2 did. If it
doesn't renew interest, it will be around until something better comes
along. Which will be a while.
Enough. I have to go pack.
usenet: uunet!littlei!ihf1!bobd Bob Dietrich
or tektronix!ogcvax!omepd!ihf1!bobd Intel Corp., Hillsboro, Oregon
or tektronix!psu-cs!omepd!ihf1!bobd (503) 696-2092
Jeff Dalton
>to define a static structure definition language that (when coupled with
>Pascal as the language for programming in the small) allows Pascal to be
>used as an object oriented language. Neat huh?
Neat indeed. Can you tell me more about this? ML modules do something
similar, but I don't think the object part (a "functor" returns a module
that can be considered an object) works too well as objects, though it's
not so bad for combining modules (well, ML calls them "structures" --
and a "module" is a functor or a structure).
Scott Bigham
>...and Pascal
>is about to undergo such a change with Extended Pascal. Extended Pascal
>should offer enough of what users want (modularity, strings, random I/O,
>flexible arrays, standardization, etc.) that it should renew interest in
So who's doing this? Is this one of those ANSI committees, like the X3Jn
committees we hear so much about in comp.lang.{c,fortran}? What is n for
Pascal? Is there anyone out there on that committee, or anyone who knows
what's happening? FILL US IN!
sbigham
--
Scott Bigham "The opinions expressed above represent
Internet sbi...@dukeac.ac.duke.edu me and everyone that agrees with me.
USENET sbi...@dukeac.UUCP If that includes Duke University,
...!mcnc!ecsgate!dukeac!sbigham I'll be amazed."
Johnny J. Chin
Personally, I don't think that PASCAL will die so soon. It'll probably last
for more than another two decades.
From my experience, many more intermediate and high schools are teaching
PASCAL because its a modularized lanaguage unlike BASIC with all of its GOTOs.
Most of the schools that I've seen teaching PASCAL chose it over MODULA because
its not as teadious and they both seem to have the same basic modular
structure. Many schools still teach a bit of BASIC before PASCAL though.
As for the business world ... (since I'm primarily in the MSDOS areana, what I
have to say only applies to this arena). In the past two years, with the
rapidly standardized TURBO PASCAL ... many programs written in PASCAL has
been cropping up on the market. Programs ranging from $10 to $800.
In conclusion. From the way things look, PASCAL is here to stay for quite
some time. Besides, they said that FORTRAN and COBOL is old and obsolete and
should be placed on a back shelf ... Well, obviously, they've now become the
"grand-daddies" of programming languages, but they haven't died yet; so why
should PASCAL die so quickly?
-- J. Chin (a.k.a. Computer Dr.)
4730 Centre Avenue, Apt. #412 ARPAnet: Johnny...@andrew.cmu.edu
Pittsburgh, Pennslyvania 15213 BITnet: jc...@andrew.BITNET
(412) 268-8936 UUCP: ...!harvard!andrew.cmu.edu!jc58
[Disclaimer: As always, everything above is my own opinion and not of
Carnegie Mellon University or of my employer.]
Johnny J. Chin
James Mork
Headline: Pascal died today... Lisp, Ada, Smalltalk, Prolog, and C
attended the funeral. To the embarassment of the DOD, it was noted,
that ADA seemed to be coughing quite a bit... and it's so young too...
(sorry for the humor in this tech group)
Clay Phipps
-- -- Paul J. Galvin wrote:
-- -- ... [Some people] think that Pascal is dying out.
-- -- They say that in 20 years, it will be long gone. ...
--
-- 20 years is an awfully long time in this business.
A look back 20 years, to 1968, may provide some guidance for the next 20.
[mentions of "earlier" or "later" are relative to 1968].
Try to imagine what you would predict from what was known then.
At the time (1968), I was a senior in high school (others on the net
are undoubted older than this indicates me to be), and would not take
my first programming course until 6 months later (1969), during which
I was introduced to BASIC, and later, to FORTRAN.
15 years earlier (December 1953 or January 1954), IBM had approved
a project to provide "automatic programming" (i.e., a compiler)
for its 704 computer, which, after 3 more years (1957), culminated in
the distribution of the FORTRAN I compiler.
Only in the 60s did it become widespread; "USA Standard FORTRAN"
had been formally approved 2 years earlier (1966).
Implementation of LISP had begun, 10 years previously (1958),
by the Artificial Intelligence Project at MIT.
The first BASIC program had been run on a time-sharing system,
a GE-225, 4 years earlier (1964) at Dartmouth, and was becoming
particularly popular on the GE time-sharing system.
Some guy at Stanford named Niklaus Wirth published a paper that year
(1968) in JACM about PL360, a medium-level language that had many
of the goals and features that would be attributed in the future to C
(strangely enough, PL360 is never cited as an influence on C;
admittedly, it is not a language in the style of C). Wirth had begun
the implementation of PL360 3 years earlier (1965) at Stanford.
2 years earlier (1966), also at Stanford, Wirth published papers
in CACM on 2 different programming languages: Euler (with Helmut Weber)
and Algol-W.
Development of Pascal was still 2 years in the future (1970).
The first APL User's Manual was released that year (1968).
The language was derived from a powerful array-oriented notation
devised by Ken Iverson at Harvard 10 years earlier (1958), and first
implemented, as an interpreter on the IBM 7090 3 years earlier (1965).
It was around this year (1968?) that a stand-alone multi-user time-sharing
APL system was available "under the table" from IBM. It was not widely
used, but its few users were almost religiously devoted to it
(of course, UN*X fans wouldn't understand such near fanaticism :-).
A major complaint or deterrent was its terse and cryptic notation.
A new language developed by IBM for its relatively new System/360 first
delivered 3 years ago (1965), grandly named "Programming Language/One",
hence, PL/I, had been available for a very few years (1966? 1967?).
In PL/I, you could do practically anything you could do in COBOL or
FORTRAN, plus a lot more -- but only when it worked -- it was still a
a relatively unstable compiler. Many people believed that PL/I would
eventually take over the world, by riding on IBM's coattails and
the success of its System/360, once it became a stable compiler (1970?).
Niklaus Wirth published a paper that year (1968) in JACM on PL360,
a medium-level language that had many of the goals and features of C
(strangely enough, PL360 is never cited as an influence on C;
admittedly, it is not a language in the style of C).
Wirth had begun the implementation 3 years earlier (1965) at Stanford.
Development of Pascal was still 2 years in the future (1970).
The sexy language in Academia was Algol 68, just designed;
a more solid Algol 68 definition, the "revised" one,
was 3 years in the future (1971).
The sexy systems in academia were the Burroughs B6500, not completed
until a year later (1969), and GE/MIT MULTICS (1968).
A big *mainframe* had one, or maybe two, megabytes of main memory.
To almost everybody, chips were made from potatoes. If you mentioned
a "micro", people assumed that you meant a microscope or a microphone.
Physics and engineering students used slide-rules; electronic 4-function
hand calculators were a year or two away (1970 or 1971) and would cost $400.
UN*X was 1 to 2 years in the future (1969..1970), but written in assembler.
It would be 5 years (1973, hence 3..4 more) before it was rewritten
in the future language C; Ken Thompson would not write C's predecessor[?],
B, for two years (1970).
A relatively final Ada specification was 12 years away.
Even the very early draft: "Strawman" would not appear for 7 years (1975).
-- If you come out of school knowing Pascal, C, Ada (at least some),
-- and Lisp (at least some) you should be employable
-- and able to learn new languages as they come into existance.
As the above indicates, Ada, C, Pascal, and UN*X did not exist
20 years ago. PL/I never took over the world, but COBOL and FORTRAN
are still going strong. Pascal will probably survive; whether it's
niche will be relatively larger than PL/I's is now, who knows ?
C will probably come to be regarded as the "FORTRAN of the 80s",
providing the vehicle for large amounts of useful programs,
many of them *clever*, that no one dares to change or enhance.
Unless you win some lottery, you may very well decide that
the jobs that do not require you to learn things that didn't exist
when you were in school are simply too boring to keep doing.
More rapid changes are coming, and we can't be certain what
the world, nation, or job-market will be like in 20 years.
Plan to be adaptable and keep learning. Over the short term,
try to find some computer-related (but non-gofer) jobs over the summer,
or part-time during the school session. They may make more of a
difference to a prospective employer that whether you can program
in Turbo Pascal 13.0. Develop some interests *outside of computers*
and related fields, so that you can carry on intelligent conversations
without mentioning them; I, for example, don't go scuba diving
or backpacking to hear about the relative merits of Pascal versus C.
Hmmm. A far longer monologue than I had intended;
I hope it provides some useful perspectives.
--
[The foregoing may or may not represent the position, if any, of my employer]
Clay Phipps {ingr,pyramid,sri-unix!hplabs}!garth!phipps
Bob Dietrich
>In article <3884@omepd> bobdi@omepd (Bob Dietrich) writes:
>>...and Pascal
>>is about to undergo such a change with Extended Pascal. Extended Pascal
>>should offer enough of what users want (modularity, strings, random I/O,
>>flexible arrays, standardization, etc.) that it should renew interest in
>>the language...
>
>So who's doing this? Is this one of those ANSI committees, like the X3Jn
>committees we hear so much about in comp.lang.{c,fortran}? What is n for
>Pascal? Is there anyone out there on that committee, or anyone who knows
>what's happening? FILL US IN!
Maybe you're new to the newsgroup, or maybe my postings haven't been making
it off my machine. In any event, I've tried to update the readers from time
to time as to what's going on. Yes, Extended Pascal is being worked on by a
(uniquely) joint committee of ANSI and IEEE. It is officially known as the
Joint ANSI X3J9/IEEE Pascal Committee, or JPC. There has been a lot of
cooperation with the British and ISO committees as well.
Although the American public comment period is officially over, below is an
extract of the announcement I posted. You can still obtain the document and
send in comments, although JPC will not be obliged to act upon them.
I hope to post a summary of where things stand in the standardization process
shortly.
Bob Dietrich
Intel Corporation, Hillsboro, Oregon
(503) 696-2092
usenet: uunet!littlei!ihf1!bobd
or tektronix!tessi!agora!ihf1!bobd
or tektronix!ogcvax!omepd!ihf1!bobd
or tektronix!psu-cs!omepd!ihf1!bobd
=====================================================
[Extracted from a previous posting]
Extended Pascal is an upward-compatible extension to the presently-existing
standards for Pascal. It has been developed in an international effort between
the American Joint X3/IEEE committee, the British Pascal committee,
International Working Group on Pascal, and the ISO/JTC1 Subcommittee 22. As
such, Extended Pascal is being put forth as an American, British, and
International standard. This standard is intended to coexist with the existing
Pascal standards until such time as these standards are no longer needed.
The major features in Extended Pascal that distinguish it from the classic
language defined by Jensen and Wirth are: modules with separable definition and
interface parts (including initialization and finalization of modules), a
generalized type definition mechanism (schemata) which permits the static and
dynamic selection from a "set of types", a secure method for initializing
variables of a given type (even if they are outside of the module where the
type is defined), and the ability to define private variables which have
restrictions placed on their access.
In addition, Extended Pascal contains many pragmatic features which make it a
more practical and usable language than "classic" Pascal. Some of these are:
string types of both dynamic and fixed length, short-circuit logic operators,
exponentiation, direct-access files, external file binding, complex numbers,
constant expressions, record and array value constructors, non-decimal integer
constants, time and date functions, and numerous other features.
Extended Pascal also includes many simple conveniences which have become
standard practice, such as an underscore character in identifiers, relaxed
order of declarations, and an otherwise clause in the case statement and
variant records.
This draft standard is available for public review and comment for a two-month
period ending October 11, 1988. Copies may be obtained from GLOBAL ENGINEERING
DOCUMENTS, INC.
Phone: 800-854-7179 (USA)
+1-714-261-1455 (International)
FAX: 714-261-7892
Address:
Global Engineering Documents, Inc.
2805 McGaw Ave.
Irving, CA 92714
USA
Note: Because the public comment period only lasts two months, it is advisable
that all requests be made by telephone so that you will have more time to
submit comments within the designated period for public comment.
Single Copy Price: $ 35.00 International Copy Price: $45.50
[U.S. dollars. I believe they take credit cards or will bill you. Be sure to
ask for "X3.160-198x", because last time they didn't know what you were
talking about if you said "Extended Pascal". Maybe they've improved.]
WAPJAS
I think it is more accurate to think of Pascal as be-calmed than
dying.
I believe the main obstacle facing Pascal is the lack of portability
between different implementations of Pascal. This is rather ironic as
the ISO and ANSI standards for Pascal were approved several years ago,
whereas C, a language that is considered to be very portable, has
not been standardized yet (though the draft ANSI C standard could be
approved fairly soon).
The main strengths of Pascal are it's strong typing and simplicity.
It's main weakness is that it lacks the functionality needed to write
"real" programs. Most Pascal implementors chose to increase functionality
by adding extensions to Standard Pascal to their compilers. Unfortunately
there is no consistency in what extensions are provided or how the
extensions are implemented between different Pascal compilers. Extensions
to Standard Pascal are only helpful to users who do not care about
portability.
The situation is further clouded by the existance of Turbo Pascal.
There are probably more copies of Turbo Pascal in use than any other
Pascal compiler. Unfortunately, Turbo Pascal does not conform to the
Pascal standard (it's close but no cigar!). This makes Turbo Pascal
a defacto Pascal standard.
Is there any way to get Pascal moving again? Yes there is. What we
have to do is
1) Get the draft ISO/ANSI Extended Pascal standard approved. Extended
Pascal provides much more functionality than the current Pascal
standard. New features include modules, varying length strings,
relaxed order of declarations, etc.
2) Users have to pressure the people who write and sell Pascal
compilers to make their products conform to the Extended Pascal
standard.
Is it worth it? If you believe as I do that Pascal's strong typing
and good error detection help you write correct programs quickly than the
answer should be yes.
Regards.. John Stewart <WAP...@CARLETON.BITNET>
Mike Burton
I am very new to this group, so please don't flame me too badly if
this has been asked before. I see this talk about extended PASCAL,
but it appears as though someone took PASCAL, added maybe 60% of the
features that can already be found in Ada, and proposed extended
PASCAL. If Ada has most of these features already, why bother
reviving PASCAL?
Anton Rang
> I see this talk about extended PASCAL,
>but it appears as though someone took PASCAL, added maybe 60% of the
>features that can already be found in Ada, and proposed extended
>PASCAL. If Ada has most of these features already, why bother
>reviving PASCAL?
For one thing, it's nearly impossible to put Ada on a micro. Things
like tasking, etc., just are *very* hard to do (I know of one
implementation on a 386 machine w/16MB of memory, but that's it).
Extended Pascal is an attempt to add useful features to Pascal
without making it too inefficient on small machines (or even big
machines, for that matter). At least, that's my understanding.
(Personally, the only useful Ada systems I've worked with cost
$50,000+ and need a VAX to run--I stick with Pascal for the rest!).
Just my thoughts....
Anton
+---------------------------+------------------------+----------------------+
| Anton Rang (grad student) | "UNIX: Just Say No!" | "Do worry...be SAD!" |
| Michigan State University | ra...@cpswh.cps.msu.edu | |
+---------------------------+------------------------+----------------------+
Richard Pattis
> like tasking, etc., just are *very* hard to do (I know of one
> implementation on a 386 machine w/16MB of memory, but that's it).
> Extended Pascal is an attempt to add useful features to Pascal
> without making it too inefficient on small machines (or even big
> machines, for that matter). At least, that's my understanding.
> (Personally, the only useful Ada systems I've worked with cost
> $50,000+ and need a VAX to run--I stick with Pascal for the rest!).
> Just my thoughts....
>
> Anton
>
Both Meridian and R&R sell validated Ada compilers that run on 640K PCs.
My performance on an 8 megaherz AT is approximately that of moderately
loaded VAX 8650 running DEC-Ada. The costs are still high, $500-$1,000 but
I believe this will come down (I can remember back when one Modula-2 compiler
existed (Logitech) and it cost about this much too; now a wide range of M-2
compilers exist for 1/10th the price). You can get a site-license for a much
cheaper cost/machine. If Ada compilers follow the same curve as M-2 compilers
I expect much cheaper ones in a few years. They will probably never compile
as fast as Pascal, but the hope is that with Ada you will not need to compile
as much code as many times.
We have begun teaching Ada in our introductory courses here a U. Washington
and things seem to be proceeding OK, if a bit slowly. But the more complex
the language, the slower it is learned (with a big payoff during the second
quarter). After all, it takes more time to learn Pascal than BASIC, but we
all think that it is worth it, when we must use the language to develop large
programs.
zif...@taurus.bitnet
>In article <96...@swan.ulowell.edu> sbru...@hawk.ulowell.edu (Sean Brunnock) wr
>>
>>developers anymore, thank/blame C for that.
>
>You are wrong. Pascal is still very much used by serious programmers.
>
>1) Pascal is a nice language. It is (and I don't think anyone disagrees with
> this) an ideal language to learn programming with.
>2) It is not easy or quick to work with standard Pascal filing methods -
> If you need to do serious work, get libraries. I use the standard Mac
> routines, so I can load in records, windows, arrays as binary files with
> two or three lines of code, and very quickly. This (and rigorous typing -
> which is annoying) is its worst defect for the serious programmer.
>3) C is a much more flexible language (hopefully this is indisputable).
> This is both good and bad. It is good in that more compact, subtle code
> is possible, and bad in that you can write overly subtle, unreadable code.
> For a well-disciplined programmer this is no problem. For most of us, it is.
>
>In summary, I use Pascal happily all the time, hate doing filing using it, but
>prefer it because it is very readable, simple and keeps me on the rails as
>regards readability, modifiability and structuredness. With C I tend to hack.
>
I agree with Graham. If you need to produce a large system, where many
programmers are working together, Pascal is a much better language to
accomplish such things as clarity, readability, maintainability, etc' then
many other languages. In addition, the strength of Pascal in producing
unlimited number of data structures, its use of pointers - restrictive
enough so to prevent you from making foolish mistakes, and the sets put it
as my primary choice for implementation language.
As most Pascal compilers extend the language by adding an "otherwise"
clause in a case statement, and some add string manipulation, it is fair
for most applications (file I/O can be handled, most of the times, by
system call routines).
I have worked in a private company, where a certain product was developed
in Pascal. I have no doubts that doing it in C would have lengthen the
development time.
Doron Zifrony - zif...@taurus.bitnet or
Msc student zif...@MATH.Tau.Ac.IL
Department of Computer Science
Tel Aviv University
Israel
Warren Harrison
> like tasking, etc., just are *very* hard to do (I know of one
> implementation on a 386 machine w/16MB of memory, but that's it).
> Extended Pascal is an attempt to add useful features to Pascal
> without making it too inefficient on small machines (or even big
> machines, for that matter). At least, that's my understanding.
> (Personally, the only useful Ada systems I've worked with cost
> $50,000+ and need a VAX to run--I stick with Pascal for the rest!).
> Just my thoughts....
>
> Anton
Based on literature I received from the AJPO, Janus Ada has become
validated which means it does all those things ... on a modest 286
to boot. I've not used the validated compiler yet, but their earlier
ones seem quite reasonable (for $100), and run fine on my At w/640K.
True, they're kind of slow, and only create .COM files, but wadda ya
want fer a hundred bucks? (actually, the validated on is closer to
$500 as I recall, and I think it will create .EXE files).
--
-------------------------------------------------------------------------------
Warren Harrison CSNET: war...@pdx.edu
Department of Computer Science UUCP: {ucbvax,decvax}!tektronix!psu-cs!warren
Portland State University Internet: warren%pdx...@relay.cs.net
Portland, OR 97207-0751
Bruce Carlson
>
>For one thing, it's nearly impossible to put Ada on a micro. Things
>like tasking, etc., just are *very* hard to do (I know of one
>implementation on a 386 machine w/16MB of memory, but that's it).
I don't know exactly what you mean by saying "it's nearly impossible
to put Ada on a micro", but in any case I think your statement is
misleading.
I have run the Meridian Ada Compiler (validated) on a PC AT and a PC XT,
with no problems in installation or compilation of code. The compiler
I had included a DOS function library and some other Meridian additions to
the basic compiler.
If you are used to Turbo Pascal most Ada compilers will seem archaic. The basic
Meridian compiler was $400 (with the govt/educational discount) and did not
include an editor or debugger. The DOS function library was $50 additional.
The compiler is much slower than Turbo Pascal and generates much larger code,
but it is not harder to install or use than any other command line type
compiler.
One important caveat in my experiences is that I was implementing some
relatively simple programs, the biggest being a symbol table generator
for Ada source code. For programs of this size, with only one
programmer working on the code, Ada is probably overkill. If you are
building very large programs in Ada you may want to have a high end
micro with enough power to give you reasonably short compile times.
Bruce Carlson
Disclaimer: I don't have any connection with Meridian Software, they
just happened to have the cheapest validated compiler I could find at
the time. My opinions do not necessarily reflect the opinions of my
employer.
E.C. Loyd
is not what I would choose to program in. However, I do most of my
programming in VAX Extended Pascal, and find that with the exception of
declaring external procedures/functions (and all that tedious header
information) that I have no problems with working in Pascal.
Now, those of you that say, "But what about the powerful C language?"...
well, I program in that when I want something to work, and don't care
who sees it. In other words, if I'm hacking together my latest random
number generator, I do it in C. If I'm doing a heavy duty data-base
manager with some file structures (internal or external files, it
doesn't matter) thrown in, then I do it in Pascal.
It depends on the application.