Professional Documents
Culture Documents
SYSTEM
BY
LEONARD MBURU KIMOTHO
BIT-016-0007/2009
KAREN CAMPUS
AUGUST 2010
DECLARATION
This is my original work and has not been submitted in any other institution
of higher learning for academic or any other purpose.
.
LEONARD MBURU KIMOTHO
DATE:
The Project proposal is presented to the university for examination with the
approval of the
supervisor.
.
SAMUEL ADHOLA
JKUAT KAREN CAMPUS
NAIROBI
KENYA
DATE:
Abstract
The Water and Sanitation Services Management Billing System (WSSMBS) is
meant to provide affordable and efficient billing facilities for Water Services
Boards.
The need for this system has been brought about by the delinking of
secondary WSBs from primary WSBs, giving them the lee way to manage
their own operations.
WSSMBS is meant to enable WSBs to effectively manage their operations
and provide cheap billing services.
This can provide considerable savings for the WSBs compared to what they
used to pay to primary WSBs for printing of bills. Previously it used to cost
KShs 15.00 to print a single bill. This system will enable the preparation and
printing of bills at less than KShs 7.00 a bill thus providing a savings of KShs
8.00 per bill a saving of 54%.
Table of Contents
DECLARATION............................................................................................................. ii
Abstract..................................................................................................................... iii
Diagrams of Importance......................................................................................... vi
1
Problem Statement........................................................................................ 1
1.2
Objectives...................................................................................................... 1
1.3
1.4
1.5
Assumptions.................................................................................................. 2
1.6
Management.................................................................................................. 3
2.2
2.2.1
Overview................................................................................................. 3
2.2.2
History..................................................................................................... 5
2.2.3
2.2.4
Main Features........................................................................................ 13
2.3
2.3.1
2.3.2
Project Methodology.................................................................................... 24
3.1.1
Waterfall Model...................................................................................... 24
3.1.2
Spiral Model........................................................................................... 28
3.1.3
3.2
Research Methodology.................................................................................34
3.2.1
Requirement Specification.....................................................................34
3.2.2
Requirement Investigation.....................................................................34
3.2.3
3.2.4
Data Analysis......................................................................................... 37
3.2.5
4
4.1.2
4.1.3
Proposed System......................................................................................... 39
4.2.1
4.2.2
4.2.3
Architectural Design.................................................................................... 42
5.1.1
Definition............................................................................................... 42
5.1.2
5.2
Database Design.......................................................................................... 47
5.2.1
Normalization........................................................................................ 48
5.2.2
5.2.3
5.3
Current System............................................................................................ 38
4.1.1
4.2
Data Presentation..................................................................................37
Interface Design........................................................................................... 60
5.3.1
5.3.2
5.3.3
Implementation............................................................................................ 64
6.2
Coding.......................................................................................................... 64
6.3
6.4
System testing............................................................................................. 70
6.4.1
6.4.2
6.4.3
6.4.4
Test Data................................................................................................ 78
6.4.5
Testing Schedule....................................................................................79
6.5
Implementation Strategy............................................................................. 79
6.5.1
Phased Changeover............................................................................... 79
6.5.2
Pilot Changeover................................................................................... 80
6.5.3
Parallel Changeover...............................................................................80
6.5.4
Direct Changeover................................................................................. 80
6.5.5
Chosen Strategy.................................................................................... 81
6.5.6
6.5.7
Error Handling........................................................................................ 82
6.6
Conclusion................................................................................................... 84
References................................................................................................................ 87
Appendix.................................................................................................................. 90
Budget................................................................................................................... 90
GANTT chart.......................................................................................................... 90
Diagrams of Importance
Figure 1: Visual overview of the Common Language Infrastructure.........................17
Figure 2: The .NET Framework stack.........................................................................18
Figure 3: The Waterfall Model...................................................................................25
Figure 4: The Spiral Model........................................................................................ 28
Figure 5: Flowchart of the Current system................................................................39
Figure 6: Flowchart of the proposed system.............................................................41
Figure 7: WSMS Use Case Diagram...........................................................................44
Figure 8: WSMS Activity Diagram............................................................................. 45
Figure 9: WSMS Class Diagram................................................................................. 46
Figure 10: WSMS Sequence Diagram........................................................................47
Figure 11: WSMS Database Model............................................................................60
Figure 12: Login form for the Water Services Management System.........................65
Figure 13: The Water & Sanitation Services Billing System Main Window................65
Figure 14: The Customer Information Management Module window........................66
Figure 15: : Consumption Information Management Module....................................67
Figure 16: The Billing Management Module..............................................................67
Figure 17: Sample Bill generated by the Water and Sanitation Services system......68
Figure 18: Installation Services Management Module...............................................69
Water
and
Sanitation
Company
Limited
have
received
1.2 Objectives
To design and deliver a system that enables preparation and printing of bills
1.5 Assumptions
Some of the assumptions made in the study are:
That staff at the WSB have been exposed to computers and basic
operations.
That WSB already owns a number of computer systems.
2.2.1 Overview
object-oriented
programming
in
part
to
address
common
their own operators around with them' (or at least "inherit" them from a
similar object or class).
The Simula programming language was the first to introduce the concepts
underlying object-oriented programming (objects, classes, subclasses, virtual
methods, co routines, and discrete event simulation) as a superset of Algol.
Simula also used automatic garbage collection which had been invented
earlier for the functional programming language Lisp. Simula was used for
physical modeling, such as models to study and improve the movement of
ships and their content through cargo ports. Smalltalk was the first
programming language to be called "object-oriented".
2.2.2 History
The concept of objects and instances in computing had its first major
breakthrough with the PDP-1 system at MIT which was probably the earliest
example of 'capability based' architecture. Another early example was
Sketchpad created by Ivan Sutherland in 1963; however, this was an
application and not a programming paradigm. Objects as programming
entities were introduced in the 1960s in Simula 67, a programming language
designed for performing simulations, created by Ole-Johan Dahl and Kristen
Nygaard of the Norwegian Computing Center in Oslo. (They were working on
ship simulations, and were confounded by the combinatorial explosion of
how the different attributes from different ships could affect one another. The
idea occurred to them of grouping the different types of ships into different
classes of objects; each class of objects being responsible for defining its
own data and behavior.) Such an approach was a simple extrapolation of
concepts earlier used in analog programming. On analog computers,
mapping from real-world phenomena/objects, to analog phenomena/objects
(and conversely), was (and is) called 'simulation'. Simula not only introduced
the notion of classes, but also of instances of classes, which is probably the
first explicit use of those notions. The ideas of Simula 67 influenced many
later languages, especially Smalltalk and derivatives of Lisp and Pascal.
The Smalltalk language, which was developed at Xerox PARC (by Alan Kay
and others) in the 1970s, introduced the term object-oriented programming
to represent the pervasive use of objects and messages as the basis for
computation. Smalltalk creators were influenced by the ideas introduced in
Simula 67, but Smalltalk was designed to be a fully dynamic system in which
classes could be created and modified dynamically rather than statically as
in Simula 67. Smalltalk and with it OOP were introduced to a wider audience
by the August 1981 issue of Byte magazine.
In the 1970s, Kay's Smalltalk work had influenced the Lisp community to
incorporate object-based techniques which were introduced to developers
via the Lisp machine. Experimentation with various extensions to Lisp (like
LOOPS and Flavors introducing multiple inheritance and mixins), eventually
led to the Common Lisp Object System (CLOS, a part of the first standardized
object-oriented
programming
language,
ANSI
Common
Lisp),
which
these features to languages that were not initially designed for them often
led to problems with compatibility and maintainability of code.
More recently, a number of languages have emerged that are primarily
object-oriented yet compatible with procedural methodology, such as Python
and Ruby. Probably the most commercially important recent object-oriented
languages are Visual Basic .NET (VB.NET) and C#, both designed for
Microsoft's .NET platform, and Java, developed by Sun Microsystems. VB.NET
and C# both support cross-language inheritance, allowing classes defined in
one language to subclass classes defined in the other language.
Just as procedural programming led to refinements of techniques such as
structured programming, modern object-oriented software design methods
include refinements such as the use of design patterns, design by contract,
and modeling languages (such as UML).
The term OOPS, which refers to an object-oriented programming system, was
common in early development of object-oriented programming.
2.2.3 Fundamental Concepts and Features
2.2.3.1Class
familiar
with
the
problem
domain,
meaning
that
the
characteristics of the class should make sense in context. Also, the code for a
class should be relatively self-contained (generally using encapsulation).
Collectively, the properties and methods defined by a class are called
members.
2.2.3.2Object
A pattern (exemplar) of a class. The class of Dog defines all possible Dogs by
listing the characteristics and behaviors they can have; the object Lassie is
one particular Dog, with particular versions of the characteristics. A Dog has
fur; Lassie has brown-and-white fur.
2.2.3.3Instance
One can have an instance of a class or a particular object. The instance is the
actual object created at runtime. In programmer jargon, the Lassie object is
10
"The process by which an object sends data to another object or asks the
other object to invoke a method". Also known to some programming
languages as interfacing. For example, the object called Breeder may tell the
Lassie object to sit by passing a "sit" message which invokes Lassie's "sit"
method. The syntax varies between languages, for example: [Lassie sit] in
Objective-C. In Java, code-level message passing corresponds to "method
calling". Some dynamic languages use double-dispatch or multi-dispatch to
find and pass messages.
2.2.3.6Inheritance
example, the class Dog might have sub-classes called Collie, Chihuahua, and
GoldenRetriever. In this case, Lassie would be an instance of the Collie
subclass. Suppose the Dog class defines a method called bark() and a
property called furColor. Each of its sub-classes (Collie, Chihuahua, and
GoldenRetriever) will inherit these members, meaning that the programmer
only needs to write the code for them once.
Each subclass can alter its inherited traits. For example, the Collie class
might specify that the default furColor for a Collie is brown-and-white. The
Chihuahua subclass might specify that the bark() method produces a high
pitch by default. Subclasses can also add new members. The Chihuahua
subclass could add a method called tremble(). So an individual Chihuahua
instance would use a high-pitched bark() from the Chihuahua subclass, which
in turn inherited the usual bark() from Dog. The Chihuahua object would also
have the tremble() method, but Lassie would not, because she is a Collie, not
a Chihuahua. In fact, inheritance is an "a... is a" relationship between
classes, while instantiation is an "is a" relationship between an object and a
class: a Collie is a Dog ("a... is a"), but Lassie is a Collie ("is a"). Thus, the
object named Lassie has the methods from both classes Collie and Dog.
Multiple inheritance is inheritance from more than one ancestor class,
neither of these ancestors being an ancestor of the other. For example,
independent classes could define Dogs and Cats, and a Chimera object could
be created from these two which inherits all the (multiple) behavior of cats
12
and Dogs. This is not always supported, as it can be hard both to implement
and to use well.
2.2.3.7Abstraction
however,
does
not
need
to
know
exactly
how
she
barks.
of an object. The result is that each object exposes to any class a certain
interface those members accessible to that class. The reason for
encapsulation is to prevent clients of an interface from depending on those
parts of the implementation that are likely to change in the future, thereby
allowing those changes to be made more easily, that is, without changes to
clients. For example, an interface can ensure that puppies can only be added
to an object of the class Dog by code in that class. Members are often
specified as public, protected or private, determining whether they are
available to all classes, sub-classes or only the defining class. Some
languages go further: Java uses the default access modifier to restrict access
also to classes in the same package, C# and VB.NET reserve some members
to classes in the same assembly using keywords internal (C#) or Friend
(VB.NET), and Eiffel and C++ allow one to specify which classes may access
any member.
2.2.3.9(Subtype) polymorphism
both inherit speak() from Animal, but their derived class methods override
the methods
of the
parent
class;
this is
Overriding Polymorphism.
Decoupling
Decoupling allows for the separation of object interactions from classes and
inheritance into distinct layers of abstraction. A common use of decoupling is
to polymorphically decouple the encapsulation, which is the practice of using
reusable code to prevent discrete code modules from interacting with each
other. However, in practice decoupling often involves trade-offs with regard
15
to which patterns of change to favor. The science of measuring these tradeoffs in respect to actual change in an objective way is still in its infancy.
Not all of the above concepts are to be found in all object-oriented
programming languages, and so object-oriented programming that uses
classes
is
called
sometimes
class-based
programming.
In
particular,
languages
and
that,
in
concert,
support
the
OOP
programming style:
efficient.
Encapsulation: or multi-methods, in which case the state is kept separate.
Subtype polymorphism
Object Inheritance (or delegation)
16
17
The .NET Framework introduces a Common Type System, or CTS. The CTS
specification defines all possible datatypes and programming constructs
supported by the CLR and how they may or may not interact with each other.
Because of this feature, the .NET Framework supports the exchange of
instances of types between programs written in any of the .NET languages.
This is discussed in more detail in Microsoft .NET Languages.
2.3.1.4Base Class Library
The Base Class Library (BCL), part of the Framework Class Library (FCL), is a
library of functionality available to all languages using the .NET Framework.
The BCL provides classes which encapsulate a number of common functions,
including file reading and writing, graphic rendering, database interaction
and XML document manipulation.
2.3.1.5Simplified Deployment
The .NET framework includes design features and tools that help manage the
installation of computer software to ensure that it does not interfere with
previously installed software, and that it conforms to security requirements.
19
2.3.1.6Security
2.3.1.7Portability
the
framework
is
implemented.
Microsoft's
commercial
20
21
All CIL is self-describing through .NET metadata. The CLR checks the
metadata to ensure that the correct method is called. Metadata is usually
generated by language compilers but developers can create their own
metadata through custom attributes. Metadata contains information about
the assembly, and is also used to implement the reflective programming
capabilities of .NET Framework.
2.3.2.4Security
.NET has its own security mechanism with two general features: Code Access
Security (CAS), and validation and verification. Code Access Security is based
on evidence that is associated with a specific assembly. Typically the
evidence is the source of the assembly (whether it is installed on the local
machine or has been downloaded from the intranet or Internet). Code Access
Security uses evidence to determine the permissions granted to the code.
Other code can demand that calling code is granted a specified permission.
The demand causes the CLR to perform a call stack walk: every assembly of
each method in the call stack is checked for the required permission; if any
assembly is not granted the permission a security exception is thrown.
When an assembly is loaded the CLR performs various tests. Two such tests
are validation and verification. During validation the CLR checks that the
23
assembly contains valid metadata and CIL, and whether the internal tables
are correct. Verification is not so exact. The verification mechanism checks to
see if the code does anything that is 'unsafe'. The algorithm used is quite
conservative; hence occasionally code that is 'safe' does not pass. Unsafe
code will only be executed if the assembly has the 'skip verification'
permission, which generally means code that is installed on the local
machine.
.NET Framework uses appdomains as a mechanism for isolating code running
in a process. Appdomains can be created and code loaded into or unloaded
from them independent of other appdomains. This helps increase the fault
tolerance of the application, as faults or crashes in one appdomain do not
affect
rest
of
the
application.
Appdomains
can
also
be
configured
independently with different security privileges. This can help increase the
security of the application by isolating potentially unsafe code. The
developer, however, has to split the application into subdomains; it is not
done by the CLR.
2.3.2.5Class Library
The .NET Framework includes a set of standard class libraries. The class
library is organized in a hierarchy of namespaces. Most of the built in APIs
are part of either System.* or Microsoft.* namespaces. These class libraries
implement a large number of common functions, such as file reading and
writing, graphic rendering, database interaction, and XML document
24
manipulation, among others. The .NET class libraries are available to all .NET
languages. The .NET Framework class library is divided into two parts: the
Base Class Library and the Framework Class Library.
The Base Class Library (BCL) includes a small subset of the entire class
library and is the core set of classes that serve as the basic API of the
Common Language Runtime. The classes in mscorlib.dll and some of the
classes in System.dll and System.core.dll are considered to be a part of the
BCL. The BCL classes are available in both .NET Framework as well as its
alternative implementations including .NET Compact Framework, Microsoft
Silverlight and Mono.
The Framework Class Library (FCL) is a superset of the BCL classes and
refers to the entire class library that ships with .NET Framework. It includes
an expanded set of libraries, including WinForms, ADO.NET, ASP.NET,
Language Integrated Query, Windows Presentation Foundation, Windows
Communication Foundation among others. The FCL is much larger in scope
than standard libraries for languages like C++, and comparable in scope to
the standard libraries of Java.
2.3.2.6Memory Management
The .NET Framework CLR frees the developer from the burden of managing
memory (allocating and freeing up when done); instead it does the memory
management itself. To this end, the memory allocated to instantiations of
.NET types (objects) is done contiguously from the managed heap, a pool of
25
27
approval/signoff
by
the
user
and
information
technology
29
e) Operations
&
Maintenance:
This
phase
is
virtually
endless.
Generally, problems with the system (which were not found during the
development life cycle) show up after its practical use begins, so the
issues related to the system are solved after deployment of the
system. Not all the problems show up immediately but some show up
with time and measures have to be taken to solve; hence this process
is referred as Maintenance.
3.1.1.1Advantages of Waterfall Life Cycle Models
a)
b)
c)
d)
not all the problems (related to a phase) are solved during the same
phase.
c) The project is not partitioned in phases in flexible way.
d) As the requirements of the customer goes on getting added to the list,
not all the requirements are fulfilled, this results in development of
almost unusable system. These requirements are then met in newer
version of the system; this increases the cost of system development.
32
33
34
and
complicated
projects.
35
a) The spiral model is a realistic approach to the development of largescale software products because the software evolves as the process
progresses. In addition, the developer and the client better understand
and react to risks at each evolutionary level.
b) The model uses prototyping as a risk reduction mechanism and allows
for the development of prototypes at any stage of the evolutionary
development.
c) It maintains a systematic stepwise approach, like the classic life cycle
model, but incorporates it into an iterative framework that more reflect
the real world.
37
that
encourages
teamwork,
self-organization
and
Lean manufacturing.
Soft systems methodology.
38
That is, while there is value in the items on the right, we value the items
on the left more.
3.1.3.2Principles behind the Agile Manifesto:
harness
change
for
the
customer's
competitive
advantage.
Deliver working software frequently, from a couple of weeks to a
daily
enhances agility.
Simplicity--the art of maximizing the amount of work not done--is
essential.
The best architectures, requirements, and designs emerge from
self-organizing teams.
At regular intervals, the team reflects on how to become more
effective, then tunes and adjusts its behavior accordingly.
This is the preferred model to build the system. The decision is guided
by:
a) Agile methods, produce completely developed and tested
features (but a very small subset of the whole) every few weeks.
The emphasis is on obtaining the smallest workable piece of
functionality to deliver business value early and continually
improving it and/or adding further functionality throughout the
life of the project. If a project being delivered under Waterfall is
cancelled at any point up to the end, there is often nothing to
show for it beyond a huge resources bill. With Agile, being
cancelled at any point will still leave the customer with some
worthwhile code that has likely already been put into live
operation.
b) In contrast to waterfall methods, agile development methods
deliver frequent "releases" to production. These releases can
occur as often as several times per week or month. Waterfall
40
driven
improvements
in
the
relationship
between
The main goal of coming up with the requirement specification document for
this system is:
41
objectives.
Identify the scope of what is managed by the system.
Identify the tools to be used during requirements elicitation process.
Water Services Boards are faced with the daunting prospects of capturing,
storing, processing, organizing, disseminating and managing huge quantities
of mission-critical information such as customer information, consumption
details and payment information.
3.2.2 Requirement Investigation
Data for this study was collected by using the following techniques:
42
3.2.3.1Interviews
Job interview
Case interview
Informational Interview
Exit interview
analytical ability and problem-solving skills; they are looking not for a
"correct" answer but for an understanding of how the applicant thinks
and how the applicant approaches problems.
During case interviews, interviewers are generally looking for the
following skills:
The researcher will use simple random sample technique due to the fact
that Water Services Boards operate in various parts of the country and
only a few were selected for investigation. The researcher will only
investigate 4 of the Water Services Boards. In order to select the
appropriate sample size, this study will employ stratified sampling to
pick samples from the population. In order to stratify the study, the
population will be divided into subgroups or strata and each has to be
44
The available sample data will be organized into a tabular format that is
easy to import into a MySQL database schema with the help of a
spreadsheet application i.e. Microsoft Excel. No in-depth analysis of data
will be required as emphasis is only on sample representative data.
3.2.5 Data Presentation
Data will be organized and presented in tabular format i.e. in rows and
columns and stored in a database i.e. MySQL. This tabular format is the
formal
method
of
data
representation
in
Relational
Database
45
46
KShs 15.00 to print a single bill. This system will enable the preparation and
printing of bills at less than KShs 7.00 a bill thus providing a savings of KShs
8.00 per bill a saving of 54%.
4.2.1 Strengths of the Proposed System
48
49
Actors
Business Processes
(Logical) Components
Activities
Programming Language Statements
Database Schemas
Reusable Software Components.
and
across
different
implementation
technologies.
UML
has
system in terms of actors, their goals (represented as use cases), and any
dependencies between those use cases.
52
The main purpose of a use case diagram is to show what system functions
are performed for which actor. Roles of the actors in the system can be
depicted.
5.1.2.2Activity Diagram
53
5.1.2.3Class Diagram
5.1.2.4Sequence Diagram
54
database. A fully attributed data model contains detailed attributes for each
entity.
The preferred model for the database to be used with the system is Rational
Model which organizes the base structures used to store data as tables and
views linked together using relationships.
5.2.1 Normalization
First Normal Form states that at every row and column intersection in the
table there exists a single value, and never a list of values. For example, we
cannot have a field named Telephone in which you place more than one
telephone number. If you think of each intersection of rows and columns as a
cell, each cell can hold only one value.
CUSTOMERID
FIRSTNAME
SURNAME
TELEPHONE
123
John
Wafula
0712 587098
456
Sue
Njambi
0722 423856
56
0752 631934
789
William
Kioko
0735 752061
To represent the above in 1st Normal Form, we use two tables, as illustrated below:
CUSTOMERID
FIRSTNAME
SURNAME
123
John
Wafula
456
Sue
Njambi
789
William
Kioko
CUSTOMERID
TELEPHONE
123
0712 587098
456
0722 423856
456
0752 631934
789
0735 752061
Second Normal Form requires that a table first be in the 1 st Normal Form and
also that each non-key column be fully dependent on the entire primary key,
not on just part of the key. This rule applies when you have a primary key
that consists of more than one column. For example, suppose you have a
table containing the following columns, where Employee, Skill and Current
Work Location:
57
EMPLOYEE
SKILL
CURRENT
WORK
LOCATION
Juma
Typing
River Road
Juma
Shorthand
River Road
Juma
Binding
River Road
Kamau
Light Cleaning
City Centre
Wanjiru
Chemistry
City Centre
Wanjiru
Flying
City Centre
Odhiambo
Light Cleaning
City Centre
Neither {Employee} nor {Skill} is a candidate key for the table. This is
because a given Employee might need to appear more than once (he might
have multiple Skills), and a given Skill might need to appear more than once
(it might be possessed by multiple Employees). Only the composite key
{Employee, Skill} qualifies as a candidate key for the table.
The remaining attribute, Current Work Location, is dependent on only part of
the candidate key, namely Employee. Therefore the table is not in 2NF.
A 2NF alternative to this design would represent the same information in two
tables: an "Employees" table with candidate key {Employee}, and an
"Employees' Skills" table with candidate key {Employee, Skill}:
EMPLOYEE
CURRENT
WORK
LOCATION
Juma
River Road
58
Kamau
City Centre
Wanjiru
City Centre
Odhiambo
City Centre
Table 5: Employees' Table.
EMPLOYEE
SKILL
Juma
Typing
Juma
Shorthand
Juma
Binding
Kamau
Light Cleaning
Wanjiru
Chemistry
Wanjiru
Flying
Odhiambo
Light Cleaning
Table 6: Skills table
Third Normal Form requires that the table not only satisfy the 2 nd Normal
Form ie every non-key column be dependent on the entire primary key, but
also that non-key columns be independent of each other. Another way of
saying this is that each non-key column must be dependent on the primary
59
key and nothing but the primary key. For example, suppose you have a table
containing the following columns:
TOURNAMENT
Chomoka
YEAR
na 2008
WINNER
DATE OF BIRTH
Jack Odhiambo
21 July 1976
Pickup
1 Million A Day
2010
Simon Kimani
17 April 1984
Shinda na Roiko
2009
Salome Macharia
5 May 1986
Concours
2009
Paul Morton
16
September
1958
Table 7: Tournament Winners table that violates 3rd Normal Form.
Because each row in the table needs to tell us who won a particular
Tournament in a particular Year, the composite key {Tournament, Year} is a
minimal set of attributes guaranteed to uniquely identify a row. That is,
{Tournament, Year} is a candidate key for the table.
The breach of 3NF occurs because the non-prime attribute Winner Date of
Birth is transitively dependent on the candidate key {Tournament, Year} via
the non-prime attribute Winner. The fact that Winner Date of Birth is
functionally dependent on Winner makes the table vulnerable to logical
inconsistencies, as there is nothing to stop the same person from being
shown with different dates of birth on different records.
In order to express the same facts without violating 3NF, it is necessary to
split the table into two:
60
TOURNAMENT
Chomoka
YEAR
WINNER
na 2008
Jack Odhiambo
Pickup
1 Million A Day
2010
Simon Kimani
Shinda na Roiko
2009
Salome Macharia
Concours
2009
Paul Morton
WINNER
DATE OF BIRTH
Jack Odhiambo
21 July 1976
Simon Kimani
17 April 1984
Salome Macharia
5 May 1986
Paul Morton
16
September
1958
Table 9: Player's Dates of Birth table.
DATATYPE
REQUIRED
PRIMARY KEY
LONG
CHAR(20)
61
otherNames
CHAR(20)
gender
CHAR(10)
postalAddress
CHAR(100)
physicalAddress
CHAR(100)
ID_Passport
CHAR(10)
PIN_Num
CHAR(10)
homePhone
CHAR(10)
officePhone
CHAR(10)
mobile
CHAR(10)
fax
CHAR(10)
CHAR(20)
deposit
CURRENCY
zoneCode
INTEGER
plotNum
CHAR(20)
tariffID
INTEGER
dateApplied
DATE
waterUseID
INTEGER
dateGrantedServi
DATE
ce
amountCharged
CURRENCY
dateOfPayment
DATE
modeOfPayment
INTEGER
bankDepositSlipN
CHAR(10)
um
recieptNum
CHAR(10)
62
DATATYPE
REQUIRED
PRIMARY KEY
jobTicketNum
LONG
customerID
LONG
premises
CHAR(50)
longitude
CHAR(10)
long_min
CHAR(5)
meterSerialNum
CHAR(20)
initReading
LONG
dateInstalled
DATE
installedBy
CHAR(20)
jobStatusID
INT
5.2.2.3Consumption table
DATATYPE
REQUIRED
PRIMARY KEY
LONG
SHORT
SMALLINT
Y
63
currentReading
LONG
dateOfReading
DATE
previousReading
LONG
avgConsumption
INT
5.2.2.4Billing table
This is used to compile data on pending bills for later printing. This
information is included in the customers bill. Its design is illustrated below.
FIELD NAME
customerID
month
year
DATATYPE
REQUIRED
PRIMARY KEY
LONG
SHORT
SMALLINT
INT
unitsConsumed
otherCharges
CURRENCY
isBillPaid
BIT
5.2.2.5Balances table
DATATYPE
REQUIRED
PRIMARY KEY
LONG
SHORT
SMALLINT
Y
64
isBalanceFor
INT
5.2.2.6Inventory
This is used to manage data on the firms resources such as water meters. Its
design is illustrated below.
FIELD NAME
DATATYPE
REQUIRED
PRIMARY KEY
meterSerialNum
CHAR(20)
datePurchased
cost
descr
size
isAllocated
DATE
CURRENCY
TEXT
SINGLE
BIT
5.2.2.7Payments
DATATYPE
REQUIRED
PRIMARY KEY
paymentNum
LONG
customerID
LONG
SHORT
SMALLINT
isPaymentFor
INT
amountOwed
CURRENCY
amountPaid
CURRENCY
month
year
65
modeOfPayment
datePaid
bankDepositSlipN
INT
DATE
CHAR(10)
um
recieptNum
CHAR(10)
66
67
This is one that is not friendly or efficient for the user to use. It makes it
difficult to achieve goals or complete operations thus impeding usability of
the system.
5.3.2 Good Interface design
The goal of user interface design is to make the user's interaction as simple
and efficient as possible, in terms of accomplishing user goalswhat is often
called user-centered design. Good user interface design facilitates finishing
the task at hand without drawing unnecessary attention to itself. Graphic
design may be utilized to support its usability. The design process must
balance technical functionality and visual elements (e.g., mental model) to
create a system that is not only operational but also usable and adaptable to
changing user needs.
An example of a good interface design is:
5.3.2.1Graphical User Interfaces (GUI)
These accept input via devices such as computer keyboard and mouse and
provide articulated graphical output on the computer monitor.
5.3.2.2Web-based user interfaces or web user interfaces (WUI)
These accept input and provide output by generating web pages which are
transmitted via the Internet and viewed by the user using a web browser
program. Newer implementations utilize Java, AJAX, Adobe Flex, Microsoft
.NET, or similar technologies to provide real-time control in a separate
68
Administrative
web
interfaces
for
web-servers,
servers
and
The system will be implemented using Graphical User Interface (GUI). GUIs,
offer a consistent visual language to represent information stored in
computers. This will make it easier for people with little computer skills to
work with and use computer software. Further to this, the system will be
designed as a Multiple Document Interface (MDI).
Multiple Document Interface (MDI) are those whose windows reside under a
single parent window (usually except for modal windows), as opposed to all
windows being separate from each other (single document interface). Such
systems often allow child windows to embed other windows inside them as
well, creating complex nested hierarchies. This enables the user to focus on
the application tasks at hand.
5.3.3.1Advantages of proposed interface
With MDI (and also TDI), a single menu bar and/or toolbar is shared between
all child windows, reducing clutter and increasing efficient use of screen
space.
An application's child windows can be hidden/shown/minimized/maximized as
a whole.
Features such as "Tile" and "Cascade" can be implemented for the child
windows.
69
Possibly faster and more memory efficient, since the application is shared,
and only the document changes, the speed of switching between the internal
windows being usually faster than having the OS switch between external
windows.
If the windowing environment and OS lacks good window management, the
70
support
responsibilities
involves
changing
from
system
6.2 Coding
The system was developed and coded using the Microsoft Visual C++ .NET
2005 which implements a managed form of C++ language operating under
the Object Oriented Programming paradigm. Due to the immense size of the
system source code going upwards of 1000+ lines of code per module, it was
deemed necessary to include the source code on CD and a few code snippets
in the Appendix section.
71
The backend to the system is implemented using MySQL 5.0 database server
interfacing with the system through a MySQL .Net Connector.
Before the user can operate the system, he/she needs to login into the
system by inputting a valid username and password and clicking the Ok
button. To cancel the whole operation click Cancel. This username and
password provides access to the system and its configuration information.
This form controls access to the system features. To successfully login, a user
must
enter
valid
username
and
password.
The water and sanitation services billing system is a suite of modules that
enable water and sanitation companies to carry out their routine activities.
72
management.
This system therefore provides facilities that go far beyond merely billing
clients for service consumption.
6.3.1.3The Customer Information Management Module
73
74
This module enables the user to view the available bills and print them to an
available printer.
This module lists information on all payable bills ordering them by customer
number, month and year.
75
Figure 17: Sample Bill generated by the Water and Sanitation Services system
76
Installation of the Water & Sanitation service for a customer may require that
a meter be available. Meter management is carried out in the Meter
Inventory Management module where the module gives information on all
meters indicating which ones are available for allocation.
This module used to manage the firms meter inventory collection. It collects
meter information
77
based on the serial number and other relevant details including size and
condition.
6.3.1.8The Rate Payment Management Module
This module handles all payments for services in this system and displays
them on a list.
78
This describes the various stages undertaken to ensure that the system
performs as desired. The stages involved are:
6.4.1.1Agile or Extreme development model
79
manual build acceptance process). The ultimate goal of this test process is to
achieve continuous deployment where software updates can be published to
the public frequently.
6.4.2 Phases of System Testing
6.4.2.1Functional Testing
This refers to tests that verify a specific action or function of the code. These
are usually found in the code requirements documentation, although some
development methodologies work from use cases or user stories. Functional
tests tend to answer the question of "can the user do this" or "does this
particular feature work".
Functional tests were carried out on the system to verify that some critical
features
had
been
implemented
on
the
system.
For
instance,
the
management of customers required that the system have the ability to filter
customers based on specific customer information such as address or
gender. Together with this the customers management module should be
able to display all existing customers in a grid form. These features and
additional functionality were however implemented and integrated into the
system successfully.
6.4.2.2Non-Functional Testing
This refers to aspects of the software that may not be related to a specific
function or user action, such as scalability or security. Non-functional testing
80
tends to answer such questions as "how many people can log in at once", or
"how easy is it to hack this software".
Figure 21: The WSMS Login window ready to receive login information.
The non functional testing was specifically focused on the security features
of the system. Tests were carried out to ensure that unauthorized use of the
system is curtailed. The security features implemented in the system are
multi leveled. They implement security in several levels:
Only a valid existing and authenticated user can access the system
using a password.
All passwords are encrypted.
Authenticated users are also assigned privileges over database
objects, for instance, a date reader is only restricted to reading specific
81
6.4.2.3Integration Testing
This is where the test team has access to the source code of the system.
When a problem is discovered, the integration team tries to find the source
of the problem and identify the components that have to be debugged.
Integration testing is mostly concerned with finding defects in the system.
Integration testing for the system was carried out to determine how the
system would perform in the operational environment. Modules were tested
one at a time, and then as a grouping of related modules to identify any
bugs. As with most software projects, a few bugs were discovered, but were
gradually sorted out an example was the zones management of the
configuration module, which had some relevant zone definitions missing.
6.4.2.4Performance Testing
device. This process can involve quantitative tests done in a lab, such as
measuring the response time or the number of MIPS (millions of instructions
per second) at which a system functions. Qualitative attributes such as
reliability,
scalability
and
interoperability
may
also
be
evaluated.
83
Figure 24: The Customer Management module displaying 939 records generated using a
data generation tool.
6.4.2.5Regression Testing
This is any type of software testing that seeks to uncover software errors by
partially retesting a modified program. The intent of regression testing is to
assure that a bug fix has been successfully corrected based on the error that
was found, while providing a general assurance that no other errors were
introduced in the process of fixing the original problem. Regression is
commonly used to efficiently test bug fixes by systematically selecting the
appropriate minimum test suite needed to adequately cover the affected
software code/requirements change. Common methods of regression testing
84
include rerunning previously run tests and checking whether previously fixed
faults have re-emerged.
Some of the bugs identified in the system included a rejection of negative
balances ie a case in which a customer made an over payment for service. In
this situation, the system had been programmed to only accept positive
values. After careful study, it was finally agreed that indeed customers
overpay in some situations and the bug was fixed. The fix was confirmed by
carrying out a regression test.
6.4.2.6Release Testing
85
6.4.2.7Acceptance Testing
In engineering and its various sub disciplines, acceptance testing is blackbox testing performed on a system (e.g. software, lots of manufactured
mechanical parts, or batches of chemical products) prior to its delivery. It is
also known as functional testing, black-box testing, release acceptance, QA
testing, application testing, confidence testing, final testing, validation
testing, or factory acceptance testing.
In software development, acceptance testing by the system provider is often
distinguished from acceptance testing by the customer (the user or client)
prior to accepting transfer of ownership. In such environments, acceptance
testing performed by the customer is known as user acceptance testing
(UAT). This is also known as end-user testing, site (acceptance) testing, or
field (acceptance) testing.
The system was put through a testing process to determine its suitability. It
was found to exceed the clients expectations since it provided more
functionality which the user had overlooked in the requirements elicitation.
6.4.2.8Acceptance testing
86
The data used was composed of both real data obtained from the previous
system and simulated data that was generated using a data generator.
6.4.5 Testing Schedule
The table below shows activities that will occur during the testing stage of
the system development and their specific durations.
ACTIVITY
DURATION
TIME (HOURS)
1 WEEK
56
1 WEEK
56
INTEGRATION TESTS
1 WEEK
56
SYSTEM TESTING
1 WEEK
56
88
The parallel operation changeover method requires that both the old and the
new information systems operate fully for a specified period. Data is input to
both systems and output generated by the new system is compared with the
equivalent output from the old system. When users, management, and IT
group are satisfied that the new system operates correctly then the old
89
The direct cutover approach causes the changeover from the old system to
the new system to occur immediately when the new system becomes
operational. It is the least expensive but involves more risks than other
changeover methods.
6.5.5 Chosen Strategy
6.5.5.1Parallel Changeover
The parallel changeover method is used whereby the new system will be
operated side by side with the existing system for a brief period of time. The
staff will be entering data on both the new and old systems and comparing
the output from both systems to ensure that the sew system is operating as
intended. After a specified duration of time, the new system will be put into
full operation and the old one will cease to be used.
6.5.5.1.1 Justification
This approach possesses low failure risk since it is more likely to catch any
major bugs in the intended system thus preventing the organization from
suffering major problems. If serious problems are discovered, the new
system is simply deactivated and the problem is fixed. It also allows users
adequate time to learn the new system and identify areas that need
attention.
90
This involves the installation of both the hardware and software components
of the system and will be carried out by the developer.
6.5.6.2Training
The implementation of the training phase will involve introducing the users
to the system, its potential and functionality at a deep level.
6.5.6.3Execution
This will involve the actual operation of the new system in parallel with the
existing system.
6.5.6.4Review
In this phase, results will be compared between both the old and new
systems and conclusions drawn.
6.5.7 Error Handling
application,
and
communications
errors.
Specialized
programs, called error handlers, are available for some applications. The best
programs of this type forestall errors if possible, recover from them when
they occur without terminating the application, or (if all else fails) gracefully
terminate an affected application and save the error information to a log file.
Error handling in the system has been implemented in several levels.
91
6.5.7.1Validation of Data
This is the process of ensuring that a program operates on clean, correct and
useful data. It uses routines, often called "validation rules" or "check
routines", that check for correctness, meaningfulness, and security of data
that are input to the system. The rules are implemented through the
automated facilities of a data dictionary, or by the inclusion of explicit
application program validation logic.
Some examples of validation methods are:
6.5.7.1.1 Format or picture check
Checks that the data is in a specified format (template), e.g., dates have to
be in the format DD/MM/YYYY. Regular expressions should be considered for
this type of validation.
6.5.7.1.2 Data type checks
Checks the data type of the input and give an error message if the input data
does not match with the chosen data type, e.g., In an input box accepting
numeric data, if the letter 'O' was typed instead of the number zero, an error
message would appear.
6.5.7.1.3 Range check
Checks that the data lie within a specified range of values, e.g., the month of
a person's date of birth should lie between 1 and 12.
92
Unlike range checks, data is checked for one limit only, upper OR lower, e.g.,
data should not be greater than 2 (>2).
6.5.7.1.5 Presence check
Checks that important data are actually present and have not been missed
out, e.g., customers may be required to have their telephone numbers listed.
6.5.7.1.6 Consistency Checks
Checks fields to ensure data in these fields corresponds, e.g., If Title = "Mr.",
then Gender = "M".
6.5.7.1.7 File existence check
Checks that a file with a specified name exists. This check is essential for
programs that use file handling.
6.5.7.1.8
Logic check
Checks that an input does not yield a logical error, e.g., an input value should
not be 0 when there will be a number that divides it somewhere in a
program.
6.5.7.1.9
Uniqueness check
Checks that each value is unique. This can be applied to several fields (i.e.
Address, First Name, Last Name).
93
6.5.7.1.10
Referential Integrity
6.6 Conclusion
The success of the system has enabled the Water Services Board to
significantly cut down on billing charges. This has enabled them to dedicate
more funds to other aspects of their operations such as buying more meters,
improving customer service etc.
Development of this system has been a great motivation for me to venture
into the software development field. I would like to further improve this
94
Board branches.
Changing
requirements:
the
management
changed
the
of some modules.
Erratic power: led to loss of data and work done on the project.
Virus infections: There were several infestations on the project
development computer due to the use of infected flash disks.
95
References
1) Agile Alliance: http://www.agilealliance.com/
2) Agile Manifesto Principles:
http://www.agilemanifesto.org/principles.html
3) Agile Processes Workshop II Managing Multiple Concurrent Agile
Projects. Washington: OOPSLA 2002
4) Boehm, B.; R. Turner (2004). Balancing Agility and Discipline: A Guide
for the Perplexed. Boston, MA: Addison-Wesley. ISBN 0-321-18612-5.
5) Kay, Alan. "The Early History of Smalltalk".
http://gagne.homedns.org/~tgagne/contrib/EarlyHistoryST.html.
Retrieved 2007-09-13.
6) Armstrong, The Quarks of Object-Oriented Development. In
descending order of popularity, the "quarks" are: Inheritance, Object,
Class, Encapsulation, Method, Message Passing, Polymorphism,
Abstraction
7) B. Stroustrup, The C++ Programming Language, 3rd-ed., p. 158
8) Pierce, Benjamin (2002). Types and Programming Languages. MIT
Press. ISBN 0-262-16209-1. , section 18.1 "What is Object-Oriented
Programming?"
9) John C. Mitchell, Concepts in programming languages, Cambridge
University Press, 2003, ISBN 0521780985, p.278
10)
Michael Lee Scott, Programming language pragmatics, Edition 2,
Morgan Kaufmann, 2006, ISBN 0126339511, p. 470
11)
A Theory of Objects, Martin Abadi and Luca Cardelli
12)
Meyer, Second Edition, p. 230
13)
M.Trofimov, OOOP - The Third "O" Solution: Open OOP. First Class,
OMG, 1993, Vol. 3, issue 3, p.14.
14)
"Mode inheritance, cloning, hooks & OOP (Google Groups
Discussion)".
96
http://groups.google.com/group/comp.emacs.xemacs/browse_thread/t
hread/d0af257a2837640c/37f251537fafbb03?lnk=st&q=
%22Richard+Stallman%22+oop&rnum=5&hl=en#37f251537fafbb03 .
15)
Aydin, M.N., Harmsen, F., Slooten, K. v., & Stagwee, R. A. (2004).
An Agile Information Systems Development Method in use. Turk J Elec
Engin, 12(2), 127-138.
16)
Scott Guthrie. "Releasing the Source Code for the NET
Framework".
http://weblogs.asp.net/scottgu/archive/2007/10/03/releasing-thesource-code-for-the-net-framework-libraries.aspx. Retrieved 2008-0601 .
17)
Microsoft. "Microsoft .NET Framework 3.5 Administrator
Deployment Guide". http://msdn.microsoft.com/library/cc160717.aspx.
Retrieved 2008-06-26.
18)
S. Somasegar. "Visual Studio 2010 and .NET FX 4 Beta 1 ships!".
Archived from the original on 2009-05-27.
http://www.webcitation.org/5h5lV7362. Retrieved 2009-05-25.
19)
"ECMA 335 - Standard ECMA-335 Common Language
Infrastructure (CLI)". ECMA. 2006-06-01. http://www.ecmainternational.org/publications/standards/Ecma-335.htm. Retrieved
2008-06-01.
20)
ISO/IEC 23271:2006
21)
"Technical Report TR/84 Common Language Infrastructure (CLI) Information Derived from Partition IV XML File". ECMA. 2006-06-01.
http://www.ecma-international.org/publications/techreports/E-TR084.htm.
97
22)
http://www.ecma-international.org/publications/standards/Ecma334.htm.
23)
"Standard ECMA-372 C++/CLI Language Specification". ECMA.
2005-12-01. http://www.ecmainternational.org/publications/standards/Ecma-372.htm.
24)
"Base Class Library".
http://msdn.microsoft.com/netframework/aa569603.aspx. Retrieved
2008-06-01.
25)
"Garbage Collection: Automatic Memory Management in the
Microsoft .NET Framework".
26)
"Garbage CollectionPart 2: Automatic Memory Management in
the Microsoft .NET Framework". Archived from the original on 2007-0626. http://web.archive.org/web/20070626080134/,
http://msdn.microsoft.com/msdnmag/issues/1200/GCI2/default.aspx .
Retrieved 2008-06-01.
98
Appendix
Budget
The project will be self-sponsored and the budget formulated from the
actual expenditure expected during the development of the system.
UNIT
NUM OF
ITEM
COST
UNITS
Computer
(Laptop)
Printer
Printing Papers
Biro
Pens/Pencils
Flash disks
(1GB)
Meals
Transport
CD/DVDs
TOTAL
SUB TOTAL
(KSHS)
75,000.00
75,000.00
1
10
7,500.00
350.00
7,500.00
3,500.00
12
20.00
240.00
1,250.00
3,750.00
6000
20
5,000.00
5,000.00
6,000.00
600.00
101,590.00
30.00
GANTT chart
The project schedule for development is summarized in the Gantt chart
below:
TIME IN WEEKS
ACTIVITIES
1
0
1
1
1
2
1
3
1
4
Proposal
Feasibility Study
System analysis
System design
Testing &
Implementation
Documentation
99
Report writing
Presentation
100