Download Document

UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
www.ouw.co.uk, or contact Open University Worldwide, Michael Young Bu1908 858785; fax +44 (0)1908 858787; email [email protected]
The Open University, Walton Hall, Milton Keynes, MK7 6AA
Licensed for use
by the Arab Open University
___________________________________________________________________________
UNIT 6 – The Structure of Hardware
& Software
SUMMARY MATERIAL
______________________________________________
2008–2009
1
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
The Structure of Hardware & Software
Software vs. hardware
 Hardware consists of the tangible parts of the computer system – ‘the parts that can
be kicked’. Examples of hardware include the electronic circuits inside the casing, the
keyboard and hard disk.
 Software, on the other hand, is more abstract – it consists of sets of instructions that
tell a computer how to perform a particular task. Examples of software are wordprocessor applications such as Microsoft Word, browsers such as Explorer or
Netscape.
Any instruction performed by software can also be built directly into hardware, and instructions
executed by hardware can often be simulated in software. As an illustration let us consider the
multiplication of two numbers. One way of thinking about multiplication is to consider it as a
number of additions: starting with nothing (zero) you need to add a particular number (one of
the numbers to be multiplied) a specified number of times (the second number to be
multiplied). For example, to multiply 3 by 4, we need to add 3 to 0, then add 3 to the result,
and so on, until we have added 3 four times, as follows:
0 + 3 gives a result of 3 (first addition)
3 + 3 gives a result of 6 (second addition)
6 + 3 gives a result of 9 (third addition)
9 + 3 gives a result of 12 (fourth addition)
Now suppose that a computer has hardware (i.e. an electronic circuit) to carry out a simple
arithmetic instruction such as ADD. Since multiplication is nothing more than repeated
addition, we could construct a new circuit (or piece of hardware) made up of a number of ADD
circuits that, working together, can multiply two numbers.
Alternatively we could instruct the computer, using a computer program, to perform repeated
addition using the existing ADD circuit. The hardware and software solutions are logically
equivalent – they both use repeated addition – but the hardware solution uses several
‘tangible’ electronic circuits, whereas the software solution uses the more abstract idea of
‘instructing’ the machine to use the same circuit repeatedly. The decision to implement some
functions in hardware and others in software is based on factors such as speed, cost and
reliability.
Firmware is the term used to refer to a sequence of instructions (software) etched into the
read-only memory (ROM) of the computer, usually to perform some system function. Because
these instructions are on a chip they form a permanent part of the computer and could be
viewed as a combination of hardware and software.
The computer as a system
2
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
One simple view of an information system is that it is a machine that can solve problems by
carrying out a sequence of instructions, usually on a given set of data. The data provided is
usually referred to as input, and the solution (or results) produced is referred to as the output.
Some of the calculating devices that you read about in History snippet 1 conformed to this
model of a simple information system. Our view is that a computer differs from a calculating
device in that it includes a mechanism that stores not only the data but also the instructions
for processing that data, and the results that are to be output. If we have a computer at the
heart of our information system we can extend our model as shown in Figure 2.2
The word ‘process’ has a very particular meaning in some areas of computing. In this unit
we are using it to refer to all the processing (or manipulation) of the input so as to produce the
output
A computer is a device that accepts data and manipulates it by carrying out a sequence of
instructions (a program), so as to produce some output. A computer also has the means of
storing the input, the output and the program. Input, output and instructions.
In modern computers, all data, including the instructions that make up a computer program,
are stored in the computer as binary digits (bits) – sequences of zeros and ones. The branch
of mathematics that defines the rules governing the manipulation of entities with only two
states, such as bits, is called binary logic (or Boolean algebra – after the Englishman, George
Boole, who developed it in the middle of the nineteenth century). We will not explore the
application of binary logic to computer circuits any further in this course but it is important to
be aware that at a fundamental level computer processing is simply the application of logic to
binary numbers.
Of course in order to make the results readable by humans, the binary representations of the
output need to be ‘translated’ back into an appropriate format.
3
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
The heart of the computer – the central processing unit (CPU)
You have learned that computer processes manipulate binary representations of data, using
instructions that are themselves stored in binary format. The component of the computer in
which this manipulation of binary data takes place is referred to as an arithmetic/logic unit
(ALU). Movement of data between the ALU and other parts of the computer is coordinated by
the control unit.
The terms ‘processor’, ‘microprocessor’ and ‘CPU’ are often used interchangeably. The
term ‘microprocessor’ usually refers to the chip on which the processor is implemented.
Within both the ALU and the control unit are small numbers of memory locations known as
registers which are used to hold single pieces of data or single instructions immediately before
and after processing. The ALU and the control unit along with their registers are together
referred to as the central processing unit (CPU) or processor of a computer. A much larger
area of memory, known as main memory, is where the data and instructions that are not
immediately required are held, and where results are eventually stored.
Individual pieces of data and instructions are moved from main memory into the registers as
required. The registers are built from more efficient (and expensive) memory than main
memory, thus allowing fast access and transfer of data.
You will have come across the concept of main memory, loosely referred to as RAM, in the
context of computer specifications. For example, the minimum computer specification for
M150 in 2004 is 16MB (megabytes) of RAM, though most computers on sale at the time of
writing have at least 256MB.
The processor of a PC is usually on a single microchip,(or microprocessor) which can contain
several tens of millions of circuits. Processors come in ‘families’, such as the Pentium 4,
Celeron, AMD Athlon XP. Each family of processors has what is termed an instruction set.
This is the collection of basic instructions, called machine language instructions, which a
particular processor understands. The terms ‘machine language’ and ‘machine code’ are
synonymous.
Figure 3.2 shows how data moves between the various components. The data flow is
coordinated by the control unit, through the sending and receiving of control signals
4
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
More about the CPU and main memory :
The control unit is responsible for interpreting the instructions in a computer program and
then sending appropriate control signals to the components that will carry them out. As soon
as one instruction has been executed, the control unit moves on to deal with the next. Once
processing of a program has started, there is no need for human intervention unless some
interactive input is required. The control unit is in two-way communication with all the other
devices in the system so that it may, for example, receive a mouse click, and then send a
control signal to another device in order to execute an instruction.
Main memory
A computer has a number of different types of memory (or data storage). As a computer user
you are probably most familiar with main memory, often referred to as RAM, and file storage
memory, such as that provided by a hard disk. Main memory is used to store a program of
instructions and the data needed by the program while it is running. Its contents are volatile,
i.e. they are lost when the computer is switched off. File storage memory is memory that is
used to store large amounts of data for use at some later date. Unlike main memory, it is nonvolatile, i.e. the data is persistent – it is not lost when the computer is turned off.
Main memory can be envisaged as a large collection of sequentially ordered pigeon-holes,
each of which can hold the same number of bits, equivalent to the word size of the computer.
The word size refers to the number of bits that the CPU can manipulate at one time. It is
determined by the size of the registers in the CPU and the number of bits that can be moved
round the computer as a single unit. When people refer to computers as being ‘32-bit’ or ‘64bit’ machines they are referring to word size.
Older personal computers (including 386, 486 and Pentium PCs) had a word size of 32 bits.
Newer processors such as the Itanium series have a 64-bit (or 8-byte) word size.
5
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
Locations in main memory are sequentially numbered, so that each one has a unique
‘address’ by which it can be directly accessed. This is why this type of memory is sometimes
referred to as random-access memory (RAM).
The addressable nature of main memory makes the retrieval of data much faster than if there
was a need to search sequentially through each ‘pigeonhole’ in turn until the right one was
found. Furthermore, random access means that each memory location takes the same
amount of time to access, regardless of its address.
Most other modern forms of memory, such as hard disk drive storage, are also random
access. However, the acronym RAM is reserved for main memory.
Registers
Registers are very fast, efficient areas of memory that are located in the CPU and used as a
holding area for all the data and other information needed during the processing of a program.
In fact there are a number of different types of register, some located in the ALU, some in the
control unit, and each designed to hold a particular type of information
Arithmetic/logic unit (ALU)
The arithmetic/logic unit is the part of the CPU where the arithmetic and logical operations are
carried out. It contains a number of registers where data is held directly prior to and following
processing. Among other things, the ALU can:
  add
 n
 subtract

