LECTURE 6

Characteristics of a Good Design

These characteristics help create software that is robust, efficient, and easy to maintain and enhance
over time.

● Modularity: Software should be divided into distinct modules or components, each

with a specific responsibility, making it easier to manage, test, and maintain.
● Maintainability: Code should be written clearly and structured logically, allowing
developers to easily update and fix issues without introducing new bugs.
● Scalability: The design should support future growth, enabling the software to handle
increased loads and accommodate new features without major changes.
● Performance: Efficient algorithms and data structures should be employed to ensure
that the software performs well under various conditions.
● Reusability: Components and modules should be designed to be reusable across
different projects or contexts, minimizing redundancy and saving development time.
● Security: Incorporating security best practices to protect against vulnerabilities and
ensure data integrity and privacy from the outset.
Characteristics of a Good Design
● Testability: The design should allow for easy unit testing and integration testing,
facilitating the identification and resolution of issues early in the development process.
● User-Centric Design: Focusing on the end-user experience, ensuring that the software is
intuitive, accessible, and meets the users' needs effectively.
● Flexibility: The architecture should allow for changes in requirements without requiring
extensive redesign, enabling quick adaptation to new needs.
● Documentation: Comprehensive documentation should accompany the design to aid
understanding, maintenance, and onboarding of new developers.
● Consistency: Following established patterns and practices throughout the codebase
ensures a uniform structure and behavior, making the software easier to understand and
use.
● Version Control: Utilizing version control systems to manage code changes, facilitating
collaboration and tracking the history of modifications.
Structured Design
Structured design is a software engineering methodology focused on breaking
down a system into smaller, manageable components. It emphasizes a
top-down approach to design, where the system is decomposed into modules
or functions, each addressing a specific part of the functionality.
Structure Chart
● A structure chart is a graphic representation of the organization of the
program structure in the form of a hierarchy of modules.
● Modules performing high-level tasks are placed in the upper levels of the
hierarchy, whereas those performing low-level detailed tasks appear at the
lower levels. They are represented by rectangles.
● Module names are so selected as to explain the primary tasks the modules
perform.
Process Design Language (PDL)
● In the context of software construction, a Process Design Language (PDL) is a
tool or formalized language used to describe the processes and behavior of a
software system.
● It typically focuses on the design, flow of control, and interactions within a system
or among system components.
● The key goal of a PDL is to bridge the gap between high-level system design (like
flowcharts, pseudocode, or architecture) and actual code implementation.
● PDLs help both in specifying the software's functionality and in aiding
communication between designers, developers, and stakeholders.
Key Concepts in PDL for Software Construction
1. Structured Descriptions: PDL allows developers to describe how software components interact and what
steps or procedures need to be followed to accomplish specific tasks. It’s similar to pseudocode but more
focused on process flow, algorithms, and interactions.
2. Control Flow and Logic: PDLs often capture decision-making logic, iterative processes (loops), conditional
statements, concurrency, synchronization, and exception handling. This makes them valuable for clearly
outlining how a system will behave under various conditions.
3. Modularity: PDL often supports a modular design approach, breaking down complex systems into
manageable components or modules. Each module may have its own process or behavior specification.
4. Implementation Agnostic: While PDLs describe processes and behaviors, they are typically
language-agnostic and can be implemented in various programming languages. This abstraction helps
developers focus on what the system should do without being bogged down by syntax or specific
programming constructs.
5. Validation and Simulation: Some PDLs can be used to validate the design or simulate processes before
coding begins. This can ensure that certain logic errors, inefficiencies, or race conditions are detected early
in the design phase.
6. Concurrency and Distributed Systems: In distributed systems, a PDL can be used to specify the
interactions between components running on different machines, handling asynchronous processes and
messaging.
Examples of PDL in Software Engineering
1. UML Activity Diagrams: Unified Modeling Language (UML) includes activity diagrams, which are a
form of PDL that captures workflows and business processes. It’s a way to describe how different
parts of a system interact, how control flows through a process, and how decisions are made.
2. Pseudocode: While not formalized, pseudocode serves as a kind of informal PDL, helping
engineers specify the logic and process of the software without worrying about specific language
syntax.
3. State Machines and Finite State Diagrams: These are used to describe systems that operate in
various states, transitioning based on events. This is a form of process design, especially useful for
reactive systems.
4. Business Process Model and Notation (BPMN): BPMN is a standard for describing business
processes. It can be considered a high-level PDL for software construction, particularly for systems
that automate or support business workflows.
Benefits of Using PDL
● Improved Clarity: Provides a clear specification of how the system operates.
● Early Error Detection: Helps in identifying potential logic or design flaws early in the design phase.
● Better Communication: Acts as a common language for developers, designers, and stakeholders.
● Easier Maintenance: The process logic and flow are well documented, making it easier to understand and
modify the system later.
Sequence Construct
The sequence construct is one of the basic control flow structures used in both software design
and programming. It refers to the straightforward execution of statements or instructions in a
specific, linear order — one after the other. There are no branches or loops in a sequence
construct; each step follows directly from the previous one.

Characteristics of a Sequence Construct:

1. Linear Execution: Operations are performed in the exact order in which they are written or
specified. There is no decision-making or repetition involved.
2. No Branching: The flow of control doesn't change based on conditions. Each step follows
the previous one.
3. Simple to Implement: Sequence constructs are the simplest form of logic to implement in
programming or design since they don't involve conditional logic or loops.
4. Foundational: Even though real-world systems often need more complex constructs (like
selection or iteration), sequences are fundamental building blocks for these higher-level
structures.
In pseudocode or Process Design Language (PDL), a sequence might look like this:

