Chapter 4️⃣: Communication 💬

Overview 📖

❇️ Communication is the cornerstone of distributed systems, enabling interaction between processes across machines.

Communication Foundations 🛠

Layered Protocols
A structured approach separates functionality into distinct layers:
🔌 Physical Layer: Transmits raw bits between sender and receiver.
🖇 Data Link Layer: Organizes data into frames with error control.
📡 Network Layer: Routes packets across network devices.
🚛 Transport Layer: Ensures end-to-end communication.
🧩 Middleware Layer: Adds functionalities like naming, marshaling data, replication, and security protocols to abstract communication for applications.

Types of Communication

Transient vs Persistent:
✨ Transient: Messages discarded if the receiver/server is unavailable.
📥 Persistent: Messages stored until successfully delivered.

Asynchronous vs Synchronous:
🏃 Asynchronous: Sender doesn’t wait for the receiver to reply.
⏳ Synchronous: The sender blocks until the receiver responds.

Remote Procedure Call (RPC) 📞

Basic RPC Operation

- RPC enables invoking procedures on a remote machine as if they were local.

Steps:
[in the next ⏭️ note]

Parameter Passing

Challenges:
- Different systems have varied data formats (e.g., byte ordering).
- Complex data structures require standardization during transmission.

Copy-in/Copy-out Semantics: Ensures updates to parameters are consistent across systems.

Variations on RPC

• Asynchronous RPCs: Clients continue execution without waiting for a server reply.
• Multiple RPCs: Clients can send parallel requests to server groups, boosting efficiency.

Message-Oriented Communication ✉️

✨ Transient Messaging

1. Sockets:
- Low-level communication interface for point-to-point connections.
- Example:
• Server: Creates a socket, accepts a connection, and responds.
• Client: Initiates a connection, sends, and receives messages.

2. Advanced Messaging with ZeroMQ:
- Higher abstraction with paired sockets:
• Request-Reply: Simple queries and responses.
• Publish-Subscribe: Broadcast messages to interested receivers.
• Pipeline: Push workloads and pull responses.

📥 Persistent Messaging

Middleware maintains message queues for delayed delivery. 🗂
Operations 🛠
✉️ PUT: Add messages to a queue.
⏳ GET: Block until a message is available.
🔍 POLL: Check for messages in the queue without blocking.
🔔 NOTIFY: Trigger actions when a message arrives.

Message Brokers 🤝
- Handle heterogeneity by transforming message formats.
- Common Example: AMQP (Advanced Message Queuing Protocol).

Multicast Communication 📡

📱Application-Level Multicasting

• Overlay networks distribute messages using:
🌳 Tree Structures: Ensure unique paths for messages.
🕸 Mesh Structures: Require routing to handle redundancy.

Metrics:
🔄 Link Stress: Number of times a message traverses the same physical link.
⏱️ Stretch: Delay ratio between application-layer and network-layer paths.

🌊 Flooding-Based Multicasting

• Sends messages to all neighbors, propagating throughout the network.
🎲 Variation: Probability-based flooding for more controlled message propagation.

🗣Epidemic Protocols (Gossip-Based Data Dissemination)

• Anti-Entropy: Nodes randomly exchange updates to synchronize states.
• Rumor Spreading: Newly updated nodes notify others until the update reaches saturation.

𝕡𝕒𝕣𝕥 2

Basic RPC Operations 🚀

Steps 🚶‍♂️

1. 🧑‍💻 Client procedure calls client stub: The client initiates the call via the stub.
2. 🏗 Stub builds message; calls local OS: The client stub packages the message and passes it to the local operating system.
3. 🌍 OS sends message to remote OS: The message is transmitted over the network to the remote operating system.
4. 📨 Remote OS gives message to stub: The remote operating system hands the message off to the server's stub.
5. 🗃 Stub unpacks parameters; calls server: The server stub unpacks the message and invokes the server procedure.
6. ⚙️ Server does local call; returns result to stub: The server performs the operation and returns the result to its stub.
7. 🏗 Stub builds message; calls OS: The server's stub packages the result into a message for the return journey.
8. 🌍 OS sends message to client’s OS: The result message is sent to the client’s operating system.
9. 📥 Client’s OS gives message to stub: The client’s operating system hands the result to the client stub.
10.🧑‍💻 Client stub unpacks result; returns to client: The client stub unpacks the response and delivers it back to the client.

Analogy: Mailing a Letter to a Friend 📮💌

