CS 211: Software Engineering Principles

Course Information

• This course is identified as CS 211
• It is offered in the first semester of 1443 (2021-2022)

Class Requirements

• Proficiency in a programming language is needed.
• Prior experience in system analysis or design is not necessarily required.
• Intended for those wanting to learn about software aspects in analysis and design of complex systems.

Objectives

• Appreciation for Software Engineering is important:
  • Focus on building complex software systems in frequently changing environments.
• Understand how to:
  • Produce quality software systems within time constraints.
  • Handle complexity and change effectively.
• Acquire technical knowledge.
• Acquire managerial knowledge.
• Understand the Software Lifecycle:
  • Including process vs product aspects.
  • Various software lifecycles and.
  • Greenfield Engineering starting from scratch.
  • Interface Engineering for legacy systems and reengineering
  • Reengineering defined by Hammer & Champy in 1993 is included.

Acquiring Technical Knowledge

• Focus on understanding System Modeling
• Learn about Modeling:
  • Using approximately 20% of UML aspects
  • UML stands for Unified Modeling Language.
• Modeling at Different Phases of the Software Lifecycle:
  • Requirements Elicitation [Chap. 4] results in Deliverable 1
  • Requirements Analysis [Chap 5] results in Deliverable 2
  • Architectural Design [Chap 6 & 7] results in Deliverable 3
  • Object/Component Design [Chap 8]results in Deliverable 4
  • Coding [Chap 10] results in Deliverable 5
  • Testing [Chap 11] results in Deliverable 6, demonstrated during demo
  • The requirements analysis marked with * mixes the domain model with the solution model, being design-oriented, and in a Waterfall fashion.
• Ability Model Traceability is key
• Learning to use tools like CASE (Computer Aided Software Engineering), such as Rational Rose.

Readings

• Required text:
  • Object-Oriented Software Engineering: Using UML, Patterns, and Java by Bernd Bruegge and Allen Dutoit, Prentice Hall, 2003
• Recommended books:
  • Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process, 2nd ed. by C. Larman
  • Design Patterns by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, Addison-Wesley, 1996.
  • The Unified Modeling Language User Guide by Grady Booch, James Rumbaugh, and Ivar Jacobson, Addison Wesley, 1999.
  • Objective Knowledge, an Evolutionary Approach by K. Popper, Oxford Press, 1979.
• Additional readings may be required

Software Engineering Context

• Software engineering addresses the fact that some software projects total 96.7 million USD and are unsuccessful
• Referencing a report to congress in 1979, it notes that 45% delivered, but never successfully used, 30% paid for, but not delivered, 3% usable with rework, and 20% used with extensive rework, but later abandoned

Characteristics of Software Systems

• Software systems are complex creations and:
  • Perform many functions
  • Achieve different and conflicting objectives such as time scales or resource budgets
  • Consist of myriad components
  • Require participation of various disciplines
  • Have development process and life cycles that span many years
• Software Systems are subject to constant change:
  • Client/end user requirements change
  • Errors get discovered
  • Developers improve understanding
  • Newer technologies emerge
  • Staff turnover occurs

Problem Solving in Software Engineering

• Analysis: Understanding the problem and breaking into constituent parts
• Synthesis: Assembling those parts into a structured hole
• Uses techniques via formal procedures with notation
• Collection of tehcniques and methodologies unify a philosophical approach
• Uses Instruments or automated systems

Definition of Software Engineering

• A discipline comprised of techniques, methodologies, and tools to produce
  • A high quality software syste
  • Within a budget
  • Before a set deadline
  • Even as changes occur

Scientist vs Engineer

• Computer Scientist:
  • Focuses on algorithms, languages, and knowledge schemas
  • Unlimited time
• Engineer:
  • Client focus
  • Utilizes tools, techniques, etc
• Software Engineer:
  • Works across domains
  • Limited time
  • Must anticipate changing requirements and tech

Factors Affecting Software Quality

• Complexity: - Software becomes so complex that no single programmer can fully understand it leading to higher rate of defects - Bug fixes may introduce further faults and problems
• Change: - A software system's entropy increases by erosion of system structure - Over time the costs for change become too high, resulting system failure

Abstraction

• Abstraction, decomposition, and hierarchy deal with complexity
• Inherent human limitation to deal with complexity includes the 7+-2 phenomena
• Chunking: Group collection of related objects for mental manageability
• Ignoring Unessential details: Reduces clutter

System Models

• Object Model: The structure and relevant relationships
• Functional Model: The functions and dataflow
• Dynamic model: How does the system react to external stimulus

Other Models

• Task Model:
  • PERT (Project Evaluation and Review Technique) to highlight task dependencies
  • The schedule is needed to implement
  • Org Chart describes the different roles
• Issues model describes opened issues and their resolutions. Constraints posed by a client are included, and resolutions are sought

Model Implications

• A good software engineer codes sparingly - Reducing code is easier to modify down the line

Issues Management

• Example of Issue: Galileo vs The Church
• Centers on the Question of Universe's Center
  • Church: Claimed earth was the centre, citing Aristotle
  • Galileo: Argued for the sun based on Copernicus and observations of Jupiter's moons

Decomposition

• Defined as dividing and conquering complexity
• Functional Decomposition:
  • System decomposes into modules
  • Each module performs a procession step (function)
• Object Oriented Decomposition:
  • System decompses into classes (objects)
  • Each class provides an abstraction

Part of Hierarchy

• Type of hierarchy
• e.g., Computer > CPU + I/O Devices + Memory > etc

Is-Kind-Of Hierarchy

• e.g., Cell > Muscle Cell + Blood Cell + Nerve Cell > etc

Where Are We Now?

• Three main ways to deal with complexitiy are:
  • Abstraction
  • Decomposition
  • Hierarchy
• Object orientiation decomposition is important where appropriate
• Many ways to correctly implement issues
• Starting with functional description using the use case model and proceed to the object model
  • Leads to software lifecycle

Software Lifecycle

• Software lifecycle defines the activity relationships needed for system development
• Includes
  • Selecting relevant activities
  • Defining dependencies
  • Scheduling activities

Software Reusability

• Reuse desgin patterns and frameworks where possible
• It should solve specific problems in a way that is generalizable.
• It should not solve from first principles, but re-use working parts.
• Frameworks provide architectural guidance

Patterns

• Chess Master - can use common Openings, Middle, and End games
• Writer- use known character tropes. or writing guidelines
• Architest - adopt known structural and architestural patterns
• and Software Engineers adopt
  • Composite pattern where a collection of objects is treated as one
  • Adaptor pattern (wrapper) in existing systems
  • Bridge patterns in existing extensibles systems

Summary

• Software engineering is a problem solving activity for developing limited time scales
• There are many ways to deal with complexity like models
• Many ways to deal with change
  • Modify the software development to fit the project
  • adopt non-dependant relationships
  • Provide configuration management
• There is poor software production
  • Space Shuttle example cost billions of dollars
  • Shuttle first launch was cancelled due to sync failures

Software Examples

• Include year 1900 bug impacting Mary
• Leapyear bug
• Airport opening delayed due to buggy automated luggage system