TOPCIT - Software Development

Software Engineering

A technical discipline that focuses on the systematic development, operation, and maintenance of software to ensure quality and productivity. It emerged in response to the "software crisis" of the 1960s, aiming to manage complexity and improve reliability.

Software Lifecycle

A structured process that defines the stages of software development, including requirements analysis, design, implementation, testing, deployment, and maintenance

Software Process Models

A framework that outlines structured approaches to software development, such as Waterfall, Agile, and Spiral models, to improve efficiency and predictability.

Software Design

A software engineering phase that translates analysis requirements into a blueprint for implementation.

Software Requirement Management

A software engineering practice that ensures requirements are properly documented, tracked, and validated throughout development.

Software Configuration Management

A software engineering discipline that controls changes to software artifacts to maintain integrity and consistency.

Software Quality Management

A software engineering approach that ensures software meets predefined standards and user expectations through testing and validation.

Software Integration in Business

A trend where software is increasingly embedded in business processes, driving demand for skilled developers and structured development practices.

Project Failures in Software Development

A common issue caused by factors such as lack of skilled developers, inadequate development culture, and poor design practices.

Software Engineering

A field that emerged in the 1960s to address the "software crisis," which arose due to increasing software complexity and late defect discovery, aimed at enabling successful software development that meets requirements, is maintainable, and reusable, using systematic approaches to manage challenges throughout the software lifecycle.

Process

A software engineering element that refers to the sequence of activities in the software lifecycle, including requirements analysis, design, implementation, testing, and maintenance.

Example: The DevOps process integrates development and operations for continuous delivery.

Method

A software engineering element that describes systematic ways of performing development, operation, and maintenance activities, including program structure, algorithms, coding, testing, and maintenance techniques.

Example: Test-driven development (TDD) ensures code correctness by writing tests before implementation.

Tools

A software engineering element that refers to automated methods used to enhance productivity and consistency throughout the software lifecycle, ideally integrating information across different tools.

Example: Integrated Development Environments (IDEs) like Visual Studio streamline coding and debugging.

Procedure

A software engineering element that defines the necessary steps to implement a method and effectively use a tool in software development.

Example: A code review procedure ensures adherence to best practices before merging changes into production.

Software Reuse

A software development method aimed at reducing development time, maintaining new features, decreasing costs, and improving overall quality and productivity.

Example: A company developing multiple web applications reuses authentication modules across different projects instead of writing new ones from scratch.

Code Reuse

A software reuse practice that involves using existing code components in new projects to improve efficiency.

Example: Open-source libraries like React.js or Bootstrap allow developers to reuse UI components instead of building them from scratch.

Software Standardization

A software reuse approach that ensures consistency in development by defining common frameworks, coding styles, and best practices.

Example: A company adopts RESTful API standards across all its applications to ensure uniform communication between services.

Software Maintenance

A software reuse concept that involves updating and improving existing software components for future use.

Example: A software team maintains a shared database connection module to ensure compatibility with new versions of their applications.

Establishing a Reuse Culture

A business strategy that encourages development teams to adopt software reuse practices by changing perceptions and workflows.

Example: A company implements internal code repositories where developers can share and reuse tested components.

Incentives for Reuse

A business approach that motivates developers to engage in reuse activities by recognizing contributions and ensuring reliability.

Example: A company offers performance bonuses to teams that successfully integrate reusable components into new projects.

Internal Information Reuse

A software reuse approach that leverages knowledge acquired through education and experience within an organization.

Example: A development team reuses internal security policies when designing new applications.

External Information Reuse

A software reuse approach that incorporates knowledge gained from external development projects or industry standards.

Example: A company adopts OAuth 2.0 authentication standards from external sources to improve security in its applications.

System Architecture Reuse

A software reuse strategy that applies proven architectural patterns to new projects.

Example: A company reuses microservices architecture for multiple applications to ensure scalability and modularity.

System Design Reuse

A software reuse strategy that applies existing design patterns to new projects.

Example: A development team reuses MVC (Model-View-Controller) design patterns across different web applications.

Program Reuse

A software reuse strategy that incorporates existing code modules into new applications.

Example: A game development company reuses physics simulation libraries across multiple game titles.

Technical and Managerial Obstacles

Challenges in software reuse, such as difficulty finding suitable components or resistance to using others' code.

Example: A team struggles to reuse legacy code due to outdated documentation and compatibility issues.

Organizational Obstacles

