Object Oriented System (MIE 111) Study Material: Comprehensive Guide

Object Oriented System (MIE 111) - Complete Study Guide

Semester: First | Credit Hour: 4 | Full Marks: 100 (Internal: 40 | Final Exam: 60)

Welcome to this comprehensive, visually rich study guide for Object Oriented System (MIE 111). This course introduces you to the powerful paradigm of object-oriented technology, UML modeling, and practical system design. Below, each unit is explained in detail with key concepts, diagrams, and recommended videos to help you understand and prepare effectively.

Unit 1: Introduction (5 Hours)

This unit introduces the course, general concepts, and the need for object-oriented systems. It explains why traditional procedural programming struggles with complex systems and how object-oriented approaches provide better solutions.

Why Object Orientation?

Procedural languages suffer from issues like global data vulnerability and poor code reuse in large systems. Object-oriented systems model real-world entities, promoting modularity, reusability, and easier maintenance.

Attributes of Complex Systems (Grady Booch)

• Hierarchic Structure: Built from interrelated subsystems.
• Relative Primitives: Basic blocks depend on abstraction level.
• Separation of Concerns: Strong intra-component links, weak inter-component (High Cohesion, Low Coupling).
• Common Patterns: Reuse of similar structures.
• Stable Intermediate Forms: Evolution from simple working systems.

The 4 Pillars of OOP

• Encapsulation: Data hiding with controlled access.
• Abstraction: Show only essential features.
• Inheritance: Code reuse through class hierarchies.
• Polymorphism: Same interface, different implementations.

Video Resources:

• Intro to Object Oriented Programming - Crash Course
• OOP Concepts in Depth

Unit 2: Object Oriented Design (10 Hours)

OOD focuses on "how" the system works, defining classes, objects, relationships, and behavior. It emphasizes reusability and maintainability through proper design principles.

Key Object Relationships

• Association: General connection between classes.
• Aggregation: "Has-a" (weak) – part can exist independently.
• Composition: "Contains" (strong) – part cannot exist without whole.
• Generalization/Inheritance: "Is-a" relationship.

Video Resource: Object Oriented Design Tutorial

Unit 3: UML (10 Hours)

UML is the standard visual language for modeling software systems. It includes structural and behavioral diagrams to represent static structure and dynamic behavior.

Main UML Diagrams

• Class & Object Diagram
• Use Case Diagram
• Sequence Diagram
• State Diagram
• Activity Diagram
• Package, Component, Deployment Diagrams

Video Resource: UML Diagrams Full Course

Unit 4: Domain Analysis (10 Hours)

Domain Analysis identifies real-world concepts (classes, attributes, relationships) before designing software. It ensures the system reflects actual business needs.

Key Steps

1. Find Classes & Associations
2. Create Data Dictionary
3. Identify Attributes & Methods
4. Refine with Inheritance
5. Test Access Paths & Iterate
6. Group into Packages

Video Resource: Domain Analysis in OOAD

Unit 5: Agent UML (5 Hours)

Agent UML (AUML) extends UML for agent-based systems where agents are autonomous, goal-oriented entities (unlike passive objects).

Key Features

• Agent roles and goals
• Negotiation protocols
• Multi-agent interaction patterns

Video Resource: Agent-Based Modeling with UML

Unit 6: Object Oriented Metrics (5 Hours)

Metrics help evaluate design quality. Focus on internal quality, cohesion, coupling, and complexity.

Important Principles

• High Cohesion
• Low Coupling
• CK Metrics Suite (WMC, DIT, NOC, CBO, etc.)

Video Resource: OO Design Metrics

Unit 7: Object Oriented System Development Life Cycle (5 Hours)

OO development is iterative and incremental. Covers building high-quality software, testing, verification, validation, and prototyping approaches.

Video Resource: Object-Oriented SDLC

Unit 8: Project Design (10 Hours)

Apply all concepts in a complete project using UML diagrams, domain models, and design principles.

Video Resource: UML Project Design Example

References

• Object Oriented System by Grady Booch
• Object Oriented Systems Analysis and Design using UML by Simon Bennett, Steve McRobb, Ray Farmer
• Object Oriented Systems Analysis and Design by JOEY F. George, Dinesh Batra, JEFFREY A. HOFFER

Why Software Systems Are Complex? Explain the properties of complex systems.

Software systems are inherently complex due to several factors stemming from their scale, evolution, and the nature of the problems they solve. Unlike physical engineering, software deals with abstract concepts that can grow exponentially in interactions and requirements. Software is often described as one of the most complex human endeavors because it spans multiple orders of magnitude—from individual lines of code to vast interconnected ecosystems. The underlying domain—such as business rules, user needs, and environmental constraints—is itself complex, leading to intricate designs that must accommodate changing requirements, scalability, and integration with other systems.

Key reasons include:

• Scale and Interdependencies: Modern software involves millions of lines of code, multiple components, and dependencies. As systems grow, managing interactions becomes challenging and may result in unintended behaviors or emergent properties.
• Evolution Over Time: Software evolves continuously. Simple initial designs accumulate features, patches, and integrations, often creating accidental complexity due to legacy code or poor decisions.
• Human and Organizational Factors: Development is shaped by teams, deadlines, and budgets. Commercial pressure often favors speed over simplicity, while organizational complexity increases coordination challenges.
• Abstract Nature: The lack of physical constraints allows great flexibility, but it can also encourage over-engineering and unnecessary abstractions.
• External Influences: Integration with hardware, networks, and user expectations introduces variability and reduces predictability.

This complexity is often unavoidable and necessary to meet real-world demands. However, poor management can lead to delayed deliveries, defects, and high maintenance costs.

Properties of Complex Systems

Grady Booch identifies five key attributes common to all complex systems, including software. These properties explain why complexity arises and how it can be managed through structured approaches such as hierarchy and decomposition.

1. Hierarchic Structure: Complex systems consist of subsystems that form a hierarchy. In software, this appears as layers, modules, and classes.
2. Relative Primitives: What is considered a basic component depends on the level of abstraction. A primitive at one level may be complex at another.
3. Separation of Concerns: Interactions within a subsystem are stronger than interactions between subsystems. This leads to high cohesion and low coupling.
4. Common Patterns: Complex systems reuse a limited set of structures in different combinations. Software design patterns address recurring problems effectively.
5. Stable Intermediate Forms: Complex systems evolve from simpler, working systems rather than being built all at once. This supports iterative and agile development.

These attributes show that complexity is structured rather than chaotic. Applying object-oriented principles such as encapsulation and abstraction helps manage this complexity effectively.