Contemporary Application Development Methods

The subject offers an introduction to modern application development techniques and tools, with particular emphasis on rapid prototyping, data access, object-oriented concepts and visual development environments, including some basic guidelines of user interface design.

Aims

1. Introduce students to the main concepts of object-oriented programming and design;
2. Introduce students to the Unified Modelling Language notation (UML) for expressing simple object-oriented designs;
3. Introduce students to the concept of rapid prototyping, and how to approach rapid prototyping methodically;
4. Make students aware of the facilities available in a typical modern visual development environment (e.g., Visual Basic, Delphi, Visual J++, C++ Builder);
5. Introduce students to guidelines of good user interface design.

1. Explain the main concepts of object-orientation;

2. Design a simple object-oriented application;

3. Express a simple object-oriented design using a subset of the Unified Modelling Language (UML);

4. Describe in detail the iterative prototyping lifecycle, and discuss where the rapid prototyping approach is likely to be useful, and why;

5. Describe the essential features of a modern visual development environment which enable rapid application development, especially with regard to database applications;

6. Explain the eight golden rules of user interface design.

Object, state and properties, behaviour and methods, encapsulation, information hiding, class, inheritance, polymorphism. Object relationships, class relationships

The diagrammatic notations for objects, classes, inheritance diagrams, state charts, use cases, sequence diagrams.

A simple object-oriented design method, based on identifying classes, responsibilities and collaborations (CRC).

The iterative prototyping lifecycle: specification of first iteration prototype, identifying evaluation criteria, building the prototype, evaluation, specification of next iteration prototype.

Event-driven environments, visual layout facilities, controls (visual and non-visual), properties, methods, events. Database access, building front ends for simple database applications.

Consistency, shortcuts, informative feedback, closure, error handling, undo facilities, internal locus of control, reducing short-term memory load.

By written examination. The pass mark is 40%. Time allowed 3 hours.

The question paper will contain: Seven questions from which four must be answered. All questions carry 25 markes.

Although the exam is theoretical (candidates will not be asked to write program code) it is unlikely that a candidate will achieve a good grade unless they have completed and understood the practical parts of the module.

A good introduction to object-oriented concepts, object-oriented design and the UML can be found in:

Database access using Visual Basic is covered in:

Access to a modern visual development environment (e.g., Visual Basic) and compatible database software (e.g., Microsoft Access) on Windows 95, 98 or NT. Although Visual Basic does not support all of the concepts of object-orientation (e.g., inheritance) it does support most. Where this module is being offered as a "follow-on" to the Introductory Programming module from the ABE Diploma (part 2) and if the language used in that module was Visual Basic, it is recommended that Visual Basic be used for this module too to avoid giving candidates the extra overhead of learning a second a second language. Those aspects of object-orientation not directly supported by Visual Basic can be treated in a theoretical manner without any loss in module quality.

Microsoft Visual Basic Version 6; Microsoft Access 2000.

It is recommended that the concepts are related to a case study which is developed as the module progresses and concepts are introduced. Wherever possible, the theoretical presentation of concepts should be followed up with a practical exercise that demonstrates how the concepts can be applied to the case study. The order in which the topics are taught can vary according to the tutor’s approach and the details of the case study.

This topic can be presented as both a natural progression of the concepts of modularity (it can be pointed out that encapsulation and information hiding are techniques which can be used in most programming languages to enhance the modularity of an application). As it is expected that candidates will have had a reasonable amount of experience of using the built-in components of the development environment, this topic can also be presented from the perspective of a developer wanting to create their own component-like classes. Candidates should be reminded that they have been using objects all along (e.g., Buttons, Textboxes, etc.) – setting and retrieving their properties and invoking their methods. It is probably best to introduce simple stand alone classes, and then introduce relationships between classes when candidates have become familiar with the basic principles.

It is not the intention of this module to cover the UML, or object-oriented design, in great depth. This topic is included to provide candidates with a simple strategy for identifying classes in a specification, identifying what information those classes should encapsulate, what roles they play within the system and what other classes they need to communicate with in order to fulfil those roles. The UML is introduced to provide candidates with a basic diagrammatic language that they can use to help communicate their ideas and (simple) designs. As such only the essentials of the notations for objects, classes, inheritance diagrams, use cases and sequence diagrams need be covered. It is suggested that the notations be introduced along with the concepts to which they relate – e.g., inheritance diagrams can be shown when introducing the concept of inheritance.

Prototyping is often seen (unfortunately) as an undisciplined substitute for proper analysis and design, so this topic should emphasise the methodical nature of the prototyping process and its purpose within the analysis phase of development, viz., to clarify requirements. Although prototyping can be applied to many aspects of a system’s specification, in the context of this module it may be useful to include an exercise in the prototyping of a graphical user interface (in which case this should be taken in to account when choosing the case study). Such an exercise would integrate this topic with the User Interface Design Guidelines and Visual Development Environments topics.

It is essential that the development environment chosen for this module should be one of the modern visual, event-driven environments, such as Visual Basic, Delphi, Jbuilder, etc. Candidates will then have practical experience of visual layout facilities, controls (visual and non-visual), properties, methods and events. In essence, this topic should run throughout the module, with relevant features being introduced in the practical sessions. The interfacing with databases aspect of this topic should illustrate the special features (data modules, bound controls, dataset/record set navigation, use of SQL) which facilitate the construction of simple "front-end" applications. However care should be taken not to give the impression (often present in the marketing materials for these environments) that industrial strength applications can be created without writing any code. Techniques for producing maintainable applications should be covered; e.g., the separating of user interface code from the code which interacts with the database.

It is not necessary to delve deeply into human cognitive psychology within this topic. Rather the intention is to provide practical advice and guidelines on how to produce intuitive, user-friendly interfaces. This includes advice about what not to do, as well as what should be done. Each of the main guidelines (taken from the GUIDE method) should be demonstrated with an example of a UI fragment in which the principle is broken, showing the consequences for the user, followed by the same fragment redesigned to adhere to the principle. The guidelines should be presented as just that – guidelines, and not as "cast-in-stone commandments".

The emphasis in this module is on a disciplined approach to the use of modern, visually-oriented application development environments and rapid prototyping techniques. This approach is based on a firm understanding of what these environments are actually doing for the developer. This will enable candidates to utilise their environment effectively, and to cope with the inevitable occasions when the environment does not provide exactly the facilities that they require. Most modern applications are written for platforms which include a graphical user interface (GUI) whose interactive possibilities are very rich, and modern development environments include advanced facilities for incorporating GUI components into applications. It is therefore important that candidates have some grounding in user interface design in order to make appropriate use of the facilities available.