Software Design Principles

Birla Institute Of Technology And Science–Pilani (BITS–Pilani) via Coursera

Go to class Write review

Overview

Coursera Flash Sale

40% Off Coursera Plus for 3 Months!

Grab it

Master the essential principles and patterns that form the foundation of modern software development. This comprehensive course guides you through the evolution of software design, from understanding the Software Engineering Body of Knowledge to implementing advanced architectural styles. You'll explore object-oriented design principles, refactoring techniques, and design patterns across disciplines, while learning to differentiate between high-level architectural design and low-level detailed design. Through practical examples and real-world applications, you'll gain expertise in aspect-oriented and service-oriented architectures, event-driven systems, and MVC patterns. By examining the historical progression of programming languages and development environments, you'll understand how to build systems ranging from simple to complex. This course equips you with the critical thinking skills to select appropriate architectural styles, apply design principles systematically, and create maintainable, scalable software solutions that meet evolving business requirements and technical challenges.

Syllabus

Software Design – A Key Knowledge Area

Software Engineering Body of Knowledge has steadily and rapidly evolved over the past decades. With software being a crucial part of nearly everything that one encounters on a day-to-day basis, it is imperative that the details of the importance and the process of design be understood. In this module, a systemic exploration of the key knowledge area of Software Design is presented with a view to understand the state of the art. As the state of the art is explored, a historical view with perspective is reviewed with some of popular examples and well-known cases.

Software Development Lifecycle and Design Roles

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.

Object-Oriented Design and Design Principles

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.

Design for Reuse and Design for Change – Refactoring

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.

Design Patterns - Historical Perspective and Relevance

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.

Crosscutting Concerns, Aspect-Oriented Design and Service-Oriented Architecture

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.

High-Level Design vs. Low-Level Design

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.

Basic Architectural Elements and Styles

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.

Architecture and Design Patterns

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.

Evolution of Software Development Systems

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.