1. ✍️ Client (you) write the letter (client stub): You decide to write a letter (prepare your request) to send to your friend. 
2. 📩 Stub prepares the envelope (builds message): You place the letter in an envelope (the stub wraps up your request), addressing it to your friend’s home. 
3. 🏤 Local postal service sends the letter (OS sends message to remote OS): You give the letter to the local postal service (your local operating system) to deliver to your friend's city (remote OS). 
4. 📨 Friend receives the letter (remote OS gives message to stub): Your friend receives the letter and hands it over to their house (the remote OS delivers the message to the friend’s stub). 
5. 📖 Friend opens the letter and reads it (stub unpacks parameters; calls server): Your friend reads the letter (the stub opens and processes it), and decides to write you a response (calls the server). 
6. ✍️ Friend writes a response (server does local call; returns result to stub): Your friend writes back to you (does their part) and prepares the reply (finishes the local task). 
7. 🏠 Friend puts the response in an envelope (stub builds message; calls OS): Your friend seals the response in an envelope (the server’s stub wraps up the result). 
8. ✈️ Mail sent back to you (OS sends message to client’s OS): Your friend gives the letter to the postal service again (server OS sends it back to your OS). 
9. 🏠 You receive the letter (client’s OS gives message to stub): The postal service delivers it straight to your doorstep (client OS delivers the message to your stub). 
10. 📬 You read the response (client stub unpacks result; returns to client): You open the envelope and read your friend’s reply (client stub processes and hands it over to you).

Simple Transient Messaging with Sockets 📬

Description: Set up communication, manage connections, exchange data, and close the connection after use.

Operations 🛠

🔌 socket: Create a new communication end point.
🔗 bind: Attach a local address to a socket.
🦻 listen: Tell the operating system the maximum number of pending connection requests.
⏳ accept: Block the caller until a connection request arrives.
🌐 connect: Actively attempt to establish a connection.
📡 send: Send some data over the connection.
📥 receive: Receive some data over the connection.
🔒 close: Release the connection.

Summary 🌟

Communication mechanisms bridge the gap between distributed processes through standardized protocols and synchronization methods.

🗝 Key components:

• RPC facilitates seamless remote operations with transparency challenges.
• Message-Oriented Middleware(MOM) supports persistent and asynchronous interactions.
• Multicast ensures efficient data dissemination with scalable protocols.

➖➖➖➖➖➖➖➖➖➖➖➖
The preview is over—now dive into the expansive world of Distributed Systems! 🖥🔗🌍
➖➖➖➖➖➖➖➖➖➖➖➖

Distributed Systems

Chapter 1️⃣ Introduction 📖

Chapter 2️⃣ Architectures 🏗

Chapter 3️⃣ Processes 🚥

Chapter 4️⃣ Communication 💬

Chapter 5️⃣ Coordination ⏳

Chapter 6️⃣ Naming 🏷

5 & 6 tomorrow ...

Chapter 5️⃣: Coordination 🕒

Clock Synchronization Basics

Physical Clocks 🕰

• Definition: Aligns a system's time with a global time standard.
• Global Standard: Universal Coordinated Time (UTC):
- Based on cesium 133 atomic clock transitions.
- Adjusted periodically with leap seconds to account for Earth’s rotation.
- Broadcasted through radio and satellite (accuracy: ±0.5ms).

Clock Drift:
- Hardware clocks deviate over time due to differences in oscillator frequencies.
- Requires periodic synchronization to minimize inaccuracies.

Drift Rate:
- Maximum rate at which a clock drifts: ρ (e.g., a clock drifts by ±ρ seconds per second).
- Correction ensures clocks are sufficiently accurate to meet system demands.

Synchronization Goals:

• Internal Synchronization: All clocks in a system differ by no more than π (precision).
- Formula: ∀ t, p, q: |Cp(t) − Cq(t)| ≤ π.

• External Synchronization: Align system clocks to UTC within bound α (accuracy).
- Formula: ∀ t, p: |Cp(t) − t| ≤ α.

Key Challenges:

- Unpredictable message delays in distributed systems.
- Balancing cost and precision in large-scale networks.

Clock Synchronization Algorithms

🌍 Cristian's Algorithm:

Use: Synchronize a client clock using a timeserver.
Process:
1. Client sends a request to timeserver.
2. Timeserver replies with UTC timestamp.
3. Client adjusts for network delay: .

🖥 Berkeley’s Algorithm:

Use: Achieve internal synchronization.
Process:
1. Master collects time from each node.
2. Computes average time (discards outliers).
3. Sends back adjustments to nodes (including itself).

📡 Reference Broadcast Synchronization (RBS):

Use: Synchronize nodes using a reference broadcast from a third-party node.
Process:
Each receiver records when the broadcast arrives.
Offsets are calculated through pairwise comparisons.

Logical Clocks 🕰

Lamport Timestamps 🔢:
• Establishes happened-before relationship (a → b):
- If a and b are events in the same process, a → b if a occurs before b.
- If a is message-sent and b is message-received, a → b.
- Transitivity: If a → b and b → c, then a → c.
• Increment local counter for events.
• Upon receiving a message, Crecv = max(Clocal,Cmsg) + 1

Vector Clocks 🧮:
•Track causality with a vector per process.
- Increment local entry for events.
- On message receipt, merge vectors: max(VCrecv[k], VClocal[k])

Mutual Exclusion 🔑

