DESIGN AND IMPLEMENTATION OF INTELLIGENT COMPUTER

TROUBLESHOOTING SYSTEM

BY

MIKE DAVID

011/02/CSC/023

A PROJECT REPORT SUBMITED TO

THE DEPARTMENT MATHEMATICS, STATISTICS AND COMPUTER SCIENCE OF

CALEB UNIVERSITY, IMOTA LAGOS.

IN PARTIAL FULFILMENT OF THE REQUIREMENTS FOR THE AWARD OF

BACHELOR OF SCIENCE (B.Sc.) DEGREE IN COMPUTER SCIENCE

SUPERVISOR: MR. PRINCE AKINSOLA AKINSANYA

AUGUST 2017
 STATUS
TITLE
( OR )

1 Front sheet 

2 Abstract 

3 Declaration of Originality 

4 Contents 

5 Acknowledgement 

6 Aims/Objectives 

7 Chapters – Each starting on a new page 

8 Sub division of chapters 

9 Discussion 

10 Conclusion 

11 Future work 

12 References 

1
 ACKNOWLEDGEMENT

I am eternally grateful to God almighty for life and mercy to get to this point in my educational

journey. Am grateful to my parents Mr. and Mrs. S. Akpan Ukpong, my siblings; Tonia, Nicky,

Cyril, Blessing, Gina and Emediong for their support. Am also grateful to my very special friend

Ada Okoro, my friends and course mates; Anthony Atta, Micah Aikhuele, Ayodeji Odulaja, Ovie

Emevor, Ogunmakin Niyi, Shedrack Udoka, Salimon Jamiu, Abraham and Moses Okotore for

their help during the course of this project.

I want to express my profound gratitude to my supervisor, MR. Prince Akinsola Akinsanya, for his

guidance and direction. Am grateful to the HOD of Computer Science Caleb University, Dr. A.O

Oloyede. I also want to express my gratitude to Prof. O. B. Longe, Dean of Student affairs Caleb

University.

2
 ABSTRACT

Even with decades of technological improvements in their development computers like all other

systems still fail one way or another or develop faults. Solving these faults is easy only if the

diagnosis is effectively carried out. Applying artificial intelligence in the diagnosis of computer

faults has been in implementation for years and this paper is written to add yet another approach

to this practice.

The aim of this project is to design and develop an intelligent trouble shooting system using a

linear matching algorithm to develop a forward chaining inference as opposed to using an expert

system shell. The developed system exhibits a two inference process to arrive at solutions to

problem, and exhibited good results when evaluated using test cases, as well as other metrics such

as ease of interaction and expandability of its knowledgebase. The system is developed using

object oriented approach and developed using a waterfall model of software engineering. The

inference module of the system was developed using java programming language, while the

knowledgebase is developed using MySQL.

This project only catches a small scope of computer system problems to be solved with this

approach to developing an expert system. The prototype showed promising results in solving

common PC issues.

3
 CONTENTS

........................................................................................................Error! Bookmark not defined.

ACKNOWLEDGEMENT .............................................................................................................. 2
ABSTRACT .................................................................................................................................... 3
TABLE OF FIGURES .................................................................................................................... 6
LIST OF TABLES .......................................................................................................................... 7
1 INTRODUCTION ................................................................................................................... 8
1.1 PROBLEM STATEMENT .................................................................................................................. 9

1.2 AIM AND OBJECTIVES ................................................................................................................... 9

1.3 SCOPE .......................................................................................................................................... 10

1.4 SIGNIFICANCE OF STUDY............................................................................................................. 10

1.5 CHALLENGES AND LIMITATIONS ................................................................................................. 10

2 LITERATURE REVIEW ...................................................................................................... 11

2.1 INTRODUCTION ........................................................................................................................... 11

2.2 THEORETICAL FRAMEWORK ....................................................................................................... 11

2.2.1 ARTIFICIAL INTELLIGENCE DEFINITION ............................................................................... 11

2.2.2 HISTORY............................................................................................................................... 12

2.2.3 APPLICATIONS/RESEARCH AREAS ....................................................................................... 14

2.3 EXPERT SYSTEMS ......................................................................................................................... 15

2.3.1 TYPES OF EXPERT SYSTEMS ................................................................................................. 17

2.3.2 BASIC STRUCTURE OF EXPERT SYSTEM ............................................................................... 18

2.3.3 RELATED WORKS ................................................................................................................. 18

2.3.4 SUMMARY OF RELATED WORKS ......................................................................................... 21

2.4 PROJECT MOTIVATION ................................................................................................................ 22

3 RESEARCH METHODOLOGY .......................................................................................... 23

3.1 DESIGN CONSIDERATIONS .......................................................................................................... 23

3.2 DEVELOPMENT PHASES/STAGES ................................................................................................ 24

4
 3.2.1 System Analysis Phase ........................................................................................................ 24

3.2.2 Design Phase ....................................................................................................................... 25

3.2.3 Implementation Phase ........................................................................................................ 25

3.2.4 Testing and debugging Phase.............................................................................................. 27

4 IMPLEMENTATION AND EVALUATION ....................................................................... 28

4.1 SYSTEM OVERVIEW ..................................................................................................................... 28

4.2 SYSTEM ANALYSIS ....................................................................................................................... 28

4.2.1 User Interface Requirements: ............................................................................................. 28

4.2.2 Knowledge-base Requirements: ......................................................................................... 29

4.2.3 System Logic/Inference Engine Requirements: .................................................................. 29

4.3 SYSTEM DESIGN .......................................................................................................................... 29

4.3.1 System Structural Design .................................................................................................... 29

4.3.2 Knowledge-base Design ...................................................................................................... 30

4.3.3 User Interface Design .......................................................................................................... 31

4.3.4 Adopted Algorithm ............................................................................................................. 33

4.3.5 System Logic Model ............................................................................................................ 33

4.4 SYSTEM DEVELOPMENT .............................................................................................................. 35

4.4.1 Utilized Hardware ............................................................................................................... 35

Utilized Software................................................................................................................................. 35

4.4.2 Knowledge-base development ........................................................................................... 35

4.4.3 Knowledge Acquisition........................................................................................................ 36

4.4.4 Knowledge Representation ................................................................................................. 36

4.4.5 Knowledge-base Development ........................................................................................... 37

4.4.6 Inference Engine Coding ..................................................................................................... 38

4.4.7 User Interface Development ............................................................................................... 39

4.5 SYSTEM TEST ............................................................................................................................... 39

5
 4.5.1 Modular Testing .................................................................................................................. 39

4.5.2 System Testing .................................................................................................................... 39

4.5.3 System snapshots................................................................................................................ 40

4.5.4 Input snapshot .................................................................................................................... 41

41

4.5.5 Output Shots ....................................................................................................................... 41

4.6 Evaluation ................................................................................................................................... 42

4.6.1 System Result ...................................................................................................................... 43

4.6.2 Discussion of results............................................................................................................ 45

5 CONCLUSION ..................................................................................................................... 46
5.1 RECOMMENDATIONS.................................................................................................................. 46

5.2 FUTURE WORKS .......................................................................................................................... 47

5.3 SUMMARY ................................................................................................................................... 47

REFERENCES ............................................................................................................................. 49
APPENDIX ................................................................................................................................... 52
Code snippet for inference engine ......................................................................................................... 52

TABLE OF FIGURES

Figure 3.1 Interaction of expert system modules. ......................................................................... 24

Figure 4.1 Structural design of troubleshooting system ............................................................... 30

Figure 4.2 Wireframe of Main Window ....................................................................................... 32

Figure 4.3 Solution window wireframe ........................................................................................ 32

Figure 4.4 An Activity Diagram of the system ............................................................................. 34

6
Figure 4.5 Knowledge Representation model ............................................................................... 37

Figure 4.6 Snapshot of the Welcome Dialog ................................................................................ 40

Figure 4.7 Main Window snapshot ............................................................................................... 40

Figure 4.8 Main Window displaying the power problems list...................................................... 41

Figure 4.9 Solutions window display causes and solution to a user power issue request. ........... 41

Figure 4.10 Result window displaying solution for user performance issue request. .................. 42