Barriers to software reuse caused by company culture, lack of incentives, or poor documentation.

Example: Developers hesitate to reuse shared libraries due to unclear ownership and maintenance responsibilities.

High-Quality Software Creations

A benefit of software reuse that improves software reliability and consistency.

Example: A fintech company reuses tested encryption algorithms to ensure secure transactions.

Time and Resource Savings

A benefit of software reuse that reduces development effort and costs.

Example: A startup accelerates product development by reusing open-source frameworks like Django and Flask.

Educational Benefits

A benefit of software reuse that enhances understanding of system structure and development methods.

Example: Junior developers learn best practices by studying reusable code snippets from experienced engineers.

Reverse Engineering

A software analysis process that examines a developed system to understand and potentially modify it, often reconstructing design information from the implementation.

Managing System Complexities

A reason for reverse engineering when frequent changes lead to increased system complexity, making maintenance difficult.

Example: A company reverse-engineers legacy code to document its structure before making updates.

System Migration and Downsizing

A reason for reverse engineering when transitioning from mainframes or older systems to modern architectures.

Example: A bank reverse-engineers its mainframe-based transaction system to migrate it to a cloud-based infrastructure.

Improved Maintenance

A benefit of reverse engineering that provides analysis of an existing system’s data and information, aiding future modifications.

Example: A software team reverse-engineers an outdated ERP system to understand dependencies before upgrading it

Use of CASE Tools

A benefit of reverse engineering that allows clarification and storage of system information using Computer-Aided Software Engineering (CASE) tools.

Example: Developers use Enterprise Architect to reverse-engineer UML diagrams from existing source code

Redocumentation Engineering

A reverse engineering type that creates documentation from source code or binaries to improve understanding.

Example: A development team generates automated API documentation from existing code using tools like Swagger.

Design Recovery Engineering

A reverse engineering type that extracts design information from source code or binaries to reconstruct architectural details.

Example: Engineers use IDA Pro to reverse-engineer software binaries and recover design logic.

Reverse Engineering for System Creation

A reverse engineering type that analyzes an existing system to create a new one, such as a database.

Example: A company reverse-engineers an old customer database to migrate it to a modern NoSQL system like MongoDB.

Array

A linear data structure that stores elements in contiguous memory locations, allowing fast access via indexing.

Example: A game leaderboard stores player scores in this data structure for quick retrieval.

Linked Lists

A dynamic data structure that allows insertion and deletion of elements at arbitrary positions.

Example: A music playlist uses this data structure to manage song order dynamically.

Stack

A linear data structure operating on the Last In, First Out (LIFO) principle, where elements are added and removed from the top.

Example: A web browser's back button uses this data structure to store visited pages.

Queues

A linear data structure operating on the First In, First Out (FIFO) principle, where elements are added at the rear and removed from the front.

Example: A printer processes print jobs in the order they are received.

H-trees

A recursive tree structure used in fractal-based designs and hierarchical data representation.

Example: VLSI circuit design uses this for efficient layout planning.

Tree

A nonlinear data structure with a hierarchical parent-child relationship, starting from a root node.

Example: File systems use these structures to organize directories and files.

Graphs

A set of vertices (nodes) connected by edges, used to model relationships in networks, AI, and search algorithms.

Example: Social networks use this to represent user connections.

Correctness

An algorithm requirement that ensures the algorithm produces accurate results for all valid inputs.

Output Generation

An algorithm requirement that ensures the algorithm produces one or more results.

Finiteness

An algorithm requirement that ensures the algorithm terminates after a limited number of steps.

Correctness

An algorithm evaluation metric that ensures the algorithm produces accurate results.

Execution Time (Work Time)

An algorithm evaluation metric that measures how long an algorithm takes to run.

Memory Usage (Space Complexity)

An algorithm evaluation metric that evaluates how much memory an algorithm consumes.

Optimality

An algorithm evaluation metric that determines whether an algorithm is the most efficient solution.

Generality

An algorithm evaluation metric that assesses whether an algorithm applies to various inputs.

Bubble Sort

A sorting algorithm that repeatedly swaps adjacent elements until the list is sorted.

Repeat until no swaps:
    For each adjacent pair (A, B):
        If A > B, swap them

• Input: [5, 3, 8, 2]

• Process: Compare adjacent elements, swap if needed → Repeat until sorted

  • [3, 5, 2, 8] → [3, 2, 5, 8] → [2, 3, 5, 8]

• Output: [2, 3, 5, 8]

