Objectives

To master the theory behind scripting and its relationship to classic programming. To survey many of the modern and way cool language features that show up frequently in scripting languages, To gain some fluency programming in Ruby, JavaScript, Perl, Python, and related languages. To design and implement one's own scripting language.

Prerequisites

A previous course in programming languages, and perhaps, though not necessarily, a previous course in compiler construction. Industry experience programming in both scripting and non-scripting languages can serve as a prerequisite in place of previous coursework.

Readings

There is no main textbook for the course that covers scripting language theory; this information is generally found in chapters in texts on programming languages, books on particular scripting languages or shells, or conference or journal articles. Texts for three of the languages featured in this course are:

• Larry Wall, Tom Christiansen, and John Orwant, Programming Perl, 3rd edition, O'Reilly, 2000. (ISBN 0596000278)
• Dave Thomas, Chad Fowler, and Andy Hunt, Programming Ruby: The Pragmatic Programmers' Guide, 2nd Edition, Pragmatic Programmers LLC, 2005. (ISBN 0974514055)
• David Flanagan, JavaScript: The Definitive Guide, 4th edition, O'Reilly, 2001. (ISBN 0596000480)
• Chet Ramey and Brian Fox, GNU Bash Reference Manual, Network Theory Ltd., 2003. (ISBN 0954161777)

We'll also take a look at:

• John K. Ousterhout, Scripting: Higher-level programming for the 21st century. IEEE Computer 31(3):23–30, March, 1998.

You are also encouraged to check out papers from the recent Dynamic Languages Symposiums (DLS06, DLS05, ...).

Additional papers and readings will be assigned throughout the course (including my own course notes, practice problems, and sample code). If you have projects or papers to work on, you'll have to find some additional readings on your own. Use judgment when researching on the web; a fair amount of information is often wrong, and much of the so-called sample code is especially atrocious. Regardless, you must take the time for effective self-study that includes practicing the craft of programming.

Assignments and Grading

You'll have several homework sets containing in-depth theoretical questions and non-trivial programming problems, and quizzes and a final exam with less difficult material. There will be a term project in which students will design their own scripting language and write an interpreter for it. The language implementation is to be packaged as an open source project. To help prepare you to meet industry expectations for college graduates, most assignments will take the form of open source software products. Unless otherwise specified, you are required to keep all work in your CVS repository and prepare all homework solutions with LaTeX document preparation system. Exams will cover material from lectures not previously assigned for homework: don't whine about this.

Generally, coursework may be done in groups of no more than two students; however, while only one solution set is turned in per group, both students are responsible for understanding all of its content and may be asked at any time for an oral explanation of any solution. Collaboration with other groups is fine but must be limited: you may share ideas and approaches but nothing resembling a solution (not even pseudocode). You must also acknowledge any help received. Academic dishonesty may result in expulsion; be certain your work meets the standards set forth in the LMU Honor Code.

Your final grade will be weighted as follows:

Letter grades are figured according to the usual scale: 90% or more of the total points gets you an A, 80% a B, 70% a C, and so on. These are minimal requirements; for example, if you get 82 points you are guaranteed a B- or better, though you might still get an A since 82 may be the top score.

Homework is due at the beginning of class; late assignments are docked 30% per class. Missing class just to get an assignment done on time will not be tolerated; the only good excuses for missing class are excellent surf conditions, family problems, sickness, and personal emergencies. Skipping class just puts your fellow students at an advantage: we often spend class time going over things that will be "on the exam".

Your programming style will play a huge part in determining your score on the programming assignments. I will not hesitate to assign D's or F's to working programs which are poorly structured, under-commented, have poor identifier names and abbreviations, contain inappropriate hard-coded values, or are not easily maintainable. Appearance of the grading policy in this syllabus constitutes fair warning of the consequences of poorly written code.

Topics and Tentative Schedule

• INTRODUCTION: What is a scripting language? Motivation for and applications of scripting; How scripting languages differ from non-scripting languages; Biased, naive, and thoughtful position papers and debates on the merits of scripting languages; Types of scripting languages.
• OVERVIEW OF POPULAR SCRIPTING LANGUAGES: Important features of and sample code in bash, Ruby, JavaScript, Perl, Python, Tcl. A list of other scripting languages with uninformative but possibly interesting synopses.
• COMMON SCRIPTING LANGUAGE CONSTRUCTS: List comprehensions, iterators, complex datatype literals, higher-order functions, closures, unlimited extent, regular expressions, threads, and others; Implementation strategies.
• DYNAMIC LANGUAGE FEATURES: Metaprogramming, introspection, reflection, distribution, mobility, instrumentation, reconfiguration, garbage collection.
• TYPING: Static vs. dynamic typing; Manifest vs. inferential typing; Duck typing; Tradeoffs; Debates; Object orientation in dynamic typing. A detailed look at the typing systems of Ruby and Python; Classical (e.g. Ruby) vs. Prototype-based (e.g. JavaScript) inheritance; The (philosophical) question of whether an object can change its type.
• INTERPRETATION AND COMPILATION: Interpretation vs. Compilation; Virtual machines; Iinterpretation at compile-time (e.g. Perl's BEGIN and END blocks) and compilation at run-time (e.g. the wonderful eval).
• PERFORMANCE OF SCRIPTING ENGINES: The real or imagined tradeoff between (1) expressiveness, flexibility, extensibility, and rapid development, and (2) high performance and compile-time type safety; How can some scripts be optimized? When do rapid development benefits outweigh slower runtimes?; Modern garbage collection algoirhtms; A look at some runtime engines.
• SHELL SCRIPTS: Responsibilities of a shell; A tour of the most popular Unix shells
• CLIENT-SIDE WEB SCRIPTING: The DOM; JavaScript; DHTML; Ajax; XSLT scripting.
• SERVER-SIDE WEB SCRIPTING: Rails, PHP, Zope, the JSP expression language; The evils of scriptlets; Scripting and the Seamantic Web.
• EXTENSION LANGUAGES: The concept of command hooks; Classic applications (Emacs); Other applications; Interoperability, e.g. Groovy and Java
• MULTIMEDIA AND GAME SCRIPTING: ActionScript and Flash; Game architecture.
• FUTURE OF SCRIPTING LANGUAGES: Will scripting languages replace non-scripting high level languages the way these langauges replaced assembly? A look at some of the newer scripting languages.

University Links

All students will want to acquaint themselves with the useful information found in the following sources:

• LMU Academic Requirements and Policies (Pay particular attention to the sections on academic dishonesty)
• LMU Disability Support Services Office
• LMU Student Codes and Policies
• LMU Learning Resource Center