Figure 4.11 A clustered bar chart showing solution results .......................................................... 44

Figure 4.12 Cluster bar chart showing number of solutions resolved .......................................... 45

LIST OF TABLES

Table 4.1 Database Table layout ................................................................................................... 30

Table 4.2 Fictitious test results. .................................................................................................... 43

Table 4.3 Real Test case result ..................................................................................................... 44

7
 CHAPTER ONE

1 INTRODUCTION

All Systems whether organic or inorganic, mechanical or electrical, digital or analogue may

potentially fail at some point in time. Computer systems are no exception to this fact, as they

exhibit failures of different kinds, costing affected organization and individuals’ loss of valuable

data, resources and time. Troubleshooting is a knowledge intensive task, which requires skill and

experience. Even with ample knowledge available, troubleshooting may still prove to be a

confusing and time consuming activity.

Intelligent systems are components if artificial intelligence which aim to simulate the decision

model of experts in a particular domain or area of expertise. Expert systems as they are called are

not meant to replace but to support human experts in reaching accurate decisions faster. Expert

systems are designed using a rule-based approach. When the user selects an item on the user

interface, a question is prompted which may be followed by a sequence of question to determine

the precise cause of system failure. An expert system has a knowledge base as a core part of its

system, from which it draws up data and facts to arrive at a decision. The knowledge base of an

expert system contains knowledge (data, facts and information) from experts in a specific field.

The inference engine is the decision maker of the expert system. It is a rule-based program which

makes decisions based on stated conditions.

This project is study which reports an implementation of a troubleshooting expert system. This

study utilizes the benefits of an expert system in the area of troubleshooting. Standard methods in

troubleshooting were acquired as knowledge base. An expert system software was designed using

8
the acquired knowledge. This system purpose is to mitigate error and time wastage in

troubleshooting.

1.1 PROBLEM STATEMENT

An Intelligent system with a knowledgebase that is standardized and accurate in prognosis of

system problem issues, can aid both experts and users in resolving system issues. The task of

accurately diagnosing a system failure can be highly prone to error, thereby leaving system with

probable additional damage from erroneous diagnosis. It is therefore imperative that computer

troubleshooting should be an undertaking which has standard steps and tested guidelines in its

approach to diagnosing and solving system problems. Even with industry best-practice solutions

available, the nature of some problems have varying methods of resolution. Currently available

expert system are commonly designed using expert system shells which were developed in the

early days of expert system development, and hence might not meet up with current demands of

such system. It is therefore imperative to develop new approaches, algorithms and/or models for

developing expert systems. An intelligent system is a very valuable tool to ICT technicians,

reducing error plagued diagnosis, reducing overall troubleshooting resolution by hours. Expert

systems do not forget knowledge once acquired, having negligible time lag in accessing data. It is

an invaluable tool to any computer technician for searching through a database that provides

technical resources for system failure prognosis and resolution.

1.2 AIM AND OBJECTIVES

The aim of this study is to develop a troubleshooting system that is intelligent, and enables users

to speedily system issues, and effectively utilize the computer system. The objectives of the study

is:

 To implement a linear matching algorithm in developing an intelligent expert system.

9
  To develop a knowledgebase that is independent of the logic code (can be modified without

adjusting source code).

 To evaluate the developed system using test cases

 To develop a system that uses minimal steps in its inference.

1.3 SCOPE

Computer problems could be hardware or software based in nature, or may even be categorized in

the nature of system utilization like network troubleshooting. Each type of system has its own set

of steps and diagnostic approach, as system attempting to solve every type of system altercation

would be too broad. Due to this reason this study focused on basic hardware problems, software

problems, namely; power issues, performance issues and booting/shutdown issues.

1.4 SIGNIFICANCE OF STUDY

As with every research endeavor carried on this particular subject matter, this work aims to add to

the body of knowledge in this particular area of research. The results of this work should reveal

new methods or approach, algorithms or model to solving problems of similar nature. This write-

up facilitates an evaluation of already existing systems and their modes of implementation, to highlight

areas of potential improvement.

1.5 CHALLENGES AND LIMITATIONS

 Time factor: Developing a system of this nature requires 3 months for each of the

development steps to be followed thoroughly carried out.

 Acquisition of expert knowledge: troubleshooting procedures for general troubleshooting

are not well documented or easily obtained and interviewing experts is time consuming.

10
 CHAPTER TWO

2 LITERATURE REVIEW

2.1 INTRODUCTION

Intelligent systems is a popular area of research in computer science stimulating lots of research

and development efforts over the years. Multiple research and study has been conducted into

developing and improving these systems, for both commercial and academic purposes. A study of

materials and documentations of research works carried out in this area provides deeper insight

into the theoretical basis of this study, as well as its vast potential in synthesizing expert decision

making. Improvements have been made in the development of these systems, albeit, there is still

room for more improvement. The sections that follow is an exploration of the theoretical

background for the study and a summation of related works reviewed by the researcher in a bid to

gain greater insight into the subject matter, its theoretical foundation and its current

implementation methods and limitations.

2.2 THEORETICAL FRAMEWORK

Research and development of systems that can exhibit any form of reasoning or cognitive thinking

is a subfield of computer science, which integrates knowledge from other disciplines such as

neuroscience and psychology. This subfield of computer science is called artificial intelligence

2.2.1 ARTIFICIAL INTELLIGENCE DEFINITION

According to the father of Artificial Intelligence John McCarthy, it is “The science and

engineering of making intelligent machines, especially intelligent computer programs. According

to Nils J. Nilsson “Artificial intelligence is that activity devoted to making machines intelligent,

and intelligence is that quality that enables an entity to function appropriately and with foresight

11
in its environment”. It is a branch of computer science concerned with synthesis or modeling of

intelligence using mathematical, algorithm and standard theoretical considerations.

2.2.2 HISTORY

The first ever formal work recognized to be associated with artificial intelligence was carried out

by Warren McCulloch and Walter Pitts in 1943. They proposed a model of neurons described as

being in “on” or “off” states, and the “on” state being switch by stimuli from adjacent neurons.

Their work was based on the physiological function of neurons in the human brain, propositional

logic due to Russell and Whitehead, and Alan Turing’s theory of computation. They showed that

functions could be computed by a network of neurons and that logical operators could be realized

using a number of structured nets. In 1950 two Harvard undergraduates, Marvin Minsky and Dean

Edmonds built the first neural network computer called the SNARC. The term ‘artificial

intelligence’ had not been coined prior to 1956.

In 1956 at Dartmouth College in Hanover New Hampshire, John McCarthy who later became one

of the most influential individuals in the field, organized a summer workshop of ten researchers in

the U.S. interested in neural nets, intelligence and related studies. McCarthy proposed a study of

artificial intelligence, with the purpose of show that a machine could stimulate all forms of

intelligence. The workshop did not achieve any notable new fits in the field, but brought together

important individuals that would be pivotal in the advancement of the field in the near future,

established artificial intelligence as a field. In 1958 John McCarthy designed LISP, a high level

programming language that became the popular tool for AI programming.

From the beginning there were a lot of bold predictions from AI researchers on the future

breakthroughs and milestones in the field. One of such predictions was made by Herbert Simon

who predicted that a computer would be chess champion and would prove a significant

12
mathematical theorem in ten years. These actually became a reality 40 years down the line. These

failures were as a result of early achievements being based on solving simple problems with

algorithms that were only effect for simple problems, as well as limitations in hardware

performance. And so these simple systems failed when tried on more complex and wider selection

problems. An example of such failure was the translation machine by the U.S National Research

Council to translate Russian scientific papers during the wake of the sputnik launch in 1957. The

syntactic translation and word replacement alone could not capture the meaning of sentences. The

famous translation of “the spirit is willing but the flesh is weak” as “the vodka is good but the meat

is rotten” by the machine illustrates difficulty in solving problems without proper background

understanding of the subject matter.

During the early decades of AI problems were solved by hard coding elementary reasoning into

steps to solve problems. Due to the limitation of this approach the alternative was to build programs

with more specific and robust data. The DENDRAL program (Buchanan et al 1969) was one of

the first examples of this approach. The program was developed by ED Feigenbaum, Bruce

