2.1. What is a Programming Language
There are many definitions of what constitutes a programming language, and none of these is the correct answer. What might have defined a programming language in the 19th century would not necessarily be detailed enough for a modern definition. Programming languages are needed to allow human beings and computers to talk to each other. Computers, as yet, are unable to understand our everyday language or, in fact, the way we talk about the world. Computers understand logic expressed mathematically through what is known as machine code. Computer language consists of 1s and 0s or the binary system, which the majority of human beings would find very difficult to communicate in. Computer languages enable humans to write in a form that is more compatible with a human system of communication. This is then translated into a form that the computer can understand. Here are some different ideas on what constitutes a programming language.
A programming language has been defined as a tool to help the programmer.
A way of writing that can be read by both a human being and a machine.
A sequence of instructions for the machine to carry out.
A way for a human being to communicate with a machine that is unable to understand natural language.
A computer language offers a means of writing algorithms that can be understood by both human being and machine. Machines are unable to understand natural language, so a human being uses algorithms that are translated into machine code by the programming language. Machine code is difficult for humans to use, so a language translates human readable language into machine readable form.
A computer program offers humans a standard way of expressing algorithms to solve particular problems. As languages offer a convention it allows other humans to read the program, and change it if they need to.

2.2. Types of Programming Languages
There are three levels of programming languages;
Machine language (low level language)
Assembly (or symbolic) language
Procedure-oriented language (high level language)

2.2.1. Machine language
The lowest-level programming language (except for computers that utilize programmable microcode) Machine languages are the only languages understood by computers. While easily understood by computers, machine languages are almost impossible for humans to use because they consist entirely of numbers. It is a programming language in which the instructions are in a form that allows the computer to perform them immediately, without any further translation being required. Instructions are in the form of a Binary code also called machine code and are called machine instructions. Commonly referred to as the First Generation language

2.2.2. Assembly Language
Introduced in 1950s, reduced programming complexity and provided some standardization to build and applications. Also referred to second generation language. The 1 and 0 in machine language are replaced by with abbreviations or mnemonic code. It consists of a series of instructions and mnemonics that correspond to a stream of executable instructions. It is converted into machine code with the help of an assembler. Common features includes;
Mnemonic code; used in place of the operation code part of the instruction eg SUB for substract, which are fairly easy to remember
Symbolic Addresses which are used in place of actual machine addresses. A programmer can choose a symbol and use it consistently to refer to one particular item of data. Example FNO to represent First No.
The symbolically written program has to be translated into machine language before being used operationally. A 1 to 1 translation to machine language, ie one symbolic instruction produces one machine instruction/code.

Advantages of Assembly language over machine language
It is easy to locate and identify syntax errors, thus it is easy to debug it.
It is easier to develop a computer application using assembly language in comparison with machine language
Assembly language operates very efficiently.

2.2.3. High level language
A Machine independent and a Problem oriented (POL) programming language. High level language is portable across different machine types (architectures); The machine independence of the high level languages means that in principle it should be possible to make the same high-level language run on different machines. It reflects the type of problem solved rather than the features of the machine.

High level languages are more abstract, easier to use and more portable across platforms as compared to low-level programming languages. A programmer uses variables, arrays or Boolean expressions to develop the logic to solve a problem. Source programs are written in statements akin to English. A high level language code is executed by translating it into the corresponding machine language code with the help of a compiler or interpreter. High level languages can be classified into the following categories;
Procedure-oriented languages (third generation)
Problem-oriented languages (fourth generation)
Natural languages (fifth generation).

Procedure languages.
High-level languages designed to solve general-purpose problems, example BASIC, COBOL, FORTRAN, C, C++ and JAVA. They are designed to express the logic and procedure of a problem. Though the syntax of the languages may be different, they use English-like commands that are easy to follow. They are portable.

Problem-oriented languages
Problem-oriented languages also known as Fourth Generation Languages (4GL) are used to solve specific problems and includes query languages, report generators and Application generators which have simple English like syntax rules. The 4GLs have reduced programming efforts and overall cost of software development. They use either visual environment or a text environment for program development similar to that of third-generation languages. A single statement of the 4GL can perform the same task as multiple line of a third-generation language. It allows a program to just drag and drop from the toolbar, to create various items like buttons, text boxes, label etc. A program can quickly create a prototype of the software applications

Natural Languages
Natural languages widely known as fifth generation languages, are designed to make a computer to behave like an expert and solve problems. The programmer just needs to specify the problem and the constraints for problem solving. Natural languages such as LISP and PROLOG are mainly used to develop artificial intelligence and expert systems.

