FIT3082 is a level 3 elective unit in the Bachelor of Computer Science (BCS) and the Bachelor of Software Engineering (BSE). It was introduced as part of the faculty restructure for 2006.The topics in this unit have previously been taught in CSE3322 (Programming Languages and Implementation), CSE3393 (Prolog Programming) and CSE3394 (Lisp Programming). CSE3322 previously was a core unit in BCS. As the revised new core structure does not leave room for this unit, some material (translators) has been moved from CSE3322 into FIT2014, whereas the material regarding programming language paradigms is now conversed in the FIT3082 elective. CSE3393 and CSE3394 previously presented examples of concrete programming languages in alternative paradigms (Prolog=Logical, Lisp=Functional). This material is now merged into FIT3082.

This unit has been updated as part of a 2009 review and comparison of data with current Handbook, Syllabus + and Callista data.

30/11/2017 - Unit disestablished at FEC 5/17 Item 7.3.

This unit is a third level elective in the Bachelor of Computer Science (BCompSci) and Bachelor of Software Engineering (BSE) degree. It is the only unit that allows BCS/BSE students to gather in-depth knowledge of programming paradigms different from those present in the programming language Java, such as functional programming and logic programming. It also provides students with their first introduction to semantics of programming languages and other programming language design issues.

The only other programming language-oriented offering is FIT3042 System Tools and programming Languages. While FIT3042 is concerned with programming languages as tools for systems programming, FIT3082 focuses on programming languages themselves and on basic questions of language design as the objects of investigation.

Using an appropriate programming language for a given application is crucial for the quality of the resulting implementation. Furthermore, designing or modifying a programming language is sometimes needed in order to cater for applications which somehow break traditional principles, for example, Java was primarily designed in response to the need for new web applications.

A thorough understanding of different programming paradigms is crucial for high quality computer science graduates who must be able to judge and assess the suitability of different languages for different types of problems, as well as to design new languages based on different principles.

At the completion of this unit students will have -

A knowledge and understanding of:

• the history of programming languages and the reasons for their introduction. Understanding of the fact that programming languages and programming language paradigms have evolved and will almost certainly change in the future;
• programming language paradigms including imperative, object-oriented, functional and logical. Comprehension that the choice of programming language affects the ease of programming. Ability to evaluate whether a particular paradigm or programming language is well-suited for a particular programming application;
• the importance of formal mathematical calculi as the basis for programming languages (in particular, Lambda Calculus and First Order Predicate Calculus). Understanding of how these calculi can provide the basis for programming language semantics;
• the core aspects of modern functional programming languages Functions as first class objects, type systems, higher-order functions, eager and lazy evaluation;
• a particular functional programming language, such as ML or Scheme, which exemplifies most of these aspects and the ability to use it for implementing non-trivial algorithms;
• the core aspects of logic programming: logical inference, deduction, resolution, negation as failure, logic variables and unification;
• a particular logic language, such as Prolog or CLP, which exemplifies most of these aspects and the ability to use it for implementing non-trivial algorithms;
• the main issues in programming language design and comprehension of the various design alternatives. Examples of languages that mix influences from different programming paradigms, such as Python;
• how language design decision impact on the implementation of a programming language.

Developed attitudes that enable them to:

• value the important role that theory (in this case formal language theory and type theory) can play in the development of practical software applications (in this case compilers and other data translation applications.);
• carefully consider the characteristics of the different programming languages available whenever developing a new application.

Developed the skills to:

• become an informed consumer of programming languages, choosing the right programming language for a particular task;
• be able to implement and debug non-trivial algorithms in both a functional and a logic language.

020103

This unit provides a thorough understanding of the four main programming language paradigms: imperative, functional, logic and object-oriented. In doing this, it reviews different example languages and the kinds of applications each language is intended for, focusing on how the choices made during the design of a language affect the resulting ease of programming. Particular emphasis will be made on functional and logic languages. Students will gain practical programming experience in languages that use these paradigms, such as SML and Prolog. Implications of language design on the implementation of programming languages will be highlighted.

On-campus

Examination (3 hours): 70%; In-semester assessment: 30%

2 hrs lectures/wk, 1 hr laboratory/wk

FIT

FIT2004 or CSE2304, FIT2014 or CSE2303

Students are assumed to be competent programmers in at least one programming language based on a paradigm other than procedural. Students are required to have a thorough understanding of datatypes and recursion. Furthermore, knowledge of first order predicate calculus is required.

Maria Garcia de la Banda/Bernd Meyer