Buchanan and Joshua Lederberg (a Nobel laureate geneticist). The DENDRAL was a program to

deduce molecular structure using information from a spectrometer. This knowledge-intensive

approach to AI development sparked renewed interest in the field with more expert systems being

developed.

The first commercial AI system (expert system) was the R1, an automated ordering system for

Digital Equipment Corporation. From 1980 the AI became an industry with unprecedented growth.

Corporations started building expert systems, vision systems and robots. AI intelligent

systems/programs are now integrated to almost every technology available spanning from search

engines, mobile phones, voice recognition systems and a vast collection of applications.

13
2.2.3 APPLICATIONS/RESEARCH AREAS

Game Playing; Early AI implementations exhibited their problem solving capabilities by playing

simple board games such as chess or checkers. In recent times AI is playing a more strategic role,

both as the opponent to humans in some games and as a game character decision making feature

in complex gaming scenarios.

Language Processing; is one the most widely researched application of AI, due to its apparent

benefits. Much work is now put into making machines that can communicate effectively with

humans, thereby surpassing limitations of earlier system that were based solely on syntactic

manipulation.

Expert systems; this is the most prevalent applications of AI. It is a knowledge based system that

accesses knowledge of experts. It used in a lot of industry proprietary software and commercially

available software products.

Vision systems; studies how a machine receives and interprets visual information, this is one of the

most important area of AI research. Its applications in machine perception include; face detection

and recognition, detection of objects, self-navigating machines etc.

Speech recognition; an application of AI for voice recognition and is also crucial to how machines

will communicate and interact with humans.

Robotics; the goal is to make robots that can be autonomous in decision making. A lot of decision

making and learning areas of AI is being implemented in robotics to make these machines

intelligent agents.

14
Deep learning; a collection of learning procedures, which has facilitated object recognition in

images, video labeling, and activity recognition, and is currently being applied in other areas of

perception such as, speech, natural language, and audio processing.

Neural Networks; is an area of research for the purpose modeling the neural network of the human

brain in machines. It has made recent strides in pattern recognition and object detection, but is still

limited by its implementation in a Von-Neumann architecture.

2.3 EXPERT SYSTEMS

For this project a knowledge-based system also called an expert system is going to be employed

in the development of an intelligent troubleshooting system.

Expert systems also known as knowledge based systems is a field of AI that deals with simulating

the decision making capabilities of human experts in a particular knowledge domain. These

systems are referred to as ‘knowledge based’ for their data intensive approach at decision making

and problem solving, as opposed to the classical algorithmic approach at problem solving. This

technique of decision making is modelled on the presumption that human experts can make

decisions based on how much knowledge they have concerning that specific domain, this

knowledge must be specific, unambiguous and detailed. The major differentiating factor of ES

over other programs is that its core algorithm is not encapsulated in its code, but as knowledge

stored in its knowledge base. This facilitates easier modification of the program without

necessarily rewriting or its improving its program code.

Expert systems surfaced in the 60s as further research in AI sought to remedy the limitations of

hard coded algorithm based reasoning. One of the earliest implementations of ESs was

DENDRAL, which was developed at Stanford in the late 1960s. It was designed to identify

15
molecular structure of organic chemicals from spectral analysis and chemical formula of

molecules.

‘The DENDRAL program (Buchanan et al., 1969) was an early example of this approach. It was

developed at Stanford, where Ed Feigenbaum (a former student of Herbert Simon), Bruce

Buchanan (a philosopher turned computer scientist), and Joshua Lederberg (a Nobel laureate

geneticist) teamed up to solve the problem of inferring molecular structure from the information

provided by a mass spectrometer. The input to the program consists of the elementary formula of

the molecule (e.g., C6H13NO2) and the mass spectrum giving the masses of the various fragments

of the molecule generated when it is bombarded by an electron beam. For example, the mass

spectrum might contain a peak at m = 15, corresponding to the mass of a methyl (CH3)

fragment.’(Stuart J. Russell and Peter Norvig , 2010)

Further implementation of knowledge-based approach to by Feigenbaum and others at Stanford,

resulting in a second milestone program MYCIN, which was a medical diagnoses program

developed by Feigenbaum, Buchanan and Dr. Edward Shortliffe to diagnose blood infections. It

was a program with about 450 rules. It was a significant program because it wasn’t developed on

any theoretical framework like DENDRAL did. It was the first system in which its knowledge

base was derived from extensively interviewing experts in the domain, who have derived their

knowledge from text books and experience, which is the general methodology for contemporary

expert system design.

Other early expert systems include the PROSPECTOR for identifying ore deposits in a particular

locations (Duda et al 1979), SID (Synthesis if Integral Design) software program, developed in

1982 was the first system used for design of a product. By the end of 80s a majority of the fortune

500 companies had deployed their own expert systems in some capacity or the other. Since then

16
the usage of expert systems has grown over the years, as it is applied for decision support in almost

all industries.

2.3.1 TYPES OF EXPERT SYSTEMS

Early expert systems were mostly rule based, but there have been other approaches over the years

for building knowledge based systems:

Rule-Based Expert Systems; is the most popular method of implementing an expert system, which

represents data in a modular manner. The bases of this approach is the use of ‘if then’ conditional

reasoning, with rules that are the condition to be met in other to arrive at a specific decision.

Object Oriented Expert System; in object-based system also called frame-based system, objects

are used to represent knowledge rather than rules. One advantage of this kind of knowledge

representation is the fact that an object contains not only information about itself, but defines also

how the object behaves. This kind of approach is like object oriented programming used in most

high level programming languages. This kind of approach can also be implemented with known

OOP languages.

Model-Based Expert System; is a reasoning system, which attempts to solve problems by

representing and reasoning with a deeper knowledge of the application domain. This approach

sometimes attempts to represent the domain knowledge mathematically. This approach reduces

the need for knowledge acquisition.

Case-Based Expert System; solves problems by reusing knowledge from past similar situations.

The aim of this approach is to learn from past experience of similar situations and offer solutions

based on previous experience. Case-based systems a solution oriented in problem solving instead

of symptomatic in nature.

17
Hybrid Expert System; are expert systems designed by integrating two or more types of expert

system approaches together to make one system. It can be very effective as the drawbacks of one

approach can be overcome by the other integrated type of system.

2.3.2 BASIC STRUCTURE OF EXPERT SYSTEM

1. Knowledge Base; Consists of problem solving rules procedures, and intrinsic data relevant to the

problem domain.

2. Working Memory; refers to task-specific data for the problem under consideration.

3. Inference Engine; is the brain of the system, it is a generic control mechanism that applies the

knowledge in the knowledge base to the task specific data to arrive at some solution or conclusion.

There are two types of inference approaches;

Forward chaining; this approach checks the condition of a rule to determine whether it is

true or false. If the condition is true, then the action part of the rule is also true. This

procedure continues until a solution is found or a dead end is reached. Forward chaining is

commonly referred to as data driven reasoning.

Backward Chaining; is the reverse of forward chaining. It backtracks from a goal to

steps/paths that leads to the goal. Backward chaining is very good when all outcomes are

known and the number of possible outcomes is not large. In this case, a goal is specified

and the expert system tries to determine what conditions are needed to arrive at the specified

goal. Backward chaining is thus also called goal driven.

2.3.3 RELATED WORKS

Sourav et al (2013) proposed a web based troubleshooting system. This is a web based

troubleshooting intelligent system developed using turbo prolog. It is an extension of an already

18
existing troubleshooting system written in prolog by the developers. It implemented a rule-based

expert system for diagnosing and troubleshooting computer faults. It also included Microsoft

standard error codes and solutions for handling such errors, through integrating DLLs (Dynamic

Link Library).The system being web operated with network connection and thus, can be affected

by network issues. Also Mohd et al ( 2009) developed a web based troubleshooting software

designed with computer networks in mind, its main aim is to provide an expert solution system

designed to cater to network issues alone. The system relied heavily on inputs by the system user

in order to proffer solutions. The system was implemented as a web based application using

existing web technologies; ASP (active server pages), HTML and Scripts. As with other web based

system it is prone to network issues and its user interaction is cumbersome.

