Machine language
Machine code was the language of early programs, written in the instruction set of the
particular machine, often in binary notation. Assembly languages were soon developed that let
the programmer specify instructions in a text format (e.g., ADD X, TOTAL), with abbreviations for
each operation code and meaningful names for specifying addresses. However, because an
assembly language is little more than a different notation for a machine language, two machines
with different instruction sets also have different assembly languages.
Wired control panel for an IBM 402 Accounting Machine.
Wires connect pulse streams from the card reader to counters and other internal logic and
ultimately to the printer.
Compiler languages
See also: Compiler
High-level languages made the process of developing a program simpler and more
understandable, and less bound to the underlying hardware. The first compiler related tool,
the A-0 System, was developed in 1952[13] by Grace Hopper, who also coined the term
'compiler'.[14][15] FORTRAN, the first widely used high-level language to have a functional
implementation, came out in 1957,[16] and many other languages were soon developed—in
particular, COBOL aimed at commercial data processing, and Lisp for computer research.
These compiled languages allow the programmer to write programs in terms that are
syntactically richer, and more capable of abstracting the code, making it easy to target varying
machine instruction sets via compilation declarations and heuristics. Compilers harnessed the
power of computers to make programming easier[16] by allowing programmers to specify
calculations by entering a formula using infix notation.
Source code entry
See also: Computer programming in the punched card era
Programs were mostly entered using punched cards or paper tape. By the late 1960s, data
storage devices and computer terminals became inexpensive enough that programs could be
created by typing directly into the computers. Text editors were also developed that allowed
changes and corrections to be made much more easily than with punched cards.
Modern programming
Quality requirements
Main article: Software quality
Whatever the approach to development may be, the final program must satisfy some
fundamental properties. The following properties are among the most important:[17] [18]
Reliability: how often the results of a program are correct. This depends on conceptual
correctness of algorithms and minimization of programming mistakes, such as mistakes
in resource management (e.g., buffer overflows and race conditions) and logic errors
(such as division by zero or off-by-one errors).
Robustness: how well a program anticipates problems due to errors (not bugs). This
includes situations such as incorrect, inappropriate or corrupt data, unavailability of
needed resources such as memory, operating system services, and network connections,
user error, and unexpected power outages.
Usability: the ergonomics of a program: the ease with which a person can use the
program for its intended purpose or in some cases even unanticipated purposes. Such
issues can make or break its success even regardless of other issues. This involves a wide
range of textual, graphical, and sometimes hardware elements that improve the clarity,
intuitiveness, cohesiveness, and completeness of a program's user interface.
Portability: the range of computer hardware and operating system platforms on which
the source code of a program can be compiled/interpreted and run. This depends on
differences in the programming facilities provided by the different platforms, including
hardware and operating system resources, expected behavior of the hardware and
operating system, and availability of platform-specific compilers (and sometimes
libraries) for the language of the source code.
Maintainability: the ease with which a program can be modified by its present or future
developers in order to make improvements or to customize, fix bugs and security holes,
or adapt it to new environments. Good practices[19] during initial development make the
difference in this regard. This quality may not be directly apparent to the end user but it
can significantly affect the fate of a program over the long term.
Efficiency/performance: Measure of system resources a program consumes (processor
time, memory space, slow devices such as disks, network bandwidth and to some extent
even user interaction): the less, the better. This also includes careful management of
resources, for example cleaning up temporary files and eliminating memory leaks. This is
often discussed under the shadow of a chosen programming language. Although the
language certainly affects performance, even slower languages, such as Python, can
execute programs instantly from a human perspective. Speed, resource usage, and
performance are important for programs that bottleneck the system, but efficient use of
programmer time is also important and is related to cost: more hardware may be
cheaper.
Using automated tests and fitness functions can help to maintain some of the aforementioned
attributes.[20]
Source: [Link]
