Informatics 43
Abstraction
Formed by removing irrelevant information and retaining relevant information. Every design notation supports a degree of abstraction.
No Silver Bullet (Brooks) - Silver Bullet: Incremental development
Grow, not build software
Client-Server Architecture
Has a server with a bunch of clients. Advantage: Centralized controll
No Silver Bullet (Brooks) - Silver Bullet: Requirements refinement/ rapid prototyping
Having really specific requirements makes it easier to build software that conforms to what the client wants
Software Design
How and the what of the requirements.
Relationship between classes: Composition
If parent is deleted, child is deleted. Ex: Cannot have a room without a building.
Perspective of Software Engineering: Engineer
Internal quality
Pipe and Filter Architecture
Pipes are the interactions between the filters. Goes from one end the other. Advantages: Modularity Reuse Anticipation of change
Publish and Subscribe Architecture
Publishers send out the data and the subscribers only receive the data that they are subscribed to. Advantages: Efficiency and Scalability Examples: Stock market, news
No Silver Bullet (Brooks) - Silver Bullet: Great designers
Really ****ing smart people.
Use case
Textual description defining interactions between an actor and the system to achieve the primary actor's goal. Serve as a communication/understanding tool among diverse stakeholders.
Recurring Fundamental Principles: Generality
The ability to reuse code, so writing code in a way which allows one to reuse it elsewhere without writing something similar again.
Descriptive Architecture
The actual architecture of the system once it is built.
Prescriptive Architecture
The intended architecture before the system is built.
Layered Architecture
When there are different layers, and each one only interacts with the one below or above it. Advantages: Modularity Abstraction: you abstract all the parts that are not above or below the one you are working on. Anticipation of Change Reuse: Different parts of different layers can be easily reused. Examples: Operating Systems, networks
Brooks' Law formula
n(n-1)/2
Model-View-Controller Architecture
A model is affected by a controller. The view is the interface. Advantages: Modularity: everything pertaining to one thing is shown in one area. Anticipation of change: Easily changeable, as you can update just the components. Same reason as object oriented.
Why spend a lot of time in requirements?
As the development process goes on, it costs more and more in order to change a requirement.
Parts of a use case
Basic, alternative, exception flows.
Recurring Fundamental Principles: Anticipation of Change
Being able to anticipate future change in the software
Hubble Psychology
Being overly optimistic on large projects.
Recurring Fundamental Principles: Rigor and Formality
Being rigorous about formalities. Make sure that one adheres to the requirements and software engineering process.
Recurring Fundamental Principles: Incrementality
Building your software incrementally. Growing it.
Architectural style
A collection of architectural design decisions that are applicable in a given development context.
Parts of a use case diagram.
Actor, System boundary, use case
Brooks' Law
Adding more people to a late project makes causes it to be even more late.
Relationship between classes: Association
All objects have their own life cycle and there is no owner. Ex. Multiple teachers can associate with one student and multiple students can associate with one teacher.
Evolution
All successful software evolves. Essential part of software development. Must be accommodated/ planned as possible.
Approaches to software design: Object Oriented Design
An "object" contains both data and methods. "Class" is a blueprint for making objects. UML
No Silver Bullet (Brooks) - Silver Bullet: Buy vs build
Buying parts of software. Ex. buying google maps api instead of making a whole new map function.
Components of Architecture
Components and connectors put into configurations.
Perspective of Software Engineering: Business
Cost, time profit.
Approaches to software design: Relational Database Design
Designing a table that shows the data being stored and how they're related.
Approaches to software design: User Interfaced Design
Designing the user interface in a concept sketch.
Peer to Peer Architecture
Each component is connected with a peer. Advantages: Robustness: if one peer goes down, just connect to another one bc they're all the same Efficiency: they are very efficient because you directly connect to another peer. Do not have to go through a server. Ex: Skype, file sharing systems
Perspective of Software Engineering: Design
External quality
Failure readings: Shopa
Failed because they were unsure of what the software they were building actually was.
Top Software Failure Causes
Lack of user input/involvement Incomplete specifications and requirements Changing requirements and specifications Lack of discipline in the development process Lack of methodical usage of metrics (eg testing how long a function takes on a super fast computer, but not the same as a typical consumer. Also incorrect in measuring cost and scheduling) Lack of resources
Software Design Goals/Activities
Making system-wide decisions: architecture, languages, libraries, platforms Making lower leveled-decisions in an iterative manner Studying the problem, identifying solutions, creating abstractions
Recurring Fundamental Principles: Separation of Concerns
Modularity: Dividing functions into smaller modules, as well as dividing problems into smaller versions of themselves. Divide and Conquer: Dividing the issue into different parts which each person can conquer individually. Abstraction: Abstracting things that do not pertain to what you are concerned with.
What is software engineering?
Multi-person construction of multi-version software.
Relationship between classes: Aggregation
Objects have their own life cycle but there is ownership and child cannot belong to another parent. Ex. Teacher has a department, but when the department is deleted, the teacher still exists.
Architectural Erosion
Occurs when the prescribed architecture differs from the descriptive architecture.
Mythical Man Month: Causes of late projects
Optimistic estimations Confuse effort with progress. Man Months Poor system testing and mischeduling Poor schedule monitoring Adding manpower
Essential ingredients to software engineering
People, Process, Tools
Approaches to software design: Functional Decomposition
Separating the whole functionality of the system into smaller building blocks. Ex: Timekeeper 9000 1 Authentication 1.1 Login 1.2 Logout
Software Architecture
Set of principle design decisions about the system. A blueprint for its construction and evolution.
Object Oriented Architecture
Setting having each item in the architecture represented by a physical object. Advantages: Abstraction: Each object is a physical object. Anticipation of change: Easy to upgrade, just change each module and as long as the interface between others is the same, it will work. Understandably: Very understandable.
Non-functional requirements
Software ilities. Linear scale. Traits that the software has
No Silver Bullet (Brooks) - Difficulty: Complexity
Software is complex and it is really difficult to keep track of every component.
No Silver Bullet (Brooks) - Difficulty: Invisibility
Software is invisible. There is no way to find issues until they are found through testing.
No Silver Bullet (Brooks) - Difficulty: Changeability
Software must be changeable because requirements and intentions change all the time.
No Silver Bullet (Brooks) - Difficulty: Conformity
Software must conform to the platform and environment it is in. This is always different. Ex. Engineers conform to laws of physics but software engineers conform to whatever laws given in the language.
Failure readings: CA Payroll and LADWP
The systems failed because they were underfunded and they also took on an issue that was way too complex for them. Progress was hard to measure and it was difficult to conform to the old system.
Other Design Diagrams
User interface mockups, storyboard, sketches.
Requirements
What the software should do without saying how it should do it.