Centralized Algorithm:
• A single coordinator manages critical section (CS) access.
Steps:
1. Process sends a request to the coordinator.
2. Coordinator grants access to the process with the earliest request.
3. On release, coordinator processes the next queued request.

• Pros: Simple, no starvation.
• Cons: Single point of failure, bottleneck.

Distributed Algorithm:
• Processes coordinate directly:
Steps:
1. Process broadcasts a REQUEST message with timestamp to all other processes.
2. Processes reply with OK if the requesting process’s timestamp is earlier than their own pending request or if they have no pending request.
3. Access granted when all responses are received.
4. After exiting, process sends a RELEASE message to inform others.

• Pros: Fault-tolerant.
• Cons: High communication overhead.

Decentralized Algorithm:
• Processes collaboratively handle CS access, maintaining queues and decision rules.
Steps:
1. Each process maintains a queue of requests.
2. Requests are granted based on a predefined rule (e.g., priority or timestamps).
3. Processes periodically exchange messages to update their queues and decisions.

• Pros: No bottleneck, fault-tolerant.
• Cons: Complex, high overhead.

Token-Ring Algorithm:
• Token circulates among processes for CS access.
Steps:
1. Token circulates in the ring.
2. A process holds the token to enter the CS.
3. After use, the token is passed to the next process.

• Pros: Fair, no extra communication.
• Cons: Token loss requires detection and regeneration, recovery mechanisms needed for failed processes.

𝕡𝕒𝕣𝕥 2

Election Algorithms 🗳

Problem: Select a leader in a distributed system.

• Bully Algorithm:

The process with the highest ID becomes leader.

Steps:
1. A process with a higher ID sends ELECTION messages to all higher-ID nodes.
2. If a higher-ID node responds, the current process stops.
3. If no response is received, it declares itself the leader and broadcasts COORDINATOR messages.

Edge Case: Handles failed nodes by assuming non-responding nodes are down.
Pros: Simple, clear winner.
Cons: High message cost in dense networks.

- Failed leaders are overridden by challengers.
- Cons: High message load.

• Ring Algorithm:

Processes in a logical ring pass election messages.
Highest-ID node wins.
Efficient for sparse networks.

🔑 Key Points:
- Election algorithms ensure a single leader even in failure-prone networks.
- Fault tolerance mechanisms handle node failures and ensure leader reelection when necessary.

• Gossip-Based Coordination 🗣

Relies on processes exchanging small bits of information periodically.
Applications:
- Aggregating data.
- Sampling peers for network maintenance.

Challenges

• Scalability: Adapting to large systems.
• Fault Tolerance: Handling crashes gracefully.
• Performance: Balancing speed and reliability.

Summary ⭐️

- Clock synchronization is essential for consistency in distributed systems.
- Lamport and Vector Clocks establish event ordering and causality.
- Mutual Exclusion algorithms aim to serialize access to shared resources.
- Election algorithms like Bully and Ring ensure leader selection.
- Practical examples include file locking, distributed databases, and GPS systems.


➖➖➖➖➖➖➖➖➖➖➖➖
The preview is over—now dive into the expansive world of Distributed Systems! 🖥🔗🌍
➖➖➖➖➖➖➖➖➖➖➖➖

Chapter 6️⃣: Naming 🏷

Naming is 🔑 in distributed systems, enabling the identification, location, and access of entities such as resources, processes, and services.

Introduction to Naming

In distributed systems, names abstract entities like hosts, files, printers, or services, making them accessible without requiring users or applications to know their exact location or physical representation.

🏷 Names: Strings identifying entities (e.g., “/home/docs/file.txt” for a file).
🆔 Identifiers: Unique, immutable names assigned exclusively to a single entity.
📍 Addresses: Names that refer to an entity’s access point and may change over time (e.g., IP addresses for devices).

Flat Naming

Flat naming uses unstructured, globally unique identifiers without any hierarchy. It’s ideal for machines but not user-friendly.

Key Resolution Methods:

📡 Broadcast and Multicast: Sends a query to all nodes until the desired entity responds. Simple but unscalable.
➡️ Forwarding Pointers: Tracks movement via pointers that redirect requests but needs cleanup to remove stale links.
🏠 Home-based Resolution: Uses a central "home" server to store the entity’s current location. Risks bottlenecks and single points of failure.
📊 Distributed Hash Tables (DHTs): Decentralized systems mapping identifiers to entities using a hash function. Scalable and fault-tolerant.
🗂 Hierarchical Approaches: Organizes entities using structured paths for efficient lookup.
🛡 Secure Flat Naming:
🔒 Self-Certifying Names: Use hashes or public keys to verify entities.
🔐 Secure Resolution: Prevent Sybil and eclipse attacks via verified identifiers.

Structured Naming

Structured naming systems use human-readable names organized hierarchically (e.g., domain names or file paths).

