Real-time (what I do)
Str#106. "Real Time: Timeliness" Strategy
- timeliness: must be "on time"
- put performance constraints on your scenarios (on
services, too, as needed--although allocating performance
constraints to individual services often takes more guesswork
than most engineers feel comfortable with).
Str#107. "Real Time: Dynamic Internal Structure"
Strategy
- dynamic internal structure: dynamic creation and
destruction of software components
- how: show dynamic creation and deletion of objects in
scenarios.
-
- every class knows how to create new objects in that
class.
- every collection knows how to add and remove objects
in that collection.
- every object knows how to delete itself.
- in addition, you can selectively place additional
creation and deletion constraints.
Str#108. "Real Time: Reactiveness" Strategy
- Reactiveness: continuously responds to different events
in its environment, detected by data acquisition and control
devices, or by interacting systems
- Use a specific "maintain" or "monitor" service, for
ongoing capabilities.
- Use the "activate, monitor, deactivate" triad.
Str#109. "Real Time: State-Dependency" Strategy
- State-dependency: responds differently, depending upon
the state of a system
- Attributes: state, state-dependent,
state-independent
-
- In its description, include: applicable states.
- Services: state-dependent, state-independent
-
- In its description, you may need to include:
-
- precondition: <indicate what you assert to be
true, before this service can run>
- postcondition: <indicate what you assert to be
true, before this service can go to
completion>
- trigger condition: <indicate what state
transitions activate this service>
- terminate condition: <indicate what state
transitions terminate this service>
- exception: <indicate object.service to invoke,
upon detecting an exception>.
Str#110. "Real Time: Concurrency" Strategy
- Concurrency: multiple simultaneous activities can be
taking place.
- Objects can do more than one thing at once -- they are
multitasking creatures.
- Objects encapsulate real-time tasks.
-
- Activation / deactivation
-
- Trigger condition: <request, state change,
value change, time lapse>
- Terminate condition: <request, state change,
value change, time lapse>
- Communication, coordination
- Communication between objects is by synchronous
messaging.
- Communication within objects is by synchronous and
asynchronous messaging, as needed.
- Note: this encapsulation is made possible with effective
object modeling (not with data objects and controller
objects).
Str#111. "Real Time: Multiple Device Abstractions"
Strategy
- Multiple device abstractions: needs both physical and
logical abstractions.
- Physical abstraction -- express with an object in the
system interaction component.
- Logical abstractions -- express with:
-
- a domain-based object (a problem-domain object)
- an object which shows "this is how we'll work with
it" (a human interaction object)
- an object which persists from one program invocation
to the next (a data management object).
Str#112. "Real Time: Distribution" Strategy
- Distribution: multiple computing sites
- Across multiple computing systems
-
- Use software that supports distributed objects.
- Or do it yourself (inevitable, at least for systems
that you must interact with and cannot change).
-
- Allocate objects, not mere functionality.
- Add "pack and ship; receive and route"
infrastructure.
- Within an existing system
-
- Use an object model to understand what's really going
on.
- Tag each service with its location; tag each
attribute with who is using it.
Establishing responsibilities
/ what I do
Strategies for building object
models