About COP 4020

This page provides general information about COP 4020 (Programming Languages I) 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. Required Software
  4. Computer Accounts
  5. Accommodations for Disabilities
  6. Course Description and Credit Hours
  7. Course Learning Objectives
  8. Course Learning Outcomes
  9. Prerequisites
  10. 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.


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

Lectures: Tuesdays and Thursdays, at 4:30PM-5:45PM, in the Mathematical Sciences Building (MSB), room 360.

Return to top

Course Textbooks

There are no required textbooks for this course. However...

Recommended Texts

The following two books are recommended.

Additional Readings

If you want more reading material, or help with background and concepts, then you may want to check out the following books from the UCF Library:

We may use 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 Eustis cluster to run software for this course. The Eustis cluser can be reached at eustis.eecs.ucf.edu.

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."


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, FORTRAN, Java, Lisp, ML, Oz, Python, Ruby, Smalltalk as well as special purpose programming languages like the Unix Shell, JavaScript, Perl, PHP, and the macro language of Microsoft Excel.

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, functional 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 and in several other areas of computing. 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.), and 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

A major challenge in modern software engineering is how to take advantage of the parallelism offered by modern machines (to gain a competative advantage). We will explore two major techniques for parallel programming: functional approaches, which eliminate race conditions by eliminating mutation, and actor-based techniques, which relegate parallelism to large-scale "actors" that communicate by messae passing. To study these techniques we will use Haskell and Erlang.

Erlang also demonstrates distributed programming techniques, which are essential to modern cloud computing.

We also need to spend some time comparing programming models and programming languages. We will do this during the course of learning particular models and languages, but we will also need to take a bit of time to think about this more explicitly.

Time permitting the course could also cover other programming models, such as logic (relational) programming, object-oriented programming, and aspect-oriented programming.

This offering should 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] and make reasoned judgments about what programming model and language features to use to solve a particular problem [CSObj2] 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 problems [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, we say that the set of essential programming models (or paradigms) is a set of programming models, such as the lazy functional, implicit parallelism, and actor models. 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 language and programming model if it follows the syntax of the given programming language it only uses features of the given programming model, it 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 that learning experience. 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


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


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 Tuesday, January 13, 2015.

This web page is for 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.