Programming Languages Course Group Report

1. Summary

Students and faculty are generally satisfied with the courses in this group. Students find CSE 655 a worthwhile course; it not only brings together ideas from a number of earlier courses in the program such as CSE 321, 560, 625, and Math 366; it also often addresses issues in a way that is directly related to actual practice. One important recent change is the development of CSE 421, Software Development in Java. This course serves to highlight the strong relations between software engineering issues and programming language issues. The original plan was to make this a required course, sandwiched between CSE 321 and 560. But, with the apparently impending change to semesters, the consensus is that there is no reason to try to go through the effort of making it a required course. So, for now, this course will be an elective for both CSE and CIS majors.

2. Detailed Analysis

2.1 Summary of the courses

• Provide students with the skills needed to write medium-size programs from scratch (rather than starting with skeletal outlines of the programs);
• Reinforce key design principles from the intro sequence (CSE 221-222-321) illustrating how these principles manifest themselves in a mainstream language (i.e., Java);
• Help students understand some of the limitations of mainstream languages, in particular of Java;
• Expose students to important industry-standard ideas such as JUnit for testing, Javadoc for documentation, Ant for makefiles, Eclispe as an IDE (including CVS and the debugger).

CSE 459.XX: This is a series of one-credit courses intended to ensure that students learn the syntax of, and write some simple programs in, at least one other language than the one they have used in the Software Spine (CSE 221, 222, and 321). As new languages become popular, we have tried to introduce corresponding 459's in response to student demand for them. The most recent example is the new course on C#. At the same time, the 459 series also allows us to meet the needs of industries by continuing to offer 459's corresponding to somewhat older languages used by legacy-systems; an example of this is the 459 course on COBOL. In addition, we have also used the 459 sequence to familiarize students with some important software tools such as the one on Unix. Students are required to take at least one of these courses; with the introduction of CSE 421, students may also use that course to meet this requirement.

CSE 655: This is the main undergrad course on programming languages. It is not a survey of languages. Rather, the course is intended to ensure that the students gain a thorough understanding of the major concepts underlying different languages; use standard ways of describing programming language features; and gain an appreciation of alternate programming paradigms such as functional programming. Students also gain a thorough understanding of ways of implementing languages such as compilers and interpreters, as well as run-time questions such as memory management. The main programming project in the course requires students to implement an interpreter for a simple programming language. This allows students to gain a first-hand appreciation for problems ranging from parsing the input program, to detecting errors (both compile-time and run-time) in the program, to managing memory. The project is a natural extension of a similar but much smaller project that students are assigned in CSE 321; in that project, students are required to implement a compiler (using an artificial target language) for a very simple "bugs world programming language". Seeing the ideas of recursive descent parsing and compilation/interpretation in a second project in 655 that is both more involved and in which they receive much less assistance with building the final implementation helps reinforce the lessons on this topic from 321, especially since in the meantime, students have also taken 625 which gives them a thorough grounding in theoretical ideas involving formal grammars. It is too early to judge the impact of the new CSE 421 on this course.

Another programming task, one that is quite different from everything that most students have seen thus far, is to have them design and implement a program in the language SCHEME to help acquire some facility with and understanding of functional programming.

CSE 755: This is a continuation of CSE 655 but with a strong focus on the theoretical foundations underlying programming languages. Some of the topics in this course are attribute grammars and their use in specifying context sensitive conditions as well as a discussion of how compilers can check these conditions using the attribute grammar specifications; approaches to defining operational semantics including the meta-circular approach used in languages such as Lisp, as well as a thorough discussion of how an implementation of Lisp may be based on such a specification; a thorough discussion of the axiomatic semantics, and its application to reasoning about program behavior; in some offerings, brief discussion of the use of language semantics to compiler correctness and optimization questions. CSE 755 is geared toward graduate students but some undergraduates with a strong interest in foundational questions, especially those considering graduate studies, take this course as an elective.

CSE 756: This is also a continuation of CSE 655. Students in this course study, in depth, the various problems in implementing compilers for programming languages and study various possible solutions. They put these solutions into practice by designing and implementing a compiler for a standard imperative programming language. This is a fairly demanding and extensive programming task and brings together ideas that students have seen in a variety of courses, from CSE 560, CSE 625, and CSE 655. This course usually sees a mixture of undergraduate and graduate students.

Due to staffing constraints, CSE 756 was not offered for a number of years. It was offered in 2007-'08 and is expected to be offered again in '08-'09. Given faculty interest and expertise in the area, we plan to continue offering it every year in the coming years.

2.2 Evaluation of courses

CSE 421: The LOs of this course include:

