Journal of Computer Technology & Applications

Volume 2, Issue 1, March, 2011, Pages 32-40.

_____________________________________________________________________________________________

SOFTWARE-FAULT TOLERANCE WITH OOP APPROACH BY .NET

Jigna B. Prajapati*, Savan K.Patel, Dr.S.M,Parikh

Acharya Motibhai Patel Institute of Computer Studies, Ganpat University, Kherva, Mehsana,
Gujrat, India.

Abstract
Present study was focus on Object Oriented Paradigm using Visual Basic.net which can
be reusable and robust structures that support the prediction of fault tolerance of
software errors in the application layer. Once any software developed, their first goal is
to create error free and objective met software. Although developers often have several
problems after completion of their task, here we will give fault-tolerance techniques
with vb.net. We are trying to show Fault tolerance can be implemented with Visual
Basic.net. Implementation supports the approach of user defined library and re-designs.

KeyWords — Visual basic.net, object-oriented programming, software-fault tolerance,

Recovery Block (RcB), N-Version Programming (NVP).

*Author for correspondence Email: jigna.prajapti@ganpatuniversity.ac.in Tel: 9925043272

Introduction

To manage software system complexity, to
convert any real time problem, we use
object-oriented programming. To enhance
reliability into any Software system we need
some of the new creation introducing by
Software fault-tolerance (1). Approaches
and mechanisms are therefore required to
allow the system working with software
faults remaining in the system after its
development. There are many ways to do
which have been proven successful (2).
Here, we introduce our experience using
Visual basic.net for the implementation of
reusable, robust structure that can effectively
support the prediction of software fault
tolerance at the application level in object-
oriented software (3). We focus on reliable
systems that can reduce the encumbrance of
individual programmers, and therefore less
likely to produce software failures.
© STM Journals 2011. All Rights Reserved.
As we develop our routine any code with
Object Oriented Paradigm (OOP) with
object Library based on meta object
protocols, we implement a set of monitoring
mechanisms for software fault tolerance in
Visual basic.net. Meta-level interface hides
most implementation details of the fault-
tolerant mechanism at the application level
and allows the programmer to flexibly
change the use of various schemes of fault
tolerance without modifying the code of
application programs.
In Addition, the document includes our
reproduced model and implementation
framework for software error tolerance and
addresses the separation of concerns
regarding the development of fault-tolerant
programs. Visual basic.net is used to define
and implement object libraries that support
32
Journal of Computer Technology & Applications
Volume 2, Issue 1, March, 2011, Pages 32-40.
_____________________________________________________________________________________________
software fault tolerance. Very firstly we
would like to focus on the software fault
tolerance framework, later OOP and fault
tolerance is discussed. Here we are
developing the code for dealing with faults
when the application is running. Finally, our
experiments focus on different sets of code
and their results.
An Approached Framework of Software-
Fault Tolerance
Fault tolerance can be made available, by
redundancy, functionality according to the
requirement, and when the flaws that
occurred or are occurring. Laprie argues that
resilience is achieved by redundancy (5). It
may be fine for the bugs that are not caused
by design flaws; though, repeatedly of the
design fault in more than a few places will
not help in the implementation of the
specification. It is also important to
emphasis on the specification as the final
arbiter that no software faults tolerance in
the context of this work is a concern with all
methods required by the system to tolerate
software design faults. To discuss the
software fault tolerance, we must first
establish, or uncover a conceptual model for
describing software systems. The system is
supposed to consist of many components
that interact under the control design (1).
The components are as systems in their way,
but the design of the system is also a
component which has special characteristics
for managing the interaction between the
components and the linkage between the
system and its environment.
© STM Journals 2011. All Rights Reserved.
As we know, software failures are endless. It
can occur any time because of any reason
though we keep mind over the development.
There are many ways to manage errors in
fault tolerance. First, we would focus on the
Design Diversity. It is an approach in which
the making of two or more components
intended at achieving the same output
through independent designs and
implementations (6, 7). Design diversity
begins with the initial requirement of
specification. (1).
Variety of designs with data diversity and
environmental diversity of the whole system
can produce better services. There may be at
least two variations to design system faults
tolerance, which requires a primary solution
that provides expected error-free result of
performance variations.
Classical techniques for tolerating software
design faults are mostly based on some form
of design diversity including Recovery
Blocks (RcB) (8) and N-version
programming (NVP) (6). The RcB is one of
the two original varieties of techniques of
software fault tolerance. It was introduced in
1974, Horning et al., from early
implementations developed by Randall in
1975 and Hecht in 1981 (8).
33
Journal of Computer Technology & Applications
Volume 2, Issue 1, March, 2011, Pages 32-40.
_____________________________________________________________________________________________
Fig. 1: Design diversy by RcB
RcB work with variations in output made
during the program execution on the basis of
results of acceptance tests. RcB uses the
acceptance test, back and restore order to
achieve fault tolerance. We know that most
of the functions of the program can be
executed in more than one ways using
different algorithms and structures. These
different functions are variations which have
varying degrees of effectiveness in the
management and use of memory, execution
time, reliability and other criteria. RcB
includes this variation, the most efficient
module, is the first in the flow. And it is
called a primary alternative or primary unit.
© STM Journals 2011. All Rights Reserved.
Thus, the resulting rank of the variation
reflects the degradation in the performance
of the variation. A voting mechanism
determines a single adjudication result from
a set or a subset of all the results of variation
which are usually executed in parallel.
Apart from the two well-known approaches,
a number of other schemes for software-
fault tolerance have been developed such as
N Self-Checking Programming (7) for
sequential programs and Conversations (8).
NVP was suggested by Elmendorf in 1972
and developed by Avizienis and Chen in
1977–1978. NVP gives us the different
version of the same system (6). Compared
with RcB, NVP is static method. This means
that the task is executed by multiple
processes or programs, and the result will be
accepted only if it is recognized as an
acceptable outcome usually via a majority
vote. Hardware fault tolerance architectures
associated with NVP are N-modular (6).
We classify programmers into three classes
of fault-tolerant object-oriented program:
users failover objects, designers of fault-
tolerant objects (or foot-designer) and
system (or meta-level) programmers. If only
using fault-tolerant object or an improved
version of the original object, the user must
know a little information about the
interested object of fault-tolerant or not.
34
Journal of Computer Technology & Applications
Volume 2, Issue 1, March, 2011, Pages 32-40.
_____________________________________________________________________________________________
Fig 2: Design diversity by NVP
Though FT-designer is required for the
construction of fault-tolerant program, and
therefore he/she must know more about the
schemes to combat software-error and is
responsible for development and associated
abnormalities of the arbitrator. He / she will
also choose the special schemes such as RcB
or NVP for the development of fault-tolerant
program. Notice that the control mechanism
for fault-tolerance scheme should be
independent of the application and so can be
done to re-use. It is a system programmer
who is responsible for providing FT-
designer with high-level programming
interface for various software fault-tolerance
schemes, which hides the implementation
details of the mechanisms of their control.
© STM Journals 2011. All Rights Reserved.
So, a supporting system for the development
of fault-tolerant programs may be defined in
a very conceptual way. To do so, we
required a network base system where
objects may be located in different nodes
started from node-1 to node-n which has
many objects over the network. Many
components can use many objects as shown
in communicative network. We use failover
objects, designers of fault-tolerant objects or
meta-level programs. When we concern
about the objects based network system,
where they are distributed in various nodes.
In which nodes have different collections of
objects. The objects are not generating the
same code of meta objects either for RcB or
for NVP. But this can enhance productivity
when we use OOP fundaments with the
same type of system.
OOP Approach
OOP is an approach to programming in
which each data item with the operations
used on it is designated as an object; the
routines used to operate on the data item are
called methods; and objects are grouped in a
hierarchy of classes (10). A programming
technique that enables you to work with
self-contained collections of data structures
and routines interacts with other objects
(10). OOP having many advantages like
simplicity, modularity, modifiability,
extensibility etc. OOP supports many
features like encapsulation, abstraction,
inheritance, polymorphism, message
passing, data hiding, etc. (11).
Class: collection of different entity to
perform one specific task. Encapsulation:
The values of the variables inside an object
are private, unless methods are written to
pass that information outside of the object.
Inheritance: Each subclass inherits all
variables and methods of its super class.
35
Journal of Computer Technology & Applications
Volume 2, Issue 1, March, 2011, Pages 32-40.
_____________________________________________________________________________________________
Polymorphism: ability to take more than one
form from one form.
Fig. 3: Meta Object in vb.net
Visual basic.net is one of the object-oriented
languages, and it also includes inheritance,
data abstraction, reusable components,
portable codes and device freedom (3, 4).
Abstraction and inheritance are based on the
concept of a class: instances of a class are
objects with specific operations provided for
their manipulation. Furthermore, given a
base class, a sub-class of the base class can
be defined so as to inherit some or all of the
attributes of the base class (3,4). Whole set
of code treated as the meta data for the same
program. Meta data are stored within an
assembly which isolated like Main Objects
and Sub Objects.
There are several possible solutions for
software-fault tolerance in the application
layer (2, 7), but most this is based on pre-
defined, user defined classes and runtime
libraries.
© STM Journals 2011. All Rights Reserved.
Implementation of OOPs in Visual
basic.net for Software Fault Tolerance
We will start with a simple example of a
Sorting application. This example is made
up of an application program and three
Sorting servers. Each Sorting server
implements a variation of the Sorting
operation by receiving an object which
contains a list of integer numbers, Sorting
the list, and then sending the result back to
the application. Here is one interface called
ItemList which include the Sorting
mechanism in the form of function, when we
create the object of the same class and call
the method that can help us use differently
like quick, RCB, NVP etc. One of the
Method (function) of class ItemList will use
different kind parameters can be redefined
later in the sub-classes of ItemList. The
interface will become the reusable
components of the system which will use
when ever the same set of code is required.
Public interface ItemList
Function Itemlist(ByVal k As Integer) As
IntegerFunction vector(ByVal k As Integer)
As Integer
End interface
Assume that there exist some VB library
programs provided by the system
programmers that implement the control
mechanisms for different fault tolerance
schemes. The class below provides several
interfaces for the control of recovery blocks,
N-version programming and other schemes.
Public Interface FaultT1
Function Variation(ByVal port As Integer,
ByVal machine As Char)
Function QuickSort() As Integer
Function RCB(ByVal Obj As
FaultTolerance1) As Boolean
Function NVP(ByVal Obj As
FaultTolerance1) As Boolean
36
Journal of Computer Technology & Applications
Volume 2, Issue 1, March, 2011, Pages 32-40.
_____________________________________________________________________________________________
End Interface
We are introducing our own interface for the
different faults tolerance techniques that can
be bound within one code. Interface FaultT1
having three techniques of Design diversity
would used for relative fault managing.
At this point FaultT1 is the interface of the
reference type that will be used by the
various classes in the remote servers. Both
control structures return a Boolean result
indicating if the variations achieve an
acceptable result (TRUE) or an incorrect
result (FALSE). Since an arbitrator is often
application-specific, the object passed to the
fault-tolerant control structures must provide
a pre-defined Arbitrator operation. As an
example, the control mechanism for
recovery blocks could be implemented by
the system programmer as follows.
Public class Item
Implements FaultT1, ItemList
Dim s As System.Net.Sockets.Socket
„implements all property and method from
interface
„action(event)
Public function RCB(ByVal Obj As item)
implements FaultT1. RCB
„Use socket class
Dim BK As item
BK = Obj
for i=0 to i< nVariations
„Try alternate/Variation
s.Connect("host as string", Port as integer)
s.Close()
if (obj.Arbitrator()) then
„Ensure test was not successful
„recover the object and try
„another alternate/Variation
else
return(TRUE)
end if
„ All alternates failed
return (FALSE)
next i
© STM Journals 2011. All Rights Reserved.
End function
„define each method from interface
Public function QuickSort() as integer
implements FaultT1. QuickSort()
Dim ob2 as Items
Dim err AS Boolean
Private Sub BubbleQuickSort()
Dim temp As Integer = 0
For j As Integer = 0 To arr.Length - 1
For k As Integer =(arr.Length)-1 To j + 1
Step -1
IfCInt((arr.GetValue(k)))<
CInt((arr.GetValue(k - 1))) Then
temp = CInt(arr.GetValue(k))
arr.SetValue(arr.GetValue(k-1),
k)
arr.SetValue(temp, k - 1)
End If
Next
Next
End Sub
Obj2.variation(p1,"node1.a")
Obj2.variation(p2,"node2.b")
Obj2.variation(p3,"node3.c")
err = Obj2.RCBlock(list)
return err
End class
At this point, Item is class which
implements the FaultT1, ItemList. As it
implements, means it uses the concepts of
multiple inheritance, it can use all the
property and methods of implemented
interfaces. More precisely, the structure RcB
control receives the object and passes that
object to the first variation. When the result
comes back, referee operations are
performed. If the result is acceptable, it
returns TRUE, or, otherwise object is
restored and the following alternative holds.
If all the deputies are not satisfied, the
operation RcB returns an error signal (false)
that a satisfactory result can not be obtained.
(Note that the sockets were used in this
particular experiment.
37
Journal of Computer Technology & Applications
Volume 2, Issue 1, March, 2011, Pages 32-40.

_____________________________________________________________________________________________

It can be easily modified using various enabling speedy experimentations and some
communication protocols, such as reduction of the extra burden on the FT-
mechanisms of RPC, used by the system designers. However, the application
Arjuna (11). Now, by using the reusable programmer who wishes to utilize the
control structures provided above, an fault library routines must be fully responsible for
tolerant designer can easily construct correct use of them; the programming
dependable versions (or sub-classes) of the conventions related to the use of library
ItemList class. The fault tolerant designer programs must be strictly adhered and all
has to develop the Variations and to indicate checks as to the faithfulness can be
which type of objects will be handled by the performed only by the programmer
FaultT1. him/herself. Moreover, such conventions
cannot make a clear separation between
Public function NVP(ByVal Obj As item) application code and the extra code for
implements FaultT1. NVP software-fault tolerance. To support Sorting,
Dim i As Integer = left, j As Integer = right we can have QuickSort as well as NVP for
Dim temp As Integer achieving Design diversity.
Dim pivot__1 As Integer =
CInt(arr.GetValue(Pivot(right, left))) Public class FMT
While i <= j Inherits Item
While CInt(arr.GetValue(i))< pivot1 if ( NOT obj.List) then
i += 1 „Use NVP(..)
End While Else
While CInt(arr.GetValue(j)) > pivot1 „use QuickSort()
j -= 1 End if
End While End Function
If i <= j Then End class
temp = CInt(arr.GetValue(i))
arr.SetValue(arr.GetValue(j), i) Suppose one would like to make the
arr.SetValue(temp, j) QuickSort() operation fault-tolerant. We
i += 1 should be able to make the QuickSort()
j -= 1 operation reflective first and inherits it by
End If the next used class of vb.net. Note that the
End While code of the control mechanisms
If left < j Then implemented in FMC can use Item and
QuickSort(left, j) FaultT1 both. So the base-level programs
End If will be very similar to normal, non-fault-
If i < right Then tolerant ones and Item is derived from
QuickSort(i, right) Itemlist which treated as sub objects.
End If Further, we can create any class that can use
End Function our earlier defined class for achieving same
functionality.
We defined the QuickSort() for the different
objects from different nodes which can use
it. We can achieve few advantages of this
approach as no change to the compiler so
© STM Journals 2011. All Rights Reserved. 38
Journal of Computer Technology & Applications
Volume 2, Issue 1, March, 2011, Pages 32-40.

_____________________________________________________________________________________________

Experimental Evaluation used to measure the times. Here is chart

representation of the data of above table 1.
In our experiment we use vb.net version 5 as
basic programming language. Clients and In Test One, every QuickSort operation was
servers communicate with each other using executed without fault injection, and all lists
TCP / IP by System.Net.Sockets. We received were correctly sorted. It is
believe that this means of communication is interesting to notice that the dependable
effective enough to support our experiment versions based on RcB and NVP have
on the fault-tolerance and object-oriented longer execution time than the faster
development. We define a special object that versions of the normal Sorting operation. It
provides functionality for connection over has longer execution time than RcB which
network with System.Net.Sockets.Socket. uses QuickSort as its first alternate.
Two operations are tied to Socket: However, due to the use of an acceptance
Connect(), which is responsible for test, the overhead of RcB is slightly higher
establishing the connection between the than that of the QuickSort operation itself.
client and the server to send the object on
the server, and Close () is responsible for In Test Two, design faults were also inserted
obtaining the result from the server and into the server; this causes the failure of
close the connection. QuickSort. The RcB can still deliver correct
computation. NVP fails because the voter
Table 1 Performance-related testing OUTPUT. failed to find the majority of three different
results. This time, we can see that the time
Test 1 2 3 of NVP is shorter than that of RcB since
QuickSort O/P DONE NOT NOT RcB has to activate all its alternate to reach
DONE DONE a correct result.
Time 2089 289 2207 Chart1: Performance-related testing OUTPUT
RcB O/P DONE DONE NOT
DONE
Time 4312 14004 4225
NVP O/P DONE NOT DONE
DONE
Time 9971 8971 9971

In order to examine the effectiveness of each

implementation testing based on software-
fault injection is performed. Here we have
three techniques of fault tolerance which
wrapped in reflective code through interface,
class and function as QuickSort, RcB and
NVP. The O/P of the each method‟s
execution time was measured in
microseconds (µseconds) while the time of
network communication is assumed as
constant. A data set of 200 elements was

© STM Journals 2011. All Rights Reserved. 39

Journal of Computer Technology & Applications
Volume 2, Issue 1, March, 2011, Pages 32-40.
_____________________________________________________________________________________________
In the third test, some software faults which
cannot be detected by the acceptance test
were inserted into the Sort server, and both
QuickSort and RcB produce erroneous lists
without signaling any error. The general
overhead is similar to those in the first test.
Note that NVP can tolerate such a fault very
effectively.
Conclusions
We can have modular programming
implemented in VB.net with the Meta
object. Whatever we use function, class and
interface, all these features along with
socket programming show that the run-time
overhead of software-fault tolerance. The
fault tolerance would become more effective
when we make it clear, structured,
separation of both design and operation
stages. The metaobject approach provides an
FT-designer with the clearer and simpler
interface but with a slightly higher run-time
overhead. We experiments these modules
with different types of error at different type
of phase and shown the results of their
Execution.
© STM Journals 2011. All Rights Reserved.
References
1. P. A. Lee and T. Anderson. Fault
Tolerance: Principles and Practice
Second Edition, Springer-Verlag. 1990.
2. M. Lyu (ed.) Software Fault Tolerance
Trends in Software series, WILEY.
1995.
3. Gabria Oances and Bob Donald Visual
Basic .Net By Example by Techmedia
Publication.
4. Bill Evjen et al. Visual Basic.net
Programming Bible by willy-India
Publication.
5. http://www.ece.cmu.edu/~koopman/des
_s99/sw_fault_tolerance.
6. Avizienis A. “The N-Version
Approach to Fault-Tolerant Software”
IEEE Transactions on Software
Engineering 1985. SE-11(12) 1491-
1501p.
7. Laprie J. C. et al. Hardware and
software fault tolerance: definition and
analysis of architectural solutions in
Proceedings of 17th International
Symposium on Fault-Tolerant
Computing, Pittsburgh. 1987. 116-
121p.
8. Randell B. “System Structure for
Software Fault Tolerance” IEEE
Transactions on Software Engineering
1975 SE-1(2) 220–232p.
9. www.ic.gc.ca/eic/site/trmcrt.nsf/eng/rm
00196.html.
10. Robert Layfort. Object Oriented
Concept and Programming in C++
Galgotia publication.
11. Shrivastava S. K. et al. “An Overview
of the Arjuna Distributed Programming
System” IEEE Software 1991. 8(1) 66-
73p.
40