n
 compare

n
 multiply and divide (which may be derived from adding and

subtracting).
Peripheral devices
A peripheral, or peripheral device, is any computer device that is not part of the essential
computer (the CPU and main memory). The most common peripherals are input and output
(I/O) devices, and storage devices. Some peripherals, such as hard disks, are usually
mounted in the same case as the processor, while others, such as printers, are physically
outside the computer, and communicate with it via a wired or wireless connection.
The operating system
Hardware components of a computer: the processor, memory and peripheral devices.
Managing these resources to effectively coordinate and carry out all the computer’s tasks is
the job of the operating system. Common operating systems for personal computers include
Linux, Mac OS (for the Apple Macintosh) and the various versions of Windows, e.g. Windows
2000 and Windows XP.
An operating system is a complex piece of software that acts as an interface between the
user (or an application program) and the computer hardware.
The functions of the operating system include the following.
6
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
 Provision of a user interface :
The user interface is the software that enables us to communicate with our computers. It
provides us with a means of inputting data and instructions, and presents output in a way that
we can understand.
The user interfaces of early operating systems such as CP/M and DOS were text based,
requiring the user to learn a set of commands which needed to be typed in following precise
rules. Output to the screen also consisted entirely of characters. Today most PC operating
systems provide graphical user interfaces (GUIs), the most common example of which is
Microsoft Windows.
GUI-based operating systems make use of icons, menus and other graphical widgets, with
which the user interacts via a pointing device, usually a mouse. Most people find graphical
interfaces more intuitive, quicker to learn, and easier to use than sequences of commands. A
further advantage of GUIs is their availability for use by programs other than the core software
provided by the operating system.
 Management of memory :
During the processing of a program, data and instructions are stored in the computer’s main
memory. It is the job of the operating system to allocate an appropriately sized area of
memory to each process, and to ensure that program instructions and data do not interfere
with each other or with the data and instructions of other programs.
 Coordination and control of peripheral devices :