• LO1: Master core Java language features including objects, classes, interfaces, inheritance, and exceptions;
• LO2: Master core SDK packages including collections framework, logging, and IO;
• LO3: Master core best practices for component-based development including separation of abstract state and concrete representation and coding to the interface;
• LO4: Master the use of a modern IDE, such as Eclipse;
• LO5: Be familiar with advanced language features including iterators, generics, and assertions;
• LO6: Be familiar with foundations of an object-oriented paradigm, in particular encapsulation, inheritance, and polymorphism;
• LO7: Be familiar with the application of design patterns including: immutable objects, factories, and singleton objects;
• LO8: Be familiar with best practices with regards to object equality, object cloning, and checked/unchecked exceptions;
• LO9: Be familiar with CVS, JUnit, and Javadoc;
• LO10: Be exposed to advanced SDK packages including Swing for GUIs and network programming;
• LO11: Be exposed to exotic language features including nested classes, nested interfaces, and annotations.

Based on the experiences with the pilot offerings of the course, the course is organized as follows. Course content is divided into three roughly equal focus areas: language mechanics, tool support, and best practices. For language mechanics, the basic constructs of Java 6 are presented along with the most commonly-used packages (e.g., collections, Swing, IO). For tool support, students use a variety of technologies typically associated with professional software development in Java (eg JUnit, Javadoc, Eclipse, CVS). Finally, several industry-standard best practices and programming patterns are covered. The motivation and justification for these practices is discussed in terms of the manifestation in Java of sound component-based approaches as seen in RESOLVE.

Weekly individual programming labs include implementing an abstract data type (an unbounded natural number) then progressively refining the implementation with an interface, Javadoc documentation, and JUnit test cases. Students also use off-the-shelf containers from the collections framework as well as implementing their own (a multiset). The last lab is a team lab (teams of 2 or 3) in which students implement a complete application (eg word mastermind or a tag cloud generator) including a Swing-based GUI.

All of the LOs listed above are being achieved at the specified levels.

