General

Download

Overview
Project History
People

Use Cases Scenarios
Use Case Requirements
Bugs and Known Limitations
LHA

User Manuals Getting Started
General Tour
Configuration Options
Logging Tool Tour
Administration Tool Tour

Developers Architecture
Analysis of Design
Creating Plugins
Future Enhancements

Design Analysis

Analysing Support for Functional Requirements

Analysing Support for Non-Functional Requirements

Designing for Testability

• Develop an API to isolate presentation code from code use to support business operations and data persistence
• Make the presentation code interact with an API that is expressed as an interface, not as a concrete class.
• Establish exception handling policy
• Use custom checked exceptions that include useful messages for people and error codes for testing programs.
• Develop test features which can reset the data repository to a known state.
• Maintain automated test suites

Designing for Reusability

• Reuse at the Policy Level: Apache Open Source License promotes software reuse
• Reuse of Ideas: Functional requirements, design issues and the architecture have all been documented
• Reuse of code for other applications
  • Minimising technological dependencies makes application portable
  • Following coding standards and naming conventions invites reuse
  • Generating tool suite from a model makes CST domain-independent
  • Ability to launch tools as standalone applications or components makes the tool suite versatile
  • Notion of session variables supported
  • Minimal use of static variables
  • A session status flag is used to indicate whether the tools are running in standalone or component mode
  • Startup options for the tools can be parameterised through property files
  • LoggingService and AdminService APIs allow business logic to be reused by client applications
  • Ability to support plugins promotes integration of other software components
• Reuse of code within the application
  • Inheritance has been used to consolidate code used by related classes
  • Composition has been used to consolidate code used by unrelated classe
• Reuse of Data: Support for Data Migration

Designing for Extensibility

• Use a model-driven approach for generating generic features
• Support a plugin framework for domain-specific features
• Provide a synchronisation feature for ensuring consistency between the configuration file and database
• Provide design documentation for extending the code base

Designing for Maintainability

• Attract Stake Holders to Share Maintenance Costs
  • If it is feasible, design for a family of use cases rather than just one
  • Isolate sensitive data from the rest of the code base
  • Open source non-sensitive parts of the application
  • Allow groups to adapt the code base without requiring them to publish their changes.
• Develop a Design Philosophy for Maintenance
• Favour Planned Design over Agile Development
• Design for testability and software reuse
• Support maintenance by project members with different skill sets
  • Generate activity forms from a configuration file
  • Isolate user interface messages in a properties file
  • Produce design documents
  • Adopt coding conventions and best practices
  • Support a plugin framework

Author: Kevin Garwood

---

(c)2010 Medical Research Council. Licensed under Apache 2.0.