Features of high level language
Extensive vocabulary of words, symbols and sentences
Whole sentences are translated into many machine codes instructions
Portable across different machine types (architectures)
Libraries of macros and sub-routines can be incorporated
As they are problem oriented, the programmer is able to work at least to some extent independently of the machine.
Have a set of rules that must be obeyed.
Syntax: the structure of the statements and the grammatical rules governing them. Grammatical rules that govern the way in which words, symbols, expressions and statements may be formed and combined.
Semantics: the meaning of the statements written in the language. The rules that governs its meaning. what happens when the program is executed/run most are standardized by ISO/ANSI to provide an official description of the language

2.3. High Level language Translation
High level languages need to be translated into machine language which is the computer language. The translation is done by a Compiler or Interpreter

2.3.1. Compiler
A compiler is a manufacturer specifically written computer program which translates (or compiles) a source code computer program that translates the source code written in a high level language into the corresponding object code of the low level language. The translation process is called compilation. The entire high level source code / program is converted into the executable machine code file prior to the object program being loaded into main memory and executed. Translation done only ones and the object program can be loaded into the main storage and executed. A program that translates a low-level language into a high level language is called a Decompiler. Compiled languages includes C, C++, COBOL, FORTRAN etc.

Compilers are classified into single-Pass compilers and Multi-pass compilers. Single-pass compilers are generally faster than multi-pas compilers, but multi-pass compilers are required to generate high quality code

A Compiler:
Translates the source program code into machine code
Includes linkages for closed sub-routine
Allocates areas of main storage
Produces the object program.
Produces a printed copy (listing) of the source code and object code
Produces a list of errors found during compilation.

2.3.2. Interpreter:
The interpreter is a translation program that converts each high-level language statement into the corresponding machine code. The translation process is carried out just before the program statement is executed. Instead of the entire program, one program statement at a time is translated and executed immediately. When using an interpreter, the source code translated every time the program is executed

The commonly interpreted languages include BASIC and PERL. Though interpreters are easier to create as compared to compilers, the compiled languages can be executed more efficiently and are faster. Interpreters are appropriate in;
Handling user commands in an interactive system
Debugging programs as they run (removing program faults).
Handling software produced for or by a different computer.

2.4. Computer Program Compilation Process
A computer program compilation process involves the following five stages;
Lexical analysis: the source program is transformed into tokens. During the transformation all whitespaces and comments are discarded. All character sequences that do not form valid tokens are discarded and an error message is generated.
Syntactical analysis: analysis to ensure the program syntax is appropriate to the language. Failure results in an error message been generated.
Type / Semantic checking: responsible for ensuring that the compile-time semantic rules of the language are enforced. An error message is generated if the semantic rules are violated
Code optimization: improves the intermediate code based on the target machine architecture
Code generation: target machine code is generated.

The first three stages are concerned with finding and reporting errors to the programmer, while the last two are concerned with generating efficient machine code to run on the targeted computer.

Source Machine
Code Code

2.5. Evaluating Languages
Programming languages can be evaluated from a number of viewpoints, depending on either the programmer, the environment in which the programmer works or the standards of the organisation. When developing software, a programmer should consider which language is most suitable to the task, rather than relying on a language with which they are familiar. You wouldnt want to use a spreadsheet to develop a database. All the features of the language need to be considered rather than just one particular feature. A wrong choice can mean that the software has to be re-written, which can be very frustrating and time consuming.

There are a number of different ways that the programmer can think about the design of the system, from the top-down of structured programming to object oriented design issues. Some languages are geared towards one particular style of design, whilst others incorporate many types. Each of these language paradigms enables the programmer to consider the problem from a different viewpoint. There are a few basic questions that can be asked to help when making these decisions:

