software engineering - psruelearning.psru.ac.th/courses/66/document/c2_software...debugging tools...
TRANSCRIPT
Software EngineeringSoftware Engineering
Software ProcessesSoftware Processes
November 27, 2008 2
ObjectivesObjectives
�� ����������� �� ��������������������������������� �� ����������������������
�� ������������������������ !��������"���# ���$���# �!����������������������������� !��������"���# ���$���# �!�����
�� ����������%�&���������� ������ � �����������%�&���������� ������ � � requirements, requirements, ������'������������'����������,, ���" ���)���������*��� "+&,-����" ���)���������*��� "+&,-�
�� ����������.!�")&������������.!�")&�� Rational Unified ProcessRational Unified Process
�� �����������/.�.)�+�����������/.�.)�+ CASE Tools CASE Tools �+��# ��������������������+��# �������������������
Software Development Challenges
Why Software Development Team Need to Improve?
Cancelled Prior To Completion
Were Delivered over budget
Were NOT Considered Successful
Source : The STANDISH GROUP 2003
30%54% 66%
3
SE Process Models
WaterfallIterative
IncrementalRAD
Prototyping
Spiral
Concurrent
ComponentBase
Development
FormalMethods
UnifiedProcess
Aspect Oriented
AgileProcess
ExtremeProgramming
AdaptiveSoftware
Development
Crystal
Scrum
DynamicSystem
Development
FeatureDriven
Development
4
Software Development Process in Reality
REQUIREMENTS ANALYSIS
SYSTEMDESIGN
PROGRAMDESIGN
PROGRAMIMPLEMENTATION
UNITTESTING
INTEGRATIONTESTING
SYSTEMTESTING
DELIVERY
MAINTENANCE
5 November 27, 2008 6
Topics coveredTopics covered
�� Software process modelsSoftware process models
�� Process iterationProcess iteration
�� Process activitiesProcess activities
�� The Rational Unified ProcessThe Rational Unified Process
�� ComputerComputer--aided software engineeringaided software engineering
November 27, 2008 7
The software processThe software process
�� ��0�#*"&��������!�+����0� ��������'������������0�#*"&��������!�+����0� ��������'������������ Specification; Specification; �����*��)���+�"�����*��)���+�"�� Design & Development;Design & Development; ���������)���'����������)���'��� Validation;Validation; ��������/�!� ����&��1� �# ��������/�!� ����&��1� �# �� Evolution; Evolution; ��������*��� "+&,-���������*��� "+&,-�
�� .!�")&�������������������/���� �*��+���0�������&��.!�")&�������������������/���� �*��+���0�������&������������������ �,���� ����)���+�"&������������!*!!���,���� ����)���+�"&������������!*!!����,��."��2����,��."��2��..
November 27, 2008 8
Generic software process modelsGeneric software process models
�� The waterfall modelThe waterfall model�� �����0������+���4�#�"���������$������0������+���4�#�"���������$� �����*��)���+�"�)�����'������*��)���+�"�)�����'�
�� Evolutionary developmentEvolutionary development ��&����$!������*���!$��&����$!������*���!$�� �����*��)���+�"�����*��)���+�" ����'�����'� ���������������� ��/���+����,������)������/���+����,������)����
�� ComponentComponent--based software engineeringbased software engineering�� ��#�-� $���+�!+���$!���������&,-���0�������#�-� $���+�!+���$!���������&,-���0�����
�� !+.!�")�)�#��"�+��# ������$�#$�!+.!�")�)�#��"�+��# ������$�#$� formal development formal development �+�!+�+�!+��������/) ���������/) � waterfall waterfall ��$�����*��)���+�"��0������$�����*��)���+�"��0���� formal formal �,���)��������)�"�*����������������0�����+� !�5����# �" �,���)��������)�"�*����������������0�����+� !�5����# �"
November 27, 2008 9
Waterfall model (Classic life cycle)Waterfall model (Classic life cycle)
November 27, 2008 10
Waterfall model phasesWaterfall model phases
�� �����/����/�!� �����)��� /���"/�!�����/����/�!� �����)��� /���"/�!
�� �������������������� �)��)� ������������������
�� �&+��.�����!�&+��.�����! �)��)� �" ���" ��
�� �" �������" ������ �)��)� �" ����!�" ����!
�� ���# �����# �� �)��)� ��*����6��*����6
�� & ����"&��.!�")& ����"&��.!�") waterfall waterfall /��/�!�*$����+�����)+�����)�/��/�!�*$����+�����)+�����)��)��������!���������) ��)��������!���������) �.. � ���� ��� phase phase ��,���� � �4��$������!��,���� � �4��$������!�+��+� phase phase ��,����,��
November 27, 2008 11
Waterfall model advantageWaterfall model advantage
�� !�5/��/*!./�����" �$��)��!$� ��!+����)+�����)�!� !�5/��/*!./�����" �$��)��!$� ��!+����)+�����)�!�
�� !+�������0�)"��!+�������0�)"��
�� �$��$����������"���$��$����������"�� !+!+ milestone milestone �+�#�"����+�#�"��� ��$�!$�������������$�!$�����������&��1� �# ���������&��1� �# ���������
November 27, 2008 12
Waterfall model problemsWaterfall model problems
�� �!$��"��*$��� !+����)+�����)�/�!� ����&��1� �# �����!$��"��*$��� !+����)+�����)�/�!� ����&��1� �# ���� ��������$)���������$)�&�-�����!$ !�5��$��$���" ������+�� ������/�!� ����&��1� �# &�-�����!$ !�5��$��$���" ������+�� ������/�!� ����&��1� �#
�� "����-����������+-�,���!� �������+����/�!� ������$#�"�)�"����-����������+-�,���!� �������+����/�!� ������$#�"�)�!+!+����)+�����)�� ������)+�����)�� ��
�� /�!� ����&��1� �# !+����)+�����)����$� !�/�!� ����&��1� �# !+����)+�����)����$� !�
�� .!�").!�") waterfall waterfall $����7$���# ���./������7$8 $����7$���# ���./������7$8 �+�!+9��������'��+�!+9��������'������)���$������)���$�
November 27, 2008 13
How to Waterfall model successHow to Waterfall model success
�� �!$��)+����!$��)+��� RequirementRequirement
�� System Analyst System Analyst ������5��� ���!/�!� ����&��������5��� ���!/�!� ����&�� user user
100%100%
�� �!$!+����)+�����)���������!���!/�!� �����!$!+����)+�����)���������!���!/�!� ����
November 27, 2008 14
Evolutionary developmentEvolutionary development
�� Exploratory development Exploratory development
�� ���5*��� �/�/��������$�!���)��/ �) ��$�!��� � ��������/ .���5*��� �/�/��������$�!���)��/ �) ��$�!��� � ��������/ ./��/���+����� ��$�"�!�+����� ��$�"�! /������!��-���$!+/�!�& ����/������!��-���$!+/�!�& ���� requirement requirement ��$�"+�)���$�"+�)�����!/*:)��6:���!$�!�+�)��/ � ������ �����!/*:)��6:���!$�!�+�)��/ � ������ �
�� ThrowThrow--away prototypingaway prototyping
�� ���5*��� �/�/���/�!�& �����5*��� �/�/���/�!�& �� system requirement. system requirement. ."�����!��."�����!���& ��� ������������& ��/�!� ������$!#�"�& ��� ������������& ��/�!� ������$!#�"..
November 27, 2008 15
Evolutionary developmentEvolutionary development
November 27, 2008 16
Evolutionary developmentEvolutionary development
�� ProblemsProblems �;7��;7��� &"/�!��$!#�"&����������&"/�!��$!#�"&����������
�� ����./�� � �&�������!$"+������./�� � �&�������!$"+��
�� � ����/�!#�7���96� ����/�!#�7���96 �#$��#$� %6�+��# �����%6�+��# ����� rapid rapid
prototypingprototyping
�� Applicability Applicability ��!� ������!� ������ ����&�"�)4�����&�"�)4� �����)������)� �+�!+��.� ����+�!+��.� ���
�� ��0� $����,��&��������7$��0� $����,��&��������7$ �#$��#$� user interface user interface
�� �����+�!+��*���# �� �-������+�!+��*���# �� �-�
November 27, 2008 17
ComponentComponent--based software engineeringbased software engineering
�� !+��-�<�����������"�!!�# ��!$��$�!+����!+��-�<�����������"�!!�# ��!$��$�!+����.. COTS COTS ––
commercial off the shelf.commercial off the shelf.
�� Process stagesProcess stages�� �����/����#�-� $���$�8�����/����#�-� $���$�8�� ��������)+�����������)+��� requirementsrequirements
�� ������������������������ " �����&���"�!!�# ��!$" �����&���"�!!�# ��!$�� ����'��)��������!����'��)��������!
�� ���+���+-�)����0��+����!!�&,-��������#�-� $��!��<�!�# ���+���+-�)����0��+����!!�&,-��������#�-� $��!��<�!�# ��!$��!$
November 27, 2008 18
ReuseReuse--oriented developmentoriented development
A general process model for component-based software engineering
19
CBD Benefits
� Software Reusability
� Robustness of the component library
� Reduce Process Risk
� Effective use of specialist that encapsulate their knowledge in
software
� Standard Compliance
� Accelerate Development
� QSM Association, Inc. reports
� Lead to a 70 percent reduction in development cycle time.
� An 84 percent reduction in project cost.
� Productivity index of 26.2 (compared to industry norm of 16.9)
21
Development systems
Production systems
DE
VE
LO
PE
RS
US
ER
S
Build Release 1
Use Release 1
Build Release 2
Use Release 2
Build Release 3
Use Release 3
Time
The phased development model
22
INCREMENTAL DEVELOPMENT
ITERATIVE DEVELOPMENT
The incremental and iterative
models.
23 November 27, 2008 24
Process iterationProcess iteration
�� �����*/�!� ����&��������-�!+���$/�$���./����� !������*/�!� ����&��������-�!+���$/�$���./����� !� "����-�"����-����������+������/�����)������ �&���������������0����������+������/�����)������ �&���������������0��������� ����������7$� !��������� ����������7$� !�..
�� ���������-��# �" ���.!�")������������8�����������-��# �" ���.!�")������������8��
�� !+ �����+�+���+���& �����/��!+ �����+�+���+���& �����/��
�� Incremental delivery;Incremental delivery;
�� Spiral development.Spiral development.
November 27, 2008 25
Incremental deliveryIncremental delivery
�� ����+��� $�!��������-��!"��/��-��"+������+��� $�!��������-��!"��/��-��"+�� ����'��)� $�!��5����$�����'��)� $�!��5����$������0�&�-���������0�&�-���� ��$)������!+�� $�!������!���!�!�+����"�� ��$)������!+�� $�!������!���!�!�+����"�� )$���� )$����
�� ��")"��/�! /�7&��/�!� ����&��)��/ ��")"��/�! /�7&��/�!� ����&��)��/ /�!� �����+�!+)"��/�!� �����+�!+)"�� /�7 ����5�� $�!���$�� /�7 ����5�� $�!���$��
�� �!�������!��'�����!�������!��'���� incremental incremental /�����"/�!� �������-��� �/�����"/�!� �������-��� ��� ��$����� ��$��� �)����"�� ����!���!�" �+��)����"�� ����!���!�" �+�
The Incremental Model
C o m m u n i c a t i o n
P l a n n i n g
M o d e l i n g
C o n s t r u c t i o n
D e p l o y m e n t
d e l i v e r y
f e e d b a c k
analysis
design code
t est
increment # 1
increment # 2
delivery of
1st increment
delivery of
2nd increment
delivery of
nt h increment
increment # n
project calendar time
C o m m u n i c a t i o n
P l a n n i n g
M o d e l i n g
C o n s t r u c t i o n
D e p l o y m e n t
d e l i v e r y
f e e d b a c k
analysis
design code
t est
C o m m u n i c a t i o n
P l a n n i n g
M o d e l i n g
C o n s t r u c t i o n
D e p l o y m e n t
d e l i v e r y
f e e d b a c k
analysis
designcode
t est
November 27, 2008 27
Incremental developmentIncremental development
November 27, 2008 28
Incremental development advantagesIncremental development advantages
�� )��/ ���" ������.�#������ $�!��������$)�)��/ ���" ������.�#������ $�!��������$)� increment increment
��4�&,-���4�&,-�
�� Increments Increments �+� $�!���$����#$�� � �/�!� ��������!���!�+� $�!���$����#$�� � �/�!� ��������!���!�� ����� ��� increment increment �)���)��
�� )"/�!� +����+�./������) !)"/�!� +����+�./������) !
�� �����&�������+�!+)"��/�! /�7 �����" ������" ��!��+� *"�����&�������+�!+)"��/�! /�7 �����" ������" ��!��+� *"
November 27, 2008 29
Extreme programmingExtreme programming
�� ���+�+-!+<����$�������'��)� $�!�����+�+-!+<����$�������'��)� $�!�� increment increment �+�!+�+�!+ function function �)4�!��)4�!� � ����$� ����$ 20,00020,000 �����".�����!�����".�����! (line(line--
ofof--code)code)
�� &,-����$�����������*���$��$�������&,-����$�����������*���$��$�������,, 1� �# � ��!+ $���$�!����+!��'�1� �# � ��!+ $���$�!����+!��'��)����&+��.�����!������/�$�)����&+��.�����!������/�$
Extreme Programming (XP)
� The most widely used agile process, originally proposed
by Kent Beck
� XP Planning
� Begins with the creation of “user stories”
� Agile team assesses each story and assigns a cost
� Stories are grouped to for a deliverable increment
� A commitment is made on delivery date
� After the first increment “project velocity” is used to
help define subsequent delivery dates for other
increments
30
Extreme Programming (XP)
� XP Design
� Follows the KIS (Keep It Simple) principle
� Encourage the use of CRC cards (see Chapter 8)
� For difficult design problems, suggests the creation of “spike
solutions”—a design prototype
� Encourages “refactoring”—an iterative refinement of the internal
program design
� XP Coding
� Recommends the construction of a unit test for a store before
coding commences
� Encourages “pair programming”
� XP Testing
� All unit tests are executed daily
� “Acceptance tests” are defined by the customer and executed to
assess customer visible functionality 31 November 27, 2008 32
RefactoringRefactoring
�� ��������������)+�����)���������������)+�����)� software system software system ."��!$�."��!$��� �� function function �������� behavior behavior ��)+�������)+����� �)���� ./�� � ��)���� ./�� � �%���"+&,-�%���"+&,-�
�� ���� �����)$�+-���� �����)$�+- software software � ��������*�� ��������*��� Redundancy Redundancy /�!�-� ��&��& �!�)/�!�-� ��&��& �!�),, .�����!.�����!�� ��������$��+��!$5��� ����������$��+��!$5��� �� �� ������� ������� ��������$��+��!$!+/�! /�7�����!$!+���.�#����������$��+��!$!+/�! /�7�����!$!+���.�#�� �� ������� ������� 5 !+���5 !+��� Design pattern Design pattern �+�"+�+�"+ �4/���# �$����4/���# �$����� �������� Design Design �!$5��� ��/������!$5��� ��/����� Design Design ��!$�+�"+&,-���!$�+�"+&,-�
Extreme Programming (XP)
unit t est
cont inuous integrat ion
acceptance test ing
pair
programming
Release
user stories
values
acceptance test crit eria
it erat ion plan
simple design
CRC cards
spike solut ions
protot ypes
refactoring
software increment
project velocity computed
33 November 27, 2008 34
Spiral developmentSpiral development
�� ������&������������0����������&������������0���� ��)+������)+���� (iteration)(iteration) ����+�������+�����0����!)"���$����0����!)"���$�� �)���)��
�� ��$)��������)+�����!�5,���,��������$)��������)+�����!�5,���,������ phase phase &����������&����������
�� �!$���"���������$)��!$���"���������$)� phase, phase, �������)+����&,-����$���/�!�������)+����&,-����$���/�!� ����� ����
�� !+������!��/�!� +����)��� �;7��)�"��������!+������!��/�!� +����)��� �;7��)�"��������
November 27, 2008 35
Spiral model of the software processSpiral model of the software process
PLAN DEVELOP AND TEST
DETERMINE GOALS,
ALTERNATIVES,
CONSTRAINTS
EVALUATE ALTERNATIVES
AND RISKS
start
Requirements,life-cycle plan
Budget1
Alternatives1
Constraints1Risk analysis
1
Risk analysis2
Risk analysis3
Risk analysis4
Constraints2
Constraints3
Constraints4
Budget2Budget3Budget4
Altern
atives 2Alte
rnativ
es 3Altern
atives 4
Prototype1
Prototype
2Prototype
3
Prototype
4
Concept ofoperation
Softw
are
requ
irem
ents
Validated
requirements
Developmentplan
Integration
and test plan
Sof
twar
ede
sign
Validated,
verified design
Detaileddesign
Code
Unit test
SystemtestAcceptance
testImplementation
plan
The spiral model.
36
November 27, 2008 37
Spiral model sectorsSpiral model sectors
�� Objective settingObjective setting�� ���*���5*��� �/��� ������*���5*��� �/��� ��� phase phase &��./����&��./����
�� Risk assessment and reductionRisk assessment and reduction�� ����!��/�!� +�������!��/�!� +��� �)����+�!��)"/�!� +����)����+�!��)"/�!� +���
�� Development and validationDevelopment and validation�� �)���.!�")�+�����'��� �����)�������������)���.!�")�+�����'��� �����)������������
�� PlanningPlanning�� ������1���&��./����������1���&��./���� �)����1��� �)����1��� phase phase 5�"��5�"��
November 27, 2008 38
Process activitiesProcess activities
�� Software specificationSoftware specification
�� Software design and implementationSoftware design and implementation
�� Software validationSoftware validation
�� Software evolutionSoftware evolution
November 27, 2008 39
Software specificationSoftware specification
�� ��0����������+����"/�!� ������ ������0����������+����"/�!� ������ ����
�� Requirements engineering process:Requirements engineering process:
�� Feasibility study. Feasibility study. 9,�6/�!��0����" 9,�6/�!��0����"
�� / ���)����/����/ ���)����/���� ����+�� ���� ����+�� ����..
�� ���"��)���+�"�� ���/�!� �������"��)���+�"�� ���/�!� ����
�� ������/�!� ����������/�!� ����
November 27, 2008 40
The requirements engineering processThe requirements engineering process
November 27, 2008 41
Software design and implementationSoftware design and implementation
�� ��0�����������)���)���+�"&�������� ��0������+�����# ��0�����������)���)���+�"&�������� ��0������+�����# ���" ���"
�� Software designSoftware design
�� ������./�� � �&������������� �!����������)���+�"������./�� � �&������������� �!����������)���+�" ( (spec.)spec.)
�� ImplementationImplementation
�� ��)�./�� � ������ ��0�.�����!�+�����" ��)�./�� � ������ ��0�.�����!�+�����"
�� ������!���������)�������*�����-� �!����������$���) #�"�)�������!���������)�������*�����-� �!����������$���) #�"�)����� ��������� �����
November 27, 2008 42
Design process activitiesDesign process activities
�� Architectural designArchitectural design
�� Abstract specificationAbstract specification
�� Interface designInterface design
�� Component designComponent design
�� Data structure designData structure design
�� Algorithm designAlgorithm design
November 27, 2008 43
The software design processThe software design process
November 27, 2008 44
Structured methodsStructured methods
�� ��0����+����$���0�������0����+����$���0����� ������������������������������������������ ��� $����7$�����0����.!�")������ $����7$�����0����.!�")����� .!�")�+��# �" .!�")�+��# �"
�� Object model; Object model; � "�� "� object classesobject classes
�� Sequence model; Sequence model; � "���.� �������$�� "���.� �������$� objectobject
�� State transition model; State transition model; � "� 5��%�� "� 5��%� �)�����)+�����)��)�����)+�����)��� Structural model;Structural model; � "��*���:��$�8&������� "��*���:��$�8&�������� DataData--flow model: flow model: � "��� �7��&��& �!�)� "��� �7��&��& �!�)
November 27, 2008 45
Programming and debuggingProgramming and debugging
�� ��0�����)������ ��0�.�����!�)��� �&& �1�"�)"��0�����)������ ��0�.�����!�)��� �&& �1�"�)"
�� ���&+��.�����!��0�������! $��������&+��.�����!��0�������! $����� -- �!$!+�����������*���+�!$!+�����������*���+�&+��.�����!�&+��.�����!
�� Programmers Programmers ������" ��.�����!�)��� �&������" ��.�����!�)��� �&& �1�"�)"" ����������& �1�"�)"" ���������� Debugging Debugging
November 27, 2008 46
The debugging processThe debugging process
November 27, 2008 47
Software validationSoftware validation
�� ���� Verification Verification �)��)� Validation Validation ������ "��� ��4��$������ "��� ��4��$�����" �&,-�!�!�+����"�)��" �!/�!� ����&��)��/ �����" �&,-�!�!�+����"�)��" �!/�!� ����&��)��/
�� /��/�� �������#4/�)���������������)��" �������������#4/�)���������������)��" �������� ���" ���������" ������ /��/�� �� ����� �������" ��& ��" ���+��� ����� �������" ��& ��" ���+�
��"���+�!!����"���+�!!�� SpecSpec �)�& �!�)�����)�& �!�)����
November 27, 2008 48
The testing processThe testing process
November 27, 2008 49
Testing stagesTesting stages�� Component or unit testingComponent or unit testing
�� Individual components are tested Individual components are tested independently; independently;
�� Components may be functions or objects or Components may be functions or objects or coherent groupings of these entities.coherent groupings of these entities.
�� System testingSystem testing
�� Testing of the system as a whole. Testing of Testing of the system as a whole. Testing of emergent properties is particularly important.emergent properties is particularly important.
�� Acceptance testingAcceptance testing
�� Testing with customer data to check that the Testing with customer data to check that the system meets the customersystem meets the customer’’s needs.s needs.
November 27, 2008 50
Testing phasesTesting phases
November 27, 2008 51
Software evolutionSoftware evolution
�� ���������."�������!+/�!/)$������)���)+�����)��" ���������."�������!+/�!/)$������)���)+�����)��"
�� ���$/�!� ������)+��������������*������)+������$/�!� ������)+��������������*������)+��� ����������+�����������+� ��� �*��*������-��4� ���" �����������*���)+�����)��!��" �� ��� �*��*������-��4� ���" �����������*���)+�����)��!��" ��
�� �!����$����!+����$��������$��!����$����!+����$��������$� development development �)��)� evolutionevolution �$�!/�!����$������ ��)��$�!/�!����$������ ��)� ��������!+������!$8��������!+������!$8 ���"&,-�� ��!����"&,-�� ��!�
November 27, 2008 52
System evolutionSystem evolution
November 27, 2008 53
The Rational Unified ProcessThe Rational Unified Process
�� ��0�.!�")���������*$���!$��0�.!�")���������*$���!$ �+��" !��1)��������+��" !��1)������� UML UML
�)����������+���+���& ���)����������+���+���& ��
�� ."������) �������" ��."������) �������" �� 33 !*!!��!*!!���� Dynamic Dynamic -- � "�/�!� ��� &�����$���)� "�/�!� ��� &�����$���)
�� Static Static -- � "�������!&����������� "�������!&����������
�� Practical Practical -- �� /����������A����������+�"+�� /����������A����������+�"+
Iterative Development – Reduce Risk and Achieve better productivity
54
November 27, 2008 55
RUP phasesRUP phases
�� InceptionInception
�� ��B�!�&�����+�5����"��)����"�������*������ ������B�!�&�����+�5����"��)����"�������*������ ����
�� ElaborationElaboration
�� �/�!�& ���/�!�& �� Domain Domain &���;7�&���;7� ,, ���"���������"������ ,, ���1������1��� �)�����!���)�����!��/�!� +���/�!� +���,, !+���# !+���# UML UML �)��/�!� �����)��/�!� ����
�� ConstructionConstruction
�� ������������ ,, �&+��.�����!�&+��.�����! �)��" ���)� $����,��&������!+���")���������)��" ���)� $����,��&������!+���")�������� !���:� !���:� !+��� ����# ��!+��� ����# ��
�� TransitionTransition
�� ��������+��" � �� �4� $��� ��$��������+��" � �� �4� $��� ��$ user user ������������ %���") �!���������������� %���") �!����
November 27, 2008 56
RUP phase modelRUP phase model
UP Phases
Inception Elaboration Construction Transition Production
UP Phases
Workflows
Requirements
Analysis
Design
Implementation
Test
Iterations #1 #2 #n-1 #n
Support
November 27, 2008 58
RUP good practiceRUP good practice
�� ���"����'�����$)�����!/�! /�7&�������"����'�����$)�����!/�! /�7&����
�� �����/�!� ����&��)��/ �����/�!� ����&��)��/
�� �# ����������)��6:��# ����������)��6:� Component BasedComponent Based
�� �# .!�")�# .!�") UML UML � "�������&������� "�������&������
�� ������"��)�� ���������!+/*:%�������"��)�� ���������!+/*:%�
�� /��/*!����)+�����)�&�����������/��/*!����)+�����)�&�����������
November 27, 2008 59
Static workflowsStatic workflowsWorkflow Description
Business modelling The business processes are modelled using business use cases.
Requirements Actors who interact with the system are identified and use cases are
developed to model the system requirements.
Analysis and design A design model is created and documented using architectural
models, component models, object models and sequence models.
Implementation The components in the system are implemented and structured into
implementation sub-systems. Automatic code generation from design
models helps accelerate this process.
Test Testing is an iterative process that is carried out in conjunction with
implementation. System testing follows the completion of the
implementation.
Deployment A product release is created, distributed to users and installed in their
workplace.
Configuration and
change management
This supporting workflow managed changes to the system (see
Chapter 29).
Project management This supporting workflow manages the system development (see
Chapter 5).
Environment This workflow is concerned with making appropriate software tools
available to the software development team.
November 27, 2008 60
ComputerComputer--aided software engineeringaided software engineering
�� CASECASE ��0�����������+�#$������'������������0�����������+�#$������'���������� �)����������)���������������*��� �&������*��� �&
�� ������!�+�� ���."����.�!���������!�+�� ���."����.�!����� ���&+��������� � �.!�")�� �������&+��������� � �.!�")�� ����
�� �# �# Data dictionaryData dictionary #$����������#$����������
�� #$�� � �#$�� � � Graphical User Interface (GUI)Graphical User Interface (GUI)
�� DebuggersDebuggers #$��/ ��& �1�"�)"��.�����!#$��/ ��& �1�"�)"��.�����!
�� #$����)�.�����!�� ��0��*$���!$#$����)�.�����!�� ��0��*$���!$ �#$��#$� ��)���)� CobolCobol �� ��0��*$���!$�� ��0��*$���!$
November 27, 2008 61
Case technologyCase technology
�� ��/.�.)�+��/.�.)�+ CASECASE �" ������*�����������'������������ "+�" ������*�����������'������������ "+&,-�!�&,-�!� ��$����4�!�4����!$"+��$�+�/"�� ��$����4�!�4����!$"+��$�+�/"�� �� ����9����!�����������-�� ����/�!/�" � � ��/�����9����!�����������-�� ����/�!/�" � � ��/� �,���!$�#$��0����,���!$�#$��0���
."����.�!���."����.�!���
�� ����9����!���������� �������0��+! ��������9����!���������� �������0��+! ���� projectproject ��7$��7$ ����� ������� ���# ��)���������"�$�����$��+!���# ��)���������"�$�����$��+!�� ,, ��/.�.)�+��/.�.)�+ CASECASE ����!$����!$�������������������0��+!�������������������0��+!
November 27, 2008 62
CASE classificationCASE classification
�� ����"#�-�#$���� ���� �������"#�-�#$���� ���� ��� CASE tools CASE tools �)�������!�$�8�+��)�������!�$�8�+� CASECASE
��� �*� ��� �*�
�� Functional perspectiveFunctional perspective
�� ToolsTools 5����"#�-��!�� �+�����5����"#�-��!�� �+�����
�� Process perspectiveProcess perspective
�� ToolsTools 5����"#�-��!������!����������5����"#�-��!������!����������
�� Integration perspectiveIntegration perspective
�� Tools Tools 5����"#�-��!����$�����/����+�5����"#�-��!����$�����/����+� ToolsTools ��-��� �� ��� �*����$��-��� �� ��� �*����$
November 27, 2008 63
Functional tool classificationFunctional tool classification
Tool type Examples
Planning tools PERT tools, estimation tools, spreadsheets
Editing tools Text editors, diagram editors, word processors
Change management tools Requirements traceability tools, change control systems
Configuration management tools Version management systems, system building tools
Prototyping tools Very high-level languages, user interface generators
Method-support tools Design editors, data dictionaries, code generators
Language-processing tools Compilers, interpreters
Program analysis tools Cross reference generators, static analysers, dynamic analysers
Testing tools Test data generators, file comparators
Debugging tools Interactive debugging systems
Documentation tools Page layout programs, image editors
Re-engineering tools Cross-reference systems, program re-structuring systems
November 27, 2008 64
ActivityActivity--based tool classificationbased tool classification
November 27, 2008 65
CASE integrationCASE integration
�� ToolsTools�� ��� �*���������������� ��� �*���������������� �#$��#$� ������������ ,, �#4//�!�$��������#4//�!�$������� ,,
�&+��.�����!�&+��.�����!
�� WorkbenchesWorkbenches�� ��� �*� ��� �*� PhasesPhases �������������������� ��������!��������! ToolsTools �$�8�$�8 " ��" ��
�� EnvironmentsEnvironments�� ��� �*� $���+� /�7&���������� ��� �*� $���+� /�7&���������� ��������!��������! WorkbenchesWorkbenches
�)�#��"�� �)�#��"��
November 27, 2008 66
Tools, workbenches, environmentsTools, workbenches, environments
November 27, 2008 67
Key pointsKey points
�� ���������������������������������� /��/�� ������!�+���+���& ������� � ��)�������*�������!�+���+���& ������� � ��)�������*�������������������
�� .!�")&����������.!�")&���������� /��/�� �� �*��$�&������������ �*��$�&������������ ������!."�������������!."������� /��/�� ���"��)���+�"���"��)���+�",, �������)����.�����!�������)����.�����!,,
���" ���)�������*����" ���)�������*��� .!�")��������������.!�")�������������� �����./�� � �����������������������./�� � ������������������
�����$��#$������$��#$� Waterfall , Evolution , ComponentWaterfall , Evolution , Component--basedbased
(CBSE)(CBSE)
�� .!�")���������+������.!�")���������+������ (iterative)(iterative) �����5,��������������5,�������������������$��0����!*���+��&��������!����������$��0����!*���+��&��������!
November 27, 2008 68
Key pointsKey points
�� ������ RequirementRequirement /��/�� ����������'���� �����������'���� � ���*��)���+�"���*��)���+�"&�����������&�����������
�� ���������)�������*���/������)����������)�������*���/������)� SpecificationSpecification �� ��0��� ��0�.�����!�+�����" .�����!�+�����"
�� ��������/�!� ������������/�!� ���� /��/�� �������#4/�$�������������" �!�+�)��/ �������#4/�$�������������" �!�+�)��/ � ����� ����
�� EvolutionEvolution /��/�� ���� �&������*��)���������# ���) ����� �&������*��)���������# ���) ��� Rational Unified ProcessRational Unified Process /��������������8��/��������������8�� �+�����+����
Activities Activities ���������� PhasesPhases
�� ��/.�.)�+��/.�.)�+ CASE CASE ��� �*�������!�$�8 ��� �*�������!�$�8 ��������������������������������������