Sylvester and Adesola (2013) in a study developed an expert troubleshooting system using an

object-oriented analysis and Design (OOAD) using unified modeling language (UML) for its

modeling. The system featured a database built using MySQL, while its expert system

implementation was carried out using java programming language. It was developed using the

Netbean IDE for java. The program featured a vibrant and friendly user interface allowing for easy

user interaction. An Object Oriented approach was also employed by D.V. Kodavade and S.D.Apte

(2011) in creating a diagnostic system that employs backward chaining inference mechanism to

determine causes of faults. The system was designed to check for microprocessor failures using

object oriented approach and a rule based approach. It was designed with the purpose of developing

a system with the capabilities to troubleshoot circuits just from analyzing the circuit schematic on

the same level as an experienced engineer. The system recorded better results using the object

based approach for diagnosis in comparison with rule based approach. The system recorded high

19
accuracy of system diagnosis which exhibited a successful implementation of an object oriented

approach.

Abrham and Vuda (2014) in a study details a system for troubleshooting computer systems failure

using a pattern matching algorithm called Rete algorithm. The system was developed using prolog

via SWI-prolog editor tool. According to the research, the system out performed a forward

chaining expert system approach in solving PC issues. The systems performance was impressive,

even with its difficult user interface which is complex to operate. Another similar by Amanuel

(2016) was designed using a decision tree model and the framework uses the sequence stipulated

by the decision tree when diagnosing PC issues. The system is also implemented with prolog using

SWI-prolog IDE. The system uses a rule-based approach to its knowledge based implementation.

Another popular approach to developing expert systems is the forward chaining. Piotr and

Przemysław (2015) outlined a framework exhibited the utilizing of an expert system for M-28

flying machine maintenance support. It utilized CLIPS expert system development language. The

software conducted assessments by utilizing expert evaluation procedure on M-28 aircraft. The

system implemented both backward and forward chaining inference, this was achieved by setting

a trigger to the desired inference in the inference engine cache. The system gave positive

performance results which could be improved upon for maintenance solutions of other types of

aircraft. K.Selvani et al, (2011) in another similar research proposed a networking expert system

designed to diagnose wireless mesh networks for errors. It implemented a forward chaining

inference. Some of the faults of the system are; connectivity problems, insecure access, slow

response due to network drawback, packet loss, as well as a complex user interface. Forward

chaining is also applied in computer troubleshooting systems, Abdullah Saad et al (2013)

20
developed an intelligent troubleshooting in CLIPS for troubleshooting computer hardware failure.

It is designed with forward chaining inference in its expert system development.

Davood and Reza (2015) designed an expert system that could update its knowledge base,

meaning the system could learn. The system was made for the purpose of solving wired network

connections. VP-Expert shell was used for this project because it doesn’t require any inference

engine coding. The proposed systems knowledge base can be updated with new knowledge there

by giving rise to a system that can learn.

A rule based system was developed by Narendra and Bart (1997). The system was developed to

help field technicians/engineers diagnose HP T500 server platform systems. The system was

integrated into the servers to obtain crash reports when a crash case occurs. A rule based approach

was used for the system development, with a modular language developed for the purpose of

creating the system. The system proved useful but had some difficulties as it had over 1400 rules,

coding these rules was time consuming, also crash reports from the system came in burst making

it difficult to select a particular cause for system failures.

2.3.4 SUMMARY OF RELATED WORKS

Prior works in expert systems have been in diverse domain areas, spanning many industries and

applications fields. Among all of its many application areas, the use of Artificial Intelligence in

diagnosing and troubleshooting different kinds of systems and machinery has been one of its most

prominent application areas. Although this project is centered on computer system

troubleshooting, these systems have been deployed for troubleshooting varying type of systems,

ranging from large industrial machines to airplanes. From the review of different works it is

apparent that there are diverse means of developing such a system, even with the shared theoretical

21
framework, there exist many tools and programming languages to facilitate the creation of

knowledge-based systems. However, it is clear that there are still drawbacks to existing works

upon which researches such as this seek to improve on. Some of these issues are; poor user

interface which is complex for an average user to comprehend, limited expert knowledge

acquisition.

2.4 PROJECT MOTIVATION

Diagnosing and troubleshooting computer failures is a very difficult and confusing task which is

error prone in nature, even for individuals with some level of technical computer knowledge.

System maintenance and evaluation procedure is a knowledge intensive activity, which has strict

sequential pattern for some kinds of errors. It is therefore imperative that a means of making

technically guided decisions for system diagnosis is necessary.

22
 CHAPTER THREE

3 RESEARCH METHODOLOGY

This section covers the approach to design, considerations and steps to be utilized for the

development of this research. From theoretical framework of this research there a number of

approaches to building expert systems, each with its drawbacks and advantages. After careful

consideration the researcher has opted for a hybrid approach for the development of the said

system. An objected oriented approach will be applied with the integration of independent external

knowledge-base as in the rule-based system. The subsequent chapters give detail development path

for the project.

3.1 DESIGN CONSIDERATIONS

The purpose of this research is to develop a troubleshooting system that can facilitate PC diagnostic

activities even for individuals that are not knowledgeable in computer troubleshooting procedures.

With the goal of achieving the objectives of this research as the main consideration, the chosen

approach has been deduced as the best path to the systems implementation by the researcher. The

object orientation approach allows for more flexibility in interface design as compared to using

already existing rule-based shells. The developer possesses control to choose and alter the

algorithm that generates the inference of the system. Object oriented approach which is very

effective in constructing expert systems does have limitation of the expert knowledge being hard

coded with logic, which motivated the researcher to integrate the independent knowledgebase

system of the rule-based system with the object oriented approach. The knowledgebase of the

system will be developed outside of the systems logic, as this will allow the systematically upgrade

of the system with input of new data only not require a modification of the logic code. The systems

inference will be coded with a popular objective oriented language for easy user interface design

23
as these allow easy integration of user interface tools as well as inbuilt user interface libraries. The

diagram below shows the modular interaction of the proposed system.

Experts Knowledge Inference User

Knowledge Base Engine Interface User

Figure 3.1 Interaction of expert system modules.

3.2 DEVELOPMENT PHASES/STAGES

This systems development cycle/process is an adaptation of the waterfall model in software

engineering. This model was chosen for its simplicity and ease of implementation. The stages of

the development process are detailed in the subsequent sections of the write-up

3.2.1 System Analysis Phase

This is the first stage of the systems development, and the results determine every other phase of

development. This section specifies the expected features of this system in three categories

 User interface requirements

 Knowledgebase requirements

 System logic requirements

User Interface Requirement(s): This is a specification of the kinds of features required in the user

interaction module of this project. It should provide key interface requirements that will achieve

the objectives of the project.

Knowledgebase Requirement(s): This is to provide the kind of knowledgebase specifications that

should be implemented in this system

24
System Logic Requirement(s): The logic functions that specific to this project are stated here for

consideration in code development.

3.2.2 Design Phase

At this stage of the system development the structural and logical framework of the system is

designed. This phase takes the result of the Analysis phase and outputs designs for the system

implementation phase. The different design areas for this project include;

 Knowledgebase design

 System Algorithm/Modeling

 User Interface Design

Knowledgebase Design: The design of the data structures and management systems that stores and

manages the retrieval/modification of the expert knowledge is for the system, is what the

knowledgebase design is about.

System Algorithm/Modeling: The algorithm and model for the system logic development is either

obtained from already existing works or developed by the researcher.

User Interface Designed: The layout and look of the user interface is designed to fit specifications

from the analysis phase, while also considering optimum user experience.

3.2.3 Implementation Phase

This stage of development is the development of the system proper where, all of the design phase

deliverables are utilized to develop the system according to the stipulated objectives and

requirements.

 Knowledge Acquisition.

 Knowledge validation

 Knowledge Representation.

25
  Knowledge Coding.

 Inference engine coding.

 User interface design and coding.

Knowledge Acquisition: The acquisition of expert knowledge for this project will extracted from

published works by established technicians with years of experience, troubleshooting guide books

and manuals and manufacturer publications. The reason for this approach is for the timely

obtaining of required expert knowledge, and detailed outline of common PC failures and