Quick Sort

A sorting algorithm that uses partitioning and recursion for fast sorting

Choose a pivot
Partition elements into:
    - Left (≤ pivot)
    - Right (> pivot)
Recursively sort left and right partitions
Merge results

• Input: [5, 3, 8, 2]

• Process: Choose pivot (e.g., 5), partition into [3, 2] and [8], recursively sort

  • [2, 3] + [5] + [8]

• Output: [2, 3, 5, 8]

Merge Sort

A sorting algorithm that divides and merges sorted subarrays for efficient sorting.

If list has more than one element:
    Split list into two halves
    Recursively sort each half
    Merge sorted halves

• Input: [5, 3, 8, 2]

• Process: Split into [5, 3] and [8, 2], sort each, then merge

  • [3, 5] + [2, 8] → [2, 3, 5, 8]

• Output: [2, 3, 5, 8]

Depth First Search (DFS)

A graph traversal algorithm that explores as deep as possible before backtracking

Push start node to stack
While stack is not empty:
    Pop node, process it
    Push unvisited neighbors to stack

• Input: Graph {A → B, A → C, B → D, C → E} starting at A

• Process: Explore deep before backtracking → A → B → D → C → E

• Output: A, B, D, C, E

Breadth First Search (BFS)

A graph traversal algorithm that explores neighbor nodes level by level.

Enqueue start node
While queue is not empty:
    Dequeue node, process it
    Enqueue unvisited neighbors

• Input: Graph {A → B, A → C, B → D, C → E} starting at A

• Process: Explore level by level → A → B → C → D → E

• Output: A, B, C, D, E

Kruskal’s Algorithm

A greedy algorithm that finds the minimum spanning tree by selecting the smallest edges first.

Sort edges by weight
Initialize empty tree
For each edge in sorted order:
    If adding edge doesn’t form a cycle, add it to tree

• Input: Graph {A-B: 1, A-C: 3, B-C: 2}

• Process: Sort edges {A-B, B-C, A-C}, add smallest edges avoiding cycles

• Output: {A-B, B-C} (Minimum spanning tree)

Prim’s Algorithm

A greedy algorithm that grows the minimum spanning tree from a starting node.

Start from any node
While tree is incomplete:
    Add the smallest edge connecting an unvisited node

• Input: Graph {A-B: 1, A-C: 3, B-C: 2} starting at A

• Process: Add smallest edge from A (A-B), then smallest from B (B-C)

• Output: {A-B, B-C} (Minimum spanning tree)

Software Design

A critical phase in software development that ensures system quality and reliability, as design errors can lead to failures.

Example: The Ariane 5 rocket failure occurred due to incorrect data handling and conversions

Abstraction

A software design principle that simplifies complexity by focusing on essential characteristics while suppressing details, helping manage system complexity.

Example: Object-oriented programming (OOP) abstracts real-world entities into classes and objects.

Information Hiding

A software design principle that conceals internal module details from other modules, reducing dependencies and improving maintainability.

Example: Encapsulation in Java hides internal implementation details using private variables and methods.

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);
        account.deposit(500);
        System.out.println("Balance: " + account.getBalance());  // Output: Balance: 1500.0
    }
}

Stepwise Refinement

A software design principle that breaks down a problem into progressively smaller, more detailed components using a top-down approach.

Example: Software architecture design starts with high-level modules before refining them into detailed implementations.

Modularization

A software design principle that divides software into functional units called modules, improving manageability, maintainability, and reusability.

Example: Microservices architecture modularizes applications into independent services that communicate via APIs.

Structurization

A software design principle that organizes modules or system components based on processing elements or relationships.

Example: Model-View-Controller (MVC) structures web applications into separate layers for logic, UI, and data handling.

Cohesion

A software design metric that measures how functionally related elements within a module are, with high cohesion indicating a well-defined purpose.

Example: A logging module that only handles log generation and storage exhibits high cohesion.

Coupling

A software design metric that measures the interdependence between modules, with low coupling reducing the impact of changes in one module on others.

Example: RESTful APIs allow independent services to communicate with minimal coupling.

Functional Cohesion

A cohesion type where all elements contribute to a single, well-defined function.

Example: A sorting function that only sorts data without performing unrelated tasks.

Sequential Cohesion

A cohesion type where elements execute in a sequence, passing data from one to another.

Example: A data processing pipeline where each step refines the output of the previous step.

Communication Cohesion

A cohesion type where elements operate on the same data set.

