Software Engineering Core Concepts: SDLC, Architecture, VCS
Classified in Computers
Written on in 
English with a size of 5.66 KB
Software Engineering Fundamentals and Principles
Desired Software Attributes
- Maintainability
- Dependability
- Efficiency
- Usability
Major Challenges in Large Programming
- Complexity
- Change
The 5 C's (Collaboration Framework)
Key elements often cited in successful team environments:
- Collaboration
- Communication
- Coordination
- [Note: The original source implies additional C's beyond the listed three.]
Core Activities of Software Engineering (SE)
- Defining
- Managing
- Describing
- Designing
- Implementing
- Testing
- Deploying
- Maintaining
The 4 P's of Software Engineering
- People
- Process
- Project
- Product
Software Development Lifecycle Phases (SDLC)
- Requirements Planning
- High-Level Design (Architecture Design)
- Low-Level Design
- Development (Implementation)
- Note: Unit testing is typically performed during the development phase.
- Testing
- Deployment
- Maintenance
Version Control Systems (VCS)
Centralized VCS (CVCS)
A single server that contains all file versions and history.
Distributed VCS (DVCS) - Example: Git (2005)
DVCS utilizes three main areas locally:
- Working Directory
- Staging Area
- Git Directory (Repository)
Checkout Process: Files are moved from the .git directory to the working directory.
Project Management Techniques
Tools used by project managers for scheduling and tracking:
- Gantt Charts
- PERT Charts (Program Evaluation and Review Technique)
- CPM (Critical Path Method)
Critical Path Definition
The sequence of project activities that takes the longest time to complete. It is the path where all activities have zero slack time.
Project Duration
The shortest possible time required to finish the entire project.
Calculating Late Finish Time
The Late Finish Time (LF) of a task is equal to the Late Start (LS) of the succeeding task. If there is more than one succeeding task, select the smallest Late Start value.
Requirements Engineering (RE)
Types of Requirements
- User Requirements
- System Requirements
- Business Requirements
Generic Process in RE
- Requirements Elicitation
- Requirements Analysis
- Requirements Validation
- Requirements Management
Key Activities and Steps in RE
- Identify Stakeholders
- Define Scope
- Conduct Stakeholder Interviews
- Hold Workshops
- Use Questionnaires
- Analyze Existing Documentation
- Create Prototypes
- Document Requirement Specification
- Prioritize Requirements (e.g., using MoSCoW)
- Requirement Validation and Verification
- Review and Sign-off
MoSCoW Prioritization Method
- Must
- Required for success.
- Should
- Important, but not vital.
- Could
- Desirable, but easily deferred.
- Won't
- Not implemented in this release.
Software Architecture and High-Level Design
High-level design determines what makes up the system and how the components interact (analogous to the components of a vehicle).
Software Architecture Views
Different perspectives for understanding the system structure:
- Use Case View: Functionality and user interaction.
- Logical View: Abstraction of the design (classes, components).
- Process View: Concurrency and synchronization.
- Physical View: Hardware components and deployment mapping.
- Development View: Software modules, packages, and dependencies.
Common Architecture Patterns
Monolithic Architecture
A single, unified codebase where all components are tightly coupled.
Client/Server Architecture
Clients request resources or services from centralized servers.
- Examples: Peer-to-Peer (P2P), Cloud Computing (email, document sharing, banking).
Advantages of Client/Server
- Centralized control and management.
- Scalability (easy to add servers).
Disadvantages of Client/Server
- The service can become a single point of failure.
- Susceptible to Denial of Service (DoS) attacks.
Component-Based Architecture
Components reside in the same environment (e.g., JavaBeans, Adobe Flash, ActiveX). Interface components request information from other components as needed.
Service-Oriented Architecture (SOA)
Similar to Component-Based, but pieces are implemented as independent services (often Web Services), each having its own hosting environment.
- Advantage: Loose coupling between services.
Event-Driven Architecture
Components communicate through the production, detection, consumption of, and reaction to events (e.g., Operating Systems, Graphical User Interfaces).
Model-View-Controller (MVC) Pattern
Separates the application into three interconnected parts to isolate internal representations of information from the ways information is presented to or accepted from the user.