Professional Documents
Culture Documents
Hard wares are physical parts of a computer system. They are tangible parts. They are classified into input
devices and output devices.
Input devices are:
a) Key board
b) Mouse
c) Scanner etc
Output devices are:
a) Printer
b) Monitor etc
Soft wares
These are sets of programs that are used to tell the computer hardware what to do and how to do it.
They are classified into:
a) System software
b) Application software
c) Programming languages
Types of structured programming languages.
a) Pascal
b) Structured C
c) Cobol
d) Fortran etc
History of programming languages
a. Machine languages
Consists of strings of digits or numbness that instructs the computer to perform a certain operation.
b. Assembly language
Close machine language other than human language. They are symbolic representation of machine
code.
c. High level language it close to human language or syntax. Allows a problem to be specified in a
human understandable and oriented manner. The grammer of high level language is close to human
vocabulary.
They are languages that allow the user of a program to query a database. The syntax of 4 th generation
languages is natural and user friendly. Uses menus to prompt a non-specialist to retrieve data with
easy.
These are languages that will allow program developed to mimic and copy human characters. Most of
them are still under development. E.g. Expert systems and Artificial intelligence.
Programming paradigms
a. Procedural programming
It combines returning sequences of statements into one program. A procedure call is used to
invoke the procedure to return one or more values.
b. Modular programming
The procedures of common functionalities are grouped together into separate modules. The
program is then divided into several smaller modules which interact through procedure calls and
form a whole program.
c. Unstructured programming
d. Structured programming
Statements in a program are arranged and executed in a specified order. One statement after
another are translated to machine code.
Techniques where objects communicate with one another while don’t know how they are
implemented.
This is an artificial and informal language that helps programmers to develop algorithms. Pseudo
code programs are not executed in the computer. They help a programmer to think out a
problem/program before attempting to write on a computer programming language.
Assignment
Computer hardware and software consideration in structured programming.
a) Hardware requirements
b) Appropriate operating system
a) Flow chart
A flow chart is a graphical method of designing programs. A well-drawn flow chart is also very easy to read
since it basically uses just two symbols, two decision constructs and two iteration constructs.
Start
Decision
Input/process
Output
Stop
Start
Sum = x + y
Sum
Stop
b) Pseudo code
This is an artificial and informal language that helps programmers to develop algorithms. Pseudo code
programs are not executed in the computer. They help a programmer to think out a problem/program
before attempting to write on a computer programming language. Pseudo-Code is simply a numbered
list of instructions to perform some task.
Example 1
Computing Sales Tax of sugar in Fatuma’s shop
Fatuma sales sugar in her shop. The government requires her to pay sales tax after each sale. Design a
Pseudo-code that computes the final price of the sugar after tax has been deducted. Note the three types of
instructions: input (get), process/calculate (=) and output (display).
Solution
1. Get price of item
2. Get sales tax rate
3. Sales tax = price of time times sales tax rate
4 Final prince = price of item plus sales tax
5. Display final price
6. Halt
Example 2
Compute weekly wages of the workers in Kisii coffee Farm.
The pay rate for each worker is Kshs.100 per hour for 8 hours normal hours. The pay rate for overtime is
Kshs.200 per hour. Design a Pseudo-code for the task of computing gross pay given pay rate and hours
worked.
1. Get hours worked
2. Get pay rate
3. If hours worked less than or equal to 8 hours then
4. Gross pay = pay rate times hours worked
5. Else
6 Gross pay = pay rate times hours worked plus overtime hours times overtime pay rate
7. Display gross pay
8. Halt
Condition Stubs
Condition stubs describe the conditions or factors that will affect the decision or policy. They are
listed in the upper section of the decision table.
Action Stubs
Action stubs describe, in the form of statements, the possible policy actions or decisions. They are
listed in the lower section of the decision table.
Rules
Rules describe which actions are to be taken under a specific combination of conditions. They are
specified by first inserting different combinations of condition attribute values and then putting X's in
the appropriate columns of the action section of the table.
1. Identify Conditions & Values Find the data attribute each condition tests and all of the attribute's values.
2. Compute Max Number of Multiply the number of values for each condition data attribute by each
Rules other.
3. Identify Possible Actions Determine each independent action to be taken for the decision or policy.
Fill in the values of the condition data attributes in each numbered rule
4. Enter All Possible Rules
column.
5. Define Actions for each Rule For each rule, mark the appropriate actions with an X in the decision table.
6. Verify the Policy Review completed decision table with end-users.
7. Simplify the Table Eliminate and/or consolidate rules to reduce the number of columns.
Example
A marketing company wishes to construct a decision table to decide how to treat clients according to three
characteristics: Gender, City Dweller, and Age group: A under 30, B between 30 and 60, C over 60. The
company has four products W, X, Y and Z to test market. Product W will appeal to female city dwellers.
Product X will appeal to young females. Product Y will appeal to Male middle aged shoppers who do not live
in cities. Product Z will appeal to all but older females.
A structure is the order in which programs statement in Pascal must follow. Below is the basic structure that
every Pascal program must follow.
Optional comments
Comments address solely the readers of a program. They provide an overview of a program or one of
its components. They also supply the extra information about why a program was constructed.
Comments are enclosed in curly brackets {}. Comments appear anywhere in the program other within
a string constant.
Header
The header identifies the program and is terminated by a semicolon. The header must ahave the
name of the program. And the specification on how to this program interacts with the external data.
E.g.
Var x, y, z: integer;
Declarations can be extensive in programs that are larger or more sophicated. Declarations show and
specify the variables used by the program. It also specifies the dataytypes and constants.
Body of the program
Specifies the actions to be taken when the program executes. Consists of a sequence of statements
separated the semicolons between keywords BEGIN and END.
Statements specify individual steps in computation. A period following the keyword END marks the
end a program.
PROGRAM ProgramName;
Operators in Pascal
An operator is a symbol that is used in a formula to carry out a calculation to get the result.
Types of operators
Mathematical operators
Used to carry out arithmetic functions
Plus (+)
Subtraction (-)
Division (/)
Multiplication (*)
Logical operators
Use to compare two or more values in a program to return value.
=
<
>
<=
>=
<>
Relational operators
Used to compare and relate two or more items in a program.
AND
OR
BETWEEN
IN
LIKE
Data Types
The dataType specifies the kind of data stored by the variable declared. We have two categories of dataType
in Pascal:
Built in dataType
User defined datatype
There are five built in datatype in Pascal: INTEGER, REAL, CHAR, BOOLEAN, and STRING.
INTEGER A positive or negative whole numbers between a smallest (negative) and a largest number. In
general the smallest and largest number possible depends on the machine
smallest Integer: -32766
largest Integer: 32767
REAL Are decimal numbers. They have an integer part and a fractional part. Can contain a real number in
scientific or decimal notation. There is a limit on the size and accuracy of the real number that will
be covered later. Valid real numbers are, for example:
Decimal Notation: 1.234 or -34.5507
Scientific Notation: 5.0E-3 or -7.443E3
CHAR Describes the data consisting of one alphanumeric character such as letter, a digit or special
symbol such as ‘a’,’A’,’8”
BOOLEAN Has only two parts(values) true or false.
STRING A string is a collection of up to 255 characters enclosed in single quotes. For example: 'Bert' is a
Sum:= x+y+z;
Assignments for students
The input data items must be placed in a separate file called input file before the corresponding is run. The
output data are transferred from the computer memory to output file. The data items are stored
sequentially in the order they were stored or written. the items will then be grouped into logical lines
which will be then correspond to physical lines of output when data I printed or displayed. E.g.
Program payroll(input,output);
Read statement
Used to read data items from input file and assign them to an integer, real, char and Boolean type
variables. e.g
Read(x,y,z);
Readln statement
Used to read data items from input file and assign them to an integer, real,
Readln(a,b,c);
The difference between the Readln and read is that the Readln causes the next
Read or Readln statement to begin by reading a new line of data. The read statement allows the next
read or Readln to begin on the same line.
Write statement
Write(‘X’,’X’);
Writeln statement
Identical to write except that the Writeln statements results in and of linedesignation being written
after the last data item.
Program compiling
This involves a process of testing a program in structured programming to check if the program is
error free. It is a process of converting a program from course code to its object equivalent.
Program debugging
This is a process of running (executing) programs to find errors (bugs). The process of finding bugs is
called debugging as mentioned above. Program testing is part of the procedure which ensures that
the program corresponds with original program specification and that it works in the intended
environment.
Test plan
These are the stages involved in testing the programs. They include the following.
1. Deskchecking
After writing the program the programmer goes through the program on a paper to eliminate
any error that might cause extra work later.
After coding the program is checked using the compiler or translator to detect any syntax
error. The programmer corrects these errors and then resubmits the program to the compiler
until the errors are over.
4. Diagnostic procedures
For complex programs diagnostic procedures are used to find logical errors. A trace routine
print the results at each stage to enable errors detected quickly. If the trace routine is not
available, the programmer can insert instructions in the program to print out intermediate
results at key points.
Usually new systems are run parallel with existing system for a short period so that the results
are compared and adjustments made.
Test data
This is the information that is used to test the new system or program. The program tried and executed at
least once every routine through the program and the accuracy of the program is verified to meet the
original design specification.
Dummy data
This is the data input into a system for trial purposes. Used to test the system for correctness.
This includes the general data for which the system was designed.
Exceptional data
Programs are designed to accept certain range of data. If illegal data is input it should be able to
detect and reject it rather than try to process it to avoid getting wrong results.
Logical errors
This is a human error. A programming mistake that makes a program code to output wrong results.
Syntax error
These are an error that violates rules and regulations or the syntax of a language.
Runtime error
Example 1
Using the While-Do statement write a program that prints 10 digits on the screen.
Example 2
Write a program using WHILE-DO iterative control structures that prints two numbers and gets their sum.
Program numbers(input, output);
Var x:integer;
Var sum:integer;
Begin
x:=1;
Sum:=0;
While x<=2 do
begin
x:=x+1;
Sum:=x+sum;
Writeln(sum);
End;
End.
Example 3
Write a program using WHILE-DO iterative control structures that prints six numbers and gets their average.
Program numbers(input, output);
Var x:integer;
Var sum:integer;
Average:real;
Begin
x:=1;
Sum:=0;
While x<=6 do
begin
False
Loop Conditio
n
True
Statements
Example 1
Write a program using REPEAT…..UNTIL iterative control structures that prints two numbers and gets
their sum.
Program numbers(input, output);
Var x:integer;
Var sum:integer;
Begin
x:=1;
Sum:=0;
Repeat
x:=x+1;
Wrteln(sum);
Until x<=10
Sum:=x+sum;
End.
Start
False
Statements
Boolean
expression
True
Using this formula, you can count values from a stating value to an end. To do this, you must first
declare a variable that would hold the count. In our syntax, such a variable would be the Counter
parameter. The InitialValue is a value assigned to the Counter variable as the starting value. The to
keyword is required to proceed with the counting. The counting would stop with the value of the
FinalValue parameter. The value of InitialValue should be lower than that of FinalValue.
The do keyword is required and used to introduce the Statement. After one count, the for loop would
execute the Statement. After executing the Statement, the loop would check whether the count has
reached FinalValue. If it has not, then the InitialValue would be incremented by 1 and the Statement
would be executed again. This checking -> incrementing -> Statement executing would continue until
a new incremented value of InitialValue is equal to the value of FinalValue; in which case the loop
would stop.
Example 1
Program example2(input, output);
var Number: Integer;
sum:integer;
begin
for Number := 0 to 15 do
sum:=x+sum;
Writeln(sum);
Write(Chr(10), 'Press any key to continue...');
Readln;
end.
Example 2
Program example3(input, output);
var Number: Integer;
sum:integer;
average:real;
begin
for Number := 0 to 15 do
sum:=x+sum;
Start
True
x=1 to 10
Loop
Statements
False
Increment operator
If control structure
A conditional control structure that allow some action to be taken if the given logical condition has a
specified value either true or false. The statements wil be executed only if the Boolean expression is true. If
the Boolean expression is false the program ignores the line.
Example 1
program example2(input, output);
var Age : integer;
begin
Write('please enter your age: ');
Readln(age);
If age>=18 then
Writeln(‘You are an adult’);
If age <18 then
Writeln(‘You are young’);
End.
Example 1
Program example1(input,output);
Uses crt;
Var input:string;
Begin
Clrscr;
Writeln(‘Enter the password’);
Readln(input);
If(input=’pascal’) then
Writeln(‘pascal is the easiest structured language to learn!!!!!!!!!!!!!!!!!!’);
If(input=’basic’) then
begin
Writeln(‘basic is not very hard to hard’);
End;
If(input=’0’ then
Writeln(‘wrong password’);
Case syntax:
Case Expression of
Case Choice1:
Statement1;
Case Choice2:
Statement2;
Case Choice-n:
Statement-n;
End.
Example1
Program example1(input,output);
Uses crt;
var Number: Integer;
Answer: Char;
Begin
Clrscr;
Write('Type a number between 1 and 3: ');
Readln(Number);
case Number of
1: Writeln('You typed 1');
2: Writeln('You typed 2');
3: Writeln('You typed 3');
Else
Writeln(‘you entered an invalid number…..’);
end;
Write(Chr(10), 'Press any key to continue....................');
Readln;
end.
Types of subprograms
Functions
A function is an assignment that must be performed to complete a program. Unlike a procedure, a function
must return a value. A self contained program structure that can be called to do an operation and return a
single value to finish execution. Its referenced by specifying the name within the expression as though it was
an ordinary simple type variable. The function name can be be followed by one or more actual parameters
enclosed in paranthesis and separated by commas
Function syntax:
Function FunctionName: ReturnType;
Begin
End;
end;
The begin and end keywords are required because they would enclose the assignment performed by the
function. Between the begin and end keywords, do whatever the function is supposed to do(instructions).
After performing the assignment for function, you must specify what value the function is returning.
A character:
Function ShowSomeCharacter : char;
begin
Result := 'Z';
Function call
Once a function exists or is known, you can call it the same by simply typing its name where the function is
needed. A function returns a value and this can be any values of the dataytypes, but the value must be the
type stated by the ReturnType word.
Because a function returns a value, it can be passed to a Write or a Writeln procedure to display its return
value.
Scope of variables
Variables can be declared in function. These variables belong to the functions in which they are declared.
Local variables
Local variables are accessed anywhere between begin and the matching end keywords. These
variables are only important inside the function.
Example1
Program example1(input, output);
Var x,y:integer;
Function addition;
Var answer:integer;
Begin
Answer:=x+y;
Writeln(‘The answer is: ‘,answer);
End;
Begin
Writeln(‘Please enter the two numbers’);
Readln(x, y);
Addition;
End.
Global variables
Theses are variables declared for the entire program; that is within the block containing the function
declaration. Global variables can be utilized anywhere within the block whether inside or external to the
function.
Procedures
A self contained program structure that can be called to do an operation and return a single value to finish
execution. The procedures make the program easy to debug, understand and use. They also make flexible
the use of parameters.
Procedure structure
Procedure compliment
Begin
Writeln(‘statement’);
Writeln(‘statement’);
End;
Example1
Program example1(input,output);
Var x,y,z:integer;
Procedure largest;
Var max:integer;
Begin
If x>y then max:=x else max:=y;
If x:=max then max:=z;
Example1
Parameter passing
Parameters are those variables that are used to hold data to be passed to the calling statement or procedure.
The process of transferring these parameters is called parameter passing. Arguments are real or actual values
passed to calling statement or procedure.
Types of parameters
Formal parameters
These are labeled memory blank areas that are to be used to store values to be used during execution. They
are identifiers rather than reserved words.
Actual parameters
These are variables that replace the formal parameters when the procedure or function is called. They are
given the actual parameter list of procedure call.
e.g.
program parameter(input,output);
var x,y:integer;
var z,m:integer;
procedure number(x:integer;y:real);
begin
end;
begin
number(3,x*(z+m)/y;
numner(2*(x+y),-0.5);
end.
Note: x and y are value parameter in a procedure.
Variable parameter
Used in applications where binformation must be transferred in both directions between the procedure and
procedure reference. When the procedure containing a variable parameter is accessed the actual parameter
in the procedure refernce is substituted by the formal parameter within the procedure itself.
Assignment to students
Procedure parameters
Function parameters
1. Arrays
This is a consecutive group of memory location that all have the same name and datatype. This is a
list of variables all with the same name and datatype.
When we work with a single item, we only need to use one variable. However, if we a list of items
which are similar in type we need to declare an array of instead of using a variable for each item
variables.
Declaring arrays
Arrays are declared the same way we declare normal arrays except that you have to say how many elements
you have in the array.
e.g.
Example 2
A program that prints an array of ten numbers on the screen.
Program array(input,output);
Var x:array[1..10] of integer;
Var i:integer;
Begin
For i:=1 to 5 do
Readln(x[i]);
Writeln(x[i]);
End.
Example3
A program that prints an array of ten numbers on screen and calculates their sum.
Program arrays(input,output);
Uses crt;
Const students=5;
Var numbers:array[1..5] of integer;
Var total,count:integer;
Var average:real;
Begin
Clrscr;
Total:=0;
For count:=1 to students do
Readln(numbers[count]);
Writeln(numbers[count]);
Total:=total+numbers[count];
Writeln(‘The total is ‘,total);
Average:=total/students;
Writeln(‘The average is ‘,average);
End.
Example 1
Given the following marks achieved in a test, and that the pass mark is the average of all the marks, write a
program to calculate the total marks, average marks and list all those students who have passed.
FRED 21 GEORGE 56
ANNE 52 MARY 89
ROBERT 71 ALFRED 71
CECIL 33 MIKE 54
JENNIFER 41 PAULINE 48
Trees
Trees these are hierarchal data structure constructed using rule of precedence for data items using
alphabetical or numerical sequence. The elements of a tree are called nodes and each element consists of a
datum and at least two pointers.
56 42 89 65 48
56 is the first datum placed I the tree. Its node is therefore called parent node or root node. We add 42 to
the tree next using rule of precedence; lower number to the left and higher number to the right.
Start
56
42 89
-1 48 -1 -1 65 -1
E A
S S J
E H
F
M Q
P
S
K
S
QUEUES
This a chain of of data items in the computer memory awaiting execution. Queues use FIFO, first datum in is
the first datum out.
Characteristics of queues
Data is entered to the end but removed from the front.
The term FIFO is used to describe queues because first datum in is the first datum out.
Each data stays in the storage location until its turn comes thereby reducing time spent in data
movement.
STACKS
They are used too temporarily store information or data. Related to queues but data is removed and added
differently. Data is added at the top and removed from top using LIFO.
Pointers
These are variables that stores memory addresses. They point to a particular address that can be used to
store data items. There are two types of pointers:
Typed pointers
Typed pointers
You declare typed pointers using ^ in front of he variable type which you want to point to. The @ symbol can
also be used in front of a variable to get its memory address. This memory address can be stored in a pointer
because pointers store memory addresses.
e.g.
program pointers;
var x:integer;
p:^integer;
begin
p:=@i;
end.
If you change the value stored at the memory address pointed at by a pointer you must first deference the
pointer variable using ^ after the pointer name.
e.g.
program pointers;
var i:integer;
var p:^integer;
begin
i:=1;
p:=@i;
p^:=2;
writeln(i);
end.
You can allocate new memory to a typed pointer using new command. The new command gets the memory
that is the size of the variable type of the pointer and then sets the pointer to point to a memory address of
it. When you finish using the pointer use dispose command to free the memory that was allocated to the
pointer.
Program pointers;
Var p:^integer;
Begin
Untyped pointers
To declare the untyped pointers you must use the variable type called pinter. To allocate memory to an
untyped pointer you must use the Getmem command instead of new command. You must also use Freemem
command instead of dispose command to free the memory. The Getmem command have a second
parameter which is the size in bytes of the amount of memory which must be allocated to the pointer. You
can either use a number for the size or sizefuction to get the size of a specific variable type.
e.g.
program pointers;
var p:pointer;
begin
getmem(p,sizefunctionof(integer));
freemem(p,sizefunctioof(integer));
end.
Linked lists
Lists are flexible ways of handling data items in order. For example:
Each word in the sentence is a data item, which is linked to the next data item by a pointer. Datum plus a
pointer make a node or element of a list. The last item in the list is a terminator. This may be stored in an
array of records. Each row of an array is one element in the list. A start pointer saying where the first datum
is stored and a free storage pointer saying where the next datum can go.
Head
In order to understand strings, one has to keep in mind that a string is made up of an array of characters. The
string data type is an in-built data type that is an array of 256 characters (Type String = Packed Array[0..255]
of Char). When stored in memory, the processor should know where the string starts and where it finishes.
In order to know where the string finishes, in Pascal, the 0th element of a string is defined as the length of
the string. So, if you try to access character 0 of a string, the number of characters stored in that array is
returned, thus letting the processor to know where the string finishes.
Example 1
Program example1(input,output)
Begin
myString := 'Hey! How are you?';
Writeln('The length of the string is ',byte(myString[0]));
Write(myString[byte(myString[0])]);
Write(' is the last character.');
End.
I have used an automatic data-type conversion, normally referred to as data type-casting. When type-casting
from one data type to another, all that is happening is simply a conversion from one data type to another
based on the data type in subject and the wrapping data type to which the old data type is being converted.
String Functions
There are some basic Pascal functions that have to do with string operations.
Example 1
Program example1(input,output);
Var S: String;
Begin
S:= 'Hey there! How are you?';
Write('The word "How" is found at char index ');
Writeln(Pos('How',S));
If Pos('Why',S) <= 0 then
Writeln('"Why" is not found.');
End.
Example 1
Program example1(input,output);
Var S : String;
Begin
S := 'Hey there! How are you?';
S := Copy(S, 5, 6); { 'there!' }
Write(S);
Deletes a specified number of characters from the string S. The starting position of deletion is from
character index Index. The number of characters that will be deleted is specified through Count. The
new string is passed back through the variable parameter S.
Example 1
Var S: String;
Begin
S:= 'Hey Max! How are you?';
Delete(S, 4, 4); {‘Hey! How are you?’}
Write(S);
End.
Example 1
Program example1(input, output);
Var S: String;
Begin
S: = 'Hey! How are you?';
Insert(S, ' Max', 4);
Write(S);
{‘Hey Max! How are you?’}
End.
Example 2
Example 1
Example 1
Example 1
File concepts
Bit
Byte
(Bits)
Character
(Collection of byte)
Data
(Collection of characters)
Field
(Collection of data)
Record
(Collection of fields)
File
(Collection of related records)
Database
(Structured collection of files)
Types of files
There are different types of files:
Master file
Transaction file
Backup file
Sort file
Etc
FILE DESIGN
To create a file you first declare a variable of that file. After declaration you should assign the file a name
using a command. To create an empty file use rewrite command. To read from an existing file we use reset
command. Use readln to read lines of text from the file. You will also need to use while loop that repeats
until it comes to the end of the file.
Example 1
Program textfile(input, output);
Var Fname, txt: string[10];
Userfile:text;
Begin
Fname:=’textfile’;
Assign(userfile,’c:\’+Fname+’.txt’);
Rewrite(userfile);
Writeln(userfile,’This is structured programming’);
Writeln(userfile,’It is easy to learn and understand’);
Writeln(userfile,’If you did not understand’);
Writeln(userfile,’Please send a mail to my inbox’);
Writeln(userfile,’kenny@yahoo.com’);
Readln(txt);
Writeln(userfile,’’);
Writeln(userfile,’the user entered this text’);
Writeln(userfile,txt);
Close(userfile)
End.
Example 1
Program file;
Var userfile: text;
Fname: textfile: string;
Begin
Writeln(‘Enter the name of the file’++(with its full path)of the text file:’);
Readln(Fname);
Assign(userfile,Fname+’.textfile’);
Reset(userfile);
Program files;
Type studentrecords=record
Name: string;
Admno: integer;
Gender: string;
Age: integer;
End;
Var student: text;
Students: studentrecords;
Begin
Assign(student,’c:\student.txt’);
Rewrite(student);
Students.name:=’John Karani’;
Students.admno:=’1234’;
Students.gender:=’Male’;
Students.age:=22;
Writeln(‘name:=students.name’);
Writeln(‘admno:=students.admno’);
Writeln(‘gender:=students.gender’);
Writeln(‘age:=students.age’);
Writeln(students);
Readln;
End.
Importance of documentation
Reduces downtime costs.
Speeds maintenance costs.
Supports system users
Types of program documentation
System documentation
Describes system function and how they are implemented. This includes data dictionary, flowcharts,
data flow diagrams, object oriented models, screen layout and source documents.
Operational documentation
Contains all the information needed for processing and distributing online and printed output. It
includes: system analyst, programmer and system identification. Input files, scheduling information
for printed output and emails and report distributing lists.
User documentation
Consists of instructions and information to the system end-users who will interact with the system. It
includes: user manuals, help screens and tutorials.
User manuals
The styles and formats used in user manuals include the following.
Headings
Marks he key contents
Lists
Use numbered and bulleted lists to help the user scan information quickly.
Special notices
Use notices and warning to alert user to some potential problems.
Instructional design
Use standard design of instructions.
Graphics
Shows readers key components of the objects they will be working with.