How readable is the language, to humans? If parts of the program are going to be read or altered separately from the entire program is might be worth considering how legible they are going to be. It is also useful to consider the length of names allowed in the language, for instance an early form of Fortran allowed for only 6 characters. This can lead to clumsy abbreviations that are difficult to read. Statements such as GO TO, FOR, WHILE and LOOP have increased the readability of programs, and lead to neater programs. These statements also affect the syntax or grammar.
When it comes to writing the program, how easy is it to write the program in this particular language? A programming language that is easy to write in can make the process easier and faster. It may help to reduce mistakes. FOR loops and other types of statement allow the programmer to write much simpler code. This will save time and money, and also make the program smaller.
How reliable is the language? Not all languages create robust programs, and some help the programmer to avoid making errors. A program that is not robust can cause errors, and code can decay. Any language that helps the programmer to avoid mistakes will make it easier to use.
How much would it cost to develop using a given language? Is the language expensive to use and to maintain? Programs may need to be updated or redeveloped, and an expensive language may make this prohibitive.
How complicated is the syntax going to be? Syntax is an important consideration. Clarity and ease of understanding are important, as is a syntax that seems logical and sensible. Errors are very likely to occur where one area of syntax too closely resembles another, and the program may prove difficult to debug. Some theorists reason that if it is difficult to write a program to parse the language, then it follows that it will be problematical for the programmer to get it right.
Does the language have standards? Languages that have standards for writing programs have greater readability; for instance Java has standards for naming, commenting and capitalization.

2.6. The Programming Language Generations
The language generations span many decades, and begin with the development of machine code. Each generation adds new features and capabilities for the programmer to use. Languages are designed to create programs of a particular type, or to deal with particular problems. Modern languages have led to the development of completely different styles of programming involving the use of more human-like or natural language and re-usable pieces of code.
The first generation of languages was machine language. Instructions and addresses were numerical. These programs were linked to the machine they were developed on.
The second generation allowed symbolic instructions and addresses. The program was translated by an assembler. Languages of this generation include IBM, BAL, and VAX Macro. These languages were still dependent on the machine they were developed on.
Third generation languages allowed the programmer to concentrate on the problem rather than the machine they were writing for. Other innovations included structured programming and database management systems. 3GL languages include FORTRAN, COBOL, Pascal, Ada, C, and BASIC. All 3GL languages are much easier for the human being to understand.
4GL languages (fourth generation). These are known as non-procedural, they concentrate on what you want to do rather than how you are going to do it. 4GL languages include SQL, Postscript, and relational database orientated languages.
5GL (fifth generation). These languages did not appear until the 1990s, and have primarily been concerned with Artificial Intelligence and Fuzzy Logic. The programs that have been developed in these languages have explored Natural Language (making the computer seem to communicate like a human being).

Chapter Review Questions
Describe the C program compilation process
What criteria should a programmer use to evaluate a programming language
What are advantages of High-level languages over the Assembly language.
Describe the categories of the high-level languages

1.2. Problem Solving with Computer;
There are a number of concepts of relevance to problem solving using computers. Two particular concepts includes computability and complexity. A problem is said to be computable if it can in principle be performed by a machine. Some mathematical functions are not computable. The complexity of a problem is measured in terms of resources required, time and storage

The steps involved in solving a problem using a computer program includes;
Step 1. Define the Problem: State in the clearest possible terms the problem you wish to solve. It is impossible to write a computer program to solve a problem that has been ambiguously or imprecisely stated.
Step 2. Devise an Algorithm: An algorithm is a step-by-step procedure for solving the problem. Each of the steps must be a simple operation which the computer is capable of doing. A universally-used representation of an algorithm is a flowchart or flow diagram, in which boxes representing procedural steps are connected by arrows indicating the proper sequence of the steps. In many problems you will need to define a mathematical procedure, expressed in strictly numerical terms since the use of computers to do higher level analytic processes such as solving algebraic equations or doing integrals in a non-numerical fashion is relatively limited. The Algorithm can also be represented using Pseudo-code
Step 3. Code the Program: The steps in an algorithm, translated into a series of instructions to the computer, comprise the computer program. There are many languages in which computer programs can be coded, each with its own syntax, vocabulary, and special features.
Step 4. Debug the Program: Most programs of any length don’t work properly the first time they are run and must therefore be debugged.” Often, during the debugging phase, errors and ambiguities in the original statement of the problem reveal themselves, calling for basic revisions in the solution algorithm.
Step 5. Run the Program: After the program has been fully debugged you run it, possibly using many sets of input data. This step may take anywhere from a few seconds to many hours depending on the complexity of the problem and the speed of the computer.
Step 6. Analyze the Results: Often the output from a computer program requires considerable further analysis. In some cases, even though the program worked perfectly, you may find that you solved the wrong” problem. There is an acronym well known to computer users: GIGO, which stands for garbage in, garbage out.”