In order to carry out its tasks a computer may need to communicate with one or more
peripheral devices. For example, it may wish to receive input data from the keyboard or
mouse; read from a file on a storage device; send output to the monitor or printer; connect to
a network. The operating system coordinates all these operations, ensuring that data is
moved safely and efficiently between the components of the system.
Scheduling access to the processor
 The operating system manages access to the processor:
By prioritising jobs to be run and ensuring that the processor is not idle. For example, if the
currently running program finishes or is interrupted in order to wait for data from the hard disk,
the operating system will ensure that another process is given access to the processor.
 Providing an interface between application programs and the computer hardware :
Operating system provides a ‘common’ interface between application software and the
computer hardware. It is generally not possible to build application software that can run on
the many different types of processor made by different companies. The operating system
ensures that a ‘standard’ way of interacting with the hardware exists, and application
programmers can then rely on this standard without worrying about the minutiae of the
processor specifications.
 Providing basic utilities :
Most modern operating systems also provide basic utilities such as disk formatting facilities,
file management systems and software installation wizards.
 Read-only memory (ROM) and bootstrapping :
7
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
When you switch on a computer, the first thing it needs to do is to load its own operating
system (which is usually stored on the hard disk). You learned earlier in this unit that in order
to carry out any processing, the computer needs to load instructions from its main memory –
but also that main memory is volatile – when the power is turned off, its contents are lost. So
how does the computer ‘know’ how to load its operating system from the hard disk? The
answer is that there is another type of memory, called read-only memory (ROM) installed in
the computer.
The data in ROM is built into the memory chips during manufacture and is permanent. It
cannot be overwritten and will not disappear when power is lost to the computer
An important function of ROM is to store a program, called a boot program, which is
automatically executed when the computer is first switched on. This small program will
typically run a test of main memory and see what peripherals are connected to the system,
before loading larger programs, such as the operating system. The process of using a short
program to load a larger program is called bootstrapping, which comes from the idea of
someone pulling themselves up by their own bootstraps.
Running a program \ The fetch/execute cycle:
that data and instructions are stored in main memory, but moved to registers in the CPU as
required, and that operations such as adding and logical comparisons are carried out by the
ALU. We can summarize the steps carried out by the CPU in the execution of a computer
program as follows:
  Get an instruction from the program;
 Find and transfer any data necessary to perform the instruction;
 Carry out the instruction (which may involve saving a result)
The process of locating, transferring and carrying out a single instruction during the execution
of a computer program is known as the fetch/ execute cycle or fetch/execute sequence.
During each cycle the CPU must:
 locate the next (or if execution has just started, the first) instruction
in the program , which is stored in main memory.
 transfer this instruction into the processor by placing it into an
appropriate register.
 decode the instruction .
 locate (in main memory) any data the instruction refers to, and fetch