complementing solutions that have been used before. These document will be used on the

recommendation of an experienced technician.

Knowledge Verification: For the purpose of creating a system that proffers relevant solutions that

resolves PC failure successfully, a validation process for the expert knowledge would be carried

out. This activity is to ensure that solutions submitted to a user is relevant to real PC issues, and is

effective to solving that particular issue.

Knowledge Representation: Knowledge procured from the acquisition phase of the project will

require arrangement to facilitate efficient structuring and coding of the knowledge base. A model

will be designed to show the hierarchy of symptoms and solutions, which will illustrate a solution

path from failures to solutions.

Knowledge Coding: The knowledge coding phase involves the converting of the knowledge base

into a digital data that can be integrated with the inference engine of the system. The expert

knowledge will be injected into a relatable database, with its hierarchy structured as database tables

and sub-tables. These tables and sub-tables will be classified into symptom tables and solution

tables, and integrated with the knowledge base classes of the program logic.

26
Inference Engine Coding: The inference engine will be coded using a high level objected oriented

programming language. The inference engine will implement the rule-based approach using ‘if

then else’ rules, by utilizing the inbuilt conditional statements and functions of the language.

User Interface Development: The user interface will be designed using the UI tools of the objected

oriented language used in the logic coding. Other graphics and UI development tools may also be

engaged in the development of the UI to create a more user friendly experience.

3.2.4 Testing and debugging Phase

To ensure that the system works properly and is efficient in terms of performance, the system will

be subjected to debugging of its code to check for errors and bugs. It is important that all

performance phase are resolved at this stage of development.

Also an evaluation of the systems performance would be carried out to exhibit the results of the

development efforts of the researcher. Also to show that the system meets its intended objectives

and its overall aim.

27
 CHAPTER FOUR

4 IMPLEMENTATION AND EVALUATION

4.1 SYSTEM OVERVIEW

An intelligent troubleshooting software is a program that can help individuals remedy computer

failures by suggesting solutions to various categories of PC problems. The system is designed to

prompt users to choose from a list of problems that could accurately describe the kind of issues

that the user is experiencing, for the purpose of providing probable solutions to the specified

problem. The system is composed of three modules; the user interface which is how a user

communicates with the system, the inference engine which is the brain of the system and

implements the rules of the system, and the knowledge-base contains the expert knowledge used

by the software.

The system will be called “PCRestore”, and will be restricted to computer start-up and

performance problems for the sake of this dissertation.

4.2 SYSTEM ANALYSIS

An intelligent troubleshooting system developed for the purpose of aiding system failure diagnosis

and failure resolution should fulfil some basic and technical requirements, if it is to effectively

achieve its objectives. For this particular system, the objective to consider include; a user friendly

and easy to use interface, an implementation of a knowledge-base that is independent of system

logic, a proper implementation of expert knowledge in expert system. With these objectives, as a

backdrop, the requirements for this system are broken into categories;

4.2.1 User Interface Requirements:

 The user interface should be user friendly

28
  The interface should provide good user experience

 User interaction with the system should be restricted to mouse clicking gestures

4.2.2 Knowledge-base Requirements:

 The knowledge-base should be independent of the logic code of the system. That is, the

data structure for storing the expert knowledge should not be part of the systems source

code.

 The knowledge-base should be subject to modification without the need of tampering with

the programs source code.

4.2.3 System Logic/Inference Engine Requirements:

 A rule based approach should be used in the inference engine

4.3 SYSTEM DESIGN

The system is separated into independent modules that integrate together to function as a single

system that troubleshoots PC failure or performance issues. With the requirements obtained from

the system analysis, a design of the system is performed with each module of the system designed

independently of one another. The design of each of the modules was structured to meet its

required objectives with the stipulated requirements as guidelines.

4.3.1 System Structural Design

The systems structure is a modular design consisting of modules that are independent of each other

integrated into a single system. This system is composed of three modules; the user interface, the

inference engine or the system logic and the knowledge-base which holds the expert knowledge.

29
 The

Jx jxxj jx x
Inference
Engine

Figure 4.1 Structural design of troubleshooting system

4.3.2 Knowledge-base Design

The knowledge base of the system is implemented as a relational database that can be integrated

with the systems logic, and allows retrieval of the expert knowledge for inference purposes.

The knowledge-base will be a database that can be accessed from the program code, it will consist

of tables containing troubleshooting problems and their corresponding causes and solutions. Each

table will represent a particular category of computer problem, containing common problems in

the related area and solutions that can resolve them.

Table 4.1 Database Table layout

Table Description

Power issue Table It stores power issue problems with its causes and solutions

Performance issue Table This table stores performance issue problem and its

corresponding causes and solutions

Booting issue Table The table stores booting problems and solutions

30
4.3.3 User Interface Design

The user interface is designed to restrict user interactions to mouse clicking events for ease of use

and to amplify a good user experience, this ensures consistent user interaction even with different

users with varying technical knowledge of computer systems. The user interface will consist of

buttons and display areas for displaying options to users, obtaining inputs from a user and returning

appropriate results.

Interface Structure: this is a structure of the overall compositions of the UI categorized in

functional windows. The interface would be composed of multiple windows, with each window

designed for a specific activity. The user interface of this application is structured into various

view;

 The Welcome Dialog; is the first interactive component the user sees when the program is

started. It informs the user on how the software operates

 The Main window; is the main UI component that the user interacts with. It prompts the

user for a selection of problems and gets the input from the user inference.

31
 Figure 4.2 Wireframe of Main Window

 The Results window; Displays the solution to the selected problem with its probable cause.

Figure 4.3 Solution window wireframe

32
Graphic Design: these include the design of user interface components to give visual appeal to

the user and enhance user interaction. These design of components include;

 a system icon,

 button icons,

 Background image design.

4.3.4 Adopted Algorithm

An adaptation of the linear search algorithm was adapted into the development linear matching

algorithm for implementing the system logic. This algorithm is used to find a match from a linear

set, by making a sequential search over all items in the set. The systems expert knowledge is made

up of rules which are the problems to be detected by the system, and a sequential match of the user

input with the set rules is how the system will arrive at problem resolution.

Algorithm Steps

Linear match (Rule set S, user input X)

Step 1: set i = 1;

Step 2: if S[i] = X then go to step

Step 3: set i+1

Step 4: Go to step 2

Step 5: Print the element x found at index i and go to step 6

4.3.5 System Logic Model

The model of this system was developed with UML (Unified Modeling language). It is a general

purpose modeling language utilized by software engineers for software development. It is a widely

used and accepted modeling language in software development.

33
4.3.5.1 Activity Diagram

A model called ‘rule matching model’ was developed to depict the sequence of the logic execution.

This model depicts the stepwise flow of how the system matches problems rules to user inputs to

diagnose and proffer solutions to resolve the user’s system failure.

Figure 4.4 An Activity Diagram of the system

The modeled is an adapted activity UML model, which shows graphical workflow representations

and operational process of the program.

34
4.4 SYSTEM DEVELOPMENT

This section of the report details the implementation activities of this project, with appropriate

information of tools used to perform these activities. This phase of development utilized the

outputs of the design stage to guide the development of the different modules of the system. The

efforts were carried out modularly, with each module being developed, independent of the other.

But even with the modular nature of the system, each components development was executed with

integration, considering other components of the system.

4.4.1 Utilized Hardware

System type: x64 based processor,

CPU: Intel Celeron(R) 1005M. 1.9GHz

RAM: 4.00GB memory

Utilized Software

Operating System: Windows 10, Home Edition

OS type: 64bit operating system.

IDE: Netbeans IDE 8.0.2,

MySQL Query Browser

Java SE SDK 1.8

4.4.2 Knowledge-base development

The knowledge-base development is carried out using knowledge engineering best practices.

Certain consideration were taken into account on the development of the knowledge such as;

availability of expert knowledge in specified domain area, reliability of expert knowledge in this

domain, ease of utilization of obtained knowledge and effective representation in the expert

knowledge.

35
4.4.3 Knowledge Acquisition

The acquiring of relevant expert knowledge for this project was obtained through already existing

industry documentation on the subject matter. This approach to knowledge acquisition guaranteed

