Pascal is the most famous--and arguably the most influential--of the Wirth Languages. Its initial implementation was completed in 1970, on a CDC 6000-series mainframe at ETH in Zurich, Switzerland, and soon reported by Niklaus Wirth (1971a).
The Pascal source code, and a later p-kit, were widely distributed. Wirth (1971b) wrote that his new language, named after the mathematician Blaise Pascal, 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 Language For Teaching in the 1980s (i.e., as a tool to introduce students to Imperative Programming).
Pascal was originally an Imperative Language in which the source code for an entire program was expected to be contained in a single file, to allow Static Typing (i.e.: Compile Time 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 Static Typing for avoiding run-time errors, programmers began increasingly to try to use Pascal for serious programming beyond what was supportable by a Language For Teaching. A Modular Programming 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 Ucsd Pascal unit was a very usable example of a modularity extension.
Later, several extensions for Object Oriented Programming were developed.
Turbo Pascal (the Object Oriented Programming features arrived in version 5.5).
Object Pascal (1985)
Free Pascal (Open Source support for the Turbo and Delphi object models)
Pascal has numerous descendants:
Concurrent Pascal: Caltech (1975)
Modula (Modula Language a.k.a. Modula One): another of the Wirth Languages (1975)
Euclid (1978)
Pascal* (Pascal Star): Stanford University (circa 1980)
Modula 2 (Modula Two): yet another of the Wirth Languages (1982)
Pascal Plus (1984)
Pascal also seemed to provide an almost spiritual heritage for other languages:
Ada (Ada Language)
Mesa (Mesa Language)
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:
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)
Alternatives To Cee Syntax - Borrows some ideas from Pascal.
You can find an out of date Pascal syntax description at
www.csci.csusb.edu 
This predates the last revision that added some object-oriented stuff.
One thing I loved about Pascal was sub-functions (sometimes called Nested Functions). See Long Function Heresy. 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?}
See original on c2.com