Software

System software and application software

Software falls into two groups, and the test that separates them is who the software is for. System software provides the services that the computer requires: it manages the hardware and keeps the machine running. Application software provides the services that the user requires: it does the job the person at the keyboard actually wants done.

System software is more than just the operating system. It also includes utility software, a set of small programs that maintain, protect or configure the computer. A utility program carries out one housekeeping job, such as backing up files, compressing files, checking a disk for faults or scanning for malware. Utilities count as system software because they keep the machine healthy rather than doing a task for the user.

Both kinds of software run at the same time. When you type in a word processor, the word processor is application software and the operating system underneath it is system software, deciding how much processor time and memory the word processor is given. Application software cannot run on its own: without system software there would be nothing to load it, no memory to load it into and no way to save the file it produces.

The operating system: role and basic functions

The operating system (OS) is the system software that sits between the user, the application software and the hardware. Its role is to manage the resources of the computer and to provide the services that everything else needs. It is the first major piece of software to load when the computer is switched on, and it stays in charge until the computer is switched off.

Managing memory means the operating system keeps track of which parts of RAM are free, allocates memory to each program that needs it, and frees that memory again when the program closes. Managing multitasking means it shares the processor between several programs that appear to run at once, switching between them so quickly that each one looks continuous. Providing an interface means it gives the user a way to work with the machine, either a graphical user interface with windows, icons and menus, or a command-line interface where instructions are typed.

Managing files means organising files into folders or directories and handling creating, naming, saving, copying, moving and deleting them. Managing peripherals and drivers means controlling the input, output and storage devices attached to the computer, using a driver for each one: a driver is the small piece of software that translates general instructions into the signals that particular device understands. Providing a platform for running applications means supplying the services that application software needs, such as memory, file access and access to devices, so that a program does not have to deal with the details of the hardware itself.

Providing system security means controlling what programs and users are allowed to do, using passwords and permissions to stop unauthorised access to the system and its files. Managing user accounts means keeping a separate account for each user, with its own settings and its own access rights, and handling logging in and logging out. Handling interrupts is the last function on the list and it has a block of its own below.

Hardware, firmware, operating system and application software

A computer runs in layers, and you need to know what sits on what. Hardware is the physical equipment. Firmware is software that is stored permanently in the hardware itself, usually in ROM, so that it is available the instant the computer is switched on and is not lost when the power goes off. Application software is the program the user is trying to run.

The layers build upwards. The bootloader is firmware: it runs on the hardware, and its job is to find and start the operating system. The operating system then runs on the firmware, using the basic instructions the firmware provides to communicate with the hardware. Application software runs on the operating system, using the services the operating system provides. The chain is hardware -> firmware -> operating system -> application software, and each layer depends on the one below it.

This is why a program cannot run by itself. Application software needs an operating system to load it, give it memory and give it access to files and devices; the operating system needs firmware to start it and to handle the lowest-level details of the hardware; and the firmware needs the hardware to exist at all. Break any layer and everything above it stops working.

• The bootloader is firmware, and firmware runs on the hardware.
• The operating system runs on the firmware.
• Application software runs on the operating system.
• Each layer depends on the layer below it, so a broken layer stops everything above it.

Interrupts and interrupt service routines

An interrupt is a signal sent to the processor telling it to stop what it is doing and deal with something else straight away. Interrupts exist because the processor cannot know in advance when a key will be pressed or when a printer will run out of paper, and it cannot sit waiting for these events either, because that would waste almost all of its time. Instead the processor gets on with its work, and the outside world interrupts it when there is something to say.

Interrupts are generated in two ways. A hardware interrupt comes from a device: pressing a key on the keyboard, moving the mouse, or a printer signalling that it has finished a job. A software interrupt comes from a program while it is running: a program trying to divide by zero, or two processes trying to access the same memory location at the same time.

When an interrupt arrives, the processor finishes the instruction it is currently executing, then saves the contents of its registers and the address of the next instruction so that it can come back later. It looks up the address of the interrupt service routine (ISR) for that interrupt and jumps to it. The ISR is a short program written to deal with that particular interrupt: it reads the key that was pressed, or handles the division by zero error, or services the printer. When the ISR has finished, the processor restores the saved registers and the address of the next instruction and carries on from exactly where it left off, as though nothing had happened.

Interrupts also have priorities, because two of them can arrive at the same time. A high-priority interrupt, such as a hardware failure warning, is dealt with before a low-priority one such as a key press. If a higher-priority interrupt arrives while a lower-priority ISR is running, the processor can interrupt the ISR, deal with the more urgent signal, and then return to finish the ISR. Interrupts waiting to be handled are held in a queue.

As a result of an interrupt something happens that would not have happened otherwise: a character appears on the screen, an error is reported to the user instead of the program failing silently, or the processor starts the next task. The point of interrupts is that the processor can respond immediately to an event without continuously checking every device to see whether it needs attention.