1.2.1. Problem Algorithm
An Algorithm is a logical sequence of discrete steps that describe a complete solution to a given problem in a finite amount of time independently of the software or hardware of the computer. It is the set of rules that define how a particular problem can be solved in finite number of steps. Algorithms are very essential as they instructs the computer what specific steps it needs to perform to carry out a particular task or solve a problem. Every algorithm should have the following five characteristics: Input, Output, Definiteness, Effectiveness and Termination. An Algorithm has the following properties;
It must be precise and unambiguous
It must give the correct solution in all cases
It must eventually end.

Efficiency and Analysis of the Algorithm
The efficiency of an Algorithm means how fast it can produce the correct results for the given problem. The Algorithm efficiency depends upon its time complexity and space complexity. The complexity of an algorithm is a function that provides the running time and space for data, depending on the size provided by us. Two important factors for judging the complexity of an Algorithm are; space complexity which refers to the amount of memory required by the algorithm for it execution and generation of the final output and time Complexity which refers to the amount of computer time required by an algorithm for its execution, which includes both the compile time and run time. The compile time of an algorithm does not depend on the instance characteristics of the algorithm. The run time of an algorithm is estimated by determining the number of various operation, such as addition, subtraction, multiplication, division, load and store executed by it.

The analysis of an algorithm determines the amount of resources, such as time and space required by it for its execution. Generally, the algorithms are formulated to work with the inputs or arbitrary length. Algorithm analysis provides theoretical estimates required by an algorithm to solve a problem. The steps of an Algorithm, they can be presented using Flow charts and pseudo-codes.

1.3. Flow Charts
A flow chart is a traditional means of showing in diagrammatic form, the sequence of steps to be undertaken in solving a problem. Flowcharts or flow diagrams are important tools in writing a computer program. A flowchart allows you to plan the sequence of steps in a program before writing it. The flowchart serves as a visual representation which many programmers find indispensable in planning any program of at least moderate complexity.

1.3.1. Elements of a Flowchart.
A flowchart consists of a set of boxes, the shapes of which indicate specific operations. The separate boxes are connected with arrows to show the sequences in which the various operations are performed. We use these standard symbols:

Shape
Name
Description

Rectangle
Process symbol: Used to represent any kind of processing activity. Details are written in the box

Diamond:
The decision Symbol: Used where a decision has to be made in selecting the subsequent path to be followed.

Used to show the flow/ path of ma sequence of symbols.
Vertical line without arrow head are assumes t flow top to bottom.
Horizontal lines without arrow heads are assumed to flow left to right.
Every operation box must have at least one incoming or outgoing arrow. Any arrow leaving a decision box must be labeled with the decision result which will cause that path to be followed.

Parallelogram
Input/output symbol: Used where data input is to be performed

Oval
The Terminal symbol: Used as the first or last symbol in a program or separately drawn program module

Or

Small Circle
Connector symbol:

Exit to or entry from another part of the chart

Used to add explanatory notes or description,

Stages of Flow charting
Program flowcharts are generally produced in two stages representing different levels of details. The first step produces the outline program flow chart which represents the first stage of turning the systems flow charts into the necessary detail to enable the programmer to write the programs. It represents the actual computer operations in an outline only. The second step produces the detailed program flow chart which is prepared from the outline charts and contains the detailed computer steps necessary to perform a particular task. It is from this charts that the programmer will prepare the program code

Limitations of program flowcharts
Not easily translated into programming language.

1.4. Pseudo code
An alternative method of representing an Algorithm to the flowcharts. Pseudo code is halfway between English and programming language and is based upon a few simple grammatical construction which avoid the ambiguities of English but which can be easily converted into computer programming language. Pseudo code is an informal high-level description of a computer programming algorithm, which omits details that are not essential for human understanding of the algorithm, is easier for humans to understand than conventional programming language code, is compact and environment-independent description of the key principles of an algorithm and resembles skeleton programs including dummy code and can be compiled without errors.

Pseudo code assumes that programming procedures no matter how complex may be reduced to a combination of controlled sequences, selection, or repetition of basic operations. This gives rise to the control structures found in pseudo-code.

1.5. Program Control Structures
Control Structure
Pseudo code
Flow Chart

Sequence:
In the absence of selection, or repetition, program statements are executed in the sequence in which the appear in the program
1st Instruction

2nd Instruction

3rd Instruction

Selection
Part of decision making and allows alternative actions to be taken according to the conditions that exist at particular stages in program execution

IF
condition
THEN
actions
ELSE
actions
ENDIF
Or

CASE
a). Actions
b). Actions
c). Actions
d). Actions
ENDCASE