Name Spaces: 🌌 Represented as directed acyclic graphs (often trees).
🌿 Leaf Nodes: Represent actual entities (e.g., files, printers).
📂 Directory Nodes: Contain pointers to other nodes, organizing entities logically.

Resolution Process:

🚶‍♂️ Traverse the name space tree to resolve names to entities.
🔄 Cache frequently accessed paths for efficiency.

Examples:
🌐 DNS (Domain Name System): Resolves domain names to IP addresses using a globally distributed hierarchy.
📁 NFS (Network File System): Maps file paths to physical storage locations across distributed systems.

Attribute-based Naming

Attribute-based naming systems describe entities using (attribute, value) pairs, supporting flexible and expressive queries.
Example Query: location=BuildingA AND type=printer. 🖨

Implementation Models:

🗂 Hierarchical (e.g., LDAP): Efficient lookups with directory structure.
🧩 Decentralized Systems: Distribute search processes for scalability and fault tolerance.

Named-Data Networking (NDN)

NDN emphasizes what data is needed rather than where it is stored. Names are structured hierarchically and directly routed, bypassing traditional address resolution.

Structure: Names like /books/DS/4/01/Naming are self-descriptive and hierarchical. 📖
Benefits:
🚀 Improves performance by caching data closer to users.
🎯 Simplifies retrieval by eliminating address mapping.

Challenges in Naming Systems

🌍 Scalability: Efficiently managing billions of entities through caching, hierarchical organization, and DHTs.
🔄 Consistency and Mobility: Maintaining entity updates and location changes without breaking references.
🛡 Security: Preventing spoofing and ensuring trustworthy name-to-entity bindings.
🪟 Transparency: Hiding resolution complexity while ensuring usability.

Examples and Applications

DNS: 🌐 Resolving human-readable web addresses to IP addresses.
Blockchain: Uses flat naming (public keys) to uniquely identify participants and transactions.
Cloud Systems: ☁️ Leverage hierarchical naming for scalability and replication transparency.
NDN: Focuses on content retrieval by names rather than host addresses.

➖➖➖➖➖➖➖➖➖➖➖➖
The preview is over—now dive into the expansive world of Distributed Systems! 🖥🔗🌍
➖➖➖➖➖➖➖➖➖➖➖➖

⏭️ Software Configuration Management

Chapter 1️⃣: Introduction to Software Configuration Management 🛠

Overview 📖

• SCM is a systematic process to manage, organize, and control changes in documents, code, and other entities throughout the Software Development Life Cycle (SDLC).
• Its primary goals include increasing productivity 📈, minimizing errors ❌, and ensuring traceability and accountability 📝.

Core Concepts of SCM 🔑

🖥 Software Configuration Items (SCIs): All intermediate and final artifacts created during software development, such as code modules, test data, and documentation.
🔧 Configuration: Refers to the product's structure, including its constituent components and specific versions.
🔄 Versioning and Change Control: Ensures accurate documentation and implementation of changes, preventing inconsistencies and overlapping edits.

Importance of SCM ⚡️

🤝 Prevents conflicts by managing concurrent modifications.
📊 Enhances traceability, integrity, and accountability.
🌍 Facilitates efficient team collaboration, even across distributed teams.
🆕 Adapts to changes in requirements, budgets, and schedules.

SCM Process 🔄

👀 Identification: Recognize and define configuration items (e.g., source code, test cases) and their interrelationships using tools like Module Interconnection Language (MIL).

📝 Version Control: Manage multiple versions and maintain baselines to ensure stability.

⚙️ Change Control: Assess and approve change requests to prevent chaos and ensure quality.

🕵️‍♂️ Configuration Audit: Verify compliance with standards and traceability of changes.

📊 Status Reporting: Provide updates on current configuration and progress to stakeholders.

🗝 Key Roles in SCM

👨‍💼 Configuration Manager: Oversees SCM processes and approves changes.
🧑‍💻 Developer: Implements changes and resolves conflicts.
🔎 Auditor: Verifies consistency and compliance through audits.
📋 Project Manager: Monitors progress, ensures adherence to SCM policies, and reports on system status.
👥 End-User: Ensures they work with the latest version of the software.

🛠 SCM Tools

SCM tools support:

🤝 Concurrency Management: Prevents issues when multiple users work on the same file ⚖️.
🔄 Version Control: Maintains historical versions for rollback if needed ⏪.
🔗 Synchronization: Ensures team members stay updated ⏰.

Examples of Tools:
• Git: Open-source version control system 🖥.
• Team Foundation Server: Collaboration and coordination tool for teams 👥.
• Ansible: Configuration management, deployment, and task automation tool ⚙️.

⚠️ Challenges and Drawbacks

• Requires skilled resources and robust infrastructure 🏗.
• Can be resource-intensive for small organizations 💼.


➖➖➖➖➖➖➖➖➖➖➖➖
Unlock the essentials of Software Configuration Management! 🧑‍💻🔧📊
➖➖➖➖➖➖➖➖➖➖➖➖