CSE 459.XX: These courses may be divided into two groups, those dealing with C++ -like languages and those dealing with other languages or other software tools. Since CSE 321 is a prerequisite for all of these courses and since CSE 221-222-321 uses RESOLVE-C++, courses in the former group are able to investigate features of the corresponding languages in greater depth than courses in the latter group. The courses in the former gruop are CSE 459.21 (C), 459.22 (C++), 459.23 (Java), and 459.24 (C#); in the latter group are 459.11 (UNIX), 459.31 (LISP), 459.41 (COBOL), and 459.51 (Perl). Thus the LOs for the former group typically include mastery of the basic aspects of the language and its usage, along with familiry with some of the more advanced aspects. The LOs of the latter group typically list familiarity with a number of aspects of the language.

For example, the LOs of 459.22 (C++) are:

• LO1: Master using C++ classes, member functions, constructors, destructors etc.;
• LO2: Be familiar with using templates and the C++ standard template library (STL);
• LO3: Be familiar with using inheritance;
• LO4: Be exposed to using virtual functions, dynamic dispatch.

• LO1: Be familiar with Perl's data types;
• LO2: Be familiar with text and file manipulations using Perl;
• LO3: Be familiar with using DBI to access a database;
• LO4: Be familiar with basic CGI scripts written in Perl.

Typical offerings of these courses require students to complete three or four programming assignments; the difficulty of the tasks range from somewhat challenging in the case of the first group and relatively simple in the case of the second group of courses although this varies somewhat with the instructor for the course. Based on student performance in the programming assignments, the courses have been generally successful, meeting their stated LOs.

Given that different students take different sections of 459, and given that while some students may gain considerable additional experience with a particular language prior to graduation and hence prior to taking the POCAT, others may not use the language from their particular 459 again, it is difficult to create suitable questions based on the 459 for inclusion in the POCAT (although some of the 655-related POCAT questions are also related to some of the 459's). Hence we will continue to rely on instructor and student feedback for evaluating these courses. As noted above, based on this feedback, the courses have been generally successful and are meeting their LOs at the specified levels.

CSE 655: The LOs of this course include:

• LO1: Master using syntax-related concepts including context-free grammars, parse trees, and recursive-descent parsing, printing, execution and code generation;
• LO2: Master analyzing programming language design issues related to data types, expressions and control structures;
• LO3: Master analyzing variable binding and scope rules;
• LO4: Master analyzing parameter passing methods;
• LO5: Master implementation techniques for imperative languages;
• LO6: Master analyzing data abstraction-related issues;
• LO7: Be familiar with principles of object-oriented languages;
• LO8: Be familiar with implementing object-oriented languages;
• LO9: Be familiar with using functional programming languages;
• LO10: Be familiar with implementing functional programming languages.

Some changes should be made in the list of LOs. First, (LO3), the LO with respect variable binding and scope rules, and (LO4), the LO with respect to parameter passing methods, should both be reduced to the "familiarity" level. Although static and dynamic scoping are still part of the class discussion, problems based on Algol-like nesting structures are no longer discussed. Similarly, discussion of parameter passing mechanisms other than call-by-value and by-reference is typically no longer part of the course. Reducing the outcome level to "familiarity" for both LOs will bring the stated LO in line with what is actually achieved in the course. At the same time, course instructors must ensure that discussion of these topics in the class and the work that students do in the homeworks and exams related to these topics do not fall below this level; the reason for this note of caution is that in some recent offerings of the course, these two topics have been barely mentioned; that is inappropriate since the topics still retain their importance. Second, (LO7), the LO with respect to the principles of OO languages, should be increased to "mastery" level. The interpreter project provides plenty of opportunities to discuss these principles and students do achieve the outcome to the mastery level. Note, however, that (LO8), with respect to implementation of OO languages should remain at the familiarity level. Also, item (LO10), implementation of functional languages, should be reduced to "exposure"; there is some discussion of how the Lisp/Scheme interpreter works but "familiarity" may be too strong.

(LO5), related to implementation techniques, should be reduced to "familiarity". The recursive-descent approach to implementations is already covered by item (LO1). What remains are issues related to activation records, variable lifetimes, run-time stack, and related issues of code generation. Many of these are discussed but not at the level of mastery; so familiarity seems the right level for this outcome. Also, (LO2), about data types, expressions, and control structures should be omitted. Data-abstraction related topics are discussed extensively in the course; but these are covered in (LO6). We don't discuss different control structures or serious type-related ideas. So it seems appropriate to omit this item from the LOs.

Recent POCATs have included two questions directly related to 655 topics. The first concerns memory management issues in current languages (C++ and Java); the question asks whether C++ programs are more or less likely to have memory-related bugs than Java programs. This is related to (LO1), (LO5), and (LO8) of 655. About 80% of the students answer this question correctly. The second question asks, given two languages one of which has polymorphism and the other doesn't, which will have virtual calls. This is related to (LO7). Again about 80% of the students answer this question correctly. But both of these questions might be considered too easy, especially given the expected levels of achievement of these outcomes. There are also a couple of questions about formal grammars but those are more directly related to CSE 625 than to 655.

A POCAT question for (LO1) should be easy to construct. For example, describe some condition that must be satisfied by legal programs in a language and ask if it is context-free or context-sensitive or both etc. Interestingly, however, during the drafting of this CGR, we discovered that while some sections of CSE 655 do discuss this topic in detail, others do not. The question of whether or not this topic should be discussed in 655 and to what level of detail remains to be resolved.

The POCAT test bank should include some questions related to (LO6) and (LO7), especially assuming we change the level of (LO7) to "mastery"; perhaps something that explores the relation between "public/ protected/ private" of C++/Java and data abstraction. Also a question concerning how the stack and heap are organized and how they are used in implementing OO languages might be worth including. We will work on constructing these questions in the next few months. In the process, we should also be able to come to consensus on such questions as whether discussion of context-free vs. context-sensitive conditions belongs in the course, to what level of detail issues related to stack and heap organization for standard OO langauges should be discussed, etc.

CSE 755 lists the following LOs:

• LO1: Master using attribute grammars for specifying context-sensitive grammars;
• LO2: Master using the meta-circular approach to defining operational semantics of Lisp;
• LO3: Master using the axiomatic approach to reasoning about the behavior of imperative programs;
• LO4: Be familiar with using structured operational semantics;
• LO5: Be exposed to using denotational semantics.

But there is also concern that the course is too theoretical, both for the handful of undergrads who take it as well as for the many terminal MS students we now admit. The main concern has to do with the second half of the course, i.e., the portion concerned with axiomatic semantics, structured OS, and denotational semantics. Should this portion be substantially reduced and some other more practical material added to the course? Of course, with the apparently looming switch to semesters, this may not be the time to consider such changes.

CSE 756 lists the following learning objectives:

• LO1: Master using lexical analyzer and parser generator tools
• LO2: Master building symbol tables and generating intermediate code;
• LO3: Master generating assembly code for a RISC machine;
• LO4: Master programming in Java;
• LO5: Be familiar with compiler architecture;
• LO6: Be familiar with register allocation;
• LO7: Be exposed to compiler optimizations.

Ideas for revisions in the list of outcomes were discussed in the group. There was consensus that (LO4), master programming in Java, doesn't belong in the list. There was also consensus that intermediate code analysis and compiler optimization techniques belong in the list but there was disagreement about the level (from "mastery" to "exposure"). Similarly, there was disagreement about whether lexical analysis and parsing techniques (and skills with automatic tools for these tasks) should be at the mastery level or should be at the familiarity level. There was also concern that while skill with automatic tools are listed in LO1, lexical analysis & parsing techniques are not; one could reasonably argue that mastery of/familiarity with these should come before skills with automatic tools to perform them. For now, we will eliminate (LO4) from the list and wait for one more offering of the course before deciding on the other changes.

2.3 Relation to BS-CSE program outcomes (POs) and evaluation

1. an ability to apply knowledge of computing, mathematics including discrete mathematics as well as probability and statistics, science, and engineering;
2. an ability to design and conduct experiments, as well as to analyze and interpret data;
3. an ability to design, implement, and evaluate a software or a software/hardware system, component, or process to meet desired needs within realistic constraints such as memory, runtime efficiency, as well as appropriate constraints related to economic, environmental, social, political, ethical, health and safety, manufacturability, and sustainability considerations;
4. an ability to function effectively on multi-disciplinary teams;
5. an ability to identify, formulate, and solve engineering problems;
6. an understanding of professional, ethical, legal, security and social issues and responsibilities;
7. an ability to communicate effectively with a range of audiences;
8. an ability to analyze the local and global impact of computing on individuals, organizations, and society;
9. a recognition of the need for, and an ability to engage in life-long learning and continuing professional development;
10. a knowledge of contemporary issues;
11. an ability to use the techniques, skills, and modern tools necessary for practice as a CSE professional.
12. an ability to analyze a problem, and identify and define the computing requirements appropriate to its solution;
13. an ability to apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems in a way that demonstrates comprehension of the tradeoffs involved in design choices;
14. an ability to apply design and development principles in the construction of software systems of varying complexity.

Below, for each of CSE 459.22, 459.51, and 655, we first list the LOs for the course (copied from Section 2.2). Next, a table summarizes the contribution of the course to the program outcomes (POs). The table is organized as follows. There are as many rows in the table as the number of LOs for the course. The first column of each row specifies the number of the corresponding LO. The remaining columns specify the contribution of the particular LO to the fourteen program outcomes, (a) through (n), respectively. In specifying this contribution, we use "XXX" to signify strong contribution; "XX" to signify moderate contribution; "X" to signify minimal contribution; if a given LO makes no contribution to a particular outcome, the cell is empty. Following the table is a brief summary, based on the discussion in 2.2, of how well the recent offerings of the course achieved each LO as indicated by both the course content and student performance in the course; and results from POCAT, if any, related to the various LOs of the course. A brief summary of the proposed changes in the course (content or activities or LOs) should conclude the summary for this course.

CSE 459.22: The learning outcomes of this course are:

• LO1: Master using C++ classes, member functions, constructors, destructors etc.;
• LO2: Be familiar with using templates and the C++ standard template library (STL);
• LO3: Be familiar with using inheritance;
• LO4: Be exposed to using virtual functions, dynamic dispatch.

Summary: Recent offerings of 459.22 have mostly met the listed LOs of the course. However, templates and the STL have not been discussed in as much depth as indicated by LO2, and there are typically no programming assignments on these topics. Hence, LO2 should be reduced to "exposure".
There have been no questions in POCATs related to 459.22 (but see below under 655).
Other than changing LO2 to "exposure", no other changes are needed in the course.

CSE 459.51: The learning outcomes of this course are:

• LO1: Be familiar with Perl's data types;
• LO2: Be familiar with text and file manipulations using Perl;
• LO3: Be familiar with using DBI to access a database;
• LO4: Be familiar with basic CGI scripts written in Perl.

Summary: Recent offerings of 459.51 have met the listed LOs of the course.
There have been no questions in POCATs related to 459.51.
No major changes are needed in the course.

CSE 655: The learning outcomes of this course are:

• LO1: Master using syntax-related concepts including context-free grammars, parse trees, and recursive-descent parsing, printing, execution and code generation;
• LO2: Master analyzing programming language design issues related to data types, expressions and control structures;
• LO3: Master analyzing variable binding and scope rules;
• LO4: Master analyzing parameter passing methods;
• LO5: Master implementation techniques for imperative languages;
• LO6: Master analyzing data abstraction-related issues;
• LO7: Be familiar with principles of object-oriented languages;
• LO8: Be familiar with implementing object-oriented languages;
• LO9: Be familiar with using functional programming languages;
• LO10: Be familiar with implementing functional programming languages.

Summary: Recent offerings of CSE 655 have met most of the listed LOs of the course. But, as discussed in detail in Section 2.2, some changes in the LOs are called for: the levels of LO3 and LO4 should be reduced to "familiarity"; LO7 should be increased to "mastery"; LO10 should be reduced to "exposure". It may also be appropriate to omit LO5 since it seems covered by LO1; in any case, it should at least be reduced to "familiarity". LO2 should probably be omitted since the other LOs cover these topics (although not using the same terminology).

Recent POCATs have included two questions directly related to 655 topics. The first concerns memory management issues in current languages (C++ and Java); the question asks whether C++ programs are more or less likely to have memory-related bugs than Java programs. This is related to (LO1), (LO5), and (LO8) in the list of LOs for the course. About 80% of the students answer this question correctly. The second question asks, given two languages one of which has polymorphism and the other doesn't, which will have virtual calls. This is related to (LO7) in the list. Again about 80% of the students answer this question correctly. But both of these questions might be considered too easy, especially given the expected levels of achievement of these outcomes. There are also a couple of questions about formal grammars but those are more directly related to CSE 625 than to 655.

The POCAT test bank should contain several additional questions, specifically focused on the important LOs of 655. Ideas for such questions are discussed in Section 2.2. We will work on constructing these questions in the next few months.

No changes in the course other than the ones noted above course are indicated.

2.4 Major changes since the previous report

One new 459 (CSE 459.24 on C#) was developed recently. The others continue to be offered although there has been a suggestion that we might stop offering 459.41 (COBOL) given the reduced demand for the course. For now there are no plans to develop additional 459's. One point worth noting about the 459's is that, since the last report, both 459.22 and 459.23 have been taught by faculty. The lecture notes etc. developed during those offerings are available to GTAs who teach the courses; this should help address problems, reported in previous CGRs, of unevenness in these courses. The new 459.24 was piloted by a faculty member and the notes from that offering will be available to GTAs who may teach the course in the future. The other 459's (with the exception of 459.21, C, which is usually taught by GTAs), are taught regularly by the same (non-faculty) CS professionals.

There have been no major changes in CSE 655 and 755. The previous concern about CSE 755 being too theoretical remains although the introduction of the LISP interpreter project has helped considerably. The textbook situation remains the same for both courses - i.e., we continue to rely heavily on class notes.

After a hiatus of many years, we were able to offer 756 in 2007-'08 and was well received by the 10 or so (mix of grad and undergrad) students who took it. The course will be offered again in 2008-'09. And given faculty interest in the topic, we plan to continue offering it every year.

2.5 Planned changes

• Changes in LOs of CSE 655;
• Develop consensus among CSE 655 faculty about certain topics (and their depth of coverage) that seem to receive different levels of attention in sections taught by different faculty; and
• Develop POCAT questions based on CSE 655 LOs.

One other point concerning CSE 655 is the question of making CSE 421 a prerequiste for the course. The way 421 presents the material on Java makes an excellent basis for discussion of object-oriented languages; data types, both primitive and user-defined; polymorphism; and data abstraction in general. But there are a number of technical problems in requiring 421 as a prerequisite for 655. First, where are the additional 3 credit hours to come from? Second, wouldn't it make more sense to require CSE 421 as a pre-req for CSE 560 (as was, in fact, the original intent)? Third, if 421 is a pre-req for 560, wouldn't that increase the number of quarters to graduation? Finally, and perhaps most importantly, since such a change (whether 421 is added a pre-req for 560 or for 655) amounts to changing the major programs, and since changes in major programs take a very long time to go through, shouldn't we wait until the (apparently) looming switch to semesters gets resolved? If the switch is abandoned, we could pursue this question and come up with some sensible solution; if the switch takes place, all courses, including 421, 560, and 655, would have to be redesigned anyway.

There is a question having to do with 459.21 (C). This course, as noted in Section 2.4, has not been taught recently by a faculty member. We will consider doing this so that the notes and other materials developed during such an offering can be made available to GTAs who teach the course, thereby ensuring uniformity in the offerings of the course.

There are also the questions, raised near the end of Section 2.2, concerning the LOs of CSE 756. We will wait until the course has been offered one or two more times and revisit these questions. (Of course, a switch to semesters will impact 756 as well.)

3. Conclusions

People involved in preparing report: Neelam Soundarajan, Eitan Gurari, Atanas Rountev, Paul Sivilotti, Bruce Weide.

Date of report: Dec. 2008.