Training Courses in the UK and Europe

Software Engineering In The Small And The Large

This three-day course is designed for those of us who have come to programming from other backgrounds, particularly science or engineering. It looks at the extremes of the programming skills spectrum. It assumes that you already know a language well, but that you might not have encountered all of the low-level techniques such as regular expressions, hashing, B-trees, etc.; as well as the high-level considerations of analysis, design and software project management. It aims to ensure that our software is efficient and maintainable in addition to being appropriate.

• Background
• Aims
• Audience
• Pre-requisites
• Duration and Construction
• Delivery
• Content

Background

Several well-known tricks and techniques have accumulated in the lore of programming over the last fifty years. Those of us who did not follow a computer science education run the risk of being unaware of some of them. There is a risk that our algorithms might be more difficult to follow, less elegant, less efficient, or more difficult to maintain and update than they could, or should, be. Of course, it's also important to be aware of when efficiency and maintainability really are important issues and when they are not.

In a review of Bentley's classic "Programming Pearls", it was once remarked that one must study design in the small and design in the large. In this course, as well as "the small", we also introduce some of the software engineering topics that are important for control and maintainability. Many a strategically important software system began with someone tinkering at their terminal, never imagining that they would still be supporting the software ten or more years later, and increasingly regretting the industrial-strength that had not been engineered in.

This course is complemented by the Design Patterns course that is also available. The patterns discussed there are specific to object-oriented architectures and languages, whereas this course is technology and language independent.

Aims

• To acquaint participants with detailed, algorithmic, language-independent programming techniques that have stood the test of time;
• To ensure that software is appropriately efficient;
• To learn how to tune code;
• To ensure that software is appropriately elegant;
• To ensure that software is appropriately maintainable;
• To acquaint participants with the software engineering issues important to medium- and large-scale software-intensive systems;

Audience

This course will be of interest to anyone involved in programming, but will be particularly interesting to those whose computational needs and experiences arose in another discipline.

Pre-requisites

Course participants will already know a high-level programming language such as Fortran, C or C++, for example.

Duration and Construction

The course last three days, typically from 0900 to 1630 and is delivered via lecture and discussion. Start, end and break times can be tailored to suit individual sites.

Delivery

Courses are normally delivered at the customer site.

The course deliverables comprise:

• lectures and a copy of the lecture notes;
• exercises and sample solutions;
• leading and moderating of discussion, questions and answers;
• reference and resource lists;

Content

Programming

• The right tool for the job
  • “Shrink-wrapped” packages
  • Tools
  • Problem- and domain- specific languages
  • Generators
  • Frameworks
  • Writing programs is a last resort
    
• Program organization
  • Tactical and strategic subroutines
  • Structured programming and the goto considered harmful
• Algorithms
  • Effective procedure
  • Letting data structures structure algorithms
  • Complexity
  • Recursion
  • Backtracking
• Efficiency
  • Jackson’s law
  • Believe profilers not programmers
  • ... and elegance
  • Optimizers and optimization
• Correctness
  • Assertions

Memory organization

• Integrity
  • Parity, checksums, error-correcting
• Data types
  • Character representations
  • Number representations

Abstract data types

• Objects
• Generic programming

Data (Re)Organization

• Data structures
  • Strings and ropes
  • Arrays
  • Stacks
  • Lists, queues, deques, buffers, ring buffers
  • Bags and sets
  • Trees, balanced trees, binary trees, B-trees, red-black trees
• Indexing
  • Benefits
  • Strategies
• Sorting
  • Bubble
  • Shell
  • Quick
  • Heap, radix, etc.
  • Merge sorts
• Normal forms
  • Normalization (or the software engineer's affirmation)
  • ... 3NF, BCNF...

Data Retrieval

• Searching
  • Binary search
  • Hashing, bins and buckets
  • ISAM and VSAM
  • Trees
  • Bitsets

Lexers, compilers and compiler compiling

• Regular expressions and context-free grammars
• State machines
  • The nature thereof
  • Generators

Security topics

• Encryption
  • Encryptions standards (e.g. DES)
  • Public-key encryption

Contacting

Please contact John Deacon by telephone on +44 20 7498 3773; by fax on +44 20 7498 3747; by emailing  jdeacon@jdl.co.uk; or by visiting http://www.jdl.co.uk

[ Home page | Courses List ]

Last modified: Thursday, 08-Feb-2007.
Copyright © 2007 John Deacon. All rights reserved.