Chapter 2️⃣: Management of the SCM Process ⚙️

Organizational Context for SCM 🏢

• SCM and Organizational Structure: SCM interacts with various organizational elements, such as quality assurance and software development teams.
• Integration with Larger Systems: SCM operates alongside hardware and firmware CM activities, ensuring consistency across the system.
• Role in Quality Assurance: Assists in managing non-conforming items and tracking software configuration records.

Constraints and Guidance 📜

• Constraints: SCM is shaped by corporate policies, contracts, regulatory requirements, and the chosen software life cycle process.
• Guidance: Standards (e.g., SEI/CMMI, ISO/IEC 15504) and best practices help in designing and implementing SCM processes.

Planning for SCM 📝

• Key Activities: Includes configuration identification, control, auditing, and release management.
• SCM Plan (SCMP): A "living document" outlining responsibilities, schedules, resources, and compliance requirements.

Tools and Resources 🛠

• Tool Capabilities: Support tasks like change management, auditing, builds, and release tracking.
• Integration: Tools often serve multiple roles, linking SCM, development, and quality assurance.

Vendor and Interface Control 🔗

• Vendor/Subcontractor Control: SCM ensures third-party software integrates seamlessly with project libraries.
• Interface Management: Tracks and manages changes between software and hardware components.

Surveillance and Auditing 🔍

• Process Surveillance: Ensures SCM compliance with established processes.
• Audits: Provide insights into the status and effectiveness of SCM activities, driving process improvements.


➖➖➖➖➖➖➖➖➖➖➖➖
Unlock the essentials of Software Configuration Management! 🧑‍💻🔧📊
➖➖➖➖➖➖➖➖➖➖➖➖

Chapter 3️⃣: Software Configuration Identification (SCI) 🔍

What is SCI?

Definition: SCI identifies items to be controlled, their relationships, and tools for management.
Importance: Forms the foundation for all SCM activities.

Key Concepts

Software Configuration: Functional and physical characteristics of software.
Software Configuration Item (SCI): Aggregated software entities managed as a single unit (e.g., code, documentation, tools).

SCI Relationships and Versions 🧩

Relationships: Track connections between SCIs for traceability and change impact analysis.

Versions:
🔹 Revision: Replaces old versions.
🔹 Variant: Adds new versions without replacing old ones.

Baselines 📏

Definition: Fixed reference points during the software life cycle, representing approved configurations.

Types:
• Functional Baseline: System requirements.
• Allocated Baseline: Software requirements.
• Developmental Baseline: Evolving configurations.
• Product Baseline: Final software for integration.

Acquiring SCIs

Process: SCIs are incorporated into baselines after formal acceptance and approval, ensuring traceability.

Software Libraries 📚

Definition: Controlled collections of software and documentation supporting development and maintenance.

Types:
• Working Library: For coding.
• Project Support Library: For testing.
• Master Library: For finished products.

Access Control: Security and authority levels vary by library type.


➖➖➖➖➖➖➖➖➖➖➖➖
Unlock the essentials of Software Configuration Management! 🧑‍💻🔧📊
➖➖➖➖➖➖➖➖➖➖➖➖

Chapter 4️⃣: Software Configuration Control (SCC) 🔄

Overview of SCC

• Purpose: Manages changes throughout the software life cycle, ensuring they are evaluated, approved, and implemented effectively.

• Scope: Includes requesting changes, evaluating impacts, implementing approved changes, and handling deviations or waivers.

Change Management Process 🔍

Change Requests:
• Submitted using Software Change Requests (SCRs).
• Evaluated for cost, impact, and feasibility.
• Handled by the Configuration Control Board (CCB), which may consist of multiple levels depending on project scope and criticality.

- The authority for accepting or rejecting proposed changes rests with an entity typically known as a Configuration Control Board (CCB).
- In smaller projects, this authority may actually reside with the leader or an assigned individual rather than a multi-person board.

Tracking Changes: SCRs are tracked to ensure implementation aligns with project baselines and quality standards.

Implementation of Changes ⚙️

▪️Version Control: Tools manage code versions, supporting check-in/out and parallel development.
▪️Quality Assurance: Changes undergo audits to verify compliance with project requirements.

Deviations and Waivers 📜

🔹Deviation is an authorization to depart from a provision prior to the development of the item.
🔹Waiver is an authorization to use an item, following its development, that departs from the provision in some way.

Summary ⭐️

Software Configuration Control (SCC) manages changes throughout the software life cycle, addressing:

🔄 Change Requests: Evaluating, approving, and implementing changes.
🚧 Deviations: Pre-approval to bypass specifications during development.
✅ Waivers: Post-development approval for non-compliance with specifications.


➖➖➖➖➖➖➖➖➖➖➖➖
Unlock the essentials of Software Configuration Management! 🧑‍💻🔧📊
➖➖➖➖➖➖➖➖➖➖➖➖