that knowledge obtained were already tested and verified as acceptable solutions to well-known

and common errors. Also, because computers have been around for decades, there are industry

standard fault diagnosis and failure repair that are accepted and have been used in resolving many

error cases. The documents containing such knowledge are made available by manufacturers,

technical institutes and authors with years of experience in the field. For this project knowledge

documentation and acquisition was obtained from these sources;

 Manufacturer websites: HP (Hewlett Packard), Microsoft windows website

 Technical Troubleshooting books: UPGRADING AND Repairing PCs 20th Edition by

Scott Mueller 2011.

 Manufacturer Repair Guides: HP pavilion notebook; troubleshooting and repair guide,

Toshiba repair guide.

4.4.4 Knowledge Representation

In order that the knowledge acquired is effectively developed into the knowledge-base of the

system, the knowledge obtained from different sources should be represented using a technique

that delivers the knowledge in a consistent manner. A model is used to present the knowledge for

the knowledge base development.

The knowledge obtained is broken down into categories according the kind of issues they address.

Each category of knowledge is then separated into problems, causes and solutions. Each problem

has cause(s) and solution(s) that maps to it.

36
 Figure 4.5 Knowledge Representation model

4.4.5 Knowledge-base Development

MySQL query language was used in the development of the knowledge-base, via MySQL query

browser. The knowledge-base is developed as a relational database with the relations as the

different categories of troubleshooting problems. A database called pcrestore was created in the

query browser, and the various categories of expert knowledge were subdivided into tables. Three

tables were created; power, performance and booting to represent the three categories of

knowledge obtained. Each table had three columns; a problem column, cause column to hold the

cause(s) corresponding to related problem and a solution column where the solution knowledge is

stored. The other part of the knowledge-base development is the integration into the system logic

code which would be covered in the subsequent section.

37
4.4.6 Inference Engine Coding

The inference engine which is the brain of the system was developed using java programming

language. Java is a strongly typed, high level, object oriented computer programming language. It

is a widely used and well documented language with a wide variety of application area. It possesses

all the major features of OOP (object oriented programming); inheritance, encapsulation and

polymorphism. The project uses an object oriented approach to rule based expert system for

developing the system, and java supports this approach well since it is object oriented and can

execute conditional statement which the basics of the rule-based system.

The system login was separated into two major classes, the main class in which all inference was

coded and also integrated the user interface code and the knowledge class which holds functions

for integrating with the knowledge base for knowledge retrieval. The main class extends the java

JFrame library for creating the user interface with java. This class contains code for displaying

problems when a user selects a category of problem from the displayed category buttons. It also

has functions for comparing a user selection with the knowledge-base to retrieve relevant solutions

for the user from the knowledge class. The knowledge class contains code for integrating the

knowledge base to the system logic. It consist of functions to pass retrieved data to the main class

and also nested classes each holding code for retrieving data for each of the specific categories of

expert knowledge. These subclasses are; power, performance and booting. Each of the subclasses

contains statements of establishing a connection to the knowledge base, and functions for querying

the database and retrieving data. Java can connect to the database via the JDBC (Java Database

Connectivity) driver and API which is part of the JDK (java development kit). The system logic

code was written and debugged using the Netbean IDE.

38
4.4.7 User Interface Development

The user interface was developed in the Netbean IDE using the drag and drop feature for building

swing application and also coded in the same IDE. Its code is embedded along with the main code

of the main class of the system logic for easy and direct integration. The UI is built using the Java

Swing library which supports basic interface development in most operating systems. Since the

user interface design specified two windows, the main and results windows, two separate window

layouts were created using java swing. The main window consist of buttons for the various

categories of system issues, a list area for displaying problems associated with the selected button

and a button for submitting the user selection for inference. The result window which is called

after the user submits a problem is composed of two text area for displaying the cause(s) and

solution(s) to corresponding problem selected by the user, and a reset button for refreshing the

system for another session. Another component of the UI is the exit dialog which recommends

other alternative for problems that are outside the scope of the system.

4.5 SYSTEM TEST

4.5.1 Modular Testing

This is the testing of each of the modules of the system independent of the other modules to

ascertain if they gave results. The three modules of the system where tested after their development

to check if they met design requirements. For the system logic this entailed checking for and

resolving syntactic and semantic errors of the code.

4.5.2 System Testing

The system testing entails checking the fully integrated system if it is fully running and meeting

up to the specified objectives. The system testing was performed on the computer on which it was

developed within its IDE and also as a stand-alone java application.

39
4.5.3 System snapshots

Figure 4.6 Snapshot of the Welcome Dialog

The welcome dialog is the first component that appears when the system is started, it welcomes

the user and gives instructions on how to use the system.

Figure 4.7 Main Window snapshot

The main window of the system is the window in which the different kinds of problems is

developed by the user to select from to receive solution.

40
4.5.4 Input snapshot

Figure 4.8 Main Window displaying the power problems list

4.5.5 Output Shots

Figure 4.9 Solutions window display causes and solution to a user power issue request.

41
 Figure 4.10 Result window displaying solution for user performance issue request.

4.6 Evaluation

Evaluation of this expert system in comparison to existing works is quite difficult as most existing

works are proprietary and hence have information on their performance measurements restricted.

Other reviewed works contained limited evaluation data from which to derive their performance

number. However, I will point the features of this system that makes it stands out from other similar

works.

1. Number of diagnostic steps; is considered important for systems as it would affect speed

at which the system can respond to request. This system exhibited a two-step diagnostic

process, which the first step is identifying the problem category and the second step

diagnosis the problem. The system effectively executed the two step process with

promising result.

42
 2. Ease of interaction; is one of the drawbacks observed in reviewed works, as navigating to

obtain results can be cumbersome.

3. Expandable knowledge-base; is easily achieved as modifying the knowledge-base entails

inserting or editing the integrated database of the system. This process was also tested

during the testing phase of the system as new expert knowledge was introduced into the

system.

4.6.1 System Result

The systems diagnostic and resolution performance was tested using 10 fictitious test error and

failure cases and 5 real test scenarios.

Fictitious Result

The fictitious test cases were derived from common system failure issues reported by windows

users.

Table 4.2 Fictitious test results.

Problem Solved Unsolved Total

Power 3 1 4

Performance 2 0 2

Booting/Startup 2 2 4

43
 Chart Title

Booting/Shutdown

Performance

Power

0 0.5 1 1.5 2 2.5 3 3.5

Unsolved Solved

Figure 4.11 A clustered bar chart showing solution results

Real Test Results

Real test cases were obtained from some Caleb university student with common system issues

Table 4.3 Real Test case result

Problem Solved Unsolved Total

Power 2 0 2

performance 2 0 2

Booting/Shutdown 0 1 0

44
 Chart Title

Booting/Shutdown

Performance

Power

0 0.5 1 1.5 2 2.5

Unsolved Solved

Figure 4.12 Cluster bar chart showing number of solutions resolved

4.6.2 Discussion of results

The system showed effectiveness in solving some common system issues, while failing to proffer

effective solution for some of the test cases. The performance of the system relies heavily on the

knowledge-base of the system as its ability to supply effective solution depends on the quality in

precision of the expert knowledge available.

The system did solve over 70% of the cases tested, showing that it can be an effective

troubleshooting tool.

45
 CHAPTER FIVE

5 CONCLUSION

Artificial intelligence is the new frontier in computer science, even though it is decades old in

research. Expert system continues to be one of the most popular and widely used research areas of

artificial intelligence. Troubleshooting of computer failures being one of these application areas

of expert systems, has benefitted immensely as these approach can help solidify standardization of

troubleshooting practice.

This project is aimed at developing an intelligent troubleshooting system, while improving on

existing methods of implementing said systems. During the course of developing this system, the

researcher was able to gain some insight into the theoretical background of the system. This

insights and a summary of the project are detailed in this section of this work.

5.1 RECOMMENDATIONS

During the course of this project work the author observed some areas of concern as it affects this

area of research.

1. The author observed that data and effective analysis of data hold very important key to

future improvement in artificial intelligence. Therefore, efforts to better analyze data

should be considered closely by artificial intelligence experts

