Learning Outcomes:
On successful completion of this module, the student should be able to:
1. Generalize competency in dynamic languages to any programming domain, and classify domains by level of support for dynamic features.
2. Apply the features of dynamic languages to practical problems. Be capable of designing and delivering complete solutions in a dynamic language.
3. Demonstrate an understanding of the prototype-based object model. Be able to modify and adapt a traditional object hierarchy into a prototype model.
4. Formulate an effective quality approach for dynamic systems. Understand the impact of the loss of static type-checking.
5. Understand the strong/weak, static/dynamic typing distinctions, be capable of generating examples and critically assessing the inherent trade-offs.
6. Describe functional programming and connect the features of pure functional languages to dynamic languages.
Syllabus Content:
The core aim of the module is to expand the problem-solving abilities of the student by moving beyond traditional object-oriented algorithms and design patterns.
The module will introduce two dynamic languages, Ruby and JavaScript, and use these to develop an appreciation of dynamic language techniques, structures and idioms. The core concepts of functional programming will also be introduced in order to unify the material in the module. Comparison to structures and patterns in Java will be used to illustrate these concepts.
Particular emphasis will be placed upon understanding the trade-offs inherent in the use of dynamic languages, particularly with respect to performance, quality assessment and code accessibility.
Finally, design and delivery of complete, commercial-grade systems using domain-oriented frameworks (Ruby-on-Rails, Prototype) will form the basis for continuous assessment.
Pre-requisites:
1. Basic understanding of computer architecture and of operating systems.
2. Programming experience in an Object Oriented Programming Language (graduate of a Honours BSc or BEng involving significant programming experience).
3. Some exposure to software modelling concepts and notations.
Indicative syllabus content:
1. Principles
a. Object Ontologies
Classes, prototypes, and functions.
b. Type Patterns
Static and dynamic, strong and weak
c. Dynamic Idioms
Higher-order functions,
recursion, list comprehension, closure, currying.
d. Functional Programming
Overview of paradigm, LISP-style syntax, and lambda calculus.
2. Language Competency
a. Environment
Toolset and IDE use, project organisation, debugging, deployment, virtual machine hosting.
b. Community
Coding standards, online resources, thought-leader blogs.
c. Development
Architectural approaches, unit testing strategies, performance considerations, refactoring from traditional object hierarchies.
d. Functional techniques
Application of common functional idioms and techniques using dynamic code.
3. Domain Frameworks
a. Ruby-on-Rails
Design, develop and deploy commercial-grade applications.
b. Prototype
Apply and integrate into design architecture and working solutions.
Practical Programme:
This module is directly practical, despite the theoretical nature of the core material. The focus is on the utility of the techniques and ideas covered, and their usefulness in modern large-scale software development. Practical activities will be motivated by applicability to common problem spaces, particularly in distributed systems. Students will also be encouraged to adopt an agile approach to development.
Assessment shall consist of three assignments. The first assignment is to be presented by the students early in the module, in order to demonstrate familiarity with key dynamic language concepts, implemented in the Ruby language. The second (and largest) assignment will cover the Ruby-on-Rails framework, and students are to deliver a full end-to-end system, demonstrating effective use of dynamic techniques. The third and final assignment will cover the more theoretical aspects of the module, using the JavaScript language in an AJAX context.