Software Design and Implementation Quiz

Software Design and Implementation

• Software design and implementation is the stage in the software engineering process where an executable software system is developed.
• Activities in design and implementation are often interleaved.
• Software design is a creative process involving identifying software components and their relationships based on customer requirements.
• Implementation is the process of turning the design into a program.

Build or Buy

• In various domains, it's often possible to buy off-the-shelf systems (COTS) that can be adapted to meet user requirements.
• This approach, using pre-built systems, can be more cost-effective and faster than developing from scratch (especially for systems like medical records).
• When adapting COTS, design focuses on using the system's configuration features to achieve the required functionality.

Object-Oriented Design Process

• Structured object-oriented design involves developing multiple system models.
• Developing and maintaining these models requires substantial effort, which may not be cost-effective for small systems.
• For large systems developed by different groups, design models are essential for communication.

Process Stages

• Diverse object-oriented design processes exist, depending on the organization.
• Common activities include defining the system's context and modes of use, designing the system architecture, identifying principal system objects, developing design models, and specifying object interfaces.
• An example process is designing for a wilderness weather station.

System Context and Interactions

• Understanding the relationships between the software and its external environment is crucial for proper system functionality and communication.
• Defining system boundaries clarifies which features belong to the designed system and which belong to other systems.

Context and Interaction Models

• A system context model illustrates the relationships between the system being developed and other systems in its environment.
• An interaction model dynamically depicts how the system interacts with its environment.

Architectural Design

• Once system-environment interactions are well-understood, system architecture design is undertaken.
• Identifying major system components, their interactions, and choosing architectural patterns (e.g., layered, client-server) is key for this stage.
• An example would be the design of an independent subsystem communicating with a weather station by broadcasting messages on a shared infrastructure.

Object Class Identification

• Identifying object classes in object-oriented design is typically not straightforward.
• It relies on the skill, experience, and domain expertise of the designers.
• Object identification is an iterative process, as it's uncommon to get it right from the outset.

Approaches to Identification

• Various approaches to object identification exist.
• Grammatical analysis based on natural language descriptions of the system.
• Identifying tangible entities and components within the application domain.
• Behavioural analysis that identifies objects based on their roles in system actions.
• Scenario-based analysis that identifies objects, attributes, and methods based on use cases.

Weather Station Object Classes

• Object class identification in a weather station system can be rooted in tangible hardware and data components.
• Example classes include hardware objects like ground thermometers or anemometers, and classes like the weather station itself and weather data.
• These classes reflect the hardware and the system's interaction with the environment, as detailed in its use-case model.

Design Models

• Design models illustrate the objects, classes, and relationships within the system.
• There are two principal types:
  • Structural models depict the system's static structure based on object classes and relationships.
  • Dynamic models portray dynamic interactions among objects.

Examples of Design Models

• Subsystem models demonstrate the grouping of objects into logical subsystems.
• Sequence models illustrate sequences of object interactions.
• State machine models portray how objects transition between states in response to events.
• Additional models like use-case models, aggregation models, and generalization models also exist.

Subsystem Models

• Subsystem models illustrate how the design is organized into logically related groups of objects.
• In UML, these groups are represented using packages, an encapsulation construct, to maintain logical structure.

Sequence Models

• Sequence models show the sequence of object interactions.
• Objects are positioned horizontally, and time is represented vertically.
• Interactions are designated by labelled arrows. Different arrow styles depict different interaction types.

State Diagrams

• State diagrams display how objects respond to various services and the state transitions triggered by these operations.
• State diagrams offer high-level models for system or object behavior.

Interface Specification

• Object and other component interfaces must be well-defined for parallel design.
• Designers should focus on hiding the interface representation within the object to simplify complexity.
• Objects might have multiple interfaces to accommodate various viewpoints.
• UML uses class diagrams for interface specifications. However, other programming languages may also be used.

Implementation Issues

• Implementation often involves issues beyond simple programming, such as reuse, configuration management, and development platforms.
• Reuse of existing components/systems is crucial in modern software.
• Configuration management is required to track software component versions.
• Host-target development requires deploying software to separate environments (e.g., develop on one computer, execute on another).

Reuse

• Software reuse became more prevalent in the 1990s and often involves a high-level programming language.
• Reusability of modules (e.g., functions and objects) in programming libraries was the primary means of reuse in the earlier eras.
• However, the cost-effectiveness of this approach has been increasingly problematic for larger, more complex projects as the level of code integration becomes more challenging in the face of reuse.

Reuse Levels

• Abstraction level reuse entails applying knowledge of existing successful abstractions to new designs without direct code copying.
• Object-level reuse involves employing pre-built object libraries without creating the code from scratch.
• Component-level reuse involves utilizing reusable components (sets of object and classes).
• System-level reuse includes complete pre-built application system reuse.

Reuse Costs

• Reuse can involve costs associated with evaluating existing software for applicability, purchase costs (these might be very high for large systems), adaptation costs (e.g. configuring for specific requirements), and integration costs (e.g. connecting code from different systems).

Configuration Management

• Configuration management is a crucial process for controlling the management and evolution of changing software systems.
• Its goal is to help all development team members locate system or code parts, understand any changes, and successfully complete the assembly process (compile and link components).

Configuration Management Activities

• Version management supports efficient recording and tracking of different software versions.
• System integration is necessary for specifying which software components belong to a particular version, facilitating automatic system creation from compiled components.
• Problem tracking involves reporting bugs and managing issues through a managed system; this enables developers to understand who is working on issues.

Development Platform Tools

• Integrated compiler systems help create, edit, and compile code.
• Language debugging systems aid in identifying and resolving errors.
• Graphical tools allow manipulating UML models.
• Testing tools such as JUnit are used for automated testing. These types of tools can accelerate testing and aid in identifying errors during various system integration stages.
• Project management support tools assist in handling multiple developments.

Integrated Development Environments (IDEs)

• Integrated development environments (IDEs) group various development tools into a single framework, providing a common interface for different development tasks; this aims to improve usability and efficiency.
• IDEs typically support specific languages, or offer frameworks and language support integration options.

Open Source Development

• Open source development involves publishing software source code, allowing community involvement.
• The Free Software Foundation (FSF) promotes this methodology.
• Modern open-source software frequently utilizes the Internet for efficient developer recruitment, maximizing the community of individuals contributing to the project.

Open Source Systems

• Linux is the most prominent open-source operating system, serving as a server and desktop environment.
• Other widely-used open source systems include Java, Apache's web server, and MySQL database management system.

Open Source Issues

• Key questions for considering open source components in software development include:
  • Should a product use open source components?
  • Should the project apply an open-source approach during its design?

Open Source Business

• Businesses that adopt open-source methodologies often structure their business models around providing support for the software rather than direct software sale.