Course program
Software quality.
Quality is the goal of engineering; building high-quality software (software) is the goal of software engineering. External and internal factors. Correctness. Robustness. Extensibility. Reusability. Compatibility. Efficiency. Portability. Easy of Use. Functionality. Timeliness. Other qualities. About documentation. About software support.
Object Orientation Criteria
About the criteria. Categories. Method and language. Seamlessness. Classes. Assertions. Classes as modules. Classes as types. Component-based computing. Information hiding. Exception handling. Static typing. Universality (genericity). Single inheritance. Multiple inheritance. Duplicate inheritance. Constrained genericity. Redefinition. Polymorphism. Dynamic linking. Determining the type of an object at runtime. Deferred properties and classes. Memory management and garbage collection. Implementation and environment. Automatic update. Fast update. Persistence. Libraries. Basic libraries. Graphics and user interfaces. Mechanisms of library evolution. Indexing mechanisms in libraries.
Modularity
Five criteria. Decomposition. Modular Composition. Modular Understandability. Modular Continuity. Modular Security. Five rules: direct mapping, minimum interfaces, loose interface coupling, explicit interfaces, information hiding. Five principles: Linguistic Modular Units, Self-Documentation, Unified Access, Open-Closed, Single Choice.
Reuse approaches
Reuse goals. Expected benefits. Consumers and producers of reusable programs. Personnel reuse. Reuse of designs and specifications. Design patterns. Reuse of source text. Reuse of abstract modules. Repeatability in software development. Organizing access to components. Formats for distributing reusable components. Type Variation, Routine Grouping, Implementation Variation, Independence of Representations, Factorization of General Behavior. Traditional modular structures. Subroutines. Packages. Overload and versatility. Syntactic overload. Semantic overload (pre-representation). Universality (genericity).
Abstract Data Types (ADTs)
Various implementations. Stack views. The dangers of overspecification. Using operations. Laissez faire policy in module society. Name consistency. Is it possible to do without abstractions? Formalization of specifications. Type specification. Universalization (Genericity). Enumeration of functions. Categories of functions. Partial functions. Preconditions. Full specification. The role of deferred classes. Abstract data types and information hiding.
Static structures: classes
The role of classes. Modules and types. Class as a module and as a type. Unified type system. Simple class. Components. Attributes and subroutines. Unified access. Class POINT. Component type recognition. Subroutine body and header comments. indexing clause. Designation of the result of the function. Object-oriented computing style.
Dynamic structures: objects
Objects. Basic form. Simple fields. Links. Identity of objects. Announcement of links. Link to yourself. A look at the structure of runtime objects. Objects as a modeling tool. Working with objects and links. Dynamic creation and relinking. Creation procedures and overloading. Operations on links. Attaching a reference to an object. The value is void. Cloning and comparing objects. Copying objects. Aggregation. Properties of expanded types. Attachment: reference and copies. Dynamic aliases. Encapsulation of actions with links.
Memory management
Creating objects. Using dynamic mode. Disconnect. Unreachable objects. Reachable objects in the classical approach. Reachable objects in the object-oriented (OO) model. Memory management problem in the OO model. Memory recovery: problems. Programmer-controlled object deletion. Automatic memory management. Garbage collection mechanism.
Universalization
Horizontal and vertical generalization of type. The need for parameterized classes. Generic ATD. Operations on entities of generic type. Types and classes. Arrays as objects. Array properties.
Building reliable software
Basic reliability mechanisms. About software correctness. Introduction of statements into program texts. Preconditions and postconditions. Stack class. Contracts and software reliability. Rights and obligations. Errors, defects. Working with statements. Imperative and applicative (applicability).
Exception Handling
Basic concepts of exception handling. Refusals. Exceptions. Sources of exceptions. Failure situations. Exception handling.
Support mechanisms
Interaction with non-object software. External programs. OO-change of architecture (re-architecturing). Conditional Instruction. Multiple choice. Cycles. Repeating calculations. Expressions. Manifest constants. Non-strict Boolean operators. Lines.
Introduction to Inheritance
Basic conventions and terminology. Inheritance of an invariant. Inheritance and constructors. Polymorphism. Polymorphic addition. Polymorphic data structures. Typing in inheritance. Type consistency. Limits of polymorphism. Instances. Static type, dynamic type. Dynamic linking. Deferred components and classes. Re-declaring a function as an attribute. Explicit override. Access to the predecessor of a procedure. Dynamic binding and efficiency. Static linking as an optimization.
Multiple inheritance
Examples of multiple inheritance. Renaming components. Name conflict. Name changes and redefinitions. Selection of local names. Override conflict. Duplicate inheritance and universality.
Inheritance technique
Inheritance and assertions. Invariants. Preconditions and postconditions in the presence of dynamic binding. Abstract preconditions. Rule of language. Re-declaring a function as an attribute.
Typing
Typing problem. Basic design. Static and dynamic typing. Typing rules.
Global objects and constants
Constants of basic types. Constant attributes. Custom class constants. One-time functions. Shared objects. One-time procedures. Constants of string types.