UNIT 1
Introduction: The Structure of Complex systems, The Inherent Complexity of Software,
Attributes of Complex System, Organized and Disorganized Complexity, Bringing Order to
Chaos, Designing Complex Systems, Evolution of Object Model, Foundation of Object Model,
Elements of Object Model, Applying the Object Model.
1.The Structure of Complex systems
A complex system is a system composed of many components which may interact with each
other. In many cases it is useful to represent such a system as a network where the nodes
represent the components and the links their interactions. Examples of complex systems are
Personal Computer, Plants, and Education System.
The structure of personal computer
A personal computer is a device of moderate complexity. Most are composed of the same
major elements: a central processing unit (CPU), a monitor, a keyboard, and some sort of
secondary storage device, usually either a CD or DVD drive and hard disk drive. We may take
any one of these parts and further decompose it. For example, a CPU typically encompasses
primary memory, an arithmetic/logic unit (ALU), and a bus to which peripheral devices are
attached. Each of these parts may in turn be further decomposed: An ALU may be divided into
registers and random control logic, which themselves are constructed from even more
primitive elements, such as NAND gates, inverters, and so on.
Central Processing Unit (CPU) — Executes programs
Arithmetic & Logic Unit (ALU)
Registers
NAND gate
CMOS Gate
Interconnect
Inverter
Control Logic
Primary Memory
Bus — peripheral devices
Hard disk drive — Persistent storage for data
Monitor — Outputs data
Keyboard — Inputs data
Secondary storage device (DVD drive / USB) — Removable storage for data
Complex systems hierarchies
Each Level of Hierarchy represents a Layer of Abstraction
Each Layer
Is built on top of other layers: CMOS Gates —> NAND Gates—> Registers
(in turn) Supports other layers: CMOS Gates —> NAND Gates—> Registers
Is independently understandable: CPU
Works independently with clear separation of concerns: ALU, Memory
, Common services / properties are shared across Layers: Same power-tree feeds the
components of CPU
Layers together show Emergent Behavior
Behavior of the whole is greater than the sum of its parts
Systems demonstrate cross-domain commonality: Cars have processors, memory,
display
2. The Inherent Complexity of Software
There are two types of software are there in terms of complexity
Simple Software
Industrial-strength software
Simple Software
Simple Software is software with limited set of behaviors and not very complex. It is
specified, constructed, maintained, and used by the same person or a small group usually the
amateur programmer or the professional developer working in isolation. Such systems tend to
have a very limited purpose and a very short life span. Can be thrown away and replaced with
entirely new software rather than attempt to reuse them, repair them, or extend their
functionality
Industrial-strength software
Industrial-strength software applications exhibits a very rich set of behaviors, for example, in
reactive systems that drive or are driven by events in the physical world, and for which time
and space are scarce resources; applications that maintain the integrity of hundreds of
thousands of records of information while allowing concurrent updates and queries; and
systems for the command and control of real-world entities, such as the routing of air or
railway traffic. Software systems such as these tend to have a long life span, and over time,
many users come to depend on their proper functioning. Complexity of Industrial-Strength
Software systems exceeds the human intellectual capacity
Why Software Is Inherently Complex?
Inherent complexity derives from four elements:
1. The complexity of the problem domain,
2. The difficulty of managing the development process,
3. The flexibility possible through software,
4. The problems of characterizing the behavior of discrete systems.
The complexity of the problem domain
Domains are difficult to understand. Consider the requirements for the electronic system of a
multiengine aircraft, a cellular phone switching system, or an autonomous robot. The raw
functionality of such systems is difficult enough to comprehend. The functional requirements
, complex to master and often are competing, even contradictory. Non-functional Requirements
(usability, performance, cost, survivability, and reliability) are often Implicit and difficult to
justify in the budget.
This external complexity usually springs from the ―communication gap‖ that exists between
the users of a system and its developers. Users cannot express; developers cannot understand
due to lack of expertise across domains.
The difficulty of managing the development process
The task of the software development team is to engineer the illusion of simplicity. We strive
to write less code by inventing clever and powerful mechanisms. Today, it is not unusual to
find delivered systems whose size is measured in hundreds of thousands or even millions of
lines of code. The complexity of software goes well beyond the comprehension of a single (or
small group of) individual/s, even with meaningful decomposition. Hence, we need more
developers and more teams. The key management challenge is to maintain a unity and
integrity of management.
The flexibility possible through software
Software offers the ultimate flexibility, so it is possible for a developer to express almost any
kind of abstraction. This flexibility turns out to be an incredibly seductive property, however,
because it also forces the developer to craft virtually all the primitive building blocks on which
these higher-level abstractions stand. While the construction industry has uniform building
codes and standards for the quality of raw materials, few such standards exist in the software
industry. As a result, software development remains a labor-intensive business.
Problems of characterizing the behavior of discrete systems
Software is built and executed on digital computers. Hence, they are Discrete Systems. A large
application would have hundreds or even thousands of variables and more than one (often
several) thread of control. A state is entire collection of variables, the current values of
variables, the current address of each process, the calling stack of each process. Software has
finite number of states. Yet, many of these the states are often intractable and influenced by
external factors. This change is not deterministic (unlike continuous system) and needs
extensive Testing.
3. Attributes of Complex System
1. Hierarchic Structure
2. Relative Primitives
3. Separation of Concerns
4. Common Patterns
5. Stable Intermediate Forms
Hierarchic Structure
All systems are composed of interrelated sub-systems
Sub-systems are composed of sub-sub-systems, and so on
Introduction: The Structure of Complex systems, The Inherent Complexity of Software,
Attributes of Complex System, Organized and Disorganized Complexity, Bringing Order to
Chaos, Designing Complex Systems, Evolution of Object Model, Foundation of Object Model,
Elements of Object Model, Applying the Object Model.
1.The Structure of Complex systems
A complex system is a system composed of many components which may interact with each
other. In many cases it is useful to represent such a system as a network where the nodes
represent the components and the links their interactions. Examples of complex systems are
Personal Computer, Plants, and Education System.
The structure of personal computer
A personal computer is a device of moderate complexity. Most are composed of the same
major elements: a central processing unit (CPU), a monitor, a keyboard, and some sort of
secondary storage device, usually either a CD or DVD drive and hard disk drive. We may take
any one of these parts and further decompose it. For example, a CPU typically encompasses
primary memory, an arithmetic/logic unit (ALU), and a bus to which peripheral devices are
attached. Each of these parts may in turn be further decomposed: An ALU may be divided into
registers and random control logic, which themselves are constructed from even more
primitive elements, such as NAND gates, inverters, and so on.
Central Processing Unit (CPU) — Executes programs
Arithmetic & Logic Unit (ALU)
Registers
NAND gate
CMOS Gate
Interconnect
Inverter
Control Logic
Primary Memory
Bus — peripheral devices
Hard disk drive — Persistent storage for data
Monitor — Outputs data
Keyboard — Inputs data
Secondary storage device (DVD drive / USB) — Removable storage for data
Complex systems hierarchies
Each Level of Hierarchy represents a Layer of Abstraction
Each Layer
Is built on top of other layers: CMOS Gates —> NAND Gates—> Registers
(in turn) Supports other layers: CMOS Gates —> NAND Gates—> Registers
Is independently understandable: CPU
Works independently with clear separation of concerns: ALU, Memory
, Common services / properties are shared across Layers: Same power-tree feeds the
components of CPU
Layers together show Emergent Behavior
Behavior of the whole is greater than the sum of its parts
Systems demonstrate cross-domain commonality: Cars have processors, memory,
display
2. The Inherent Complexity of Software
There are two types of software are there in terms of complexity
Simple Software
Industrial-strength software
Simple Software
Simple Software is software with limited set of behaviors and not very complex. It is
specified, constructed, maintained, and used by the same person or a small group usually the
amateur programmer or the professional developer working in isolation. Such systems tend to
have a very limited purpose and a very short life span. Can be thrown away and replaced with
entirely new software rather than attempt to reuse them, repair them, or extend their
functionality
Industrial-strength software
Industrial-strength software applications exhibits a very rich set of behaviors, for example, in
reactive systems that drive or are driven by events in the physical world, and for which time
and space are scarce resources; applications that maintain the integrity of hundreds of
thousands of records of information while allowing concurrent updates and queries; and
systems for the command and control of real-world entities, such as the routing of air or
railway traffic. Software systems such as these tend to have a long life span, and over time,
many users come to depend on their proper functioning. Complexity of Industrial-Strength
Software systems exceeds the human intellectual capacity
Why Software Is Inherently Complex?
Inherent complexity derives from four elements:
1. The complexity of the problem domain,
2. The difficulty of managing the development process,
3. The flexibility possible through software,
4. The problems of characterizing the behavior of discrete systems.
The complexity of the problem domain
Domains are difficult to understand. Consider the requirements for the electronic system of a
multiengine aircraft, a cellular phone switching system, or an autonomous robot. The raw
functionality of such systems is difficult enough to comprehend. The functional requirements
, complex to master and often are competing, even contradictory. Non-functional Requirements
(usability, performance, cost, survivability, and reliability) are often Implicit and difficult to
justify in the budget.
This external complexity usually springs from the ―communication gap‖ that exists between
the users of a system and its developers. Users cannot express; developers cannot understand
due to lack of expertise across domains.
The difficulty of managing the development process
The task of the software development team is to engineer the illusion of simplicity. We strive
to write less code by inventing clever and powerful mechanisms. Today, it is not unusual to
find delivered systems whose size is measured in hundreds of thousands or even millions of
lines of code. The complexity of software goes well beyond the comprehension of a single (or
small group of) individual/s, even with meaningful decomposition. Hence, we need more
developers and more teams. The key management challenge is to maintain a unity and
integrity of management.
The flexibility possible through software
Software offers the ultimate flexibility, so it is possible for a developer to express almost any
kind of abstraction. This flexibility turns out to be an incredibly seductive property, however,
because it also forces the developer to craft virtually all the primitive building blocks on which
these higher-level abstractions stand. While the construction industry has uniform building
codes and standards for the quality of raw materials, few such standards exist in the software
industry. As a result, software development remains a labor-intensive business.
Problems of characterizing the behavior of discrete systems
Software is built and executed on digital computers. Hence, they are Discrete Systems. A large
application would have hundreds or even thousands of variables and more than one (often
several) thread of control. A state is entire collection of variables, the current values of
variables, the current address of each process, the calling stack of each process. Software has
finite number of states. Yet, many of these the states are often intractable and influenced by
external factors. This change is not deterministic (unlike continuous system) and needs
extensive Testing.
3. Attributes of Complex System
1. Hierarchic Structure
2. Relative Primitives
3. Separation of Concerns
4. Common Patterns
5. Stable Intermediate Forms
Hierarchic Structure
All systems are composed of interrelated sub-systems
Sub-systems are composed of sub-sub-systems, and so on