Repetition also called looping
There are many programming problems in which the same sequence of statements needs to be performed again and again for a definite or indefinite number of times

WHILE
condition
DO
Actions
ENDWHILE

REPEAT
actions
UNTIL
condition

1.6. Programming Methods
1.6.1 Top-down and Bottom-up methodology
A top-down approach (is also known as step-wise design) is essentially the breaking down of a system to gain insight into its compositional sub-systems. In a top-down approach an overview of the system is formulated, specifying but not detailing any first-level subsystems. Each subsystem is then refined in yet greater detail, sometimes in many additional subsystem levels, until the entire specification is reduced to base elements. A top-down model is often specified with the assistance of “black boxes”, these make it easier to manipulate. However, black boxes may fail to elucidate elementary mechanisms or be detailed enough to realistically validate the model.

Top-down-design starts with a description of the overall system and usually consists of a hierarchical structure which contains more detailed descriptions of the system at each lower level. The lower level design details continue until further subdivision is no longer possible, i.e., until the system is described in terms of its “atomic” parts. This method involves a hierarchical or tree-like structure for a system as illustrated by the following diagram:

At the top level, we have that part of the system which deals with the overall system; a kind of system overview or main top-level module.

Top down programming method process
Define exactly what data the program will get and what it has to do with them.
If the task is simple enough, write the program code.
Otherwise, split the task into smaller parts and define exactly the duty of each part and interface to the rest of the program.
Repeat the steps 14 separately for each subtask.

Advantages of the Top-Down Design Method
It is easier to comprehend the solution of a smaller and less complicated problem than to grasp the solution of a large and complex problem. Separating the low level work from the higher level abstractions leads to a modular design. Modular design means development can be self contained. Much less time consuming (each programmer is only involved in a part of the big project).
It is easier to test segments of solutions, rather than the entire solution at once. This method allows one to test the solution of each sub-problem separately until the entire solution has been tested.
It is often possible to simplify the logical steps of each sub-problem, so that when taken as a whole, the entire solution has less complex logic and hence easier to develop. A simplified solution takes less time to develop and will be more readable.
The program will be easier to maintain. If errors occur in the output it is easy to identify the errors generated from each of the modules / sub-programs of the entire program.

A bottom-up approach is the piecing together of systems to give rise to grander systems, thus making the original systems sub-systems of the emergent system. In a bottom-up approach the individual base elements of the system are first specified in great detail. These elements are then linked together to form larger subsystems, which then in turn are linked, sometimes in many levels, until a complete top-level system is formed. This strategy often resembles a “seed” model, whereby the beginnings are small but eventually grow in complexity and completeness. However, “organic strategies” may result in a tangle of elements and subsystems, developed in isolation and subject to local optimization as opposed to meeting a global purpose.

Top-down is a programming style, the mainstay of traditional procedural languages, in which design begins by specifying complex pieces and then dividing them into successively smaller pieces. The technique for writing a program using top-down methods is to write a main procedure that names all the major functions it will need. Later, the programming team looks at the requirements of each of those functions and the process is repeated. These compartmentalized sub-routines eventually will perform actions so simple they can be easily and concisely coded. When all the various sub-routines have been coded the program is ready for testing. By defining how the application comes together at a high level, lower level work can be self-contained. By defining how the lower level abstractions are expected to integrate into higher level ones, interfaces become clearly defined.

Top-down approaches emphasize planning and a complete understanding of the system. It is inherent that no coding can begin until a sufficient level of detail has been reached in the design of at least some part of the system. The Top-Down Approach is done by attaching the stubs in place of the module. This, however, delays testing of the ultimate functional units of a system until significant design is complete. Bottom-up emphasizes coding and early testing, which can begin as soon as the first module has been specified. This approach, however, runs the risk that modules may be coded without having a clear idea of how they link to other parts of the system, and that such linking may not be as easy as first thought. Re-usability of code is one of the main benefits of the bottom-up approach

1.6.2. Structured programming Method
Structured programming is a special type of procedural programming. It provides additional tools to manage the problems that larger programs were creating. Structured programming requires that programmers break program structure into small pieces of code that are easily understood. It also frowns upon the use of global variables and instead uses variables local to each subroutine.

Structured programming was developed during the 1950s after Edgar Dijkstras insightful comments into the harmful nature of the GO TO statement. Dijkstra and others subsequently created a set of acceptable structures in programming that would enable development without GO TO statements. These structures produced programs that were easier to read by humans, easier to debug and easier to test. These structures have become some of the founding principles of modern programming methods.

