Implementation
CSC303
Implementation
Implementation phase is the stage where he
theoretical design is translated into a working
system
This is the most critical stage of the development
life cycle in order to achieve a successful new
system
In this phase programmers will execute the time-
consuming and costly task of writing programs,
while the systems analyst sets out different test
plan to verify the performance of the system as
expected.
Implementation
Coding
The coding phase (program writing) is the single
largest component of the systems development
project with respect to time and cost
often times systems analyst are not usually the
actual programmer but they pay attention and
manage the programming process
As programmers transform the specifications
into working program code, the systems analysts
carry out the testing function to ascertain
efficiency and effectiveness
Coding
The project manager assigns program modules to
the different programmers.
Each programming module should be distinct and
separate as possible.
Related programming modules are group together
and assigned to programmers based on their
experience and skill level
The experienced, skilled programmers will be
assigned the most complex modules, while novice
programmers will be given less complex ones
Cordinating Coding Activities
Regular meetings, even if they are brief, to
encourage the widespread communication and
discussion of issues before they become problems.
Change control technique is kept to track what
programs are being changed by whom, through
the use of a program log.
Standards can be created and followed ranging
from formal rules for naming files to forms that
must be completed when goals are reached to
programming guidelines.
Coding Activities
There are several sub activities involved during
coding activity
Network building and testing
Database building and testing
Install and test new software
Write and test new programs
During this phase, the class objects and their
interrelationship is translated and actually coded
using the programming language decided upon.
The databases are made and the complete system
is given a functional shape.
Coding Activities
Coding Activities
Coding Activities
An
i mp
em
ent
a tion
in P
yth
on
Convert pseudocode to codes
An impementation in Python
Converting ERD to tables
The analysts will also want to ensure that the
DFDs and ERDs balance properly
This phase converts the Entity Relational diagram
into tables in a database management system
(DBMS)
Step 1: Converting strong entities
Create a separate table for each strong entity
identified.
Composite attribute must be separated into simple
attributes.
At this point, ignore multivalued characteristics.
Converting ERD to tables
Step 2: Converting weak entity
Create a separate table with same name for each weak
entity.
The table must Include all attributes in your list.
The weak entity contains the Primary key of a strong entity
as a foreign key.
Declare the weak entity’s P key as a combination of foreign
key as well as decimator attribute.
Step 3: Converting one-to-one relationship
Modify either the A or B side of each one-to-one connection,
say A and B, to add the P key of the opposite side as a
foreign key.
If A or B has 100% participation, then the table should be
Converting ERD to tables
Step 4: Converting one-to-many relationship
Modify the N side of each one-to-many relation to include
the P key of one of the sides as a foreign key.
If the relationships have attributes, make sure to mention
them as well.
Step 5: Converting many-to-many relationship
Create a new table for each many-to-many relationship,
using the P key from the M side and the N side as foreign
keys.
Declare Primary key for the new table’s foreign key
combination.
If your relationships have properties, insert those in the new
table as well.
Converting ERD to tables
Step 6: Converting multivalued attributes
Create a separate table for each multivalued attribute
and use the current table’s P key as a foreign key.
P keys are created by combining a foreign key and a
multivalued attribute.
Step 7: Converting n-ary relationship
Create a separate table for each n-ary relationship and
then include the P key of all the entities as a foreign key.
Declare the P key as a combination of foreign keys.
Example
CUI
Converting ERD to tables
Customer{CUI, Name} Order{CNR, Date}
Customer Order
CUI Name CNR CNR Date
Article{ANR, Name, Price} OPOS{CNR,ANR, Quality}
Article Opos
ANR Name Price ANR CNR Quality
Program Testing
Program Test
Testing is the process of checking the functionality and
correctness of the software based on the user requirements
in order to improve the quality and reliability of the system.
Testing is an expensive, time consuming, and critical aspect
of the system development life cycle which require proper
planning of the overall testing process.
A successful test is one that finds the errors.
It executes the program with explicit intention of finding error.
The intention is to create a strong system and mainly focuses on
the weak areas of the software.
Program Test
1. Unit Testing
The system analyst tests each program module independently
The intention is to execute each statement of the module at least
once.
It identifies maximum errors in a program as compared to other
testing techniques.
2. Integration Testing
The analyst tests multiple module working together.
It is used to find discrepancies between the system and its original
requirements, and systems documentation.
It investigate areas where modules have been designed with different
specifications for data length, type, and data element name.
It verifies file sizes adequacy and ensure that indices have been built
properly
Program Test
3. Functional Testing: It verifies if the system is
functioning appropriately based on its
requirements specification and relevant
standards documentation.
Functional testing typically starts with the
implementation of the system, which is very
critical for the success of the system.
Functional testing is divided into two categories
−
Positive Functional Testing is done to test the system
with valid inputs to verify that the outputs produced
are correct.
Test Strategies
1. Test Plan
System analysis will draw out a test plan to test the entire system
It must provide a plan for testing the system and verifies that the
system satiafies all the design and functional requirements.
The test plan must provides the following information
The objectives of testing
Approaches and tools for testing
Responsibilities and time required for each testing phase
Availability of tools, facilities, and test libraries
Procedures and standards required for carrying out the test
Factors responsible for successful completion of testing process
Test Strategies
2. Test Case Design
The number of test cases must be defined for each
module of the system to be tested.
Every test case will specify how the implementation of a
particular requirement or design decision is to be tested
and the criteria for the success of the test.
The test cases are documented alongside with the test
plan as a part of a system specification document
Test Strategies
3. Test Procedures
It involves the defining of the steps that should be
taken to execute each of the test cases.
These procedures must be specified in separate
document called test procedure specification
document.
The document will also highlight any special
requirements and formats for reporting the result of
testing.
4. Test Result Documentation
This will contain information about the total number of
test cases executed, the number of errors, and nature
of errors.
Rules for Testing
Rules for System Testing
Testing should be done based on the requirements
Analyst must understand the business logic before
drafting testing plan
Test plan must be done on time
Testing should be carried out by third party
Testing should be done for valid and invalid input
conditions.
Testing should be reviewed and examined to reduce the
costs.
Testing should be reviewed and evaluated to reduce the
costs.
Both static and dynamic testing should be conducted on
the software.
