Pascal is the most famous--and arguably the most influential--of the WirthLanguages. Its initial implementation was completed in 1970, on a CDC 6000-series mainframe at ETH in Zurich, Switzerland, and soon reported by NiklausWirth (1971a).

The Pascal source code, and a later ''p-kit'', were widely distributed. Wirth (1971b) wrote that his new language, named after the mathematician BlaisePascal, was designed, in part, "[t]o gain more insight into the methods of organizing large programs and managing software projects." Just a few years later (1975), he had not gained much objectivity about its shortcomings. More than a decade later, Wirth (1982) insisted that Pascal was "designed as a general-purpose language", but it was widely used -- perhaps mostly used -- as a LanguageForTeaching in the 1980s (i.e., as a tool to introduce students to ImperativeProgramming).

Pascal was originally an ImperativeLanguage in which the source code for an entire program was expected to be contained in a single file, to allow StaticTyping (i.e.: CompileTime type-checking).  That was sometimes too restrictive, because in Pascal as originally designed, array ''dimensions'' are part of an array's ''type''. Thus, the language did not allow generalized array-handling or character-string-handling ''functions'' or ''procedures''. Pascal does allow explicit storage allocation, via the predefined ''new'' procedure, and later its reverse by the ''dispose'' procedure.

Because of the proven usefulness of StaticTyping for avoiding run-time errors, programmers began increasingly to try to use Pascal for serious programming beyond what was supportable by a LanguageForTeaching. A ModularProgramming construct was very high on the list of extensions made to Wirth's Pascal to make it practical for teams of programmers to develop software in Pascal. The UcsdPascal ''unit'' was a very usable example of a modularity extension.

Later, several extensions for ObjectOrientedProgramming were developed.
* TurboPascal (the ObjectOrientedProgramming features arrived in version 5.5).
* ObjectPascal (1985)
* DelphiLanguage
* FreePascal (OpenSource support for the Turbo and Delphi object models)

Pascal has numerous descendants:
* ConcurrentPascal: Caltech (1975)
* Modula (ModulaLanguage a.k.a. ModulaOne): another of the WirthLanguages (1975)
* Euclid (1978)
* Pascal* (PascalStar): Stanford University (circa 1980)
* Modula 2 (ModulaTwo): yet another of the WirthLanguages (1982)
* Pascal Plus (1984)

Pascal also seemed to provide an almost spiritual heritage for other languages:
* Ada (AdaLanguage)
* Mesa (MesaLanguage)

References:
* Wirth 1971a: "The programming language Pascal". ''Acta Informatica'', vol. 1, p. 35--63
* Wirth 1971b: "The design of a Pascal compiler". ''Software--Practice and Experience'', v. 1 num. 4 (Oct.--Dec. 1971), p. 309--333
* Wirth 1975: "An assessment of the programming language Pascal". ''IEEE Transactions on Software Engineering'', vol. SE-1, num. 2 (June 1975), p. 192--198
* Wirth 1982: ''Programming in Modula-2'', Springer-Verlag, p. 3

----
See also:
* PascalCase
* Kathleen Jensen and Wirth 1974: ''Pascal: User Manual and Report''. Springer-Verlag 1974; also revised in 1985 and 1991, appending ''ISO Pascal Standard'' to its title.
* Wirth 1996: "Recollections about the development of Pascal". In T.J. Bergin and R.G. Gibson (eds.): ''History of programming languages''. Addison-Wesley: Reading, MA (USA)
* AlternativesToCeeSyntax - Borrows some ideas from Pascal.

----
You can find an out of date Pascal syntax description at
http://www.csci.csusb.edu/dick/samples/pascal.syntax.html

This predates the last revision that added some object-oriented stuff.

----
One thing I loved about Pascal was sub-functions (sometimes called NestedFunctions). See LongFunctionHeresy. They simplified a lot of scope and function name collision issues.

----
One thing I love about Pascal is the order of declarations. It forces programmers to design before coding using a technique known as top-down design/bottom-up implementation.  Code developed using bottom-up techniques is much easier to verify for correctness because it supports "unit testing," which is not supported very well by top-down implementation methods.  Top-down coding requires one to perform "string testing" to verify correctness.   String testing is both more labor intensive and less reliable.

''This is the result of Pascal using a single-pass compiler.''

{I found that feature annoying. I like the "main" stuff at the top and the details at the bottom. Just about every other writing technique puts the details toward the bottom, why change that?}

----
CategoryProgrammingLanguage 
CategoryPascal