Professional Documents
Culture Documents
Presented By
Software is a product
Delivers computing potential Produces, manages, acquires, modifies, displays, or transmits information Supports or directly provides system functionality Controls other programs (e.g., an operating system) Effects communications (e.g., networking software) Helps build other software (e.g., software tools)
What is Software?
Software is a set of items or objects that form a configuration that includes programs documents data ...
What is Software?
Software Applications
system software application software engineering/scientific software embedded software product-line software Web Apps (Web applications) AI software
SoftwareNew Categories
Ubiquitous computingwireless networks Net sourcingthe Web as a computing engine Open sourcefree source code open to the computing community (a blessing, but also a potential curse!) Also (see Chapter 32)
Legacy Software
Why must it change?
software must be adapted to meet the needs of new computing environments or technology. software must be enhanced to implement new business requirements. software must be extended to make it interoperable with other more modern systems or databases. software must be re-architected to make it viable within a network environment.
Software Myths
Management Myths
We have books of standards, my staff will have sufficient info. I work very hard to put the latest, greatest, fastest, state-of-the-art hardware in front of all my programmers. We have the greatest CASE tools around. If we get behind, we can just add more programmers. A general statement of objectives is sufficient to start coding, fill in the details later. Project requirements change constantly, but change is easy because software is flexible. Once the program is written and working, our job is done. Until the program is running, there is no way to assess quality. The only deliverable for a successful project is the working program.
Customer myths
Programmer myths
Consists of a collection of concepts, principles, methods, and tools that a software engineer calls upon on a daily basis Equips managers to manage software projects and software engineers to build computer programs Provides necessary technical and management how tos in getting the job done Transforms a haphazard unfocused approach into something that is more organized, more effective, and more likely to achieve success
2)
4)
Is it possible to test each component of the solution? Does the solution produce results that conform to the data, function, and behavior that are required?
The software should provide value to its users and satisfy the requirements All design and implementation should be as simple as possible
2) 3) 4)
5)
Never design yourself into a corner; build software that can be easily changed and adapted
Reuse of software reduces the long-term cost and increases the value of the program and the reusable components Placing clear, complete thought before action will almost always produce better results
6)
7)
Communication Practices
(Requirements Elicitation)
Communication Project initiation Requirements gathering Planning Estimating Scheduling Tracking
Modelling Analysis Design Construction Code Test Deployment Delivery Support Feedback
15
Communication Principles
1) 2) 3) 4) 5) 6) 7) 8) 9)
10)
Listen to the speaker and concentrate on what is being said Prepare before you meet by researching and understanding the problem Someone should facility the meeting and have an agenda Face-to-face communication is best, but also have a document or presentation to focus the discussion Take notes and document decisions Strive for collaboration and consensus Stay focused on a topic; modularize your discussion If something is unclear, draw a picture Move on to the next topic a) after you agree to something, b) if you cannot agree to something, or c) if a feature or function is unclear and cannot be clarified at the moment Negotiation is not a contest or a game; it works best when both parties win
Planning Principles
1) 2)
3)
4) 5) 6) 7) 8) 9) 10)
Understand the scope of the project Involve the customer in the planning activity Recognize that planning is iterative; things will change Estimate based only on what you know Consider risk as you define the plan Be realistic on how much can be done each day by each person and how well Adjust granularity as you define the plan Define how you intend to ensure quality Describe how you intend to accommodate change Track the plan frequently and make adjustments as required
Why is the system being developed? What will be done? When will it be accomplished? Who is responsible for each function? Where are they organizationally located? How will the job be done technically and managerially? How much of each resource is needed?
The answers to these questions lead to a definition of key project characteristics and the resultant project plan.
5)
The information domain of a problem (the data that flows in and out of a system) must be represented and understood The functions that the software performs must be defined The behavior of the software (as a consequence of external events) must be represented The models that depict information, function, and behavior must be partitioned in a manner that uncovers detail in a layered (or hierarchical) fashion The analysis task should move from essential information toward implementation detail
2)
3) 4) 5) 6) 7) 8) 9)
The design should be traceable to the analysis model Always consider the software architecture of the system to be built Design of data is as important as design of processing functions Interfaces (both internal and external) must be designed with care User interface design should be tuned to the needs of the end-user and should stress ease of use Component-level design should be functionally independent (high cohesion) Components should be loosely coupled to one another and to the external environment Design representations (models) should be easily understandable The design should be developed iteratively; with each iteration, the designer should strive for greater simplicity
Construction Practices
Communication Project initiation Requirements gathering
Coding Principles
(Preparation before coding)
1) 2) 3) 4) 5)
Understand the problem you are trying to solve Understand basic design principles and concepts Pick a programming language that meets the needs of the software to be built and the environment in which it will operate Select a programming environment that provides tools that will make your work easier Create a set of unit tests that will be applied once the component you code is completed
Coding Principles
(As you begin coding)
1) 2) 3) 4) 5) 6) 7) 8)
Constrain your algorithms by following structured programming practices Select data structures that will meet the needs of the design Understand the software architecture and create interfaces that are consistent with it Keep conditional logic as simple as possible Create nested loops in a way that makes them easily testable Select meaningful variable names and follow other local coding standards Write code that is self-documenting Create a visual layout (e.g., indentation and blank lines) that aids code understanding
Coding Principles
1) 2) 3)
Conduct a code walkthrough Perform unit tests (black-box and white-box) and correct errors you have uncovered Refactor the code
Testing Principles
1) 2) 3)
All tests should be traceable to the software requirements Tests should be planned long before testing begins The Pareto principle applies to software testing
80% of the uncovered errors are in 20% of the code
4)
Testing should begin in the small and progress toward testing in the large
Unit testing --> integration testing --> validation testing --> system testing
5)
Test Objectives
1) 2) 3)
Testing is a process of executing a program with the intent of finding an error A good test case is one that has a high probability of finding an asyet undiscovered error A successful test is one that uncovers an as-yet undiscovered error
Deployment Practices
Communication Project initiation Requirements gathering Planning Estimating Scheduling Tracking Modelling Analysis Design Construction Code Deployment Test Delivery Support Feedback
Deployment Principles
1)
2) 3) 4)
5)
A complete delivery package should be assembled and tested A support regime must be established before the software is delivered Appropriate instructional materials must be provided to end users Buggy software should be fixed first, delivered later
Software Process
Process Models
Waterfall model
Requirements are reasonably understood. When work flow is linear in fashion Systematic sequential approach
Incremental model
Evolution of waterfall model New features added to 1st Increment(core product) Incremental software development model may be applicable to projects where:
Software Requirements are well defined, but realization may be delayed. The basic software functionality are required early
Inc 1
Inc 2
Inc 3
RAD Model
Rapid Application Development Short development cycle Faster development (60-90) days High quality results Use of (CASE) Tools Component based construction System delivered in short time (2 to 3 months) Useful where requirements are well understood and scope is limited
C o n s t r u c t io n
Team # 2
Mo d eling
b u si n e ss m o d e l i n g dat a m odeling p ro ce ss m o d e l i n g
Planning
Co nst r uct io n
De ploym e nt
int egrat ion deliv ery feedback
co m p o n e n t re u se a u t o m a t i c co d e g e n e ra t i o n t e st i n g
6 0 - 9 0 days
40
Process Models
Rapid application development model Incremental model Prototyping model Spiral model Component-Based Development Formal Method model
Prototyping
Early approximation of a final system Linear and iterative Customer is unable to define the system Requirements are not freezed a prototype is built to understand the requirements
plan
communication
Mo d e lin g Modeling Qu ick d e sig n
Quick design
feedback
43
Spiral Model
Simplified form
Waterfall model plus risk analysis Alternatives Risk analysis Evaluation Planning of next phase
communication modeling
analysis design start
deployment
delivery feedback
construction
code test
45
COTS
Commercial off-the-shelf software components developed by vendors who offer them as products.
Decomposition of the engineered systems into functional or logical components with well-defined interfaces used for communication across the components.
Mathematically based techniques for representing and analysis of software. Formal methods include
Formal specification Specification analysis and proof Transformational development Program verification
Reduces requirements errors as it forces a detailed analysis of the requirements Incompleteness and inconsistencies can be discovered and resolved Currently very time consuming and expensive Extensive training required Difficult to use this model to communicate with the customer.
Unified Process
inception
co nst r uct io n
Release
soft ware increment
t r ansit io n
p r o d uct io n
52
UP (contd)
Inception
Identify resources, assess risks, defines schedule In the form of use cases. A tentative outline of major sub-systems, functions and features that populate them.
Rough architecture
UP (contd)
Elaboration
Customer communication Modeling activity Expands the use cases. Expands the architecture to:
Use case model, analysis model, design model, implementation model and deployment model. Evaluate scope, risks, project delivery dates
UP (contd)
Construction
Develop software components (that make the use cases operational). Complete the analysis and design models. Implement all functions and features for that increment. Conduct unit testing for the components Integrate components.
UP (contd)
Transition
Create user manuals, guidelines, installation procedures. Software is given to users for beta testing. Get user feedback The increment is now a useable software release.
UP Work Products
Incept ion phase
Vision document Init ial use-case model Init ial project glossary Init ial business case Init ial risk assessment . Project plan, phases and it erat ions. Business model, if necessary . One or more prot ot y pes
I nc e pt i o n
57
Is a group of software development methodologies based on iterative and incremental development, where requirements and solutions evolve through collaboration between self-organizing, cross-functional teams. Self Organization: is the process where a structure or pattern appears in a system without central authority. Cross-Functional team : is a group of people with different functional expertise working toward a common goal.
Extreme Programming
Is a software development methodology which is intended to improve software quality and responsiveness to changing customer requirements. It releases product in short development cycles (time boxing) Pair Programming: Driver and Observer Time Boxing Code Review Unit Testing