Software Design Patterns

Design Patterns

• A pattern describes a problem with a well-tested and reusable solution.
• The purpose is to encapsulate best practices and design experiences for reuse in different settings.
• Design patterns have significantly influenced object-oriented software design by providing a shared vocabulary for discussing design solutions.
• The principle applies to any software design, including configuration patterns for reusable systems, though often used in object-oriented design.
• Pattern descriptions typically use object-oriented characteristics such as inheritance and polymorphism.

Pattern Elements

• Four essential elements are typically identified:
• Every pattern must have a meaningful name.
• Problem description explains when a pattern should be applied.
• Solution Description details the design solution's components, relationships, and responsibilities. It is often graphically represented.
• Consequences outline the results and trade-offs of using a pattern, to help determine its suitability.

Observer Pattern

• The name of this pattern is "Observer."
• Description: This pattern defines a one-to-many dependency between objects and allows multiple observers to be automatically updated when the subject changes its state.
• As a result, the display of the object's state is decoupled from the object itself.
• Problem: Useful when an object's state changes need to be reflected in multiple views/components.
• For example, in a weather station application, temperature and humidity displays need to update when new data is available.
• Components required:
  • The Subject maintains a list of observers and provides methods to attach and detach observers.
  • Observers define an interface for receiving updates from the subject.

Implications of using the Observer Pattern

• Optimizations to enhance display performance are impractical.
• Benefits include:
  • Loose Coupling: Observers can be added/removed without modifying the subject.
  • Dynamic Updates: Multiple views are updated in real-time as the state changes.
• Drawbacks include:
  • Performance Issues: Many observers can lead to notification overhead.
  • Management Complexity: Coordinating numerous observers and their lifecycles can be challenging.
  • Optimization Limitations: Immediate update requirements may hinder performance optimizations.

Addressing Design Problems with Design Patterns

• Design problems can often be addressed using established design patterns.
• The Observer pattern informs several objects when the state of another object changes, for notifying multiple objects of state changes.
• Apply the Façade pattern to streamline interfaces among related objects when simplifying interfaces.
• Implement the Iterator pattern to provide a uniform way to access elements when standardizing collection access.
• Use the Decorator pattern to add or extend functionalities when extending class functionality at runtime.

Implementation Issues

• Implementation issues extend beyond coding and encompass several critical aspects.
• Reusing existing components and systems maximizes the use of pre-existing code to improve efficiency and avoid redundancy.
• Manage different software component versions effectively as it is crucial during development. A configuration management system aids in tracking and controlling these versions.
• Develop software on one computer (the host system) but execute it on a different one (the target system), management of this separation is important for successful deployment and execution.

Reuse

• The concept of software reuse has evolved significantly from the 1960s to the 1990s.
• Initially, software development relied on reusable functions and objects within programming language libraries.
• However, increasing costs and schedule pressures, made this approach less feasible.
• Focus is now on reusing existing software to improve efficiency.
• Levels of Reuse:
  • Abstraction Level: Utilize knowledge from successful abstractions to guide software design.
  • Object Level: Reuse pre-existing objects from libraries.
  • Component Level: Employ collections of objects and classes, which can be integrated.
  • System Level: Reuse entire application systems.

Reuse Costs

• The costs include:
  • Search and Evaluation Costs: Time spent searching for reusable software
  • Acquisition Costs: Expenses related to purchasing reusable software
  • Adaptation and Configuration Costs: Costs of modifying reusable software components
  • Integration Costs: Integrating reusable software elements from various sources with each other and with newly developed code.

Configuration Management

• Oversee a changing software system to support system integration and ensure controlled access to project code and documents
• Activities include:
  • Version Management: Track different versions of software components & coordinate development.
  • System Integration: Help developers manage versions used to build each system version.
  • Problem Tracking: Allow users to report bugs/issues, and enable developers to track their status.

Host-Target Development

• Software is developed on one computer (the host) and run on a separate machine (the target).
• This generalizes to a development platform and an execution platform.
• Key tools for the development platform:
  • Integrated Compiler and Editor: For creating, editing, and compiling code.
  • Language Debugging System: For identifying and fixing code errors.
  • Graphical Editing Tools: For editing models, such as UML diagrams.
  • Testing Tools: For automatically running tests on new program versions.
  • Project Support Tools: For organizing and managing code across different projects.
• Development and execution platforms often differ in installed software and architectures.

Integrated Development Environments (IDEs)

• These are collections of software tools to support software development within a unified framework and user interface.
• Key points:
  • Tool Integration: Streamlines process by grouping multiple development tools together.
  • Common Framework: Tools work together seamlessly in a Common Framework.
  • Language-Specific Support: IDEs are often tailored to specific programming languages.

Component/System Deployment Factors

• When deploying components or systems, consider:
  • Platform Compatibility: Providing necessary hardware and software support.
  • High Availability: Deploying components on multiple platforms to provide redundancy.
  • Communication Efficiency: Minimizing message delay by deploying related components together.

Open Source Development

• Software development where a system's source code is publicly available, allowing volunteer contribution.
• Key aspects include:
  • Public Access: Source code is public for anyone to view, modify, and enhance.
  • Community Involvement: Volunteers participate in its development process.
  • Historical Roots: Rooted in the Free Software Foundation's philosophy.
  • Internet Utilization: Facilitates recruitment of a broad community of developers.

Open Source Systems

• Notable examples:
  • Linux is a widely-used operating system for servers and desktops.
  • Java is a popular programming language.
  • Apache Web Server is a major web server.
  • MySQL is a database management system.
• Issues to consider:
  • Use of components in your product.
  • Development approach.

Open Source Business

• It is a business model that leverages open source software as a core part of its operations.
• More companies are adopting open source methodologies that create and maintain software with publicly accessible source code.
• These systems encourage collaboration and contributions from the community.
• Instead of charging for the software, revenue can be generated by selling support, consulting, customization, and training. The expertise is monetized while keeping the software accessible.

Community Benefits (Open Source)

• Engaging with the open source community can lead to:
  • Community contributions enhance the software without development costs.
  • Faster feature releases and bug fixes with more developers.
  • Increased user engagement and product visibility through community.

Open Source Licensing

• While source code is freely available, its usage is governed by legal conditions set by the developer.
• Ownership: The developer retains ownership and imposes conditions on how the code is used.
• Usage conditions: Dictate if derivative works must also be open source or if proprietary systems can be developed.
• License Models include:
  • GNU General Public License (GPL): Any software uses GPL-licensed code to also be open source.
  • GNU Lesser General Public License (LGPL): Allows open source code in components without requiring the components to be open source.
  • Berkeley Standard Distribution (BSD) License: Permits inclusion in proprietary software.

License Management

• Key practices for open-source components include:
  • Maintain a record of all components downloaded and utilized by systematic tracking.
  • Understand license types and specific licensing terms by building license awareness.
  • Staying informed about development and updates of your components by tracking evolution pathways.
  • Educate team members about open-source practices and licensing.
  • Implement systems to audit and ensure compliance with licensing terms.
  • Actively participate in the open source community to stay informed and contribute through Community Engagement.