|
|
CSC 131
|
A programming language is a programmer's principal interface with the computer. As such, the choice of an appropriate language can make a large difference in a programmer's productivity. A major goal of this course is to present a comprehensive introduction to the principal features and overall design of both traditional and modern programming languages. As such you will be examining language features both in isolation and in the context of a more complete language description.
Programming languages are fundamental to program design, analysis, and implementation. Every student passing this course should be able to:
The Education Board of the ACM Special Interest Group in Programming Languages (SIGPLAN) recently released "Why Undergraduates Should Learn the Principles of Programming Languages" that explains the importance of the principles of programming languages for undergraduate CS education. That report is available at http://www.cs.pomona.edu/~kim/why.pdf. Please take a look.
We will examine features of a large variety of languages, though we will not study many of the languages themselves extensively. Like other CS courses, we will be discussing alternate ways of solving problems, looking at the pros and cons of different approaches. Because programming languages are so tied up with (and motivated by) programming problems, we will not only investigate language features, but also the software engineering problems that spawned them.
We will also investigate and practice writing interpreters and/or compilers for simple programming languages. This hands-on experience will provide a firm grounding in both the run-time characteristics of programming languages and the formal specification of programming language semantics. We will also see how the formal specification of different aspects of languages allows us to prove properties of the languages themselves, such as type safety, as well as reason properly about programs in the languages.
At the end of this course you should have a more thorough understanding of why certain programming language features provide more support for the production of reliable programs, while others are fraught with ambiguity or other problems. Since programming languages mediate between the programmer and the raw machine, we will also gain a deeper understanding of how programming languages are compiled, what actually happens when a program is executed on a computer, and how the programming language design affects these. As an example, by the end of the course, you should be able to understand why Java is generally considered a more reliable language than C or C++, while it will also generally execute slightly slower (at least on single processor machines). Similarly you will understand why Python must execute significantly slower than Java or C++.
In the last section of the course we will turn our atention to one of the biggest current problems in computer software: How to write concurrent and parallel programs. Our particular focus will be on languages that can support these kinds of programs. This is now a focus of considerable research, and we hope for a break-through in the near future, as we need to learn how to use the new multi-core (and soon many-core) computers effectively to create faster software.
This course will involve extensive reading on your part, both in the text and in outside sources. The segments of the course that introduce new programming language paradigms will also feature some relatively simple programming in newer languages supporting functional, object-oriented, and concurrent styles of programming, such as Haskell, Java, and Scala.