• An interrupt is a signal to the processor that something needs attention now.
• Hardware interrupts come from devices: a key press, a mouse movement, a printer finishing.
• Software interrupts come from a running program: division by zero, or two processes trying to use the same memory location.
• The processor saves its registers and the address of the next instruction, runs the interrupt service routine, then returns to where it left off.
• Interrupts have priorities, and interrupts waiting to be handled are held in a queue.

High-level and low-level languages, including assembly language

A high-level language is written in a form close to English, using meaningful names and structures such as loops, conditions and procedures. A low-level language is written in a form close to the hardware, using the processor's own instructions and memory addresses.

High-level languages are easier to read and write, because the code reflects the problem being solved rather than the design of the processor. They are easier to debug, because the code is easier to follow and the translator can report an error together with the line it is on. They are also machine independent: the same program can be translated to run on different types of processor, because the high-level code does not refer to any particular processor's instructions. The cost is that the programmer loses direct manipulation of the hardware, so high-level code cannot be written to use a specific processor feature, and it may not make the most efficient use of memory or processing time.

Low-level languages are the mirror image. Because the programmer works directly with the processor's own instructions, registers and memory addresses, code can be written to run very fast or to fit into a very small amount of memory, which is why low-level languages are still used for device drivers and for the parts of an operating system where speed and control matter. The cost is that low-level code is hard to read and write, hard to debug because mistakes are easy to make and difficult to trace, and machine dependent: a program written for one type of processor will not run on another.

The processor itself executes only machine code, which is binary instructions made up of an opcode saying what to do and an operand saying what to do it to. Writing in binary is slow and full of errors, so assembly language was created: a low-level language that uses mnemonics, short letter codes such as LDA for load, ADD for add and STO for store, in place of the binary opcodes, and names in place of memory addresses. Assembly language is still a low-level language because each mnemonic corresponds to exactly one machine code instruction and the programmer still has to think about registers and addresses.

Because the processor does not understand mnemonics, an assembler is needed to translate an assembly language program into machine code. The assembler replaces each mnemonic with its binary opcode and each named address with the actual address, producing a machine code program the processor can execute. The translation is close to one assembly language instruction for one machine code instruction.

Compilers and interpreters

A compiler translates the whole program at once, before any of it is executed, and produces an executable file. The programmer runs the compiler, gets the executable, and can then run that executable as many times as they like without the compiler being involved again. If the compiler finds errors it produces an error report for the whole program, listing the errors it has found with the line each one is on, and no executable file is produced until those errors are fixed.

An interpreter translates and executes the code line by line. No separate executable file is produced: the interpreter reads a line, translates it, runs it, then moves on to the next line. If it finds an error it stops execution at that point and reports the error, which means the lines before it have already run and any errors further down the program have not been found yet.

The advantages of a compiler follow from translating everything in advance. Errors are reported for the whole program at once, so the programmer can fix several at the same time. Because the program has already been translated into machine code by the time it runs, execution is fast, and the finished executable can be given to users who do not have the compiler or the source code installed. The disadvantages are that the compiler must be run again every time the code is changed, which slows development down, that translating a large program can take a long time, and that the executable file is machine dependent, so a different version is needed for a different type of processor.

An interpreter's advantages are the mirror image. It is useful while a program is being developed, because the programmer can run part of the program and see the result immediately without waiting for the whole program to be translated, and an error stops the program at the line that caused it, which makes that error easier to locate. It is also useful for teaching and for testing a few lines quickly. Its disadvantages are that the same line is translated again every time it is executed, so the program runs more slowly, and that the interpreter must be installed on the computer for the program to run at all.

In practice both are used. An interpreter is mostly used when developing a program, because it gives feedback line by line while the code is being written; a compiler is used to translate the final program, because the finished version should run as fast as possible and be ready to hand to users.

Integrated development environments (IDEs)

An integrated development environment (IDE) is a single piece of application software that provides everything a programmer needs to write, test and translate a program. Its role is to bring the separate tools of program development together in one place, so the programmer does not have to keep switching between a text editor, a translator and a testing tool.

The code editor is where the code is typed. It is more than a plain text editor: it numbers the lines, colours the different parts of the code so that keywords and strings stand out, and indents automatically. Error diagnostics means the IDE reports errors as the programmer works, marking the line where a problem is and explaining what the translator objected to, which turns debugging from guesswork into reading a message.

Auto-completion means the IDE suggests how a word or line might finish as it is typed, and offers a list of the available options, so the programmer types less and makes fewer typing mistakes. Auto-correction means the IDE corrects or completes obvious mistakes, such as closing a bracket that was left open or fixing the spelling of a keyword. The run-time environment means the IDE can run the program and show the output, and often step through it line by line to watch the values in variables change. The translators built into the IDE, which may include a compiler, an interpreter and an assembler, mean the program can be translated without leaving the IDE.