Chapter 5️⃣: Software Configuration Status Accounting (SCSA) 📊

Purpose of SCSA

Definition: Captures and reports configuration information for effective software management.

Scope: Tracks changes, deviations, waivers, and baseline configurations throughout the software life cycle.

Status Information Management 📋

Activities:
• Collecting and maintaining configuration data.
• Using automated tools for tracking and reporting.

Types of Information:
• Approved configurations, current status of changes, and deviation/waiver details.

Status Reporting 📝

Usage: Supports project management, quality assurance, and software engineering.

Reporting Formats:
• Ad hoc queries for specific insights.
• Predefined reports for periodic updates.

Software Configuration Auditing (SCA) 🔍

Purpose: Evaluates compliance with standards, regulations, and project requirements.

Types of Audits:

🔘 Functional Configuration Audit (FCA): Ensures software consistency with specifications.
🔘 Physical Configuration Audit (PCA): Confirms design and documentation match the as-built product.
🔘 In-Process Audits: Verifies consistency of evolving baselines during development.


➖➖➖➖➖➖➖➖➖➖➖➖
Unlock the essentials of Software Configuration Management! 🧑‍💻🔧📊
➖➖➖➖➖➖➖➖➖➖➖➖

Chapter 6️⃣: Software Release Management and Delivery (SRM&D) 📦🚛

Overview of SRM&D 📖

Definition: The process of distributing a software configuration item, both internally and to customers.

- When different versions of a software item are available for delivery, such as versions for different platforms or versions with varying capabilities, it is frequently necessary to recreate specific versions and package the correct materials for delivery of the version.
- The software library is a key element in accomplishing release and delivery tasks.

Purpose: Ensures the right versions are packaged and delivered for specific platforms or capabilities.

Software Building 🛠

🔸Activity: Combines correct versions of configuration items into an executable program.
🔸Rebuild Capability: Necessary for recovery, testing, or maintenance of previous releases.
🔸Tool Support: Automates selection of versions and building processes for target environments.

Key Outputs:
• Quality-verified builds.
• Records for future reference or audits.

Software Release Management 📤

Scope:
• Identification, packaging, and delivery of executable programs, documentation, release notes, and configuration data.
• Tracks product distribution and ensures timely notifications for reported issues.

🔅Version Description Document: Documents the physical contents of a release.
🔅Release Notes: Outline new capabilities, known issues, and platform requirements.
🔅Tool Integration: Links with change request tools to map release contents to approved changes.


➖➖➖➖➖➖➖➖➖➖➖➖
Unlock the essentials of Software Configuration Management! 🧑‍💻🔧📊
➖➖➖➖➖➖➖➖➖➖➖➖

Chapter 7️⃣: Software Configuration Management Tools 🛠

Categories of SCM Tools

SCM tools are divided based on their scope of support:

i) Individual Support Tools: Suitable for small organizations or teams.
ii) Project-Related Support Tools: Designed for medium to large teams managing parallel development.
iii) Companywide-Process Support Tools: Automate formal processes across organizations, including certification.

Individual Support Tools 🤝

• Version Control Tools: Track changes to configuration items.
E.g.
- Git: speedy and efficient branching and merging capability tool used for distributed version control system
- Subversion(SVN): centralized version control system that tracks changes to files and directories over time. E.g. atomic commit, branching and merging
- Others: Mercurial, perforce, team foundation version control(TFVC)

• Build Handling Tools: Compile and link an executable version of the software, with advanced features like quality checks
E.g. Maven, Gradle, Apache Ant, Make, Bazel.

• Change Control Tools: Manage change requests and notifications (for example, change request status changes, milestones reached)
E.g. Git, Subversion(SVN), Mercurial, perforce, team foundation version control(TFVC)

Project-Related Support Tools 🗂

Purpose: Facilitate workspace management and distributed development.

Examples: Jira, Trello, Asana, Basecamp, Slack, Microsoft project

Selection Factors: Team size, project nature, development methodology.

Companywide-Process Support Tools 🌐

- They are able to handle many items, data, and life cycles.
- Such tools add to project-related support by supporting a more formal development process, including certification requirements.

Features: Workflow automation, role management, and artifact tracking.
Examples: Atlassian Confluence, Git-Hub Enterprise, Microsoft Azure DevOps, GitLab, JFrog Artifactory, IBM Rational Team Concert


➖➖➖➖➖➖➖➖➖➖➖➖
Unlock the essentials of Software Configuration Management! 🧑‍💻🔧📊
➖➖➖➖➖➖➖➖➖➖➖➖

Check your emails🚨

A2SV is sending acceptance emails for G6🎉🎉

#A2SV #G6
@AASTUSE

💻 Huawei ICT Competition 2024/25 Preliminary Exam

The written exam for the Huawei ICT Competition Northern Africa 2024-2025 Preliminary Exam (Ethiopia) is scheduled for 22 January 2025.

