1.
Computer 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
2.
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
3.
Executable
–
These instructions are traditionally machine code instructions for a physical CPU. Executable code is used to describe sequences of instructions that do not necessarily constitute an executable file, for example. Several object files are linked to create the executable, object files, executable or not, are typically in a container format, such as Executable and Linkable Format. This structures the generated code, for example dividing it into sections such as the. text. data. In order to be executed by the system, a file must conform to the systems Application Binary Interface. For example, in ELF, the point is specified in the header in the e_entry field. In the GCC this field is set by the based on the _start symbol. For C, this is done by linking in the crt0 object, Executable files thus normally contain significant additional machine code beyond that directly generated from the specific source code. In some cases it is desirable to omit this, for example for embedded systems development or simply to understand how compilation, linking, comparison of executable file formats EXE File Format at What Is
4.
Interpreter (computing)
–
An interpreter generally uses one of the following strategies for program execution, parse the source code and perform its behavior directly. Translate source code into some efficient intermediate representation and immediately execute this, explicitly execute stored precompiled code made by a compiler which is part of the interpreter system. Early versions of Lisp programming language and Dartmouth BASIC would be examples of the first type, perl, Python, MATLAB, and Ruby are examples of the second, while UCSD Pascal is an example of the third type. Source programs are compiled ahead of time and stored as machine independent code, some systems, such as Smalltalk and contemporary versions of BASIC and Java may also combine two and three. Interpreters of various types have also constructed for many languages traditionally associated with compilation, such as Algol, Fortran, Cobol. The terms interpreted language or compiled language signify that the implementation of that language is an interpreter or a compiler. A high level language is ideally an abstraction independent of particular implementations, the first interpreted high-level language was Lisp. Lisp was first implemented in 1958 by Steve Russell on an IBM704 computer, Russell had read John McCarthys paper, and realized that the Lisp eval function could be implemented in machine code. The result was a working Lisp interpreter which could be used to run Lisp programs, or more properly, Programs written in a high level language are either directly executed by some kind of interpreter or converted into machine code by a compiler for the CPU to execute. While compilers generally produce machine code directly executable by computer hardware and this is basically the same machine specific code but augmented with a symbol table with names and tags to make executable blocks identifiable and relocatable. Compiled programs will typically use building blocks kept in a library of object code modules. A linker is used to combine library files with the file of the application to form a single executable file. The object files that are used to generate an executable file are thus often produced at different times, thus, both compilers and interpreters generally turn source code into tokens, both may generate a parse tree, and both may generate immediate instructions. However, a program still runs much faster, under most circumstances, in part because compilers are designed to optimize code. This is especially true for simpler high level languages without dynamic data structures, checks, when the program is loaded for execution. Historically, most interpreter-systems have had an editor built in. This is becoming more common also for compilers, although some prefer to use an editor of their choice. During the software development cycle, programmers make frequent changes to source code, the larger the program, the longer the wait
5.
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
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.
Microcode
–
Microcode is a technique that imposes an interpreter between the hardware and the architectural level of a computer. As such, the microcode is a layer of hardware-level instructions that implement higher-level machine code instructions or internal state machine sequencing in many digital processing elements. Microcode typically resides in special high-speed memory and translates machine instructions and it separates the machine instructions from the underlying electronics so that instructions can be designed and altered more freely. It also facilitates the building of complex multi-step instructions, while reducing the complexity of computer circuits, writing microcode is often called microprogramming and the microcode in a particular processor implementation is sometimes called a microprogram. Some hardware vendors, especially IBM, use the term microcode as a synonym for firmware, when compared to normal application programs, the elements composing a microprogram exist on a lower conceptual level. To avoid confusion, each microprogram-related element is differentiated by the prefix, microinstruction, microassembler, microprogrammer, microarchitecture. Engineers normally write the microcode during the phase of a processor, storing it in a read-only memory or programmable logic array structure. However, machines also exist that have some or all microcode stored in SRAM or flash memory and this is traditionally denoted as writeable control store in the context of computers, which can be either read-only or read-write memory. Complex digital processors may also more than one control unit in order to delegate sub-tasks that must be performed essentially asynchronously in parallel. A high-level programmer, or even an assembly programmer, does not normally see or change microcode, microprograms consist of series of microinstructions, which control the CPU at a very fundamental level of hardware circuitry. g. 128 bits on a 360/85 with an emulator feature, microcode was originally developed as a simpler method of developing the control logic for a computer. Initially, CPU instruction sets were hardwired, each step needed to fetch, decode, and execute the machine instructions was controlled directly by combinational logic and rather minimal sequential state machine circuitry. Microcode simplified the job by allowing much of the processors behaviour, even late in the design process, microcode could easily be changed, whereas hard-wired CPU designs were very cumbersome to change. Thus, this greatly facilitated CPU design, the IBM Future Systems project and Data General Fountainhead Processor are examples of this. During the 1970s, CPU speeds grew more quickly than memory speeds and numerous techniques such as memory block transfer, memory pre-fetch, high-level machine instructions, made possible by microcode, helped further, as fewer more complex machine instructions require less memory bandwidth. For example, an operation on a string can be done as a single machine instruction. Architectures with instruction sets implemented by complex microprograms included the IBM System/360, the approach of increasingly complex microcode-implemented instruction sets was later called CISC. An alternate approach, used in microprocessors, is to use PLAs or ROMs mainly for instruction decoding
8.
Android Runtime
–
Android Runtime is an application runtime environment used by the Android operating system. While Dalvik interprets the rest of applications bytecode, native execution of those short bytecode segments, unlike Dalvik, ART introduces the use of ahead-of-time compilation by compiling entire applications into native machine code upon their installation. As a downside, ART requires additional time for the compilation when an application is installed, Android 4.4 KitKat brought a technology preview of ART, including it as an alternative runtime environment and keeping Dalvik as the default virtual machine. In the subsequent major Android release, Android 5.0 Lollipop, Android 7.0 Nougat introduced JIT compiler with code profiling to ART, which lets it constantly improve the performance of Android apps as they run
9.
Common Language Runtime
–
The Common Language Runtime, the virtual machine component of Microsofts. NET framework, manages the execution of. NET programs. A process known as just-in-time compilation converts compiled code into machine instructions which the computers CPU then executes, the CLR provides additional services including memory management, type safety, exception handling, garbage collection, security and thread management. All programs written for the. NET framework, regardless of programming language, are executed by the CLR, all versions of the. NET framework include CLR. CLR implements the Virtual Execution System as defined in the Common Language Infrastructure standard, a public standard defines the Common Language Infrastructure specification. The runtime provides the features, The ability to easily use components developed in other languages. Extensible types provided by a class library, Language features such as inheritance, interfaces, and overloading for object-oriented programming. Support for threads that allows creation of multithreaded, scalable applications, use of delegates instead of function pointers for increased type safety and security. For more information about delegates, see Common Type System
10.
Java virtual machine
–
A Java virtual machine is an abstract computing machine that enables a computer to run a Java program. There are three notions of the JVM, specification, implementation, and instance, the specification is a document that formally describes what is required of a JVM implementation. Having a single specification ensures all implementations are interoperable, a JVM implementation is a computer program that meets the requirements of the JVM specification. An instance of a JVM is a running in a process that executes a computer program compiled into Java bytecode. Java Runtime Environment is a package that contains what is required to run a Java program. It includes a Java Virtual Machine implementation together with an implementation of the Java Class Library, the Oracle Corporation, which owns the Java trademark, distributes a Java Runtime environment with their Java Virtual Machine called HotSpot. Java Development Kit is a superset of a JRE and contains tools for Java programmers, the Java Development Kit is provided free of charge either by Oracle Corporation directly, or by the OpenJDK open source project, which is governed by Oracle. The Java virtual machine is an abstract computer defined by a specification, the main reason for this omission is to not unnecessarily constrain implementers. Any Java application can be run only inside some concrete implementation of the specification of the Java virtual machine. Starting with Java Platform, Standard Edition 5.0, changes to the JVM specification have been developed under the Java Community Process as JSR924. As of 2006, changes to specification to support changes proposed to the file format are being done as a maintenance release of JSR924. Oracle provides tests that verify the operation of implementations of the Java Virtual Machine. One of Oracles JVMs is named HotSpot, the other, inherited from BEA Systems is JRockit, clean-room Java implementations include Kaffe and IBM J9. Oracle owns the Java trademark and may allow its use to certify implementation suites as fully compatible with Oracles specification, one of the organizational units of JVM byte code is a class. A class loader implementation must be able to recognize and load anything that conforms to the Java class file format, any implementation is free to recognize other binary forms besides class files, but it must recognize class files. Initialization, invokes Java code that initializes class variables to their proper starting values, in general, there are two types of class loader, bootstrap class loader and user defined class loader. Every Java virtual machine implementation must have a class loader. The Java virtual machine specification doesnt specify how a class loader should locate classes, the JVM has instructions for the following groups of tasks, The aim is binary compatibility
11.
Chrome V8
–
The V8 JavaScript Engine is an open source JavaScript engine developed by The Chromium Project for the Google Chrome web browser. It has been used in other projects, such as Couchbase, MongoDB. As of 2012, the programmer is Lars Bak. The first version of the V8 engine was released at the time as the first version of Chrome. The compiled code is additionally optimized dynamically at runtime, based on heuristics of the codes execution profile, optimization techniques used include inlining, elision of expensive runtime properties, and inline caching, among many others. V8 can compile to IA-32, x86-64, ARM, or MIPS ISAs, it has also ported to PowerPC. The garbage collector of V8 is a generational incremental collector, the V8 assembler is based on the Strongtalk assembler. On 7 December 2010, a new compiling infrastructure named Crankshaft was released, since version 41 of Chrome in 2015, project TurboFan has been added to enable more speed, e. g. for asm. js. In 2016, the Ignition interpreter was added to V8 with the goal of reducing the memory usage on small memory Android phones in comparison with TurboFan
12.
Node.js
–
Node. js is an open-source, cross-platform JavaScript runtime environment for developing a diverse variety of server tools and applications. Although Node. js is not a JavaScript framework, many of its modules are written in JavaScript. The runtime environment interprets JavaScript using Googles V8 JavaScript engine, Node. js has an event-driven architecture capable of asynchronous I/O. These design choices aim to optimize throughput and scalability in Web applications with many input/output operations, the Node. js distributed development project, governed by the Node. js Foundation, is facilitated by the Linux Foundations Collaborative Projects program. Corporate users of Node. js software include GoDaddy, Groupon, IBM, LinkedIn, Microsoft, Netflix, PayPal, Rakuten, SAP, Voxer, Walmart, Yahoo. Node. js was originally written in 2009 by Ryan Dahl. The initial release supported only Linux and Mac OSX and its development and maintenance was led by Dahl and later sponsored by Joyent. Dahl was inspired to create Node. js after seeing a file upload progress bar on Flickr, the browser did not know how much of the file had been uploaded and had to query the Web server. Dahl demonstrated the project at the inaugural European JSConf on November 8,2009, Node. js combined Googles V8 JavaScript engine, an event loop and a low-level I/O API. The project received a standing ovation, in January 2010, a package manager was introduced for the Node. js environment called npm. The package manager makes it easier for programmers to publish and share code of Node. js libraries and is designed to simplify installation, updating. In June 2011, Microsoft and Joyent implemented a native Windows version of Node. js, the first Node. js build supporting Windows was released in July 2011. In January 2012, Dahl stepped aside, promoting coworker and npm creator Isaac Schlueter to manage the project, in January 2014, Schlueter announced that Timothy J. Fontaine would lead the project. In December 2014, Fedor Indutny started io. js, a fork of Node. js, due to the internal conflict over Joyents governance, io. js was created as an open governance alternative with a separate technical committee. Unlike Node. js, the authors planned to keep io. js up-to-date with the latest releases of the Google V8 JavaScript engine, in February 2015, the intent to form a neutral Node. js Foundation was announced. By June 2015, the Node. js and io. js communities voted to work together under the Node. js Foundation, in September 2015, Node. js v0.12 and io. js v3.3 were merged back together into Node v4.0. This brought V8 ES6 features into Node. js, and a long-term support release cycle, as of 2016, the io. js website recommends that developers switch back to Node. js and that no further releases of io. js are planned due to the merger. Node. js allows the creation of Web servers and networking tools using JavaScript, modules are provided for file system I/O, networking, binary data, cryptography functions, data streams and other core functions. Node. jss modules use an API designed to reduce the complexity of writing server applications, Node. js applications can run on Linux, macOS, Microsoft Windows, NonStop, and Unix servers
13.
GNU Compiler Collection
–
The GNU Compiler Collection is a compiler system produced by the GNU Project supporting various programming languages. GCC is a key component of the GNU toolchain and the compiler for most Unix-like Operating Systems. The Free Software Foundation distributes GCC under the GNU General Public License, GCC has played an important role in the growth of free software, as both a tool and an example. Originally named the GNU C Compiler, when it handled the C programming language. It was extended to compile C++ in December of that year, front ends were later developed for Objective-C, Objective-C++, Fortran, Java, Ada, and Go among others. Version 4.5 of the OpenMP specification is now supported in the C and C++ compilers, by default, the current version supports gnu++14, a superset of C++14 and gnu11, a superset of C11, with strict standard support also available. It also provides support for C++17 and later. GCC has been ported to a variety of instruction set architectures. GCC is also available for most embedded systems, including ARM-based, AMCC, the compiler can target a wide variety of platforms. Versions are also available for Microsoft Windows and other operating systems, GCC can compile code for Android and iOS. In an effort to bootstrap the GNU operating system, Richard Stallman asked Andrew S. Tanenbaum, when Tanenbaum told him that while the Free University was free, the compiler was not, Stallman decided to write his own. Stallmans initial plan was to rewrite an existing compiler from Lawrence Livermore Laboratory from Pastel to C with some help from Len Tower, none of the Pastel compiler code ended up in GCC, though Stallman did use the C front end he had written. GCC was first released March 22,1987, available by FTP from MIT, multiple forks proved inefficient and unwieldy, however, and the difficulty in getting work accepted by the official GCC project was greatly frustrating for many. In 1997, a group of developers formed Experimental/Enhanced GNU Compiler System to merge several experimental forks into a single project, the basis of the merger was a GCC development snapshot taken between the 2.7 and 2.81 releases. Projects merged included g77, PGCC, many C++ improvements, and many new architectures, with the release of GCC2.95 in July 1999 the two projects were once again united. GCC has since been maintained by a group of programmers from around the world under the direction of a steering committee. It has been ported to more kinds of processors and operating systems than any other compiler, GCC has been ported to a wide variety of instruction set architectures, and is widely deployed as a tool in the development of both free and proprietary software. GCC is also available for most embedded systems, including Symbian, ARM-based, AMCC, the compiler can target a wide variety of platforms, including video game consoles such as the PlayStation 2, Cell SPE of PlayStation 3 and Dreamcast
14.
LLVM
–
The LLVM compiler infrastructure project is a collection of modular and reusable compiler and toolchain technologies used to develop compiler front ends and back ends. LLVM is written in C++ and is designed for compile-time, link-time, run-time, the LLVM project started in 2000 at the University of Illinois at Urbana–Champaign, under the direction of Vikram Adve and Chris Lattner. LLVM was originally developed as an infrastructure to investigate dynamic compilation techniques for static and dynamic programming languages. LLVM was released under the University of Illinois/NCSA Open Source License, in 2005, Apple Inc. hired Lattner and formed a team to work on the LLVM system for various uses within Apples development systems. LLVM is an part of Apples latest development tools for macOS and iOS. Since 2013, Sony has been using LLVMs primary front end Clang compiler in the development kit of its PS4 console. Now, LLVM is a brand that applies to the LLVM umbrella project, the LLVM intermediate representation, the LLVM debugger, LLVM is administered by the LLVM Foundation. Its president is compiler engineer Tanya Lattner, the Association for Computing Machinery presented Adve, Lattner, and Evan Cheng with the 2012 ACM Software System Award for LLVM. LLVM can provide the middle layers of a compiler system, taking intermediate representation code from a compiler. This new IR can then be converted and linked into machine-dependent assembly language code for a target platform, LLVM can accept the IR from the GNU Compiler Collection toolchain, allowing it to be used with a wide array of extant compilers written for that project. LLVM can also generate relocatable machine code at compile-time or link-time or even binary machine code at run-time, LLVM supports a language-independent instruction set and type system. Each instruction is in static single assignment form, meaning that each variable is assigned once and this helps simplify the analysis of dependencies among variables. LLVM allows code to be compiled statically, as it is under the traditional GCC system, or left for late-compiling from the IR to machine code via just-in-time compilation, similar to Java. The type system consists of basic types such as integer or floating point numbers and five derived types, pointers, arrays, vectors, structures, a type construct in a concrete language can be represented by combining these basic types in LLVM. For example, a class in C++ can be represented by a mix of structures, functions and this feature is used in the OpenGL pipeline of Mac OS X Leopard to provide support for missing hardware features. Graphics code within the OpenGL stack can be left in intermediate representation, on systems with high-end graphics processing units, the resulting code remains quite thin, passing the instructions on to the GPU with minimal changes. On systems with low-end GPUs, LLVM will compile optional procedures that run on the central processing unit that emulate instructions that the GPU cannot run internally. LLVM improved performance on machines using Intel GMA chipsets
15.
Emulator
–
In computing, an emulator is hardware or software that enables one computer system to behave like another computer system. An emulator typically enables the host system to run software or use peripheral devices designed for the guest system, emulation refers to the ability of a computer program in an electronic device to emulate another program or device. Many printers, for example, are designed to emulate Hewlett-Packard LaserJet printers because so much software is written for HP printers. If a non-HP printer emulates an HP printer, any software written for a real HP printer will also run in the non-HP printer emulation and produce equivalent printing. Since at least the 1990s until today, some video game enthusiasts use emulators to play 1980s arcade games using the original 1980s programming code, a hardware emulator is an emulator which takes the form of a hardware device. In a theoretical sense, the Church-Turing thesis implies that any operating environment can be emulated within any other environment. However, in practice, it can be difficult, particularly when the exact behavior of the system to be emulated is not documented and has to be deduced through reverse engineering. Emulation is a strategy in digital preservation to combat obsolescence, emulation addresses the original hardware and software environment of the digital object, and recreates it on a current machine. The emulator allows the user to have access to any kind of application or operating system on a current platform and he further states that this should not only apply to out of date systems, but also be upwardly mobile to future unknown systems. Potentially better graphics quality than original hardware, potentially additional features original hardware didnt have. Emulators maintain the look, feel, and behavior of the digital object. Despite the original cost of developing an emulator, it may prove to be the more cost efficient solution over time, many emulators have already been developed and released under GNU General Public License through the open source environment, allowing for wide scale collaboration. Emulators allow software exclusive to one system to be used on another, for example, a PlayStation 2 exclusive video game could be played on a PC using an emulator. This is especially useful when the system is difficult to obtain. Copyright laws are not yet in effect to address saving the documentation and these protections make it more difficult to design emulators, since they must be accurate enough to avoid triggering the protections, whose effects may not be obvious. Emulators require better hardware than the system has. Because of its use of digital formats, new media art relies heavily on emulation as a preservation strategy. The paradox is that the emulation and the emulator have to be made to work on future computers, emulation techniques are commonly used during the design and development of new systems
16.
Computer architecture
–
In computer engineering, computer architecture is a set of rules and methods that describe the functionality, organization, and implementation of computer systems. Some definitions of architecture define it as describing the capabilities and programming model of a computer, in other definitions computer architecture involves instruction set architecture design, microarchitecture design, logic design, and implementation. The first documented computer architecture was in the correspondence between Charles Babbage and Ada Lovelace, describing the analytical engine, johnson had the opportunity to write a proprietary research communication about the Stretch, an IBM-developed supercomputer for Los Alamos National Laboratory. Brooks went on to develop the IBM System/360 line of computers. Later, computer users came to use the term in many less-explicit ways, the earliest computer architectures were designed on paper and then directly built into the final hardware form. The discipline of architecture has three main subcategories, Instruction Set Architecture, or ISA. The ISA defines the code that a processor reads and acts upon as well as the word size, memory address modes, processor registers. Microarchitecture, or computer organization describes how a processor will implement the ISA. The size of a computers CPU cache for instance, is an issue that generally has nothing to do with the ISA, system Design includes all of the other hardware components within a computing system. These include, Data processing other than the CPU, such as memory access Other issues such as virtualization, multiprocessing. There are other types of computer architecture, E. g. the C, C++, or Java standards define different Programmer Visible Macroarchitecture. UISA —a group of machines with different hardware level microarchitectures may share a common microcode architecture, pin Architecture, The hardware functions that a microprocessor should provide to a hardware platform, e. g. the x86 pins A20M, FERR/IGNNE or FLUSH. Also, messages that the processor should emit so that external caches can be invalidated, pin architecture functions are more flexible than ISA functions because external hardware can adapt to new encodings, or change from a pin to a message. The term architecture fits, because the functions must be provided for compatible systems, the purpose is to design a computer that maximizes performance while keeping power consumption in check, costs low relative to the amount of expected performance, and is also very reliable. For this, many aspects are to be considered which includes Instruction Set Design, Functional Organization, Logic Design, the implementation involves Integrated Circuit Design, Packaging, Power, and Cooling. Optimization of the design requires familiarity with Compilers, Operating Systems to Logic Design, an instruction set architecture is the interface between the computers software and hardware and also can be viewed as the programmers view of the machine. Computers do not understand high level languages such as Java, C++, a processor only understands instructions encoded in some numerical fashion, usually as binary numbers. Software tools, such as compilers, translate those high level languages into instructions that the processor can understand, besides instructions, the ISA defines items in the computer that are available to a program—e. g
17.
Full virtualization
–
In such an environment, any software capable of execution on the raw hardware can be run in the virtual machine and, in particular, any operating systems. The obvious test of full virtualization is whether a system intended for stand-alone use can successfully run inside a virtual machine. Other forms of platform virtualization allow only certain or modified software to run within a virtual machine, the concept of full virtualization is well established in the literature, but it is not always referred to by this specific term, see platform virtualization for terminology. An important example of full virtualization was that provided by the program of IBMs CP/CMS operating system. It was first demonstrated with IBMs CP-40 research system in 1967, then distributed via open source in CP/CMS in 1967-1972, each CP/CMS user was provided a simulated, stand-alone computer. Each such virtual machine had the capabilities of the underlying machine. This simulation was comprehensive, and was based on the Principles of Operation manual for the hardware and it thus included such elements as instruction set, main memory, interrupts, exceptions, and device access. The result was a machine that could be multiplexed among many users. Full virtualization is possible only with the combination of hardware and software elements. Similarly, full virtualization was not quite possible with the x86 platform until the 2005-2006 addition of the AMD-V, many platform hypervisors for the x86 platform came very close and claimed full virtualization even prior to the AMD-V and Intel VT-x additions. Examples include Adeos, Mac-on-Linux, Parallels Desktop for Mac, Parallels Workstation, VMware Workstation, VMware Server, VirtualBox, Win4BSD, a key challenge for full virtualization is the interception and simulation of privileged operations, such as I/O instructions. But other instructions that would pierce the virtual machine cannot be allowed to execute directly, such instructions either access or affect state information that is outside the virtual machine. Compatibility is Not Transparency, VMM Detection Myths and Realities
18.
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
19.
Hypervisor
–
A hypervisor or virtual machine monitor is computer software, firmware, or hardware, that creates and runs virtual machines. A computer on which a hypervisor runs one or more virtual machines is called a host machine, the hypervisor presents the guest operating systems with a virtual operating platform and manages the execution of the guest operating systems. Multiple instances of a variety of operating systems may share the virtualized hardware resources, for example, Linux, Windows, the term dates to circa 1970, in the earlier CP/CMS system the term Control Program was used instead. In their 1974 article, Formal Requirements for Virtualizable Third Generation Architectures, Gerald J. Popek, for this reason, they are sometimes called bare metal hypervisors. The first hypervisors, which IBM developed in the 1960s, were native hypervisors and these included the test software SIMMON and the CP/CMS operating system. Modern equivalents include Xen, Oracle VM Server for SPARC, Oracle VM Server for x86, Microsoft Hyper-V, type-2 or hosted hypervisors These hypervisors run on a conventional operating system just as other computer programs do. A guest operating system runs as a process on the host, type-2 hypervisors abstract guest operating systems from the host operating system. VMware Workstation, VMware Player, VirtualBox, Parallels Desktop for Mac, however, the distinction between these two types is not necessarily clear. Linuxs Kernel-based Virtual Machine and FreeBSDs bhyve are kernel modules that convert the host operating system to a type-1 hypervisor. CP-40 ran on a S/360-40 that was modified at the IBM Cambridge Scientific Center to support Dynamic Address Translation, prior to this time, computer hardware had only been virtualized enough to allow multiple user applications to run concurrently. With CP-40, the hardwares supervisor state was virtualized as well, programmers soon re-implemented CP-40 for the IBM System/360-67, the first production computer-system capable of full virtualization. Both CP-40 and CP-67 began production use in 1967, CP/CMS was available to IBM customers from 1968 to early 1970s, in source code form without support. CP/CMS formed part of IBMs attempt to build robust time-sharing systems for its mainframe computers, IBM announced its System/370 series in 1970 without any virtualization features, but added virtual memory support in the August 1972 Advanced Function announcement. Virtualization has been featured in all successor systems, the 1972 announcement also included VM/370, a reimplementation of CP/CMS for the S/370. Unlike CP/CMS, IBM provided support for this version, VM stands for Virtual Machine, emphasizing that all, and not just some, of the hardware interfaces are virtualized. Both VM and CP/CMS enjoyed early acceptance and rapid development by universities, corporate users, users played an active role in ongoing development, anticipating trends seen in modern open source projects. It enjoyed a resurgence of popularity and support from 2000 as the z/VM product, as mentioned above, the VM control program includes a hypervisor-call handler that intercepts DIAG instructions used within a virtual machine. This provides fast-path non-virtualized execution of file-system access and other operations, when first implemented in CP/CMS release 3
20.
QEMU
–
QEMU is a free and open-source hosted hypervisor that performs hardware virtualization. QEMU is a virtual machine monitor, it emulates CPUs through dynamic binary translation and provides a set of device models. It also can be used together with KVM in order to run virtual machines at near-native speed, QEMU can also do CPU emulation for user-level processes, allowing applications compiled for one architecture to run on another. QEMU was written by Fabrice Bellard and is free software and is licensed under GNU General Public License. Various parts are released under BSD license, GNU Lesser General Public License or other GPL-compatible licenses, there is an option to use the proprietary FMOD library when running on Microsoft Windows, which, if used, disqualifies the use of a single open source software license. However, the default is to use DirectSound, QEMU has multiple operating modes, User-mode emulation In this mode QEMU runs single Linux or Darwin/macOS programs that were compiled for a different instruction set. System calls are thunked for endianness and for 32/64 bit mismatches, fast cross-compilation and cross-debugging are the main targets for user-mode emulation. System emulation In this mode QEMU emulates a full computer system and it can be used to provide virtual hosting of several virtual computers on a single computer. KVM Hosting Here QEMU deals with the setting up and migration of KVM images and it is still involved in the emulation of hardware, but the execution of the guest is done by KVM as requested by QEMU. Xen Hosting QEMU is involved only in the emulation of hardware, QEMU can save and restore the state of the virtual machine with all programs running. Guest operating-systems do not need patching in order to run inside QEMU and these include, hard disks, CD-ROM drives, network cards, audio interfaces, and USB devices. USB devices can be emulated, or the hosts USB devices can be used. Virtual disk images can be stored in a format that only take up disk space that the guest OS actually uses. This way, an emulated 120 GB disk may occupy only a few hundred megabytes on the host, the QCOW2 format also allows the creation of overlay images that record the difference from another base image file. This provides the possibility for reverting the emulated disks contents to an earlier state, for example, a base image could hold a fresh install of an operating system that is known to work, and the overlay images are used. Should the guest system become unusable, the user can delete the overlay, QEMU can emulate network cards which share the host systems connectivity by doing network address translation, effectively allowing the guest to use the same network as the host. The virtual network cards can connect to network cards of other instances of QEMU or to local TAP interfaces. Network connectivity can also be achieved by bridging a TUN/TAP interface used by QEMU with a non-virtual Ethernet interface on the host OS using the host OSs bridging features
21.
Central processing unit
–
The computer industry has used the term central processing unit at least since the early 1960s. The form, design and implementation of CPUs have changed over the course of their history, most modern CPUs are microprocessors, meaning they are contained on a single integrated circuit chip. An IC that contains a CPU may also contain memory, peripheral interfaces, some computers employ a multi-core processor, which is a single chip containing two or more CPUs called cores, in that context, one can speak of such single chips as sockets. Array processors or vector processors have multiple processors that operate in parallel, there also exists the concept of virtual CPUs which are an abstraction of dynamical aggregated computational resources. Early computers such as the ENIAC had to be rewired to perform different tasks. Since the term CPU is generally defined as a device for software execution, the idea of a stored-program computer was already present in the design of J. Presper Eckert and John William Mauchlys ENIAC, but was initially omitted so that it could be finished sooner. On June 30,1945, before ENIAC was made, mathematician John von Neumann distributed the paper entitled First Draft of a Report on the EDVAC and it was the outline of a stored-program computer that would eventually be completed in August 1949. EDVAC was designed to perform a number of instructions of various types. Significantly, the programs written for EDVAC were to be stored in high-speed computer memory rather than specified by the wiring of the computer. This overcame a severe limitation of ENIAC, which was the considerable time, with von Neumanns design, the program that EDVAC ran could be changed simply by changing the contents of the memory. Early CPUs were custom designs used as part of a larger, however, this method of designing custom CPUs for a particular application has largely given way to the development of multi-purpose processors produced in large quantities. This standardization began in the era of discrete transistor mainframes and minicomputers and has accelerated with the popularization of the integrated circuit. The IC has allowed increasingly complex CPUs to be designed and manufactured to tolerances on the order of nanometers, both the miniaturization and standardization of CPUs have increased the presence of digital devices in modern life far beyond the limited application of dedicated computing machines. Modern microprocessors appear in electronic devices ranging from automobiles to cellphones, the so-called Harvard architecture of the Harvard Mark I, which was completed before EDVAC, also utilized a stored-program design using punched paper tape rather than electronic memory. Relays and vacuum tubes were used as switching elements, a useful computer requires thousands or tens of thousands of switching devices. The overall speed of a system is dependent on the speed of the switches, tube computers like EDVAC tended to average eight hours between failures, whereas relay computers like the Harvard Mark I failed very rarely. In the end, tube-based CPUs became dominant because the significant speed advantages afforded generally outweighed the reliability problems, most of these early synchronous CPUs ran at low clock rates compared to modern microelectronic designs. Clock signal frequencies ranging from 100 kHz to 4 MHz were very common at this time, the design complexity of CPUs increased as various technologies facilitated building smaller and more reliable electronic devices
22.
Kernel (operating system)
–
The kernel is a computer program that is the core of a computers operating system, with complete control over everything in the system. It is the first program loaded on start-up and it handles the rest of start-up as well as input/output requests from software, translating them into data-processing instructions for the central processing unit. It handles memory and peripherals like keyboards, monitors, printers, the critical code of the kernel is usually loaded into a protected area of memory, which prevents it from being overwritten by applications or other, more minor parts of the operating system. The kernel performs its tasks, such as running processes and handling interrupts, in contrast, everything a user does is in user space, writing text in a text editor, running programs in a GUI, etc. This separation prevents user data and kernel data from interfering with other and causing instability. The kernels interface is an abstraction layer. When a process makes requests of the kernel, it is called a system call, Kernel designs differ in how they manage these system calls and resources. A monolithic kernel runs all the operating instructions in the same address space. A microkernel runs most processes in space, for modularity. The kernel takes responsibility for deciding at any time which of the running programs should be allocated to the processor or processors. Random-access memory Random-access memory is used to both program instructions and data. Typically, both need to be present in memory in order for a program to execute, often multiple programs will want access to memory, frequently demanding more memory than the computer has available. The kernel is responsible for deciding which memory each process can use, input/output devices I/O devices include such peripherals as keyboards, mice, disk drives, printers, network adapters, and display devices. The kernel allocates requests from applications to perform I/O to an appropriate device, key aspects necessary in resource management are the definition of an execution domain and the protection mechanism used to mediate the accesses to the resources within a domain. Kernels also usually provide methods for synchronization and communication between processes called inter-process communication, finally, a kernel must provide running programs with a method to make requests to access these facilities. The kernel has full access to the memory and must allow processes to safely access this memory as they require it. Often the first step in doing this is virtual addressing, usually achieved by paging and/or segmentation, virtual addressing allows the kernel to make a given physical address appear to be another address, the virtual address. This allows every program to behave as if it is the one running
23.
Hardware virtualization
–
Virtualization hides the physical characteristics of a computing platform from the users, presenting instead another abstract computing platform. At its origins, the software that controlled virtualization was called a control program, the term virtualization was coined in the 1960s to refer to a virtual machine, a term which itself dates from the experimental IBM M44/44X system. The creation and management of machines has been called platform virtualization, or server virtualization. Platform virtualization is performed on a hardware platform by host software, which creates a simulated computer environment. The guest software is not limited to applications, many hosts allow the execution of complete operating systems. The guest software executes as if it were running directly on the physical hardware, access to physical system resources is generally managed at a more restrictive level than the host processor and system-memory. In the case of server consolidation, many small physical servers are replaced by one physical server to increase the utilization of costly hardware resources such as CPU. Although hardware is consolidated, typically OSs are not, instead, each OS running on a physical server becomes converted to a distinct OS running inside a virtual machine. The large server can host many such guest virtual machines and this is known as Physical-to-Virtual transformation. Consolidating servers can also have the benefit of reducing energy consumption. A typical server runs at 425 W and VMware estimates a reduction ratio of up to 15,1. A virtual machine can be easily controlled and inspected from outside than a physical one. This is very useful in development and for teaching operating system courses. A new virtual machine can be provisioned as needed without the need for an up-front hardware purchase, a virtual machine can easily be relocated from one physical machine to another as needed. For example, a salesperson going to a customer can copy a virtual machine with the software to his laptop. Likewise, an error inside a virtual machine does not harm the host system, because of the easy relocation, virtual machines can be used in disaster recovery scenarios. There are several approaches to platform virtualization, evaluating an alternate operating system, The new OS could be run within a VM, without altering the host OS. Server virtualization, Multiple virtual servers could be run on a physical server
24.
Virtual memory
–
In computing, virtual memory is a memory management technique that is implemented using both hardware and software. It maps memory addresses used by a program, called virtual addresses, main storage as seen by a process or task appears as a contiguous address space or collection of contiguous segments. The operating system virtual address spaces and the assignment of real memory to virtual memory. Address translation hardware in the CPU, often referred to as a management unit or MMU. Memory virtualization can be considered a generalization of the concept of virtual memory, virtual memory is an integral part of a modern computer architecture, implementations usually require hardware support, typically in the form of a memory management unit built into the CPU. While not necessary, emulators and virtual machines can employ hardware support to increase performance of their virtual memory implementations, during the 1960s and early 70s, computer memory was very expensive. The introduction of virtual memory provided an ability for software systems with large memory demands to run on computers with less real memory, the savings from this provided a strong incentive to switch to virtual memory for all systems. The additional capability of providing virtual address spaces added another level of security and reliability, most modern operating systems that support virtual memory also run each process in its own dedicated address space. Each program thus appears to have access to the virtual memory. However, some operating systems and even modern ones are single address space operating systems that run all processes in a single address space composed of virtualized memory. This is because embedded hardware costs are kept low by implementing all such operations with software rather than with dedicated hardware. In the 1940s and 1950s, all larger programs had to contain logic for managing primary and secondary storage, virtual memory was therefore introduced not only to extend primary memory, but to make such an extension as easy as possible for programmers to use. To allow for multiprogramming and multitasking, many early systems divided memory between multiple programs without virtual memory, such as models of the PDP-10 via registers. The first Atlas was commissioned in 1962 but working prototypes of paging had been developed by 1959, in 1961, the Burroughs Corporation independently released the first commercial computer with virtual memory, the B5000, with segmentation rather than paging. Before virtual memory could be implemented in operating systems, many problems had to be addressed. Dynamic address translation required expensive and difficult to build specialized hardware, there were worries that new system-wide algorithms utilizing secondary storage would be less effective than previously used application-specific algorithms. The first minicomputer to introduce virtual memory was the Norwegian NORD-1, during the 1970s, other minicomputers implemented virtual memory, virtual memory was introduced to the x86 architecture with the protected mode of the Intel 80286 processor, but its segment swapping technique scaled poorly to larger segment sizes. The Intel 80386 introduced paging support underneath the existing segmentation layer, however, loading segment descriptors was an expensive operation, causing operating system designers to rely strictly on paging rather than a combination of paging and segmentation
25.
Time-sharing
–
In computing, time-sharing is the sharing of a computing resource among many users by means of multiprogramming and multi-tasking at the same time. Its introduction in the 1960s and emergence as the prominent model of computing in the 1970s represented a major shift in the history of computing. The earliest computers were expensive devices, and very slow in comparison to later models. These programs might take hours, or even weeks, to run, as computers grew in speed, run times dropped, and soon the time taken to start up the next program became a concern. Batch processing methodologies evolved to decrease these dead periods by queuing up programs so that as soon as one program completed, to support a batch processing operation, a number of comparatively inexpensive card punch or paper tape writers were used by programmers to write their programs offline. When typing was complete, the programs were submitted to the operations team, important programs were started quickly, how long before less important programs were started was unpredictable. When the program run was completed, the output was returned to the programmer. The complete process might take days, during which time the programmer might never see the computer, the alternative of allowing the user to operate the computer directly was generally far too expensive to consider. This was because users might have long periods of entering code while the computer remained idle and this situation limited interactive development to those organizations that could afford to waste computing cycles, large universities for the most part. Programmers at the universities decried the behaviors that batch processing imposed and they experimented with new ways to interact directly with the computer, a field today known as human–computer interaction. Time-sharing was developed out of the realization that any single user would make inefficient use of a computer. Given an optimal size, the overall process could be very efficient. Similarly, small slices of time spent waiting for disk, tape, in a paper published in December 1958 by W. F. Bauer, he wrote that The computers would handle a number of problems concurrently. Implementing a system able to take advantage of this was initially difficult, batch processing was effectively a methodological development on top of the earliest systems. Since computers still ran single programs for single users at any time, developing a system that supported multiple users at the same time was a completely different concept. The state of each user and their programs would have to be kept in the machine and this would take up computer cycles, and on the slow machines of the era this was a concern. However, as computers rapidly improved in speed, and especially in size of memory in which users states were retained. The first project to implement a system was initiated by John McCarthy at MIT in 1959, initially planned on a modified IBM704
.svg)
