1.
Embedded system
–
An embedded system is a computer system with a dedicated function within a larger mechanical or electrical system, often with real-time computing constraints. It is embedded as part of a device often including hardware. Embedded systems control many devices in use today. Ninety-eight percent of all microprocessors are manufactured as components of embedded systems, examples of properties of typically embedded computers when compared with general-purpose counterparts are low power consumption, small size, rugged operating ranges, and low per-unit cost. This comes at the price of limited processing resources, which make them more difficult to program. For example, intelligent techniques can be designed to power consumption of embedded systems. Modern embedded systems are based on microcontrollers, but ordinary microprocessors are also common. In either case, the processor used may be ranging from general purpose to those specialised in certain class of computations. A common standard class of dedicated processors is the signal processor. Since the embedded system is dedicated to tasks, design engineers can optimize it to reduce the size and cost of the product and increase the reliability. Some embedded systems are mass-produced, benefiting from economies of scale, complexity varies from low, with a single microcontroller chip, to very high with multiple units, peripherals and networks mounted inside a large chassis or enclosure. One of the very first recognizably modern embedded systems was the Apollo Guidance Computer, an early mass-produced embedded system was the Autonetics D-17 guidance computer for the Minuteman missile, released in 1961. When the Minuteman II went into production in 1966, the D-17 was replaced with a new computer that was the first high-volume use of integrated circuits. Since these early applications in the 1960s, embedded systems have come down in price and there has been a rise in processing power. An early microprocessor for example, the Intel 4004, was designed for calculators and other systems but still required external memory. By the early 1980s, memory, input and output system components had been integrated into the chip as the processor forming a microcontroller. Microcontrollers find applications where a computer would be too costly. A comparatively low-cost microcontroller may be programmed to fulfill the role as a large number of separate components
2.
PowerPC
–
PowerPC is a RISC instruction set architecture created by the 1991 Apple–IBM–Motorola alliance, known as AIM. PowerPC was the cornerstone of AIMs PReP and Common Hardware Reference Platform initiatives in the 1990s and it has since become niche in personal computers, but remain popular as embedded and high-performance processors. Its use in game consoles and embedded applications provided an array of uses. In addition, PowerPC CPUs are still used in AmigaOne and third party AmigaOS4 personal computers, the history of RISC began with IBMs 801 research project, on which John Cocke was the lead developer, where he developed the concepts of RISC in 1975–78. 801-based microprocessors were used in a number of IBM embedded products, the RT was a rapid design implementing the RISC architecture. The result was the POWER instruction set architecture, introduced with the RISC System/6000 in early 1990, the original POWER microprocessor, one of the first superscalar RISC implementations, was a high performance, multi-chip design. IBM soon realized that a microprocessor was needed in order to scale its RS/6000 line from lower-end to high-end machines. Work on a one-chip POWER microprocessor, designated the RSC began, in early 1991, IBM realized its design could potentially become a high-volume microprocessor used across the industry. IBM approached Apple with the goal of collaborating on the development of a family of single-chip microprocessors based on the POWER architecture and this three-way collaboration became known as AIM alliance, for Apple, IBM, Motorola. In 1991, the PowerPC was just one facet of an alliance among these three companies. The PowerPC chip was one of joint ventures involving the three, in their efforts to counter the growing Microsoft-Intel dominance of personal computing. For Motorola, POWER looked like an unbelievable deal and it allowed them to sell a widely tested and powerful RISC CPU for little design cash on their own part. It also maintained ties with an important customer, Apple, and seemed to offer the possibility of adding IBM too, at this point Motorola already had its own RISC design in the form of the 88000 which was doing poorly in the market. Motorola was doing well with their 68000 family and the majority of the funding was focused on this, the 88000 effort was somewhat starved for resources. However, the 88000 was already in production, Data General was shipping 88000 machines, the 88000 had also achieved a number of embedded design wins in telecom applications. The result of various requirements was the PowerPC specification. The differences between the earlier POWER instruction set and PowerPC is outlined in Appendix E of the manual for PowerPC ISA v.2.02, when the first PowerPC products reached the market, they were met with enthusiasm. In addition to Apple, both IBM and the Motorola Computer Group offered systems built around the processors, Microsoft released Windows NT3.51 for the architecture, which was used in Motorolas PowerPC servers, and Sun Microsystems offered a version of its Solaris OS
3.
ARM architecture
–
ARM, originally Acorn RISC Machine, later Advanced RISC Machine, is a family of reduced instruction set computing architectures for computer processors, configured for various environments. It also designs cores that implement this instruction set and licenses these designs to a number of companies that incorporate those core designs into their own products, a RISC-based computer design approach means processors require fewer transistors than typical complex instruction set computing x86 processors in most personal computers. This approach reduces costs, heat and power use and these characteristics are desirable for light, portable, battery-powered devices—including smartphones, laptops and tablet computers, and other embedded systems. For supercomputers, which large amounts of electricity, ARM could also be a power-efficient solution. ARM Holdings periodically releases updates to architectures and core designs, some older cores can also provide hardware execution of Java bytecodes. The ARMv8-A architecture, announced in October 2011, adds support for a 64-bit address space, with over 100 billion ARM processors produced as of 2017, ARM is the most widely used instruction set architecture in terms of quantity produced. Currently, the widely used Cortex cores, older classic cores, the British computer manufacturer Acorn Computers first developed the Acorn RISC Machine architecture in the 1980s to use in its personal computers. Its first ARM-based products were coprocessor modules for the BBC Micro series of computers, according to Sophie Wilson, all the tested processors at that time performed about the same, with about a 4 Mbit/second bandwidth. After testing all available processors and finding them lacking, Acorn decided it needed a new architecture, inspired by white papers on the Berkeley RISC project, Acorn considered designing its own processor. Wilson developed the set, writing a simulation of the processor in BBC BASIC that ran on a BBC Micro with a 6502 second processor. This convinced Acorn engineers they were on the right track, Wilson approached Acorns CEO, Hermann Hauser, and requested more resources. Hauser gave his approval and assembled a team to implement Wilsons model in hardware. The official Acorn RISC Machine project started in October 1983 and they chose VLSI Technology as the silicon partner, as they were a source of ROMs and custom chips for Acorn. Wilson and Furber led the design and they implemented it with a similar efficiency ethos as the 6502. A key design goal was achieving low-latency input/output handling like the 6502, the 6502s memory access architecture had let developers produce fast machines without costly direct memory access hardware. The first samples of ARM silicon worked properly when first received and tested on 26 April 1985, Wilson subsequently rewrote BBC BASIC in ARM assembly language. The in-depth knowledge gained from designing the instruction set enabled the code to be very dense, the original aim of a principally ARM-based computer was achieved in 1987 with the release of the Acorn Archimedes. In 1992, Acorn once more won the Queens Award for Technology for the ARM, the ARM2 featured a 32-bit data bus, 26-bit address space and 27 32-bit registers
4.
Linux kernel
–
The Linux kernel is a monolithic Unix-like computer operating system kernel. The Android operating system for computers, smartphones and smartwatches is also based atop the Linux kernel. While the adoption on desktop computers is low, Linux-based operating systems dominate nearly every segment of computing. As of November 2016, all but two of the worlds 500 most powerful supercomputers run Linux, Linux rapidly attracted developers and users who adopted it as the kernel for other free software projects, notably the GNU Operating System. The Linux kernel has received contributions from nearly 12,000 programmers from more than 1,200 companies, the Linux kernel API, the application programming interface through which user programs interact with the kernel, is meant to be very stable and to not break userspace programs. As part of the functionality, device drivers control the hardware. However, the interface between the kernel and loadable kernel modules, unlike in many other kernels and operating systems, is not meant to be stable by design. The Linux kernel, developed by contributors worldwide, is a prominent example of free, day-to-day development discussions take place on the Linux kernel mailing list. The Linux kernel is released under the GNU General Public License version 2, in April 1991, Linus Torvalds, at the time a 21-year-old computer science student at the University of Helsinki, Finland, started working on some simple ideas for an operating system. He started with a task switcher in Intel 80386 assembly language, on 25 August 1991, Torvalds posted the following to comp. os. minix, a newsgroup on Usenet, Im doing a operating system for 386 AT clones. This has been brewing since April, and is starting to get ready, id like any feedback on things people like/dislike in minix, as my OS resembles it somewhat. Ive currently ported bash and gcc, and things seem to work and this implies that Ill get something practical within a few months Yes - its free of any minix code, and it has a multi-threaded fs. It is NOT portable, and it never will support anything other than AT-harddisks, as thats all I have. Its mostly in C, but most people wouldnt call what I write C and it uses every conceivable feature of the 386 I could find, as it was also a project to teach me about the 386. As already mentioned, it uses a MMU, for both paging and segmentation and its the segmentation that makes it REALLY386 dependent. Some of my C-files are almost as much assembler as C, unlike minix, I also happen to LIKE interrupts, so interrupts are handled without trying to hide the reason behind them. After that, many people contributed code to the project, early on, the MINIX community contributed code and ideas to the Linux kernel. At the time, the GNU Project had created many of the components required for an operating system
5.
Operating system
–
An operating system is system software that manages computer hardware and software resources and provides common services for computer programs. All computer programs, excluding firmware, require a system to function. Operating systems are found on many devices that contain a computer – from cellular phones, the dominant desktop operating system is Microsoft Windows with a market share of around 83. 3%. MacOS by Apple Inc. is in place, and the varieties of Linux is in third position. Linux distributions are dominant in the server and supercomputing sectors, other specialized classes of operating systems, such as embedded and real-time systems, exist for many applications. A single-tasking system can run one program at a time. Multi-tasking may be characterized in preemptive and co-operative types, in preemptive multitasking, the operating system slices the CPU time and dedicates a slot to each of the programs. Unix-like operating systems, e. g. Solaris, Linux, cooperative multitasking is achieved by relying on each process to provide time to the other processes in a defined manner. 16-bit versions of Microsoft Windows used cooperative multi-tasking, 32-bit versions of both Windows NT and Win9x, used preemptive multi-tasking. Single-user operating systems have no facilities to distinguish users, but may allow multiple programs to run in tandem, a distributed operating system manages a group of distinct computers and makes them appear to be a single computer. The development of networked computers that could be linked and communicate with each other gave rise to distributed computing, distributed computations are carried out on more than one machine. When computers in a work in cooperation, they form a distributed system. The technique is used both in virtualization and cloud computing management, and is common in large server warehouses, embedded operating systems are designed to be used in embedded computer systems. They are designed to operate on small machines like PDAs with less autonomy and they are able to operate with a limited number of resources. They are very compact and extremely efficient by design, Windows CE and Minix 3 are some examples of embedded operating systems. A real-time operating system is a system that guarantees to process events or data by a specific moment in time. A real-time operating system may be single- or multi-tasking, but when multitasking, early computers were built to perform a series of single tasks, like a calculator. Basic operating system features were developed in the 1950s, such as resident monitor functions that could run different programs in succession to speed up processing
6.
Machine code
–
Machine code or machine language is a set of instructions executed directly by a computers central processing unit. Each instruction performs a specific task, such as a load. Every program directly executed by a CPU is made up of a series of such instructions, numerical machine code may be regarded as the lowest-level representation of a compiled or assembled computer program or as a primitive and hardware-dependent programming language. While it is possible to write directly in numerical machine code, it is tedious and error prone to manage individual bits and calculate numerical addresses. For this reason machine code is almost never used to programs in modern contexts. Almost all practical programs today are written in languages or assembly language. However, the interpreter itself, which may be seen as an executor or processor, performing the instructions of the source code, every processor or processor family has its own machine code instruction set. Instructions are patterns of bits that by physical design correspond to different commands to the machine, thus, the instruction set is specific to a class of processors using the same architecture. Successor or derivative processor designs often include all the instructions of a predecessor, systems may also differ in other details, such as memory arrangement, operating systems, or peripheral devices. Because a program normally relies on such factors, different systems will not run the same machine code. A machine code instruction set may have all instructions of the same length, how the patterns are organized varies strongly with the particular architecture and often also with the type of instruction. Not all machines or individual instructions have explicit operands, an accumulator machine has a combined left operand and result in an implicit accumulator for most arithmetic instructions. Other architectures have accumulator versions of common instructions, with the accumulator regarded as one of the general registers by longer instructions, a stack machine has most or all of its operands on an implicit stack. Special purpose instructions also often lack explicit operands and this distinction between explicit and implicit operands is important in machine code generators, especially in the register allocation and live range tracking parts. A good code optimizer can track implicit as well as explicit operands which may allow more frequent constant propagation, constant folding of registers, a computer program is a sequence of instructions that are executed by a CPU. While simple processors execute instructions one after another, superscalar processors are capable of executing several instructions at once, program flow may be influenced by special jump instructions that transfer execution to an instruction other than the numerically following one. Conditional jumps are taken or not depending on some condition, a much more readable rendition of machine language, called assembly language, uses mnemonic codes to refer to machine code instructions, rather than using the instructions numeric values directly. For example, on the Zilog Z80 processor, the machine code 00000101, the MIPS instruction set provides a specific example for a machine code whose instructions are always 32 bits long
7.
GNU C Library
–
The GNU C Library, commonly known as glibc, is the GNU Projects implementation of the C standard library. Despite its name, it now also directly supports C++ and it was started in the early 1990s by the Free Software Foundation for their GNU operating system. Released under the GNU Lesser General Public License, glibc is free software, the Glibc project was initially written mostly by Roland McGrath, working for the Free Software Foundation in the 1980s. In February 1988, FSF described glibc as having completed the functionality required by ANSI C. By 1992, it had the ANSI C-1989 and POSIX. 1-1990 functions implemented, in September 1995 Ulrich Drepper made his first contribution to the glibc project and gradually became over the 1990s the core contributor and maintainer of glibc. Drepper held the position for many years and accumulated until 2012 63% of all commits of the project. In the early 1990s, the developers of the Linux kernel forked glibc and their fork, called Linux libc, was maintained separately for years and released versions 2 through 5. At this point, the Linux kernel developers discontinued their fork, the last used version of Linux libc used the internal name libc. so.5. Following on from this, glibc 2. x on Linux uses the soname libc. so.6, the *. so file name is often abbreviated as libc6 following the normal conventions for libraries. Starting in 2001 the librarys development had been overseen by a committee, with Ulrich Drepper kept as the lead contributor, the steering committee installation was surrounded by a public controversy as it was openly described by Ulrich Drepper as a failed hostile takeover maneuver by RMS. While previously in a CVS repository, in 2009 glibc was migrated to a Git repository on Sourceware, after the change in glibc maintainership Debian and other projects migrated back to the glibc, who before switched to alternatives. Also, since the beginning of 2014, the glibc fork EGLIBC is no longer being developed, for most systems, the version of glibc can be obtained by executing the lib file.2, with all extensions common to XSI compliant systems along with all X/Open UNIX extensions. In addition, glibc also provides extensions that have been deemed useful or necessary while developing GNU, Glibc is used in systems that run many different kernels and different hardware architectures. It officially supports the Hurd and Linux kernels, additionally, there are heavily patched versions that run on the kernels of FreeBSD and NetBSD, as well as a forked-version of OpenSolaris. It is also used and named libroot. so in BeOS, Glibc has been criticized as being bloated and slower than other libraries in the past, e. g. by Linus Torvalds and embedded Linux programmers. For this reason, several alternative C standard libraries have been created which emphasize a smaller footprint, however, many small-device projects use GNU libc over the smaller alternatives because of its application support, standards compliance, and completeness. Examples include Openmoko and Familiar Linux for iPaq handhelds, there are compatibility layers to allow programs written for other ecosystems, e. g. Googles Android and Microsofts Windows, to run on glibc interface offering systems. Libhybris is a compatibility layer for Androids Bionic and Wine can be seen as compatibility layer from Win32 API/ABI to glibc
8.
Linux kernel interfaces
–
The Linux kernel provides several interfaces to user-space applications that are used for different purposes and that have different properties by design. There are two types of application programming interface in the Linux kernel that are not to be confused, the kernel–user space API, the Linux API is the kernel–user space API, which allows programs in user space to access system resources and services of the Linux kernel. It is composed out of the System Call Interface of the Linux kernel, the Linux API, by choice, has been kept stable over the decades and never breaks, this stability guarantees the portability of source code. At the same time, Linux kernel developers have historically been conservative, much available free and open-source software is written for the POSIX API. As far as these additional features provide an advantage, programming for the Linux API is preferred over the POSIX-API. Well-known current examples are udev, systemd and Weston, people such as Lennart Poettering openly advocate to prefer the Linux API over the POSIX API, where this offers advantages. Most of those mistakes cannot be fixed because doing so would break the ABI that the presents to the user space. System Call Interface is the denomination for the entirety of all implemented, various subsystems, such as e. g. the DRM define their own system calls and the entirety is called System Call Interface. Various issues with the organization of the Linux kernel system calls are being publicly discussed, issues have been pointed out by Andy Lutomirski, Michael Kerrisk and others. The GNU C Library is a wrapper around the system calls of the Linux kernel, DRM was developed for Linux, and since has been ported to other operating systems as well. The term Linux ABI refers to a kernel–user space ABI, the Application binary interface refers to the compiled binaries, in machine code. Any such ABI is therefore bound to the instruction set, in the Wikipedia a category is maintained for articles on Category, Proprietary software for Linux. An ABI has to be defined for every set, such as x86, x86-64, MIPS, ARMv7-A, ARMv8-A, etc. with the endianness. It should be able to compile the software with different compilers against the definitions specified in the ABI, compilers that are free and open-source software are e. g. GNU Compiler Collection, LLVM/Clang. End-users are in fact not all interested in the Linux API, there are a lot of kernel-internal APIs for all the subsystems to interface with one another. These are being kept fairly stable, but there is no guarantee for stability, in case new research or insights make a change seem favorable, an API is changed, all necessary rewrite and testing have to be done by the author. The Linux kernel is a kernel, hence device drivers are kernel components. To ease the burden of maintaining their device drivers out-of-tree
9.
Source code
–
In computing, source code is any collection of computer instructions, possibly with comments, written using a human-readable programming language, usually as ordinary text. The source code of a program is designed to facilitate the work of computer programmers. The source code is often transformed by an assembler or compiler into binary machine code understood by the computer, the machine code might then be stored for execution at a later time. Alternatively, source code may be interpreted and thus immediately executed, most application software is distributed in a form that includes only executable files. If the source code were included it would be useful to a user, programmer or a system administrator, the Linux Information Project defines source code as, Source code is the version of software as it is originally written by a human in plain text. The notion of source code may also be more broadly, to include machine code and notations in graphical languages. It is therefore so construed as to include code, very high level languages. Often there are several steps of program translation or minification between the source code typed by a human and an executable program. The earliest programs for stored-program computers were entered in binary through the front panel switches of the computer and this first-generation programming language had no distinction between source code and machine code. When IBM first offered software to work with its machine, the code was provided at no additional charge. At that time, the cost of developing and supporting software was included in the price of the hardware, for decades, IBM distributed source code with its software product licenses, until 1983. Most early computer magazines published source code as type-in programs, Source code can also be stored in a database or elsewhere. The source code for a piece of software may be contained in a single file or many files. Though the practice is uncommon, a source code can be written in different programming languages. For example, a program written primarily in the C programming language, in some languages, such as Java, this can be done at run time. The code base of a programming project is the larger collection of all the source code of all the computer programs which make up the project. It has become practice to maintain code bases in version control systems. Moderately complex software customarily requires the compilation or assembly of several, sometimes dozens or even hundreds, in these cases, instructions for compilations, such as a Makefile, are included with the source code
10.
Compiler
–
A compiler is a computer program that transforms source code written in a programming language into another computer language, with the latter often having a binary form known as object code. The most common reason for converting source code is to create an executable program, the name compiler is primarily used for programs that translate source code from a high-level programming language to a lower level language. If the compiled program can run on a computer whose CPU or operating system is different from the one on which the compiler runs, more generally, compilers are a specific type of translator. While all programs that take a set of programming specifications and translate them, a program that translates from a low-level language to a higher level one is a decompiler. A program that translates between high-level languages is called a source-to-source compiler or transpiler. A language rewriter is usually a program that translates the form of expressions without a change of language, the term compiler-compiler is sometimes used to refer to a parser generator, a tool often used to help create the lexer and parser. A compiler is likely to many or all of the following operations, lexical analysis, preprocessing, parsing, semantic analysis, code generation. Program faults caused by incorrect compiler behavior can be difficult to track down and work around, therefore. Software for early computers was written in assembly language. The notion of a high level programming language dates back to 1943, no actual implementation occurred until the 1970s, however. The first actual compilers date from the 1950s, identifying the very first is hard, because there is subjectivity in deciding when programs become advanced enough to count as the full concept rather than a precursor. 1952 saw two important advances. Grace Hopper wrote the compiler for the A-0 programming language, though the A-0 functioned more as a loader or linker than the notion of a full compiler. Also in 1952, the first autocode compiler was developed by Alick Glennie for the Mark 1 computer at the University of Manchester and this is considered by some to be the first compiled programming language. The FORTRAN team led by John Backus at IBM is generally credited as having introduced the first unambiguously complete compiler, COBOL was an early language to be compiled on multiple architectures, in 1960. In many application domains the idea of using a higher level language quickly caught on, because of the expanding functionality supported by newer programming languages and the increasing complexity of computer architectures, compilers have become more complex. Early compilers were written in assembly language, the first self-hosting compiler – capable of compiling its own source code in a high-level language – was created in 1962 for the Lisp programming language by Tim Hart and Mike Levin at MIT. Since the 1970s, it has become practice to implement a compiler in the language it compiles
11.
Library (computing)
–
In computer science, a library is a collection of non-volatile resources used by computer programs, often to develop software. These may include data, documentation, help data, message templates, pre-written code. In IBMs OS/360 and its successors they are referred to as partitioned data sets, a library is also a collection of implementations of behavior, written in terms of a language, that has a well-defined interface by which the behavior is invoked. For instance, people who want to write a higher level program can use a library to make system calls instead of implementing those system calls over and over again, in addition, the behavior is provided for reuse by multiple independent programs. A program invokes the library-provided behavior via a mechanism of the language, for example, in a simple imperative language such as C, the behavior in a library is invoked by using Cs normal function-call. What distinguishes the call as being to a library, versus being to function in the same program, is the way that the code is organized in the system. This distinction can gain a hierarchical notion when a program grows large, in that case, there may be internal libraries that are reused by independent sub-portions of the large program. The value of a lies in the reuse of the behavior. When a program invokes a library, it gains the behavior implemented inside that library without having to implement that behavior itself, libraries encourage the sharing of code in a modular fashion, and ease the distribution of the code. The behavior implemented by a library can be connected to the program at different program lifecycle phases. If the code of the library is accessed during the build of the invoking program, an alternative is to build the executable of the invoking program and distribute that, independently of the library implementation. The library behavior is connected after the executable has been invoked to be executed, either as part of the process of starting the execution, in this case the library is called a dynamic library. A dynamic library can be loaded and linked when preparing a program for execution, alternatively, in the middle of execution, an application may explicitly request that a module be loaded. Most compiled languages have a library although programmers can also create their own custom libraries. Most modern software systems provide libraries that implement the majority of the system services, such libraries have commoditized the services which a modern application requires. As such, most code used by modern applications is provided in these system libraries, the earliest programming concepts analogous to libraries were intended to separate data definitions from the program implementation. JOVIAL brought the COMPOOL concept to popular attention in 1959, although it adopted the idea from the large-system SAGE software, COBOL also included primitive capabilities for a library system in 1959, but Jean Sammet described them as inadequate library facilities in retrospect. Another major contributor to the library concept came in the form of the subprogram innovation of FORTRAN
.gif){kind=small}