About COP 4020

This page provides general information about the Spring 2009 offering of COP 4020 at the University of Central Florida. The course's home page is http://www.eecs.ucf.edu/~leavens/COP4020/.

This page is organized as follows:

  1. Meetings
  2. Course Textbooks
  3. Computer Accounts
  4. Accommodations for Disabilities
  5. Course Description and Credit Hours
  6. Course Learning Objectives
  7. Course Learning Outcomes
  8. Prerequisites
  9. Acknowledgments

The course grading policy and syllabus (which includes the time of the final exam) are on separate web pages. Also on a separate page is our contact information.

I also maintain information about previous offerings of this course.

Meetings

Lecture attendance is required. The meeting time and location is as follows:

Lectures: Mondays, Wednesdays, and Fridays, at 11:30AM-12:20PM, in 103 Harris Center (Building 116).

Return to top

Course Textbooks

There is one required text for the course.

We will supplement the text with other material as described in the syllabus's bibliography.

Return to top

Computer Accounts

You should either use your own computer or have an account on the Olympus cluster to run software for this course.

See http://www.acs.ucf.edu/documents/handouts/Olympus_Info.pdf for information about the Olympus system. See http://www.acs.ucf.edu/computerlabs.html for the location of various computer labs where you can use Olympus.

Refer to the information discussed in class for Running Oz, which includes information about installation and running Oz on your own computer.

Return to top

Accommodations for Disabilities