2. Easy development of artificial intelligence with the help of existing expert shells is fast

becoming obsolete, therefore the current system demands of expert system requires

improved techniques.

46
5.2 FUTURE WORKS

The prototype developed for this project though effective, can be improved and adapted for many

domain areas. The researcher gives some ideas on potential future research works related to this

work;

1. An adaptation of this work as a distributed application, which can be accessed by users via

the internet without the need for local installation. With computing capabilities improving

at incredible pace, web based applications are currently increasing in availability as one of

the popular forms of application deployment. An intelligent troubleshooting system, such

as the developed prototype, if accessible over the internet would be a convenient tool. The

technical implications of such a system, would require an implementation of the prototype

application on a server or cloud, as a distributed application which can be accessed by any

user connected to the server or cloud.

2. An expansion of the knowledge-base of the system, to encapsulate other forms of computer

failure.

3. A research into adapting machine perception into the existing prototype. Machine

perception is a sub-area of artificial intelligence that deals with how machines can perceive

and interact with their external environment, through evaluating and deciphering sensory

input from sensors.

4. Implementation of the system with other object oriented languages.

5.3 SUMMARY

The system developed in this project used a linear matching algorithm, which though effective can

still be improved. It exhibited an easy to use interface and a two-step inference engine, which

reduced the number of inference steps of the system. The prototype of the system did meet its

47
objective in varying degrees. It showed an overall failure resolution accuracy of 73% in test carried

out. An object oriented implementation of the system was developed using java, which showed

the effectiveness of such approach in solving logical problems. For real world use of this system,

further development testing would be required.

48
 REFERENCES

Abdullah Saad AlMalaise Al Ghamdi , Syed Mutiullah Hussaini and Abdul Khadar Jilani(2013)

Empirical Model using Expert System Techniques in Hardware Failure of a System during Backup

of Data. (IJCSNS) International Journal of Computer Science and Network Security, VOL.13

No.2, February 2013.

Abrham Debasu Mengistu and Dr.Vuda Sreenivasarao (2014), Knowledge Based Robot System

for Diagnosis and Troubleshooting of Personal Computer Using Artificial Intelligence Rete

Algorithm. American Journal of Engineering Research (AJER), 2014.

Amanuel Ayde Ergado, (2016) Self Learning Computer Troubleshooting Expert System

International Journal of Artificial Intelligence & Applications (IJAIA), Vol. 7, No. 1, January

2016.

AYANGBEKUN Oluwafemi JacobA and IBRAHIM Waliyat OlabisiB (2015), An Expert System

for Diagonising and Troubleshooting Radio Transmitter Faults. International Journal of Computer

Systems (ISSN: 2394-1065), Volume 02– Issue 06.

C.Angeli., “Diagnostic Expert Systems: From Experts a. Knowledge to Real –Time Systems.”

Advanced Knowledge Based Systems: Model, Applications & Research. Vol.1. PP 50- b. 73,

2010.

D.V. Kodavade and S.D.Apte, (2011) Troubleshooting Microprocessor Based System Using An

Object Oriented Expert System. (IJACSA) International Journal of Advanced Computer Science

and Applications, Vol. 3, No.5, 2011

49
Dattatraya Vishnu Kodavade, Shaila Dinakar Apte (2012), A Universal Object Oriented Expert

System Frame Work for Fault Diagnosis. International Journal of Intelligence Science, 2012, 2,

63-70.

Davood Ekhtiyarzadeh and Reza Radfar (2015) Designing An Expert System For Internet

Connection Problems Troubleshooting For Wired Network Users. International Journal of

Information, Security and System Management, 2015, Vol.4, No.2, pp. 476-487.

George. F Luger, Artificial intelligence; structures and strategy for complex problem solving. 6th

edition, Pearson Education 2009.

K.Selvani Deepthi, D.Srinivasa Rao, T.Naresh Kumar, L.Sugunakar Naidu (2011)

Troubleshooting Wireless Mesh Networks Using Rule-Based Expert System. International Journal

of Electronics & Communication Technology IJECT Vol. 2, Issue 2, June 2011.

Mohd Helmy Abd Wahab, Nurazzah Abu Bakar, Mohamad Farhan Mohamad Mohsin (2009)

Designing a Web-based Network Troubleshooting Expert Systems FKEE Compilation of Papers

2009.

Nalepa, G.J., Bobek, S.: Rule-based solution for context-aware reasoning on mobile devices.

Computer Science and Information Systems 11 (2014) 171–193.

Narendra Dev and Bart Anderson, (1997) Pimtool, an Expert System to Troubleshoot Computer

Hardware Failures: IAAI-97 Proceedings. Copyright © 1997, AAAI (www.aaai.org). All rights

reserved.

50
Piotr Golanski and Przemysław Madrzycki, (2015) Use of the Expert Methods In Computer Based

Maintenance Support Of The M-28 Aircraft, Zeszyty Naukowe AMW — Scientific Journal of

PNA 2015.

Samy S. Abu Naser and Abu Zaiter A. Ola (2008), AN EXPERT SYSTEM FOR DIAGNOSING

EYE DISEASES USING CLIPS. Journal of Theoretical and Applied Information Technology.

Sourav Mandal, Sumanta Chatterjee, Biswarup Neogi, (2013) Diagnosis and Troubleshooting of

Computer Faults, Based on Expert System and Artificial. Intelligence International Journal of Pure

and Applied Mathematics Volume 83 No. 5 2013, 717-729.

Stuart J. Russell and Peter Norvig, Artificial-Intelligence, A Modern Approach.Prentice-Hall-

2010.

Swati Gupta, Ritika Singhal (2012), Fundamentals and Characteristics of an Expert System.

International Journal on Recent and Innovation Trends in Computing and Communication ISSN

2321 – 8169 Volume: 1 Issue: 3, 110 – 113.

Sylvester I. Ele and Adesola W.A, 2013 Design Of Computer Fault Diagnosis And

Troubleshooting System (Cfdts): West African Journal of Industrial and Academic Research Vol.9

No.1 December 2013.

Yan C., Ma S., Zhou G., Fang J., Fault Diagnostic Expert System of Rolling Element Bearing

Based on CLIPS, ‘Journal of Information and Computational Science’, 2013, Vol. 10, No. 10, pp.

3053–3062 [available online], http://www.joics.com, pdf, [access 16.03.2015].

51
 APPENDIX

Code snippet for inference engine

package pcrestore; jPanel1 = new javax.swing.JPanel();

import javax.swing.BorderFactory; jbPower = new javax.swing.JButton();

import javax.swing.JDialog; jbPerformance = new

javax.swing.JButton();
import javax.swing.JOptionPane;

jLabel1 = new javax.swing.JLabel();

* @author AKAN David

