In the realm of software development, a complete understanding of the Software Development Lifecycle (SDLC) is foundational. This involves navigating through key phases such as planning, design, implementation, testing, deployment, and maintenance. An integral aspect of this understanding lies in differentiating between high-level and low-level design. The former provides a conceptual blueprint, defining the overall structure, while the latter delves into specifics, guiding the actual implementation. These design levels play a pivotal role in contributing to the efficiency of each SDLC phase, with high-level design setting the foundation and low-level design adding intricate details. Moreover, the application of design principles is crucial for a smooth transition between these phases, ensuring consistency, scalability, and maintainability throughout the software development journey.

In this module, the Objection-Oriented Design is discussed to enable the learning of foundational methods using such a design, along with its significance. Key concepts like abstraction, inheritance, and polymorphism are discussed, and their benefits are explored with examples.

Refactoring is very beneficial when it comes to evolving code to a different level of maintainability and scalability. While developers desire to develop new code at all times; they do encounter situations, most of the time, to modify the current code to either build a feature or fix a defect; while doing so, an eye-for-refactoring can do wonders. In this module, let’s explore and apply some of the principles to refactor code.

This module explores the design patterns – especially in comparison to other domains like building architecture. The historical evolution of design patterns across disciplines provides insights into their origin and transformation. A comparative analysis between design patterns in building architecture and software design reveals shared principles and distinct methodologies. Modern software design methodologies have been influenced by such architectures and lessons so applied can bring the best for the software design.

Software design methods, at times, are driven by a variety of factors. In this module the aspect-oriented design is explored which addresses the cross-cutting concerns that are identified during the requirements process. Information exchange over the web is another commonly used method and service-oriented architecture is a way to build distributed software using web services. In this module both are discussed and detailed using examples.

Any design process, typically, follows two steps: a High-Level Design (HLD) and a Low-Level Design (LLD). A High-Level Design (Architectural Design) or Top-Level Design describes how software is organised into components. A Low-Level Design or Detailed Design describes the desired behaviour of these components. At this stage of the course, in this module, the HLD and LLD are discussed for learners to understand and apply the two-step process.

Over decades, software architecture has evolved to a level where the elements and styles now can be applied to solve specific problem statements. In this module, all architectural styles are discussed – General Structures, Distributed Systems, Interactive Systems, Adaptable Systems and Others, which enable building the knowledge and skill to apply such elements and style to design and construct great software.

As a designer, one would encounter these patterns nearly at all times when developing interactive applications. In this module the two main styles Event-Driven Architectures and Interactive systems (Model View Controller) in UI are discussed and detailed with examples.

In this concluding module, a detailed discussion is made on the historical progression of software development systems in terms of programming languages, software engineering and IDEs. With the discussion and detailing of the mechanisms to build simple to complex systems the learner will be able to navigate the existing software systems and will also be able to develop new ones.