Example: A report generation module that processes and formats financial data.

Procedural Cohesion

A cohesion type where elements execute in a predefined order but may not share data.

Example: A user authentication module that verifies credentials and logs access attempts.

Temporal Cohesion

A cohesion type where elements execute at the same time but serve different purposes.

Example: System startup routines that initialize multiple components simultaneously.

Logical Cohesion

A cohesion type where elements perform similar tasks but are selected based on conditions.

Example: A utility module that contains multiple unrelated helper functions.

Coincidental Cohesion

A cohesion type where elements are grouped arbitrarily without a clear relationship.

Example: A poorly designed module that handles logging, authentication, and file management together.

Data Coupling

A coupling type where modules share only necessary data.

Example: A function that accepts parameters instead of accessing global variables.

Stamp Coupling

A coupling type where modules share complex data structures instead of individual variables.

Example: Passing an entire object instead of specific attributes to a function.

Control Coupling

A coupling type where one module controls another’s behavior via flags or parameters.

Example: A function that accepts a mode parameter to determine execution behavior.

External Coupling

A coupling type where modules depend on external systems or APIs.

Example: A payment processing module that relies on third-party banking APIs.

Common Coupling

A coupling type where multiple modules share global variables.

Example: A legacy system where different modules modify the same global configuration file.

Content Coupling

A coupling type where one module directly modifies another’s internal data.

Example: A function that directly alters another module’s private variables, violating encapsulation.

Transform Flow-Oriented Design

A structural design method used for systems where data flows sequentially through input, processing, and output, with the program structure mirroring this flow.

Example: A data pipeline that processes sensor readings in a smart home system.

Transaction Flow-Oriented Design

A structural design method used for systems that receive input triggering multiple transaction paths, with a central transaction module analyzing input and routing it accordingly.

Example: An e-commerce checkout system that routes transactions based on payment method selection.

Software Architecture

A fundamental concept in software development that defines the high-level structure of a software system, its components, and their relationships, significantly impacting quality and manageability.

Components and Connectors

A software architecture concept that defines independent software units and their interactions.

Example: A web application has to an independent database connected to an independent server via an API

Subsystem Framework

A software architecture concept that organizes related components into subsystems to improve modularity.

Example: An enterprise resource planning (ERP) system consists of subsystems for finance, HR, and inventory management.

Repository Structure

A software architecture style where components interact by accessing a shared central data repository.

Example: A version control system like Git stores all project files in a central repository.

M-V-C Model (Model-View-Controller)

A software architecture style that separates an application into three interconnected parts one that manages data and business logic, one that handles the user interface, and one that processes user input and updates the model or view.

Example: Django framework follows the pattern to separate concerns in web applications.

Client-Server Model

A software architecture style where clients request services from servers in a distributed system.

Example: A web browser (client) requests pages from a web server using HTTP.

Hierarchical System

A software architecture style that organizes components in a tree-like structure, often used for system decomposition.

Example: Operating system file structures use a hierarchical directory system.

Component and Connector Subsystem Framework

A software architecture style that focuses on independent components and connectors defining their interactions.

Example: A microservices-based application where services communicate via RESTful APIs.

Software Architects

A key role in software development responsible for understanding requirements, designing system structures, evaluating technologies, and ensuring technical success.

Understanding Requirements

A software architecture design step that involves gathering functional and non-functional requirements before defining the system structure.

Selecting Architectural Style

A software architecture design step that involves choosing the appropriate architecture based on system needs.

Detailing the Design

A software architecture design step that involves refining the structure, defining components, and specifying interactions.

Context Modeling

A software architecture representation method that depicts system boundaries and interactions with external environments.

Example: A banking system context model shows interactions with customers, payment gateways, and regulatory agencies.

Component Diagram

A software architecture representation method that illustrates system components and their dependencies.

Example: A web application component diagram shows interactions between the frontend, backend, and database.

Package Diagram

A software architecture representation method that organizes model elements into groups (packages) and shows dependencies.

Example: A software development project groups modules into packages for authentication, data processing, and UI components.

Deployment Diagram

A software architecture representation method that illustrates the physical deployment of software artifacts on hardware nodes.

Example: A cloud-based application deployment diagram shows instances running on AWS servers.

Object-Oriented Design (OOD)

A software design approach that models real-world entities using objects, improving flexibility, maintainability, and robustness.

Example: A banking system models customers, accounts, and transactions as objects with defined attributes and behaviors.