Skip to content

1. Project Planning

Definitions 1

  • Software engineering: is the systematic development, operation, maintenance; and retirement of software
  • IS: information system
  • DFD: data flow diagram
  • CASE: computer-aided software engineering
  • Software: is the sequences of instructions in one or more programming languages that comprise a computer application to automate some business function
  • Engineering: is the use of tools and techniques in problem solving
  • Software engineers’ jobs have evolved to now include evaluation, selection, and use of specific systematic approaches to the development, operation, maintenance, and retirement of software:
    • Development: begins with the decision to develop a software product and ends when the product is delivered.
    • Operations: the daily processes that take place,
    • Maintenance: changes made to the system to fix errors, change business logic, or make software more efficient.
    • Retirement: the replacement of the current application with some other method of providing the work, usually a new application. or, the process of removing a software product from use.
  • ATM: automated teller machine
  • Application: is a set of programs that automates some business function
  • Data storage require two types of data definition: logical and physical
    • logical data model: describes how we logically think of data
      • Relational logical data model: columns and rows
      • Hierarchical logical data model : parent-child relationship (tree) = one-to-many
      • Network logical data model: many-to-many relationship
      • Object-oriented logical data model(OOLDMs): combines hierarchical and network logical data models
    • physical data model: describes how data is stored on disk or db.
  • process: is a sequence of instructions or conjunctions of events that operate on data.
  • constraints: are the limitations on the process, Constraint types are prerequisite, post-requisite, time, structure, control, or inferential.
    • Pre-requisite: a constraint that must be satisfied before the process can begin (if statements)
    • post-requisite: a constraint that must be satisfied before the process can end but after the process has done its work (if statements)
    • time: actual time (before 5pm), timeout constraint (eg. on DB connections), synchronous processing constraint (eg. process C cannot start until process B has finished), response time constraint (eg. process A must respond within 5 seconds)
    • Structure: aka. data types, not all values are allowed (eg. a file name must be a string, but the file size must be an integer)
    • Control: for maintenance, eg. the total of a transaction must be equal to the sum of the individual items.
    • Inferential: infer: means to conclude by reasoning, inferential constraints are limits on the reasoning ability of the program and its ability to generate new facts out of the old ones. eg. AI that builds knowledge on a topic, but this knowledge is not a free form, eg. AI must at least store 100 facts before it can make a conclusion.
  • Interfaces: There are three types of interfaces: human, manual, and computerized.
    • Human interfaces: facing the user, the most important, hardest to design, very subjective to change.
    • Manual interfaces: are reports or other human-readable media that show information from the computer.
    • Computerized interfaces: are the means by which the computer communicates with other computers. non standard, defined by the organization. some of them are standrized using protocols (eg. HTTP)
  • Application Responsiveness: Responsiveness of an application reflects the fundamental design approach as batch-oriented, on-line, or real-time.
    • Batch applications: Apps where transactions are processed in groups, data is stored upon receiving until the batch is complete, then a one process round that process all the data in the batch at one go.
    • On-line applications: Apps that provide interactive processing with or without immediate file updates. interactive processing means that there is 2 way interactions between the user and the App. on-line processing means that programs may be resident in memory and used sequentially by numerous transactions/events without reloading.
    • the difference between on-line and batch apps, is that batch Apps writes permanently to the disk, while online stores temporarily in memory (with the option to write to disk).
    • real-time Apps: processes transactions in actual time. results are available immediately.
  • Types of Applications: There are four types of business applications: transaction, data analysis, decision support, and expert applications.
    • Transaction applications: eg. e-commerce, inventory management…
    • Data analysis: Query data from DB, then analyze it (readonly usually). eg. accounting reports applications…
    • Decision support applications (DSS) seek to identify and solve problems
    • Expert applications: are used to solve complex problems that require expert knowledge. eg. AI, expert systems…
  • Embedded systems: applications that are parts of other systems, eg. an endpoint in an api, sensor in a big appliance, etc.
  • Project life cycle three types: sequential, iterative, and learn-as-you-go.

Sequential Project Life Cycle (SPLC) (Waterfall)

  • developed in 1960s by the US Department of Defense, according to specification DOD standard 2167A. see: https://en.wikipedia.org/wiki/DOD-STD-2167A
  • has phases in a sequence:
    1. initiation
    2. problem definition
    3. feasibility study
    4. requirements analysis
    5. conceptual design
    6. design
    7. code / unit testing
    8. testing
    9. installation and checkout
    10. operation and maintenance
    11. retirement
  • in government projects, the first 4 phases (initiation, problem definition, feasibility study, requirements analysis) are done by the government or a separate organization than the one that will develop the software.
  • it is hard to distinguish the start and end of each phase, and it is hard to go back to a previous phase.

Initiation phase

  • the need for the applications is defined
  • problem is defined to assemble a team and start looking for the problem evaluation.
  • stakeholders are identified.
  • outcome: memo or formal document requesting automation support, defining the problem, and identifying the participants.

