Home
--- Introduction
--- Content Summary
--- Acknowledgements

Context
--- Teaching Philosophy
--- Institutional Context

Course Structure
--- Aims, Objectives, Content
--- Delivery Methods
--- Assessment

Reflection
--- Commenting on Content
--- Use of Voting Handsets
--- Laboratory Examination
--- Written Examination
--- Continuous Assessment
--- Overcoming Blocks

Outcomes
--- New course rationale
--- Personal learning

Rationale

CS-1P is a programming course that is intended to be of significant value to all students eligible for the module. We wish to embed a set of principles that will be effective for large scale programming for continuing students, and sufficient basics for non-continuers to transfer to other languages in their own disciplines. We are therefore concentrating on the following aspects

• Thorough treatment of problem solving skills independent of any given language
• Procedural/algorithmic program development. We do not believe that a long, thin course such as this can additionally support object-oriented concepts, and our commitment is to solid foundational learning. We expect the Level 2 curriculum to introduce object-oriented programming principles.
• Awareness of the role of programming within the larger software engineering context, along with more general attitudes and study skills appropriate for Computing Science.
• To acknowledge the complexity of this subject, progression requirements into Level 2 have been set a grade higher than for a standard pass. In this way, a solid performance is rewarded, even if we do not view the candidate as having the necessary skills for progression.

Aims

To produce programmers equipped with an understanding of

• fundamental computational concepts underlying most programming languages
• a range of problem solving techniques using computers
• the role of programming within the overall software development process
• attitudes and working practices appropriate for a professional programmer

• the solution of small problems using a programming language
• the clear expression of solutions at different levels of abstraction
• independent and self-motivated study in Computing Science.

Objectives

On completion of the course, the student should

Knowledge - know about:

• techniques for solving problems
• basic computational concepts and elementary data structures
• the edit-compile-link-run cycle from a user point of view
• testing strategies
• the main activities of software development and their interactions, and some of the major problems of software development

Skills - be able to:

• hand-execute simple programs, showing how input data is processed, output data is produced, and how the values of internal variables change
• explain at various levels the behaviour of fragments of programming language code
• amend existing programs to adjust or correct their functionality
• translate well-structured plans into working programs
• analyse simple problems involving text, numbers and graphics, producing a top-level plan with refinements
• use the error messages of the compiler to identify and correct mistakes in program syntax
• use testing strategies to identify and correct semantic errors in programs

Attitudes - appreciate that:

• a programmer requires creativity in order to solve problems and precision in the construction and manipulation of programming language code
• a programmer builds up a repertoire of techniques for solving problems, usually adapting and reusing techniques as each new problem is encountered
• a programmer must be able to communicate his/her ideas to others
• effective programming requires effort both in front of and away from a computer
• learning to program requires commitment and perseverance

Content

The following are not presented in an intended chronological order of delivery, nor are they intended to be delivered as discrete units.

Overview and Introduction: Overview of programming; background, history and context; programming languages; programming environment; compilers; the edit-compile-link-execute model; portability; programming style and conventions; hand-execution of simple programs.

Problem solving: Understanding the problem; plans; top-down design / stepwise refinement; recognition of similarities between problems leading to adaptation and reuse.

Fundamental computational concepts: Syntax and semantics; statements and expressions - execution and evaluation; flow of control - sequence, iteration, selection; state - declaration, update and use of variables; procedural and functional abstraction - declaration, use, parameters and results; I/O - graphical and textual; types - primitive and compound types, type checking; program units; programming models - simulation, data processing, event-driven.

Programming language concepts (language-specific implementations of the concepts above): Comments; identifiers; elementary types - numeric, boolean, character, enumeration; text and graphical I/O packages; variables, types and expressions; declarations and statements; iteration (while, for, etc.); selection (if, case); procedures and functions; parameters and parameter passing modes; type compatibility and strong typing; elementary data structures - arrays, strings, records, arrays of records; text files and sequential files; exceptions; program units - packages.

Testing and debugging: compile-time and run-time errors; interpreting error diagnostics; use of diagnostic statements; stubs and drivers.

Algorithms: Linear and binary search; simple sorting algorithms.

The software development process: The software life cycle; requirements; specification; design; implementation; testing; maintenance; documentation. the importance of accurate requirements; managing the process; controlling change; software components and re-use. Case studies of software development to illustrate problems.