it into the processor by placing into the processor by placing it into
an appropriate register.
 Do the processing on the data that the instruction requires (e.g. add
a number to another number .
8
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
 place the result in an appropriate register;
 if necessary move the result back to main memory so that it can be
used later in the processing;
 update the program counter to hold the memory address of the next
Instruction.
When processing the simplest set of instructions, the processor needs to keep track of several
different pieces of information at the same time, and that data and instructions need to be
moved quickly around the system. You know that the control unit manages this task. However
there is also the need for some subsystem to connect its various parts, so that the data,
instructions and control signals (in the form of bits) can flow from place to place as required.
This is achieved through buses and a processor clock
Buses
An electronic channel through which data and instructions travel between different
components of the computer is known as a bus. Generally at least three categories of bus are
needed to ensure that the fetch/execute cycle operates effectively.
 The address bus is used to carry information about the addresses in main memory to
be accessed.
 The data bus transmits the data; the external data bus transmits data between the
registers and main memory, and the internal data bus transmits data between the
different registers within the processor.
 The control bus carries control signals sent by the control unit, as well as signals that
report the status of various devices. For example, when the processor is reading data
or instructions from main memory the control bus would carry the read signal that
indicates that the control unit is currently coordinating a read from main memory.
Bus technology is also important for transferring data between the CPU and the input and
output devices.
Processor clock
During the processing of instructions, the order in which events happen is clearly critical. To
enable events to be synchronized by the control unit, all computers have a processor clock,
which sends out pulses at regular intervals. The length of time between pulses is called the
clock cycle time. Historically each instruction took at least one clock cycle to execute but
advanced processors can now execute more than one instruction in a single cycle. The
number of pulses per second, or frequency, of the clock is measured in megahertz (MHz), so
a processor with a 900MHz clock sends 900,000,000 pulses per second. All other things
being equal, a computer with a high clock frequency (sometimes called clock speed) can
execute more instructions per second than one with a lower clock frequency.
SAQ 4.3
(a) For the instruction MUL 502, identify the operand and the operator. What do you think this
instruction means? (Hint Read the comment in the table for the ADD 502 instruction.)
9
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
(b) Does every instruction in the program on page 34 have an operand? Which instruction
appears to have an operand that does not reference a memory location where a meaningful
piece of data is stored?
Answer to SAQ 4.3
(a) The operand is 502 and the operator is MUL. You might have guessed
that the instruction means multiply the contents of the accumulator by
the contents of memory location 502.
(b)
Every instruction appears to have an operand. However, in the case of
the HLT instruction, the operand is meaningless as this instruction does
not need to access any data in memory. (Not all assembly languages
require the programmer to specify an operand where it is not meaningful.
Accumulator
Historically the accumulator was the register used to store any intermediate values during a
calculation. In the simplest model of a processor all arithmetic operations are carried out using
a single accumulator. In most modern computers, the processor contains several generalpurpose registers that allow operations to be carried out directly on the contents of two
memory locations, but it is convenient to maintain the simple mental model of a single
accumulator and you will still find references to this register in computing literature.
Program counter (or next instruction pointer)
The program counter (PC), sometimes called the next instruction pointer (NIP), is located in
the control unit and holds the memory address of the next instruction to be executed. The
control unit sends a signal to this register when it needs to know from where the next
instruction must be fetched.
10
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
Instruction register
The instruction register (IR), also located in the control unit, holds the instruction that is
currently being executed. It is responsible for decoding the instruction, i.e. separating the
instruction into its operator and operand, and interpreting the meaning of the operator.
Memory address register
The memory address register (MAR) holds the address of a main memory location that needs
to be accessed.
Memory data register
The memory data register (MDR) is a temporary holding area for either data or instructions
that are being transferred between main memory and the other registers.
Status registers
The status registers hold information about the current status of an instruction. One use of a
status register is to flag up or signal a problem. For example, the status register could contain
a special code to indicate that the programmer has inadvertently tried to do something
impossible, such as divide by zero.
Thanks for the memory Running a program
When discussing the fetch/execute cycle we confined our attention largely to what was
happening within the CPU. However, during the cycle, the CPU will need to communicate with
disk storage memory and possibly also with input/output devices. We now look a little more
closely at the way in which data and instructions are stored in main memory and then
consider how hard disk storage memory can be used to supplement main memory while a
program is executing. In Subsection 4.4 we will take a brief look at the way in which large
amounts of data are moved between input/output devices and the CPU.
Storing and locating data and instructions in main memory
Finding a particular location in main memory is an important part of the fetch/execute cycle.
You have seen that main memory consists of a number of addressable (i.e. uniquely
identifiable) locations, each capable of holding a certain number of bits. The memory
addresses are numeric and start with location 0 (zero) so a computer with n cells of main
memory will have memory addresses 0 to n – 1.
The processor’s registers must normally be large enough to hold at least one word (though
some registers hold half a word but work in pairs) and the ALU must be able to manipulate
one word at a time. Generally, a computer with a large word size can process more data in
each instruction cycle than a computer with a small word size.
Virtual memory
Computer memory is expensive, and it is therefore important that efficient use is made of the
different types available. We have already seen that different kinds of memory have different
characteristics, one of which is the speed at which they can be accessed. The fastest access
takes place in the registers but register memory is very expensive. Furthermore, since
registers are built into the processor microchip, it is not possible to add to them. At the other
end of the scale, the slowest access is from hard disk storage memory, roughly 10,000 times
slower than for the registers, but hard disk storage memory is relatively cheap. Practically
speaking, computers tend to have lots of cheap, but slow hard disk storage memory and very
little fast, but expensive register memory.
11
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
The amount of main memory (usually referred to as RAM) supplied in computers has been
steadily increasing. At the time of writing it is not uncommon to find 512MB or more of RAM in
a standard multimedia PC. However, the size of programs and the amount of data they are
required to manipulate has also increased, mainly as a result of applications involving sound
and video. Main memory can be supplemented by a technique whereby an area of the disk
storage memory (hard disk) can be used to simulate additional capacity during processing.
This technique is known as virtual memory.
The use of virtual memory avoids the need for main memory to hold all the instructions and
data needed to run a program. Instead, a relatively small working set of data and instructions
are held in main memory at any one time, with the rest being kept in a special area on the
hard disk. Data and instructions are swapped in and out of main memory as required, creating
an illusion of far more main memory than actually exists. The transfer of blocks of data (called
pages) between the main memory and the hard disk is managed by the operating system.
Although the use of virtual memory enables a computer to run bigger programs, with more
data than would otherwise be possible, the speed of execution is reduced due to the
increased time needed to access the hard disk.
As with data held in main memory, data in virtual memory becomes inaccessible once the
computer loses power. This may seem surprising, given that data stored on the hard disk is
not normally volatile. However, because information on the location of the data on disk is held
in main memory, it is lost once the computer loses power.
Cache memory
As already discussed, the speed of the processor’s registers exceeds that of main memory,
potentially leading to a situation where processing is slowed down due to the wait for data to
be delivered from main memory. To bridge this gap, there exists what is known as cache
memory – faster than main memory, but slower than the registers. You will not be surprised to
learn that it is also intermediate in cost. Some cache memory is now routinely included on
most processor microchips.
Cache memory is ‘fed’ from main memory before the data is finally moved to the registers.
When an instruction calls for data, the processor first checks to see if the required data is in
the cache. If it is, it takes the data from the cache instead of fetching it from main memory. A
typical PC will have several hundred kilobytes of cache memory.
Hierarchy of speed and cost
We have seen that there is a hierarchy in terms of speed and cost – from faster, more
expensive memory to slower, less costly memory. This is summarised in Figure 4.4.
12
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
Program-controlled input and output
Fast data transfer in and out of main memory, and a fast clock speed to ensure that
instructions can be executed quickly, will not achieve fast processing overall if a great deal of
time is needed for the processor to interact with much slower peripherals (in particular the
input/output devices). Historically the lower speed of input and output relative to data flow
within the processor has slowed down the speed at which a computer can process data. This
has become more of an issue given the requirement to manipulate the very large amounts of
data associated with sound and video data and has resulted in a lot of development work in
this area.
One outcome is a local input/output bus (I/O bus) which is a high-speed bus that connects
performance-critical devices, such as video cards, modems and network interface cards, to
the main memory and the processor. The most common local I/O bus is the peripheral
component interconnect bus (PCI). PCI technology allows the processor to be bypassed
altogether when transferring data to and from main memory, resulting in very fast transfer
speeds – typically over 30MB per second compared with less than half this rate for buses that
have to channel data through the processor.
Types of programming language
Low-level languages
Machine language
Early computer programmers wrote instructions in a form that could be directly understood by
their computer’s family of processors, i.e. in some dialect of machine language. As already
discussed, a computer can only handle bits, so each instruction in machine language is a long
stream of 1s and 0s. For example, in the machine language for one particular processor
family, the command to move data from the processor’s accumulator into main memory
address 53281 is:
10001101 00100001 11010000
At first sight, this would be incomprehensible to most people, but there is, in fact, some logic
to this pattern of bits. The first byte, 10001101, is the instruction that the control unit interprets
as ‘store the contents of the accumulator in memory.’ The second and third bytes give the
memory address of the location in which the contents should be stored. For reasons we will
not explore here, the order of these two bytes needs to be reversed, 46
13
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
and so they should be interpreted as 11010000 00100001, giving memory address 53281.
Types of programming language
In a sense, machine language programs are the ‘purest’ kind of program because the
programmer is literally writing in the language of the processor without any intervening
interpreters or translators. A programmer working in machine language can therefore exploit
the capabilities of the processor to the full.
However, there are many disadvantages to reading and writing programs in machine
language, as listed below.
n Machine language programs are slow and difficult for humans to read
and write. In particular, it is hard to memorise instruction codes which,
as we have seen, consist of 8-digit binary sequences such as
10001101.
n
Memory references are given as actual location numbers. The
programmer therefore needs to assign data to particular memory
locations and to maintain a ‘memory map’ in order to keep track of
what has been stored where, and which locations are still available.
n
It is difficult to understand machine language programs without a great
deal of annotation. As a consequence they are often very difficult to
modify.
n
Each family of processors understands only its own machine language.
A processor cannot correctly execute a program that has been written
in the machine language of another family of processors.
Assembly language
As with machine language, an assembly language is a language in which each instruction
exactly corresponds to one hardware operation of the processor. Any computer programming
language with this one-to-one correspondence (including the machine language itself) is
referred to as a low-level language. In programming languages such as JavaScript, Java, C++
and Smalltalk, one instruction may be equivalent to many machine language instructions.
These programming languages are referred to as high-level languages. Because of the oneto-one correspondence between a low-level language instruction and a machine language
instruction, a program written in assembly language can directly take advantage of all the
features and instructions available on the processor. This is not the case with high-level
languages, where a single instruction may be translated into a sequence of low-level
instructions in a number of different ways – something over which the programmer has no
control.
Whenever a program is written in a language other than machine language, the instructions in
the original program (called the source code) need to be converted into equivalent machine
language instructions. The task of converting the source code into machine language is done
by special programs, called translators. When the source language is an assembly language
the program that does this translation is called an assembler.An assembler takes an assembly
language program and generates and saves an equivalent program in machine language.
This machine language program can then be executed whenever required.
Assembly language programs have a number of advantages over machine language.
n In assembly languages, mnemonic names (i.e. names that give a clue
14
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
as to the function of the instruction, such as ADD and SUB) are given to
the operations.
n
Some assembly languages allow the use of symbolic names for
memory locations. These names, together with their numeric
equivalents, are held in a table maintained by the assembler, thus
avoiding the need for the programmer to deal directly with memory
management and addressing.
n
An assembly language may allow the programmer to provide data in
forms other than binary – ordinary decimal numbers or characters for
example – and let the assembler worry about translating them.
n
Most assemblers include a facility to print a listing of the source
program (in assembly language) as well as a list of its machine
language equivalent. These listings are very helpful when it comes to
correcting errors or making modifications.
When the source language is a high-level language, the translator is called a or an
Assemblers usually notify the programmer of errors in the usage of the assembly language,
such as the inclusion of an illegal operator code.
However, assembly language retains some of the disadvantages of machine language.
n An assembly language program can only run on one family of
processors. (You will learn in the next unit that programs written in
high-level languages can potentially be run on many machines.)
n
Although slightly easier to read than machine language, assembly
language programs are still difficult to understand by anyone other
than the programmer, and so are difficult to modify or update.
n
Programs written in assembly language tend to be very long. Because
each statement in a high-level programming language is normally
equivalent to several machine language instructions, a program written
in a high-level language is shorter than the equivalent assembly
language program, sometimes by a factor of as much as ten. The
workload implications of this are very significant.
High-level languages
Most programmers write in high-level languages because these languages are easier for
humans to use. As we have already noted, a single high-level language instruction is usually
equivalent to several machine level instructions. In addition, high-level language instructions
tend to be closer to English and other natural languages. Both these characteristics lead to
increased programmer productivity. Futhermore, due to their increased readability, programs
written in high-level languages are easier to debug and to modify.
15
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
We have seen that each family of processors understands only instructions written in its own
machine language. This means that when we write programs in a high-level language, we
need the same kind of translation process that the assembler provides for assembly
programs. There are two different mechanisms by which a program written in a high-level
language may be translated into machine language: compilation and interpretation. In
compilation the program written in the high-level language, called the source code, is used as
the input to a translator program called a compiler (we say the source code is compiled). The
compiler translates the source program into a program written in the machine language
understood by the processor. The machine language version is then saved, and it is this
machine language program that is executed every time the program is run.
When you buy computer software, you are not usually able to see the program code in which
that software was written. What you have is an executable program, which has already been
compiled from the source code.
For a particular programming language several different compilers will be available to take
into account that different families of processors have different versions of machine language,
and that different operating systems interact with the processors in different ways. For
example, you can buy a C++ compiler that is written for a PC running Windows, or a C++
compiler for a computer running Linux. This means that a program written in a high-level
language (such as C++) on a PC running Windows can be moved and recompiled on a
computer running Linux. The only source code that would need to be changed would be the
parts related to I/O and the user interface.
Interpretation is a different mechanism for translating high-level languages to machine
language. In effect, an interpreter translates each instruction in the source code into machine
language as the program is running, and then immediately executes it. There is never a
complete translation of the whole of the source code into machine language, and so no
machine language program is generated or saved. The advantage of an interpreted language
is that the potentially lengthy process of compile/execute does not need to be gone through
for each small change in the source code. Interpreted languages lend themselves to situations
where small incremental changes to a program are being made, and need to be tested as
quickly as possible. The disadvantage is that the translation process must take place every
time a program is run, resulting in a slower execution process. Languages, such as
JavaScript, Perl and Basic are especially designed to be interpreted, whereas languages such
as C, C++ and Java are designed to be compiled.
The structure of computer programs
Sequence, selection and repetition
For most programming languages the default execution order is sequential – instructions are
executed in the order in which they appear in the program. The assembly language programs
that you saw in Subsection 4.2 were simple sequential programs.
‘Begin at the beginning’, the King said, gravely, ‘and go on till you
come to the end; then stop.’
(Lewis Carroll, Alice’s Adventures in Wonderland)
However, there may be occasions when the programmer might wish to specify a possible
change in the order of execution, e.g. in response to some user input. All programming
languages have mechanisms for changing the order in which their instructions are carried out.
An instruction that changes the default sequential order is referred to as a control instruction.
Examples of control instructions include instructions to jump immediately to an instruction later
in the program, skipping over the instructions in between, or instructions that cause a jump to
an earlier instruction.
16
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
Control instructions are used to support selection and repetition,which are two very powerful
mechanisms when writing computer programs. Selection refers to the process of deciding
between two or more courses of action, e.g. whether to execute the next instruction (or block
of instructions) or skip over it to do the instruction(s) that follow it. In repetition the decision
determines whether or not one or more instructions are repeated. For example, it might be
necessary to return to a particular instruction (or block of instructions) to execute it again.
Selection
Selection (sometimes called branching) occurs in a computer program when the instruction or
instructions to be executed depend on the situation. The circumstances that determine each
possible course of action are formulated as conditions which are statements that can be either
true or false, such as: ‘It is raining’ or ‘The traffic is very heavy’.
Selecting between two alternatives
As an analogy, consider the following instructions for a (non-computerised) task: ‘If it is
snowing, put the cat in the kitchen; if it is not snowing, put the cat outside.’ The condition is ‘It
is snowing’, and we take one of two courses of action depending on whether the condition is
true or false. In mathematics and computer programming, true and false are sometimes
referred to as Boolean values, and a condition that can be evaluated true or false is referred
to as a Boolean expression.
To return to our example about the cat and the weather, we have the following:
a condition: it is snowing
two possible courses of action:
put the cat in the kitchen (if the condition is true)
put the cat outside (if the condition is false)
If the condition is true, we carry out the first instruction (and skip over the second to whatever
follows next). If the condition is false, we skip over the first instruction, and carry out the
second instruction. Only one of the two instructions is executed. Once we have executed one
or the other, we move on to any other instructions which follow. Suppose our original task had
been expanded so that it read: ‘If it is snowing, put the cat in the kitchen; if it is not snowing,
put the cat outside. After you have dealt with the cat, turn out the lights.’
Informally, we could perhaps write our instructions as follows.
17
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
Here we have used parentheses to make it clear which part is the condition (a Boolean
expression) and we have used indentation to provide a clue as to which parts of the structure
are dependent on whether the condition is true or false. The fact that ‘turn out the lights’ is not
indented indicates that it is not part of the selection structure. Although this is just an informal
example, many high-level programming languages do use the words if and else to indicate a
selection structure. In computing we usually use else instead of otherwise to indicate an
alternative course of action.
For each particular language, there are strict rules about how conditions and their dependent
code sequences are delimited. You will learn about these rules for JavaScript in Unit 7.
The first alternative ‘put the cat in the kitchen’ is referred to as the if branch (or clause), and
the second branch ‘put the cat outside’ is referred to as the else branch (or clause). In a
selection structure such as this one, the if branch is executed if the condition is true, and the
else branch is executed if the condition is false. Figure 6.1 illustrates this example.
Negative conditions and NOT
Sometimes it is more convenient to couch a condition in the negative, for example:
it is not snowing But note that in this case we would need to reverse the two actions so that
the if...else construction would be as follows.
if (it is not snowing)put the cat outsideelseput the cat in the kitchenturn out the lights
Discussion
(a) if (the customer is not an adult)
charge £5.00else
charge £10.00admit the customer
18
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
More on conditions involving NOT
We wrote the condition ‘it is not snowing’ in the way we would write it in English. But when we
write instructions for a computer, we need to be as precise as possible. In programming
languages the ‘not’ appears either before or after the complete Boolean expression to make it
quite clear what we are negating. The English word ‘not’ is usually represented in Boolean
expressions by the word NOT (in upper-case letters).
For example, we could write:
NOT (it is snowing) or
(it is snowing) NOT In each case the Boolean expression shown in parentheses (round
brackets) is evaluated first, to either true or false, and the NOT then has the effect of reversing
it to the other Boolean value, i.e. making it false (if it were true) and true (if it were false.)
NOT is called a Boolean operator because it operates on a Boolean expression. It is also an
example of a unary operator, which means that it operates on a single value:
NOT (something that evaluates to true) will give false
NOT (something that evaluates to false) will give true In the next section we will come across
two further Boolean operators, both of which are binary operators, i.e. they each operate on
two Boolean values.
Truth tables
The effects of applying Boolean operators to different Boolean values are often shown in
tables, usually known as truth tables.
Here is the truth table for the NOT operator acting on the Boolean expression ‘it is snowing’.
Other examples of selection A single possibility
In the examples so far there have been two alternative actions but selection can also be
applied to a situation where there is a single action that we either wish to carry out or not,
based on a given condition.
19
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
Here’s an example:
if (changes have been made to the document)save itprint the document
The condition is: changes have been made to the document and there is a single if option
containing the instruction ‘save it’.
This instruction is executed only if the condition is true. If the condition is false, it is skipped
over. In either case the instruction after the selection structure (‘print the document’) is then
executed. You can think of this as being similar to a two alternatives structure in which the
else clause is empty, so does not need to be included.
More than two alternatives
More complicated selection structures allow a programmer to test two or more conditions,
leading to more than two possible branches. Here’s an example:
If a book is fiction put it on the first shelf, else if it is biography put it on the second shelf, else
put it on the third shelf. Here we have two conditions:
the book is fictionthe book is biography
They can be written using two if...else structures as follows:
if (the book is fiction)put it on the first shelfelseif (the book is biography)put it on the second
shelfelseput it on the third shelf
Repetition
Repetition,or looping, occurs when we have an instruction (or a sequence of instructions) that
we might want to execute more than once.
For example, an algorithm for reading a book might contain the following instructions:
while (there are pages left to read in the book)read the current pageturn the current page over
select a new book 63
20
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
Notice that, as with the selection structure, there is a condition that controls what happens – in
this case whether or not we repeat the sequence (or block) of two instructions. Like the
conditions we encountered earlier, it is a Boolean expression – it evaluates to true or false.
Unit 6 The structure of hardware and software
The instructions to be repeated are often referred to as the loop body.In our informal structure
we have indented them. Here the loop body consists of the two instructions:
read the current page
turn the current page over
This kind of loop structure is commonly called a while loop. When the start of a while loop is
encountered in a program the condition is evaluated; if it is true, the instructions in the loop
body are executed. Then the condition is evaluated again and, if it is true, the loop body is
executed again. This process continues until the condition evaluates to false, at which point
the looping stops, and the instruction following the loop body (if there is one) is executed.
Figure 6.4 illustrates the looping structure for reading a book.
As with selection structures the formal rules for writing a looping structure vary from
programming language to programming language, and in fact many high-level programming
languages have more than one looping structure.
You should be able to see that when a loop has its condition at the beginning, it is possible
that the condition may evaluate to false the first time round, and that the sequence of
statements in the body of the loop will not be executed at all. This is not necessarily a
problem, but the programmer needs to think quite carefully about what the program is do to.
Another potential pitfall in designing a loop structure is that if care is not taken to ensure that
the condition eventually becomes false, the loop body will repeat forever. This is called an
infinite loop.
Now let us trace through this loop structure to see what the output might be.
n First evaluation of the condition ‘NOT (count is 0)’
As count is 3, this becomes NOT false, which evaluates to true. Since the condition is true, we
execute the instructions in the loop
21
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
body:write the value of count (i.e. output 3 to the screen)move to the next linereduce count by
1 (i.e. count now becomes 2).
So at the end of the first execution of the loop body we have the following.
Now let us trace through this loop structure to see what the output might be.
n First evaluation of the condition ‘NOT (count is 0)’
As count is 3, this becomes NOT false, which evaluates to true. Since the condition is true, we
execute the instructions in the loop
body:write the value of count (i.e. output 3 to the screen)move to the next linereduce count by
1 (i.e. count now becomes 2).
So at the end of the first execution of the loop body we have the following.
Second evaluation of the condition
‘NOT (count is 0)’ is still true, so we execute the instructions in the loop body again: write out
count (which is 2) move to the next line
reduce count by 1 (so it becomes 1). At the end of the second execution of the loop body we
have the following.
Third evaluation of the condition
‘NOT (count is 0)’ is still true, so we execute the instructions in the loop body again: write out
count, which is 1 move to the next line
reduce count by 1 (so it is 0). At the end of the third execution of the loop body we have the
following.
Fourth evaluation of the condition
This time we get:NOT (count is 0)NOT truefalse
So we break out of the loop structure, and the next instruction after the loop structure is
executed. The final output looks like the following.
22
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
Trace tables
Another way of working out what a program does is by using a trace table,
i.e. a table that shows what’s going on as each instruction is executed. Trace tables are not
formal structures, and do not need to have any particular format. A programmer will usually
decide on a format suitable for the sequence of instructions to be traced.
In the case of the looping structure just considered, we need to know the following information
as the program progresses:
n the value of ‘count’ at various times – when we test the condition, and
when we write it out;
n
the value of the condition ‘count is 0’;
n
n
the value of the condition ‘NOT(count is 0)’;
which line we are at in the output window;
n what we are going to write out.
As long as the value in the NOT (count is 0) column is true, we continually repeat lines 3, 4, 5
and 2. Once it becomes false, we jump to line 6.
23
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
The last two columns are used to show what will be written to the output window. The last but
one column tells us which line of the window it will be written to, and the last column tells us
what will be written. As with our previous method, what we get is the following.
Compound conditions
You have seen that both selection and looping are controlled by conditions that evaluate to
true or false. In Subsection 6.2 we looked at some simple conditions, but in real-life tasks
conditions can be more complicated.
Here are some examples in English: It is raining or snowing Bill is over 18 and under 65 The
number is less than 5 or more than 12 The shape is square and red
24
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
Conditions involving OR
Consider the condition: it is raining or snowing We can write this as two quite separate
conditions, joined with the word ‘or’, as follows: (it is raining) or (it is snowing) Notice that we
use parentheses here to emphasise the fact that we have two separate conditions joined with
an or. A condition that is made up of two or more conditions is referred to as a compound
condition.
If two conditions are joined with an or, the resulting expression evaluates to true if the first or
the second (or both) is true, and false if both the first and the second are false.
The English word ‘or’ is represented in Boolean expressions by the Boolean operator OR.
Because it operates on two values, it is a called a binary operator.
We can summarise the behaviour of expressions containing OR in the following truth table
(where A and B are Boolean values).
Compound conditions involving AND
Consider the condition: Bill is over 18 and under 65 This can be written as two separate
conditions joined with the word ‘and’, as follows: (Bill is over 18) and (Bill is under 65)
Compound conditions involving NOT
Compound conditions involving NOT can sometimes be a little tricky because they are not
quite so easy to translate from English.
Consider the condition:
The shape is neither square nor filled in
We can translate this as meaning that the shape is not square and it is not filled in and write it
in Boolean notation as:
NOT (The shape is square) AND NOT (The shape is filled in)
In this example we have a mixture of binary and unary Boolean operators, and we need a rule
about the order in which we evaluate these. If there are any parentheses, we always evaluate
their contents first. Then unary operators are applied, then binary operators. That means that
once we have evaluated the two single conditions, we apply each NOT before applying the
AND.
Consider the shape in Figure 6.8.
Figure 6.8
25
Mrs. Haifaa Elayyan
UNIT 6
– The Structure of Hardware and Software
SUMMARY MATERIAL
If we evaluate the expression above we get the following.
Compound conditions involving OR and AND
It is also possible to construct conditions involving both OR and AND. We will not be covering
these conditions in this unit. However, a cautionary note is in order. The precedence of OR
and AND varies from programming language to programming language so it is wise always to
include parentheses in such conditions so as to make your meaning absolutely clear.
26
Mrs. Haifaa Elayyan