Feasibility phase

  • feasibility is the analysis of risk, cost, and benefits of the project. problem is analyzed in a greater details.
  • economic feasibility: analysis the cost.
  • technical feasibility: analyze technical alternatives, is the technology available?
  • organizational feasibility: analyze the organization, is the organization ready for the change?
  • feasibility reports summarizes:
    • the problem
    • economic, technical, organizational feasibility
    • risks
    • preferred concept for the software and explanation of its superiority to alternative concepts.
    • training needs
    • estimates of project staffing
  • at the end of feasibility phase, the Software Development Life Cycle (SDLC) is starts, SDLC is sub-cycle of SPLC.
  • outcome: feasibility report.

Requirements analysis phase

  • this phase has different synonyms: functional analysis, requirements definition, and software requirements analysis.
  • analysis activities define:
    1. functional requirements: what the system must do.
    2. performance requirements: how fast the system must respond, etc.
    3. Interfaces requirements: how the system will interact with other systems (inside or outside the organization) .
    4. design requirements: data storage, hardware, testing constraints, conversion requirements, etc.
    5. development standards: development form, timing, documentation,softwares allowed, tools allowed, etc.
    6. the plan for application development is refined.
  • outcome: requirements specification document that summarizes:
    1. the requirements (the details of the proposed system).
    2. the current method of work.
    3. graphics, text, tables, diagrams, etc are used to explain the requirements.

Conceptual design phase

  • this phase is also called preliminary design, logical design, external design or software requirements specifications.
  • detailed functional requirements of all external elements of the system are defined.
  • external elements include: screens, reports, data entry messages, forms, contents, layout.
  • logical data model is transformed into database schema and user views.
  • decide if distribution (decentralization) of databases is needed.
  • sometimes, this phase is combined with the design phase and analysis phase (partially completed during the requirement analysis, then fully completed during the design phase).
  • we treat conceptual design and design as one phase.
  • outcome: detailed definition of the external elements of the system + normalized and optimized DB schema.

Design phase

  • maps what system is supposed to do to how it is supposed to do it.
  • this phase is also called : detailed design, physical design, internal design, or product design.
  • outcome: team create documents that verify:
    1. software architecture
    2. software components and modules
    3. interfaces between components
    4. testing
    5. data: implement the actual data structures, data storage, and data access.

SubSystem/Program Design

  • treated as a sub-phase of the design phase.
  • outcome: team create documents that verify:
    1. Application control structure: how each module/program is activated, what happens when it finishes, to whom it returns/reports, etc.
    2. data structures and physical implementation scheme: create central library that interacts with DB/DBMS.
    3. sizing: buffer sizes, memory sizes, etc.
    4. key algorithms.
    5. program components.

Coding/Unit Testing phase

  • low level program elements are created from the design documents and debugged.
  • unit tests for individual components are created and executed.

Testing phase

  • this phase usually corresponds to integration testing.
  • quality assurance is carried out: programs is evaluated by a non-member of the development team.

Installation and checkout phase

  • also called implementation phase.
  • the software product is integrated into a working environment (usually staging) and prepared to go to production.
  • training is provided to the users.
  • SDLC is completed.
  • the maintenance phase begins.

Operation and maintenance phase

  • the product is working on production, and it is being monitored for satisfactory performance and modified as needed.
  • three types of maintenance:
    1. Perfective maintenance: improves performance, change algorithms to work faster, add indexes DB for queries to be faster, etc.
    2. Corrective maintenance: fixes bugs, errors, etc.
    3. Adaptive maintenance: changes the system to adapt to new requirements.
  • each type of tge maintenance types requires mini-analysis, mini-design, mini-coding, mini-testing, mini-installation.
  • documentation must be updated with every change.

Retirement phase

  • the support for the system is terminated.
  • also called phase-out

Universal activities

  • two activities that are performed in every phase: verification and validation.
  • verification: established the correctness of correspondence between the requirements (specification) and the design (product) (does the program matches the requirements).
  • validation: establishes the fitness (quality) of the product for its intended use (does the program do what it is supposed to do?) .

Iterative Project Life Cycle

  • sometimes called prototyping.

Learn-as-You-Go Project Life Cycle

  • 75% of companies do no use any development life cycle.
  • also called trial-and-error, individual problem solving. the life cycle of no life cycle.
  • better suited for small projects or small teams.
  • better suited for unique problems that have no standard solution.

Methodologies

  • There are five classes of methodologies: process, data, object, semantic, or none.
  • Process Methodology:
    • takes structured, top-down approach to evaluate problems.
    • developed in 1970s as response to: increasing complexity of software, operating systems, and introduction of file system.
    • documentation produced by this methodology includes: context diagrams, data flow diagrams, data store definitions, structured English descriptions.
    • still used today. will fade in the future.
  • Data Methodology:
    • starts by evaluating the data first and the relationships between the data then determine the architecture.
    • data architecture is then mapped out to the requirements.
    • documentation produced by this methodology includes: Entity Relationship Diagrams (ERD), entity hierarchy diagrams, process dependency diagrams, process hierarchy diagrams, and third normal form database definition.
  • Object-Oriented Methodology:
    • takes top-down view of data objects, and communications between these objects to determine system architecture.
    • data and actions are encapsulated in objects.
    • developed in 1980s,
  • Semantic Methodology:
    • used in artificial intelligence (AI) and expert systems.
    • data and data definitions/rules defined together in the same application.
  • No Methodology:
    • rely on experience and intuition of the programmer.

References

  1. Conger, S. (2008). The New Software Engineering. The Global Text Project. ↩