Although the principles of structured programming have had a profound effect on the programming world, it was not until the 1970s that an actual language was created for teaching structured programming. Pascal was developed especially for this purpose, though it is much derided as a toy language, and appears to have never been used in commercial development. It appears that existing languages such as COBOL and FORTRAN were changed to accommodate Dijkstras structures, or that programming included these structures through more indirect methods.

Later generation languages such as C are fully-fledged structured programming languages; these are from the third generation and procedural, in that they are both written and executed step-by-step. C, in its turn, has formed the foundation for the object-oriented language C++.

The three structures allowed in structured programming are sequence, selection, and iteration. Structures are also thought of in terms of substitution and combination, i.e. structures can be substituted or combined with other structures as long as the result equals a sequential structure. Structured programming also pays attention to design and testing with emphasis on a top-down approach. The top-down approach uses modularity as a means to ensure that the program is both legible and manageable, and also that these modules can be tested as they are developed. This is beneficial as it ensures that all modules should be tested and that bugs can be found in the modules that have most recently been added or altered.

Structured programming also places emphasis on program documentation, which can be in the form of a chart or the structured coding/listing. This documentation allows for subsequent updating of modules, making these modules easier to locate in the program. Modularity also ensures greater opportunity for re-use of modules during development.

1.7. Programming Aims
Good programming principles and practice aim at producing a program with the following characteristics;
Reliability: the program can be depended upon always to do what it is supposed to do
Maintainability: the program will be easy to change or modify when the need arises
Portability: the program will be transferable to a different computer with a minimum modification.
Readability: the program will be easy for a programmer to read and understand.
Performance: the program causes the tasks to be done quickly and efficiently.
Storage saving: the program is not allowed to be unnecessarily long

1.8. Programming Paradigms
A programming paradigm is a pattern of problem solving thought that underlies a particular genre of programs and languages. Four distinct and fundamental programming paradigms have evolved over the last three decades;
Imperative programming;
Object-oriented programming
Functional programming
Logic Programming;

1.8.1. Imperative programming;
The oldest and the most well-developed, it emerged with the first computers in the 1940s and its elements directly mirror the architectural characteristics of modern computers as well. The program and its variables are stored together and the program contains a series of commands that perform calculations, assign values to variables, retrieve input, produce out, or redirect control elsewhere in the series.

Procedural abstraction is an essential building block for imperative programming as are assignments, loops, sequences, conditional statements and exception handling. Imperative languages also support variable declaration and expressions. The predominant imperative programming languages include Cobol, Fortran, C Ada and Perl.

Commands are normally executed in the order they appear in the memory, while conditional and unconditional branching statements can interrupt this normal flow of execution. Originally the commands included assignment statements, conditional statements and branching statements. The assignments statements provided the ability to dynamically update the value stored in the memory location, while conditional and branching statements could be combined to allow a set of statements to be either skipped or repeatedly executed. The main features of Imperative programming includes;
Control structures;
Input/output
Error and exception handling
Procedural abstraction
Expressions and assignments
Library support for data structures

1.8.2. Object-oriented (OO) programming:
Provides a model in which the program is a collection of objects that interact with each other by passing messages that transform their state. The message passing allows the data objects to become active rather than passive. Object classification, inheritance and message passing are fundamental building blocks for OO programming. Major languages includes, C++, Java and C# .

1.8.3 Functional Programming:
Emerged in the early 1960s and its creation was motivated by the needs of researchers in artificial intelligence and its sub-fields- symbolic computation, theorem proving, rule-based systems and natural language processing. Models a computational problem as a collection of mathematical functions, each with an input (domain) and a result (range) spaces.

1.8.4. Logic Programming
Logic (declarative) programming allows a program to model a problem by declaring what outcome the program should accomplish, rather than how it should be accomplished. Sometimes called rule-based languages, since the programs declarations look more like a set of rules, or constraints on the problem, rather than a sequence of commands to be carried out.

Chapter Review Questions
Describe the processing of solving a problem using computers
Define a problem Algorithm
What are the advantages and disadvantages of using flow-charts to represent problem algorithm
What are the advantages and disadvantages of representing a problem algorithm using pseudo-codes.
A School is interested in computerizing their students grading system which is as follows;
Marks
Grade

80 – 100
A

60 – 79
B

50 – 59
C

40 – 49
D

0 – 39
E

Draw a flow chart to represent the solution.
Represent the solution in pseudo-code.