Process: Simple Sequence Example

1. Input the user's name.

2. Display a greeting message with the user's name.

3. Ask the user to input their age.

4. Display a message stating their age.

End Process
Real-World Usage
● Initialization Routines: Often, system or application initialization routines use
sequences to prepare all components or services in a specific order.
● Data Processing Pipelines: Simple data pipelines often follow a sequence where data
is fetched, processed, and output.
● User Input Handling: A basic form is found in applications that ask users to provide
input and respond accordingly in a predetermined sequence.

❏ The sequence construct is fundamental and forms the backbone of more complex
control structures like selection (conditional) and iteration (looping) constructs.
 Control Flow Constructs
● In software construction, control flow constructs are essential to determine the behavior of a program.
● Three fundamental constructs often used in algorithms and program designs are the if construct, the selection
construct, and the repetition construct. Each of these constructs alters the flow of a program based on
conditions or loops.

1. If Construct
The if construct is used to control the flow of a program based on a condition. It allows a program to execute
certain code only if a specified condition is true.

Characteristics:

● Condition-based Execution: The program checks a condition (true/false) and executes a block of code
only if the condition evaluates to true.
● Optional Else: Often used with an else statement to execute alternative code if the condition is false.
if age >= 18:

print("You are eligible to vote.")

else:

print("You are not eligible to vote.")

2. Selection Construct

The selection construct (also known as a decision construct) enables a program to choose between different
options or branches based on a condition. The most common forms of selection constructs are if-else and
switch/case statements.

Types of Selection Constructs:

● If-else: Chooses between two alternatives (already discussed above).

● Switch/case: A form of selection that allows multiple potential paths depending on the value of an
expression.

3. Repetition Construct
The repetition construct (also known as a looping construct) allows a section of code to be repeated multiple
times based on a condition or counter. This construct is essential for processes that need iteration, such as iterating
over arrays or continuously checking a condition.

Types of Repetition Constructs:

● For Loop: Repeats a block of code a specified number of times.

● While Loop: Repeats code as long as a condition is true.
● Do-While Loop: Similar to a while loop, but ensures the code block is executed at least once before
checking the condition.
 Interface Description Language (IDL)
● An Interface Description Language (IDL) is a formal specification language used to define the interfaces between
software components, often in distributed systems or systems involving different programming languages.
● The primary purpose of an IDL is to specify the methods, data types, and communication protocols that different
components or systems use to interact, regardless of how they are implemented.

Key Aspects of Interface Description Language (IDL):

1. Platform and Language Independence: IDLs are typically designed to be platform-agnostic and
programming-language-neutral. This enables different software components, written in various programming
languages or running on different systems, to communicate with each other seamlessly.
2. Method and Data Type Definitions: IDLs define the methods or procedures that can be called remotely, along
with their input and output parameters, and the data types used. This helps in ensuring that systems exchanging
data or invoking methods understand the expected structure and format of data.
3. Cross-Language Communication: One of the most common use cases of an IDL is in Remote Procedure
Calls (RPC) or Object Request Brokers (ORB), where software components implemented in different
languages (like C++ and Java) need to interact. The IDL defines the interface so that code can be generated to
handle the translation between languages.
4. Decoupling Implementation from Interface: An IDL specifies what operations are available without detailing
how they are implemented. This decouples the interface (how components interact) from the implementation
(the code that performs the work), promoting modular design.
Use Cases of IDL:
● Distributed Systems: In a system where multiple services (like microservices) need to
communicate over a network, IDL provides a clear contract for how these services should interact.
● Component-based Systems: IDLs are often used to define the interfaces in component-based
software architectures, such as CORBA (Common Object Request Broker Architecture) or COM
(Component Object Model).
● RPC Mechanisms: IDLs are fundamental in RPC frameworks, such as Google Protocol Buffers
(ProtoBuf), Thrift, gRPC, or Apache Avro, where they define the interface for remote calls
between distributed services.

Key Features of an IDL:

1. Service Definitions: Defines the operations or functions that can be invoked, including their
signatures (input parameters, return types).
2. Data Structures: Specifies the types of data that can be passed in messages, such as integers,
strings, arrays, objects, or user-defined types (like structs or records).
3. Exception Handling: Many IDLs also define how errors or exceptions are to be communicated
between systems.
4. Versioning: Some IDLs allow for versioning of interfaces, making it easier to evolve services
without breaking compatibility.
Popular IDLs in Software Construction:
1. CORBA IDL: Used in Common Object Request Broker Architecture (CORBA) to
define interfaces for distributed objects.
2. Web Services Description Language (WSDL): An XML-based IDL used for describing
web services in a service-oriented architecture (SOA).
3. Thrift: Developed by Facebook, Thrift is an IDL used for cross-language services,
supporting multiple programming languages and protocols.
4. Protocol Buffers (ProtoBuf): Google’s IDL, used primarily in gRPC, is highly efficient
and language-neutral for defining services and messages.
5. OpenAPI (formerly Swagger): Used for defining RESTful APIs, though not always
referred to as an IDL, it provides a similar function by specifying the interactions between
web services and clients.
Benefits of Using IDL in Software Construction:
● Interoperability: IDLs enable components in different languages and platforms to
communicate effectively.
● Clear Contract: The use of an IDL ensures a well-defined contract between services,
reducing ambiguity and errors during integration.
● Automated Code Generation: Many IDL frameworks allow for automated generation
of client and server code, which speeds up development and reduces manual effort.
● Modularization: IDLs promote loose coupling between components, which makes
systems more maintainable and scalable.