|
In practical terms, a computer
program might include anywhere from a dozen instructions to many
millions of instructions for something like a word processor or
a web browser. A typical modern computer can execute billions of
instructions every second and nearly never make a mistake over
years of operation.
Large computer programs may take teams of computer programmers
years to write and the probability of the entire program having
been written completely in the manner intended is unlikely.
Errors in computer programs are called bugs. Sometimes bugs are
benign and do not affect the usefulness of the program, in other
cases they might cause the program to completely fail (crash),
in yet other cases there may be subtle problems. Sometimes
otherwise benign bugs may be used for malicious intent, creating
a security exploit. Bugs are usually not the fault of the
computer. Since computers merely execute the instructions they
are given, bugs are nearly always the result of programmer error
or an oversight made in the program's design.
In most computers, individual instructions are stored as machine
code with each instruction being given a unique number (its
operation code or opcode for short). The command to add two
numbers together would have one opcode, the command to multiply
them would have a different opcode and so on. The simplest
computers are able to perform any of a handful of different
instructions, the more complex computers have several hundred to
choose from — each with a unique numerical code. Since the
computer's memory is able to store numbers, it can also store
the instruction codes. This leads to the important fact that
entire programs (which are just lists of instructions) can be
represented as lists of numbers and can themselves be
manipulated inside the computer just as if they were numeric
data. The fundamental concept of storing programs in the
computer's memory alongside the data they operate on is the crux
of the von Neumann, or stored program, architecture. In some
cases, a computer might store some or all of its program in
memory that is kept separate from the data it operates on. This
is called the Harvard architecture after the Harvard Mark I
computer. Modern von Neumann computers display some traits of
the Harvard architecture in their designs, such as in CPU
caches.
While it is possible to write computer programs as long lists of
numbers (machine language) and this technique was used with many
early computers,[7] it is extremely tedious to do so in
practice, especially for complicated programs. Instead, each
basic instruction can be given a short name that is indicative
of its function and easy to remember — a mnemonic such as ADD,
SUB, MULT or JUMP. These mnemonics are collectively known as a
computer's assembly language. Converting programs written in
assembly language into something the computer can actually
understand (machine language) is usually done by a computer
program called an assembler. Machine languages and the assembly
languages that represent them (collectively termed low-level
programming languages) tend to be unique to a particular type of
computer. For instance, an ARM architecture computer (such as
may be found in a PDA or a hand-held videogame) cannot
understand the machine language of an Intel Pentium or the AMD
Athlon 64 computer that might be in a PC.
Though considerably easier than in machine language, writing
long programs in assembly language is often difficult and error
prone. Therefore, most complicated programs are written in more
abstract high-level programming languages that are able to
express the needs of the computer programmer more conveniently
(and thereby help reduce programmer error). High level languages
are usually "compiled" into machine language (or sometimes into
assembly language and then into machine language) using another
computer program called a compiler.[9] Since high level
languages are more abstract than assembly language, it is
possible to use different compilers to translate the same high
level language program into the machine language of many
different types of computer. This is part of the means by which
software like video games may be made available for different
computer architectures such as personal computers and various
video game consoles.
The task of developing large software systems is an immense
intellectual effort. It has proven, historically, to be very
difficult to produce software with an acceptably high
reliability, on a predictable schedule and budget. The academic
and professional discipline of software engineering concentrates
specifically on this problem.
|