Exam time: (9:00 AM-5:30 PM (ከጠዋተ 3፡00 እስከ ቀኑ 11፡30)

Please use the following link to access the Huawei ICT Competition - Preliminary Exam.

- Huawei ICT Competition 2024-2025 Preliminary Exam for Ethiopia-Network Track=https://talent.shixizhi.huawei.com/iexam/1365189427395223554/examInfo?examId=1872194327910481922

- Huawei ICT Competition 2024-2025 Preliminary Exam for Ethiopia-Cloud Track=https://talent.shixizhi.huawei.com/iexam/1365189427395223554/examInfo?examId=1872194330292846593

- Huawei ICT Competition 2024-2025 Preliminary Exam for Ethiopia-Computing Track=https://talent.shixizhi.huawei.com/iexam/1365189427395223554/examInfo?examId=1872194329135218690

Make sure to follow this steps if you haven't registered yet: aastu.software/huawei

@AASTUSEA aastu.software

Chapter 1️⃣: Introduction

What is Software Engineering (SE)? 🛠

Definition: An engineering branch focused on developing software products using scientific principles and structured methodologies.

Key Techniques:
• Abstraction: Simplifying complex problems by ignoring irrelevant details.
• Decomposition: Breaking problems into smaller, manageable sub-problems.

Outcome: High-quality software products with reduced complexity.

Types of Software 📦

By Purpose:
🔧 System Software: OS, utilities.
💻 Application Software: End-user tools.

By Platform:
📱 Native Software: Designed for specific OS.
🌍 Cross-Platform Software: Runs on multiple OS.

By Deployment:
💾 Installed Software: Local installation.
☁️ Cloud-Based Software: Accessed via the internet.

By License:
🔒 Proprietary: Owned by a single entity.
🌐 Open-Source: Publicly accessible.

Software Design 🎨

Definition: A process to transform user requirements into a blueprint for implementation.

Focus Areas:
💾 Data Design: Database structures.
🖥 User Interfaces: Front-end design.
🏗 Architecture: Blueprint of system interactions.
🔧 Components: Functional modules with specific tasks.

Component

🔅A software component is a unit of composition with contractually specified interfaces, independently deployable/deliverable/configurable and subject to composition by third parties. Clemens Szypersk

🔅Components are self-contained, clearly identifiable pieces that describe and/or perform specific functions, have clear interfaces, appropriate documentation, and a defined reuse status. Johannes Sametinge

Component-Based Design (CBD) 🔗

• Concept: Breaks software into reusable, self-contained components with defined interfaces.

🔧 Analogy: Like building a car from pre-made parts (engine, tires), software can be assembled from ready-made components.

Why CBSE (Component-Based Software Engineering) ❔

⚡️ Reduces complexity and development time.
🔄 Focuses on reuse, not reinventing the wheel.

Types

📚 Class-Based Components: Often implemented as classes in object-oriented programming, encapsulating both data and behavior.
🔧 Service-Based Components: Provide specific services or functionalities, often implemented as standalone modules or microservices.
🌐 Web Components: Designed for web applications, encapsulating HTML, CSS, and JavaScript for reusable and modular UI elements.

Benefits 🎯

🔄 Reusability: Saves time and effort.
🛠 Maintainability: Modular design allows for easy updates.
📈 Scalability: Add or replace components as needed.
✅ Quality: Pre-tested components improve reliability.

Characteristics ✨

🔄 Reusable: Components work across projects.
🔄 Replaceable: Easily swapped with alternatives.
🧩 Composable: Can be combined to form larger systems.
🛠 Independent: Self-contained with minimal dependencies.
🔒 Encapsulated: Internal workings hidden behind interfaces.
🔗 Loosely Coupled: Interact via well-defined interfaces.
📦 Deployable/Configurable/Deliverable: Ready for deployment and customization.
🧠 Logically Cohesive: Each component performs a specific, logical task.
📈 Scalable/Extensible: Can grow and adapt to meet future needs.
🔧 Maintainable: Easy to update and manage over time.

Component Design Processes 🔄

📋 Requirement Analysis: Identify key functionality and interactions.
Example: Notification system handling email, SMS, and push alerts.

📝 Specification: Define interfaces, inputs, outputs, and connections.
Example: Methods like sendEmail(), sendSMS(), and sendPush().

⚙️ Design & Implementation: Build the component as per specifications.
Example: sendEmail() uses SMTP; sendSMS() integrates with a telecom API.

🧪 Testing: Test for functionality, performance, and error handling.
Example: Verify message delivery and error handling for invalid email addresses.

🔗 Integration: Integrate the component into the larger system.
Example: Connect the notification system to order processing for real-time updates.

𝕡𝕒𝕣𝕥 2

Application Area

🔹 Enterprise Applications: Large organizations use modular components for systems like HR, payroll, and customer management.
• Example: SAP and Oracle ERP with modules for accounting, procurement, and inventory.

🔹 Web Applications: Modern web apps use reusable front-end and back-end components for efficiency.
• Example: React.js or Angular components for building user interfaces across multiple websites.

🔹 Cloud-Based Systems: Cloud services leverage microservices for independent scaling and integration.
• Example: AWS components like S3 (storage) and EC2 (computing) are integrated into various apps.

🔹 Embedded Systems: Smart devices use modular components for specific tasks like monitoring or user interaction.
• Example: A smart thermostat with components for temperature control and Wi-Fi communication.

Summary ⭐️

🔘 Software Engineering simplifies complex problems using structured methods, focusing on high-quality, less complex software! 🛠
🔘 Software types vary by purpose, platform, deployment, and license—each tailored to fit specific needs! 📦
🔘 Software design creates blueprints from user requirements, focusing on data, interfaces, and components! 🎨
🔘 Component-Based Design (CBD) reuses modular components, reducing complexity and development time! 🔗
🔘 CBSE improves software quality with reusable, maintainable, and scalable components! 🎯
🔘 CBD processes like analysis, specification, design & implementation, testing, and integration build cohesive systems! 🔄



➖➖➖➖➖➖➖➖➖➖➖➖
The teaser ends here—step into the world where modular design meets innovation! ⚙️🌐✨
➖➖➖➖➖➖➖➖➖➖➖➖

Chapter 2️⃣: Software Component Specification and Repositories 🗂

Software Component Specification 📝

Definition: A detailed blueprint describing a component’s functionality, interfaces, dependencies, and interactions.
• It should be detailed, focusing on what the software is to do rather than how this is to be done.

Types:
• High-Level: Focus on functionality and relationships.
• Low-Level: Dive into implementation details.

Types of Software Components 🧩

🔧 Off-the-Shelf: Pre-made, ready-to-use components.
🛠 Third-Party: Developed externally, offering specialized functionality.
🔗 Full Experience: Existing components integrated without changes.
🔨 Partial Experience: Components requiring minor customization.
🆕 New Components: Built from scratch for unique requirements.

Software Component Repositories 🔂

Definition: Centralized storage for source code, documentation, and project files.

Types:
🔒 Local Repositories: Internal to organizations, secure but limited.
🌍 Public Repositories: Open platforms (e.g., GitHub) for global collaboration.
🔗 Hybrid Repositories: Mix of local and public features.

Advantages of Repositories 🚀

🤝 Contribution: Easily contribute to open-source projects and collaborate with others.
📚 Documentation: Simplify robust documentation development with repository management tools.
📂 Portfolio Creation: Showcase your skills and attract recruiters by displaying your work on GitHub.
📝 Track Changes: Keep track of revisions and changes in collaborative projects—no more confusion!
🔧 Tool Integration: Seamlessly integrate repositories with other development tools for smoother workflows.

Repository Constructs 🔧

📜 Version Control System (VCS):
Tracks changes, maintains a historical record, and enables collaboration across multiple contributors.

💻 Local Repository:
A developer's local copy of the project, where changes are made before being committed to the central repository.

🌐 Remote Repository:
A central storage location, shared among developers. Popular services include GitHub, GitLab, and Bitbucket.

🌿 Branch:
A parallel version of the code, allowing developers to work on features or bug fixes independently.

🔄 Merge:
Combines changes from one branch into another, typically from feature branches into the main branch.

📸 Commit:
A snapshot of changes, accompanied by a unique identifier and a message describing the changes.

🔁 Clone:
Creates a local copy of a remote repository to work on it independently.

⬇️ Pull:
Fetches and merges changes from a remote repository into the current local branch.

⬆️ Push:
Sends committed changes from the local repository to the remote repository, updating it.

🍴 Fork:
Creates a personal copy of a repository to make changes and propose them via a pull request.

📍 Tag:
Marks specific points in version history, often used for releases or milestones.

📝 Issues:
Tracks tasks, bugs, or questions related to the project, often integrated into repository hosting platforms.

📚 Readme:
Provides essential information about the project, including installation, usage, and contribution guidelines.

👥 Collaborators & Teams:
Manage access and roles within the repository for efficient teamwork.

Summary ⭐️

🔘 Component Specification: A detailed blueprint defining functionality, interfaces, and interactions. 📝
🔘 Software Components: Vary from off-the-shelf to custom-built, each with different levels of integration and reusability. 🧩
🔘 Repositories: Centralized storage for code, enabling collaboration, version control, and tool integration. 🔂
🔘 Repository Types: Local, public, and hybrid, each serving distinct collaboration and security needs. 🌐
🔘 Repository Advantages: Simplify contributions, documentation, version tracking, and tool integration. 🚀
🔘 Repository Constructs: Includes commits, branches, merges, and issues to manage code and tasks efficiently. 🔧



➖➖➖➖➖➖➖➖➖➖➖➖
The teaser ends here—step into the world where modular design meets innovation! ⚙️🌐✨
➖➖➖➖➖➖➖➖➖➖➖➖