We are happy to help with reasonable accommodations for disabilities. The procedure is outlined in the following statement (quoted from the faculty center for teaching and learning's web site):

"The University of Central Florida is committed to providing reasonable accommodations for all persons with disabilities. This syllabus is available in alternate formats upon request. Students with disabilities who need accommodations in this course must contact the professor at the beginning of the semester to discuss needed accommodations. No accommodations will be provided until the student has met with the professor to request accommodations. Students who need accommodations must be registered with Student Disability Services, Student Resource Center Room 132, phone (407) 823-2371, TTY/TDD only phone (407) 823-2116, before requesting accommodations from the professor."

Return to top

Course Description and Credit Hours

This 3 credit course is titled "Programming Languages I."

From the University of Central Florida Catalog: "PR: COP 3503C and COT 3960. Paradigms and fundamental concepts of programming languages are presented, including: scope, binding, abstraction, encapsulation, typing etc. Design paradigms object-oriented, functional and logic programming are presented."

Explanation

A programming language can be defined as a language capable of expressing everything computable. Examples include general purpose programming languages, such as AspectJ, Basic, C, C++, C#, COBOL, FORTAN, Java, Lisp, ML, Oz, Python, Ruby, Smalltalk as well as special purpose programming languages like the Unix Shell, JavaScript, Perl, PHP, and even Microsoft Excel's macro language.

A programming model, or paradigm, is a way of programming. It deals with ways of thinking about problems and how one organizes solutions.

Motivation for the Course Objectives

The currently most widely-used programming model is the object-oriented model, which is an extension of the explicit-state or procedural model. Since the 1950s when computing first became practical, the explicit-state model has been the most widely-used.

However, the functional and logic programming (or relational) programming models have been in use since the 1960s and the 1980s, respectively. Both build on the declarative computation model, which does not use assignment statements and mutation. (A computation model is a very small programming language that shows one way to compute; a programming model builds on a computation model and describes how to write and organize practical programs in that model.) The functional programming model uses functions as its main organizing principle, including functions that take functions as arguments and return functions as results. The Logic (relational) programming model uses facts and relationships among facts to organize knowledge, and uses search (with backtracking) for computation. Both these models have significant advantages in some situations.

One advantage of the functional programming model is that it makes concurrent programming easier. This is one reason that the large telephone company Ericsson uses the functional language Erlang to write all of its software. Functional programming is also a key technology for supporting domain-specific languages. See also Why Functional Programming Matters by John Hughes.

Even if you do not become a programmer, the ideas of the functional programming model (determinancy, function abstraction, infinite data structures, continuations) have important applications in all areas of computer science and in many other contexts such as mathematics and engineering.

The ideas of the logic programming model (also known as the relational model) are important in formal methods, especially for specification, and in program analysis and tool building, such as model checking. The key concept of unification is also important for type checking. Moreover, the basic ideas of logic programming are closely related to operational semantics, which is arguably the most important semantic technique for precisely defining programming languages.

Programming models are supported, to a greater or lesser extent, in particular programming languages. However, features from other programming models are adopted by languages as they grow older. Thus languages are typically not pure examples of any one programming model. For example, the procedural languages FORTRAN and COBOL have been extended with object-oriented features, and a similar transformation led from C to C++. The template mechanism of C++ allows programming in a functional style, and there are various packages to extend C++ and Java with features that support logic programming. Thus it is generally possible to program the way you think best suits a problem, in whatever language you use. Some languages just make some techniques easier to express than others.

Change in programming languages is a fact of professional life in computer science. In addition to changes within a language over time, as the language evolves, the languages in general use also change. Indeed, the currently popular programming language has always changed on a scale of 5-10 years. In the 1970s it was FORTRAN, in the 1980s was Pascal and then C; in the late 1980s and for most of the 1990s it was C++; since the late 1990s it has been Java (or C#). The time seems ripe for another major change, as Java is now over 10 years old and hardware is changing in fundamental ways.

Besides change in languages over long periods of time, today's professionals must cope with changes between languages in their daily work. This is because programmers typically use several different languages on a single project. These include special purpose languages for databases (SQL), web programming (PHP, Perl, C#, Java, JavaScript, Ruby, Python, ASP, etc.), special purpose languages for customization of application software (such as Visual Basic for MS Office).

Therefore, having a career in computer science means having to quickly learn and master new programming languages.

To meet your need to quickly learn new programming languages, and to help you master the languages you do use, this course seeks to provide a forum where you can develop an understanding of the basic concepts and design alternatives that are part of every programming language. Things like:

In addition, we address the question of what programming models are best suited for different kinds of problems, and what their relative advantages and disadvantages are.

Motivation for the Course Plan

In this offering of COP 4020 we will use the (relatively) new textbook Concepts, Techniques, and Models of Computer Programming, by Peter Van Roy and Seif Haridi (MIT Press, 2004). This book has an interesting approach to presenting a wide variety of different computation and programming models, including: a declarative computation model, functional programming, a declarative concurrent computation model, lazy functional programming, stream-based programming, a message passing concurrency computation model, actor-based programming, an explicit state computation model, object-oriented computation and programming models, a shared-state concurrency computation model, and relational computation and programming models. Several variants are considered. The book not only describes the underlying computation models, it also describes how to program in them. I In particular, it has an especially rich discussion of concurrent language features.

All of the computation and programming models are presented in terms of the Oz language. Oz forms a kernel on which all the other computation models are built as extensions. Programming in Oz is supported by the Mozart/Oz system.

This offering thus covers the following knowledge units from the Final Report of the Joint ACM/IEEE-CS Task Force on Computing Curricula 2001 for Computer Science: PF4, PL1, PL2, PL4, PL5, PL7, PL8, PL10, PL11, with some coverage of OS3, IS2, and IS3.

Return to top

Course Learning Objectives

The objectives for this course are divided into two parts: a set of essential objectives, and a set of enrichment objectives. The essential objectives will be helpful for your career as a computer scientist or software engineer; hence they lead to the course's essential outcomes that we want to help you master. The enrichment objectives are less important for the course, but lead to enrichment outcomes that you are encouraged to explore both for their own sake and because learning more about those will help deepen your understanding of the essential objectives.

This course's objectives are linked to the computer science program's learning objectives (in references that look like this: [CSObj2]).

Essential Objectives

In one sentence, this course's main objective is that you will be able to quickly learn and effectively use new programming languages [CSObj2] [CSObj3] and make reasoned judgments about what programming model and language features to use to solve a particular problem [CSObj2] [CSObj3]. In more detail the essential objectives for this course are that you will be able to:

Enrichment Objectives

Enrichment objectives could be multiplied without limit, but the following seem most important, especially in relation to the computer science program's learning objectives.

The course's enrichment objectives are that you will be able to:

Course Learning Outcomes

This course's learning outcomes are divided into two parts: a set of essential outcomes, and a set of enrichment outcomes. The essential outcomes are designed to support this course's essential learning objectives, and thus to be helpful for your career as a computer scientist or software engineer; hence we want to help you to master them. They also form the basis for grading and assessment of your learning. The enrichment outcomes are not used directly for assessment. However, you are encouraged to explore topics related to the enrichment outcomes both for their own sake and because learning more about those will help your performance relative to the essential outcomes.

The course's outcomes are linked to the course's objectives and to the computer science program's outcomes. The links to this course's objectives are shown in references that look like this: [QuicklyLearn]. The links to the computer science program's learning outcomes are shown in references that look like this: [CSOut13]).

Essential Outcomes

In one sentence, this course's main expected learning outcome is that you will be able to convincingly justify the use of various programming models for solving various kinds of problem [QuicklyLearn] [CSOut1] [CSOut13] effectively solve problems in several programming models [Master] [CSOut1] [CSOut12], and make reasoned judgments about what combinations of programming model and language features to use to solve a particular problem [Evaluate] [CSOut1] [CSOut12] [CSOut13].

To state the essential objectives in more detail, it will be helpful to define the essential programming models (or paradigms) as the following programming models: declarative, declarative concurrent, message passing concurrency, and relational.

With the above definition we can state the essential objectives for this course are that you will be able to:

Other conditions: You will be permitted to use your own textbook and course notes for all graded quizzes, homework, and exams (and assessment).

For purposes of grading (and assessment) a program correctly solves a problem in a given programming model if it only uses features of that programming model, only exhibits minor syntax errors, does not exhibit any maintenance problems (such as repeated code or lack of information hiding), and if the solution is within 25% of the length (counted in non-commentary tokens) and runtime time and space efficiency of the instructor's solution. Of course, there may be many correct solutions to a given problem.

Note that we take points off for syntax errors on exams as a way to make sure that you are doing the homework and having the learning experience of doing them. Students who do not do the homework typically make large numbers of syntax errors.

An assessment plan for these outcomes is also available.

Enrichment Outcomes

Enrichment outcomes could be multiplied without limit, but the following seem most important, especially in relation to the computer science program's learning outcomes.

The course's enrichment outcomes are that you will be able to:

Return to top

Prerequisites

The formal prerequisite in the University of Central Florida catalog is successful completion of both COP 3503C (Computer Science II) and COT 3960 (CS Foundation Exam).

See the professor if you have questions about the prerequisites.

Return to top

Acknowledgments

Many thanks to Curtis Clifton (now at Rose-Hulman) for his initial work on the HTML for these web pages, which I have adapted from another course, and his style sheets, which I have also adapted. Thanks to Steve Shaner for getting me to use an RSS feed for these web pages, and thanks to Evagoras Charalambous for the XSL style sheet and style sheet for showing such RSS feeds as a web page.

I thank the many people I have talked to over the years about programming languages, especially Barbara Liskov, David Gifford, Kelvin Nilsen, Markus Lumpe, David Schmidt, Dan Friedman, and the people mentioned in the acknowledgements for Com S 342, which I taught at Iowa State, including the authors of the various textbooks I have used.

Return to top

Last modified Wednesday, February 25, 2009.

This web page is for the Spring 2009 offering of COP 4020 at the University of Central Florida. The details of this course are subject to change as experience dictates. You will be informed of any changes. Please direct any comments or questions to Gary T. Leavens at leavens@eecs.ucf.edu. Some of the policies and web pages for this course are quoted or adapted from other courses I have taught, in partciular, Com S 342.