jScrollPane3 = new
*/
javax.swing.JScrollPane();
public class pcrestoreFrame extends
jlistQuestion = new
javax.swing.JFrame {
javax.swing.JList<String>();
Result rs = new Result();
jbSubmit = new javax.swing.JButton();
Knowledge kb = new Knowledge();
setDefaultCloseOperation(javax.swing.Window
private String[] dlist =
Constants.EXIT_ON_CLOSE);
{"jamee","johnny","peter"};
jbPower.setText("Power");
private String selected;
jbPower.setPreferredSize(new
private String issue;
java.awt.Dimension(100, 50));

/* Creates new form pcrestoreFrame */

jbPower.addActionListener(new

public pcrestoreFrame() { java.awt.event.ActionListener() {

initComponents(); }

private void initComponents() {

52
 public void jlistQuestion.setFixedCellWidth(600);

actionPerformed(java.awt.event.ActionEvent
jlistQuestion.setFocusCycleRoot(true);
evt) { jbPowerActionPerformed(evt); }
jlistQuestion.setOpaque(false);
});
jScrollPane3.setViewportView(jlistQuestion);
jbPerformance.setText("Performance");

jbPerformance.setPreferredSize(new jbSubmit.setText("SUBMIT");

java.awt.Dimension(100, 50)); jbSubmit.addActionListener(new

jbPerformance.addActionListener(new java.awt.event.ActionListener() {

java.awt.event.ActionListener() { public void

public void actionPerformed(java.awt.event.ActionEvent

actionPerformed(java.awt.event.ActionEvent evt) { jbSubmitActionPerformed(evt);

evt) { } });
jbPerformanceActionPerformed(evt); } });
javax.swing.GroupLayout jPanel1Layout =
jLabel1.setText("QUESTION"); new javax.swing.GroupLayout(jPanel1);
jlistQuestion.setBorder(javax.swing.BorderFacto
jPanel1.setLayout(jPanel1Layout);
ry.createBevelBorder(javax.swing.border.Bevel
jPanel1Layout.setHorizontalGroup(jPanel1Layo
Border.RAISED));
ut.createParallelGroup(javax.swing.GroupLayou
jlistQuestion.setFont(new
t.Alignment.LEADING).addGroup(jPanel1Layout.
java.awt.Font("Tahoma", 0, 14)); // NOI18N
createSequentialGroup() .addGap(21, 21,
jlistQuestion.setCursor(new 21).addGroup(jPanel1Layout.createParallelGrou
java.awt.Cursor(java.awt.Cursor.DEFAULT_CURS p(javax.swing.GroupLayout.Alignment.LEADING
OR)); )

53
.addGroup(javax.swing.GroupLayout.Alignment. 849,javax.swing.GroupLayout.PREFERRED_SIZE)

TRAILING, ).addContainerGap().addGroup(javax.swing.Gro

jPanel1Layout.createSequentialGroup() upLayout.Alignment.TRAILING,

jPanel1Layout.createSequentialGroup().addCo
.addGroup(jPanel1Layout.createParallelGroup(j
mponent(jbSubmit).addGap(395, 395, 395))))
avax.swing.GroupLayout.Alignment.LEADING)

.addGroup(javax.swing.GroupLayout.Alignment. );

TRAILING,
jPanel1Layout.setVerticalGroup(jPanel1Layout.c
jPanel1Layout.createSequentialGroup().addGro
reateParallelGroup(javax.swing.GroupLayout.Ali
up(jPanel1Layout.createParallelGroup(javax.swi
gnment.LEADING).addGroup(jPanel1Layout.cre
ng.GroupLayout.Alignment.TRAILING).addComp
ateSequentialGroup().addGroup(jPanel1Layout.
onent(jbPerformance,javax.swing.GroupLayout.
createParallelGroup(javax.swing.GroupLayout.A
PREFERRED_SIZE,javax.swing.GroupLayout.DEF
lignment.LEADING)
AULT_SIZE,javax.swing.GroupLayout.PREFERRE
addGroup(jPanel1Layout.createSequentialGrou
D_SIZE).addComponent(jbPower,javax.swing.Gr
p().addContainerGap(46,
oupLayout.PREFERRED_SIZE,javax.swing.GroupL
Short.MAX_VALUE).addComponent(jLabel1)
ayout.DEFAULT_SIZE,javax.swing.GroupLayout.
.addPreferredGap(javax.swing.LayoutStyle.Com
PREFERRED_SIZE)).addGap(18, 18,
ponentPlacement.UNRELATED)
Short.MAX_VALUE).addComponent(jScrollPane
.addComponent(jScrollPane3,
3,
javax.swing.GroupLayout.PREFERRED_SIZE, 517,
javax.swing.GroupLayout.PREFERRED_SIZE,849,j
javax.swing.GroupLayout.PREFERRED_SIZE).add
avax.swing.GroupLayout.PREFERRED_SIZE)).add
PreferredGap(javax.swing.LayoutStyle.Compon
Component(jLabel1,
entPlacement.UNRELATED).addComponent(jbS
javax.swing.GroupLayout.Alignment.TRAILING,
ubmit)).addGroup(jPanel1Layout.createSequent
javax.swing.GroupLayout.PREFERRED_SIZE,

54
ialGroup().addGap(59,59,59).addComponent(jb javax.swing.GroupLayout.DEFAULT_SIZE,

Power,javax.swing.GroupLayout.PREFERRED_SI javax.swing.GroupLayout.PREFERRED_SIZE)));

ZE, javax.swing.GroupLayout.DEFAULT_SIZE,
layout.setVerticalGroup(layout.createParallelGr
javax.swing.GroupLayout.PREFERRED_SIZE)
oup(javax.swing.GroupLayout.Alignment.LEADI
.addPreferredGap(javax.swing.LayoutStyle.Com
NG)
ponentPlacement.UNRELATED).addComponent(
.addGroup(layout.createSequentialGroup()
jbPerformance,
.addComponent(jPanel1,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE)))
Short.MAX_VALUE)
.addGap(41, 41, 41)) );
.addContainerGap())
javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane()); );

jPanel1.getAccessibleContext().setAccessibleNa
getContentPane().setLayout(layout);
me("");
layout.setHorizontalGroup(
jPanel1.getAccessibleContext().setAccessibleDe
layout.createParallelGroup(javax.swing.GroupLa
scription("");
yout.Alignment.LEADING)
pack();
.addGroup(javax.swing.GroupLayout.Alignment.

TRAILING, layout.createSequentialGroup() }// </editor-fold>

.addGap(0, 8, Short.MAX_VALUE) private void

jbPerformanceActionPerformed(java.awt.event.
.addComponent(jPanel1,
ActionEvent evt) {
javax.swing.GroupLayout.PREFERRED_SIZE,

issue = "performance";

55
 setList(kb.getPerformanceProblems()); elected()));

jlistQuestion.setBorder(BorderFactory.createEm rs.setSolutionText(kb.getPerformanceSolutions(

ptyBorder(10, 10, 10, 100)); getSelected())); }

} rs.setVisible(true);}

private void private String getSelected(){

jbPowerActionPerformed(java.awt.event.Action
selected = jlistQuestion.getSelectedValue();
Event evt) { issue = "power";
return selected;
jlistQuestion.setBorder(BorderFactory.createEm

ptyBorder(10, 10, 10, 100)); }

setList(kb.getPowerProblems()); public static void main(String args[]) {

} JOptionPane.showMessageDialog(null,

"Welcome to PCRestore. "+ "Instruction:

private void
Choose the appropriate category for the
jbSubmitActionPerformed(java.awt.event.Actio
problem you have and select the specific
nEvent evt) {
problem","PCRestore",
if(issue.equalsIgnoreCase("power"))
JOptionPane.PLAIN_MESSAGE);

{rs.setCauseText(kb.getPowerCauses(getSelecte
try {
d()));
for(javax.swing.UIManager.LookAndFeelInfo
rs.setSolutionText(kb.getPowerSolutions(getSel
info :
ected()));
javax.swing.UIManager.getInstalledLookAndFee

} else ls()) { if ("Nimbus".equals(info.getName())) {

if(issue.equalsIgnoreCase("performance")){ javax.swing.UIManager.setLookAndFeel(info.get

rs.setCauseText(kb.getPerformanceCauses(getS ClassName());

56
break;}} /* Create and display the form */

java.awt.EventQueue.invokeLater(new
} catch (ClassNotFoundException ex) {
Runnable() {
java.util.logging.Logger.getLogger(pcrestoreFra

me.class.getName()).log(java.util.logging.Level.S public void run() {

EVERE, null, ex);

new pcrestoreFrame().setVisible(true);}

} catch (InstantiationException ex) {

});
java.util.logging.Logger.getLogger(pcrestoreFra
} private void setList(String[] s){
me.class.getName()).log(java.util.logging.Level.S
jlistQuestion.setListData(s);
EVERE, null, ex);

}
} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(pcrestoreFra private javax.swing.JLabel jLabel1;

me.class.getName()).log(java.util.logging.Level.S private javax.swing.JPanel jPanel1;

EVERE, null, ex);}
private javax.swing.JScrollPane jScrollPane3;
catch
private javax.swing.JButton jbPerformance;
(javax.swing.UnsupportedLookAndFeelExceptio
private javax.swing.JButton jbPower;
n ex) {

java.util.logging.Logger.getLogger(pcrestoreFra private javax.swing.JButton jbSubmit;

me.class.getName()).log(java.util.logging.Level.S
private javax.swing.JList<String> jlistQuestion;
EVERE, null, ex); }
private JDialog Welcome;}

57