In computer science, a for-loop is a control flow statement for specifying iteration, which allows code to be executed repeatedly. Various keywords are used to specify this statement: descendants of ALGOL use "for", while descendants of Fortran use "do". There are other possibilities, for example COBOL which uses "PERFORM VARYING". A for-loop has two parts: a header specifying the iteration, a body, executed once per iteration; the header declares an explicit loop counter or loop variable, which allows the body to know which iteration is being executed. For-loops are used when the number of iterations is known before entering the loop. For-loops can test a loop variable; the name for-loop comes from the English word for, used as the keyword in many programming languages to introduce a for-loop. The term in English dates to ALGOL 58 and was popularized in the influential ALGOL 60; the loop body is executed "for" the given values of the loop variable, though this is more explicit in the ALGOL version of the statement, in which a list of possible values and/or increments can be specified.
In FORTRAN and PL/I, the keyword DO is used for the same thing and it is called a do-loop. A for-loop statement is available in most imperative programming languages. Ignoring minor differences in syntax there are many differences in how these statements work and the level of expressiveness they support. For-loops fall into one of the following categories: The for-loop of languages like ALGOL, Simula, BASIC, Modula, Ada, Ocaml, F#, so on, requires a control variable with start- and end-values and looks something like this: Depending on the language, an explicit assignment sign may be used in place of the equal sign. An optional step-value may be included, although the exact syntaxes used for this differs a bit more between the languages; some languages require a separate declaration of the control variable, some do not. Another form was popularized by the C programming language, it requires 3 parts: the initialization, the condition, the afterthought and all these three parts are optional. The initialization declares.
The type of a variable should be same. The condition checks a condition, quits the loop if false; the afterthought is performed once every time the loop ends and repeats. Here is an example of the traditional for-loop in Java; these loops are sometimes called numeric for-loops when contrasted with foreach loops. This type of for-loop is a generalisation of the numeric range type of for-loop, as it allows for the enumeration of sets of items other than number sequences, it is characterized by the use of an implicit or explicit iterator, in which the loop variable takes on each of the values in a sequence or other data collection. A representative example in Python is: Where some_iterable_object is either a data collection that supports implicit iteration, or may in fact be an iterator itself; some languages have this in addition to another for-loop syntax. Some languages offer a for-loop that acts as if processing all iterations in parallel, such as the for all keyword in FORTRAN 95 which has the interpretation that all right-hand-side expressions are evaluated before any assignments are made, as distinct from the explicit iteration form.
For example, in the for statement in the following pseudocode fragment, when calculating the new value for A, except for the first the reference to A will obtain the new value, placed there in the previous step. In the for all version, each calculation refers only to the original, unaltered A. for i:= 2: N - 1 do A:= / 3. Some languages offer array assignment statements, that enable many for-loops to be omitted, thus pseudocode such as A:= 0. The example loop could be rendered as But whether that would be rendered in the style of the for-loop or the for all-loop or something else may not be described in the compiler manual. Introduced with ALGOL 68 and followed by PL/I, this allows the iteration of a loop to be compounded with a test, as in for i:= 1: N while A > 0 do etc. That is, a value is assigned to the loop variable i and only if the while expression is true will the loop body be executed. If the result were false the for-loop's execution stops short. Granted that the loop variable's value is defined after the termination of the loop the above statement will find the first non-positive element in array A, or, with suitable variations, the first non-blank character in a string, so on.
In computer programming a loop counter is the variable. It is so named because most uses of this construct result in the variable taking on a range of integer values in some orderly sequences (example. Starting at 0 and end at 10 in incre
In computing, executable code or an executable file or executable program, sometimes referred to as an executable, causes a computer "to perform indicated tasks according to encoded instructions," as opposed to a data file that must be parsed by a program to be meaningful. The exact interpretation depends upon the use - while "instructions" is traditionally taken to mean machine code instructions for a physical CPU, in some contexts a file containing bytecode or scripting language instructions may be considered executable. Executable files can be hand-coded in machine language, although it is far more convenient to develop software as source code in a high-level language that can be understood by humans. In some cases, source code might be specified in assembly language instead, which remains human-readable while being associated with machine code instructions; the high-level language is compiled into either an executable machine code file or a non-executable machine-code object file of some sort.
Several object files are linked to create the executable. Object files, executable or not, are in a container format, such as Executable and Linkable Format; this structures the generated machine code, for example dividing it into sections such as the.text.data, and.rodata. In order to be executed by the system, an executable file must conform to the system's application binary interface. Most a file is executed by loading the file into memory and jumping to the start of the address space and executing from there, but in more complicated interfaces executable files have additional metadata, specifying a separate entry point. For example, in ELF, the entry point is specified in the header in the e_entry field, which specifies the memory address at which to start execution. In the GCC this field is set by the linker based on the _start symbol. Executable files also include a runtime system, which implements runtime language features and interactions with the operating system, notably passing arguments and returning an exit status, together with other startup and shutdown features such as releasing resources like file handles.
For C, this is done by linking in the crt0 object, which contains the actual entry point and does setup and shutdown by calling the runtime library. Executable files thus 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 to understand how compilation and loading work. In C this can be done by omitting the usual runtime, instead explicitly specifying a linker script, which generates the entry point and handles startup and shutdown, such as calling main to start and returning exit status to kernel at end. Comparison of executable file formats EXE File Format at What Is
Atari BASIC is an interpreter for the BASIC programming language that shipped with the Atari 8-bit family of 6502-based home computers. Unlike many 8-bit BASICs, Atari BASIC is not a derivative of Microsoft BASIC, differs in significant ways, it includes keywords for Atari-specific lacks support for string arrays, for example. The language was an 8 KB ROM cartridge for the first machines in the 8-bit series, the 400, 800 and 1200XL. Starting with the 600XL and 800XL, BASIC was built-in to the machines, but can be disabled by holding down the OPTION key while booting; the XEGS disables BASIC. The complete annotated source code and design specifications of Atari BASIC were published as The Atari BASIC Source Book in 1983; the machines that would become the Atari 8-bit family had been developed as second-generation video game consoles intended to replace the Atari 2600. Ray Kassar, the new president of Atari, decided to challenge Apple Computer by building a home computer instead; this meant the designs, among other changes, needed to support the BASIC programming language the standard language for home computers.
In 1978, Atari purchased the source code to the MOS 6502 version of Microsoft 8K BASIC. The original 8K BASIC referred to its memory footprint when compiled on the Intel 8080's instruction set; the lower code density of the 6502 expanded the code to about 9 kB. This was larger than the natural 8 kB size of the Atari's ROM cartridges. Atari felt that they needed to expand the language to add better support for the specific hardware features of their computers, similar to what Apple had done with their Applesoft BASIC; this increased the size from 9 kB to around 11 kB. Paring down the code from 11 to 8 kB to fit in a ROM turned out to be a significant problem. Adding to the problem was the fact that the 6502 code supplied by Microsoft was undocumented. Six months they were ready with a shippable version of the interpreter. However, Atari was facing a January 1979 deadline with the Consumer Electronics Show where the machines would be demonstrated, they decided to ask for help to get a version of BASIC ready in time for the show.
In September 1978, Shepardson Microsystems won the bid on completing BASIC. Shepardson had written a number of programs for the Apple II family, which used the same 6502 processor, were in the middle of finishing a new BASIC for the Cromemco S-100 bus machines. Shepardson examined the existing work and decided it was too difficult to continue cutting it down to size. To make it fit on an 8k ROM, some of the common routines would be moved to the operating system ROMs. Atari accepted the proposal, when the specifications were finalized in October 1978, Paul Laughton and Kathleen O'Brien began work on the new language; the contract specified a delivery date on or before 6 April 1979 and this included a File Manager System. Atari's plans were to take an early 8K version of Microsoft BASIC to the 1979 CES and switch to the new Atari BASIC for production. Development proceeded helped by a bonus clause in the contract, an 8K cartridge was available just before the release of the machines. Atari took that version to CES instead of the MS version.
Atari Microsoft BASIC became available as a separate product. The version Shepardson gave to Atari. Between the time they delivered the demo and the final delivery a few weeks Shepardson found several bugs in the code and had developed fixes for them. However, unknown to Shepardson, Atari had sent the CES version to manufacturing; this version was known as Revision A. Among several problems, this version contains a major bug in a subroutine that copies memory; this was sometimes known as the "two-line lockup" because it triggered when the next line of code or command was entered. It was notorious as it was one of a few problems that could not be fixed by pressing the Reset key. Revision B attempted to fix all of the major bugs in Revision A, was released in 1983 as a built-in ROM in the 600XL and 800XL models. While fixing the memory copying bug, the programmer noticed the same pattern of code in the section for inserting lines, applied the same fix; this "fix" instead introduced the original bug into this code.
Inserting new lines is much more common than deleting old ones, so the change increased the number of crashes. Another major problem in Revision B was a bug that added 16 bytes to the memory of the program every time it was SAVEd and LOADed causing the machine to run out of memory on the smallest programs. Mapping the Atari described them as "awesome bugs", advised Revision B owners "Don't fool around; the book provided a type-in program to patch Revision B to Revision C for those without the cartridge. Revision C eliminated the memory leaks in Revision B; this version was built-in on versions of the 800XLs, all XE computers, the XEGS. Revision C was available in a cartridge production run; the version can be determined by typing PRINT PEEK at the READY prompt. The result is 162 for Revision A, 96 for Revision B, 234 for Revision C. Atari BASIC uses a line editor, like most home computer BASICs. Unlike most BASICs, Atari BASIC reports errors immediately. If an error is found, the editor re-displays the line, highlighting the text near the error in inverse video.
Errors are displayed as numeric codes, with th
The IBM Personal Computer Basic shortened to IBM BASIC, is a programming language first released by IBM with the IBM Personal Computer in 1981. IBM released four different versions of the Microsoft BASIC interpreter, licensed from Microsoft for the PC and PCjr, they are known as Cassette BASIC, Disk BASIC, Advanced BASIC, Cartridge BASIC. Versions of Disk BASIC and Advanced BASIC were included with IBM PC DOS up to PC DOS 4. In addition to the features of an ANSI standard BASIC, the IBM versions offered support for the graphics and sound hardware of the IBM PC line. Source code could be typed in with a full screen editor, limited facilities were provided for rudimentary program debugging. IBM released a version of the Microsoft BASIC compiler for the PC, concurrently with the release of PC DOS 1.10 in 1982. IBM licensed Microsoft BASIC for the PC despite having its own version for the company's mainframes. Don Estridge said, "Microsoft BASIC had hundreds of thousands of users around the world.
How are you going to argue with that?" IBM Cassette BASIC came in 32 kilobytes of read-only memory, separate from the 8 KB BIOS ROM of the original IBM PC, did not require an operating system to run. Cassette BASIC provided the default user interface invoked by the BIOS through INT 18h if there was no floppy disk drive installed, or if the boot code did not find a bootable floppy disk at power up; the name Cassette BASIC came from its use of cassette tapes rather than floppy disks to store programs and data. Cassette BASIC was built into the ROMs of the original PC and XT, early models in the PS/2 line, it only supported loading and saving programs to the IBM cassette tape interface, unavailable on models after the original Model 5150. The entry-level version of the 5150 came with just 16 KB of random-access memory, sufficient to run Cassette BASIC. However, Cassette BASIC was used because few PCs were sold without a disk drive, most were sold with PC DOS and sufficient RAM to at least run Disk BASIC—many could run Advanced BASIC as well.
There were three versions of Cassette BASIC: C1.00, C1.10, C1.20. IBM Disk BASIC was included in the original IBM PC DOS; because it uses the 32 KB Cassette BASIC ROM, BASIC. COM did not run on highly compatible PC clones such as the Compaq Portable; the name Disk BASIC came from its use of floppy disks as well as cassette tapes to store programs and data. Disk-based code corrected errata in the ROM-resident code and added floppy disk and serial port support. Disk BASIC could be identified by its use of the letter D preceding the version number, it added disk support and some features lacking in Cassette BASIC, but did not include the extended sound/graphics functions of BASICA. The primary purpose of Disk BASIC was as a "lite" version for IBM PCs with only 48K of memory: BASIC. COM would have about 23K free for user code, whereas BASICA would only have about 17K. By 1986, all new PCs shipped with at least 256k and DOS versions after 3.00 reduced Disk BASIC to only a small stub that called BASICA.
COM for compatibility with batch files. With all this excess RAM, BASIC would still only allocate and manage just under 61K for user programs. IBM Advanced BASIC was included in the original IBM PC DOS, required the ROM-resident code of Cassette BASIC, it added functions such as diskette file access, storing programs on disk, monophonic sound using the PC's built-in speaker, graphics functions to set and clear pixels, draw lines and circles, set colors, event handling for communications and joystick presses. BASICA would not run on non-IBM computers or IBM models, since those lack the needed ROM BASIC. BASICA versions were the same as their respective DOS, beginning with v1.00 and ending with v3.30. The early versions of BASICA did not support subdirectories and some graphics commands functioned differently; as an example, if the LINE statement was used to draw lines that trailed off-screen, BASIC would intersect them with the nearest adjacent line while in BASIC 2.x and up, they went off the screen and did not intersect.
The PAINT command in BASIC 1.x begins filling at the coordinate specified and expands outward in alternating up and down directions while in BASIC 2.x it fills everything below the starting coordinate and after finishing, everything above it. BASIC 1.x's PAINT command makes use of the system stack for storage and when filling in complex areas, it was possible to produce an OVERFLOW error. To remedy this, the CLEAR statement can be used to expand BASIC's stack. BASIC 2.x does not use the stack when thus is free of this problem. Compaq BASIC 1.13 was the first standalone BASIC for the PC as well as the only version of BASIC besides IBM BASICA 1.00 and 1.10 to use FCBs and include the original LINE statement with intersecting lines. Early versions of PC DOS included several sample BASIC programs demonstrating the capabilities of the PC, including the BASICA game DONKEY. BAS. GW-BASIC is identical to BASICA, with the exception of including the Cassette BASIC code in the program, thus allowing it to run on non-IBM computers and IBM models that lack Cassette BASIC in ROM.
A ROM cartridge version of BASIC was only available on the IBM PCjr and supported the additional graphics modes and sound capa
A command-line interface or command language interpreter known as command-line user interface, console user interface and character user interface, is a means of interacting with a computer program where the user issues commands to the program in the form of successive lines of text. A program which handles the interface is called shell; the CLI was the primary means of interaction with most computer systems on computer terminals in the mid-1960s, continued to be used throughout the 1970s and 1980s on OpenVMS, Unix systems and personal computer systems including MS-DOS, CP/M and Apple DOS. The interface is implemented with a command line shell, a program that accepts commands as text input and converts commands into appropriate operating system functions. Today, many end users if use command-line interfaces and instead rely upon graphical user interfaces and menu-driven interactions. However, many software developers, system administrators and advanced users still rely on command-line interfaces to perform tasks more efficiently, configure their machine, or access programs and program features that are not available through a graphical interface.
Alternatives to the command line include, but are not limited to text user interface menus, keyboard shortcuts, various other desktop metaphors centered on the pointer. Examples of this include the Windows versions 1, 2, 3, 3.1, 3.11, DosShell, Mouse Systems PowerPanel. Programs with command-line interfaces are easier to automate via scripting. Command-line interfaces for software other than operating systems include a number of programming languages such as Tcl/Tk, PHP, others, as well as utilities such as the compression utility WinZip, some FTP and SSH/Telnet clients. Compared with a graphical user interface, a command line requires fewer system resources to implement. Since options to commands are given in a few characters in each command line, an experienced user finds the options easier to access. Automation of repetitive tasks is simplified - most operating systems using a command line interface support some mechanism for storing used sequences in a disk file, for re-use. A command-line history can be kept, allowing repetition of commands.
A command-line system may require paper or online manuals for the user's reference, although a "help" option provides a concise review of the options of a command. The command-line environment may not provide the graphical enhancements such as different fonts or extended edit windows found in a GUI, it may be difficult for a new user to become familiar with all the commands and options available, compared with the drop-down menus of a graphical user interface, without repeated reference to manuals. Operating system command line interfaces are distinct programs supplied with the operating system. A program that implements such a text interface is called a command-line interpreter, command processor or shell. Examples of command-line interpreters include DEC's DIGITAL Command Language in OpenVMS and RSX-11, the various Unix shells, CP/M's CCP, DOS's COMMAND. COM, as well as the OS/2 and the Windows CMD. EXE programs, the latter groups being based on DEC's RSX-11 and RSTS CLIs. Under most operating systems, it is possible to replace the default shell program with alternatives.
Although the term'shell' is used to describe a command-line interpreter speaking a'shell' can be any program that constitutes the user-interface, including graphically oriented ones. For example, the default Windows GUI is a shell program named EXPLORER. EXE, as defined in the SHELL=EXPLORER. EXE line in the WIN. INI configuration file; these programs are shells, but not CLIs. Application programs may have command line interfaces. An application program may support none, any, or all of these three major types of command line interface mechanisms: Parameters: Most operating systems support a means to pass additional information to a program when it is launched; when a program is launched from an OS command line shell, additional text provided along with the program name is passed to the launched program. Interactive command line sessions: After launch, a program may provide an operator with an independent means to enter commands in the form of text. OS inter-process communication: Most operating systems support means of inter-process communication.
Command lines from client processes may be redirected to a CLI program by one of these methods. Some applications support only a CLI, presenting a CLI prompt to the user and acting upon command lines as they are entered. Other programs support both a CLI and a GUI. In some cases, a GUI is a wrapper around a separate CLI executable file. In other cases, a program may provide a CLI as an optional alternative to its GUI. CLIs and GUIs support different functionality. For example, all features of MATLAB, a numerical analysis computer program, are available via the CLI, whereas the MATLAB GUI exposes only a subset of features; the early Sierra games, such as the first three King's Quest games, used commands from an internal command line to move the character around in the graphic window. The command-line interface evolved from a form of dialog once conducted by humans over teleprinter machines, in which human operators remotely exchanged inf
MySQL is an open-source relational database management system. Its name is a combination of "My", the name of co-founder Michael Widenius's daughter, "SQL", the abbreviation for Structured Query Language. MySQL is free and open-source software under the terms of the GNU General Public License, is available under a variety of proprietary licenses. MySQL was owned and sponsored by the Swedish company MySQL AB, bought by Sun Microsystems. In 2010, when Oracle acquired Sun, Widenius forked the open-source MySQL project to create MariaDB. MySQL is a component of the LAMP web application software stack, an acronym for Linux, Apache, MySQL, Perl/PHP/Python. MySQL is used by many database-driven web applications, including Drupal, phpBB, WordPress. MySQL is used by many popular websites, including Facebook, Twitter and YouTube. MySQL is written in C and C++, its SQL parser is written in yacc. MySQL works on many system platforms, including AIX, BSDi, FreeBSD, HP-UX, eComStation, i5/OS, IRIX, macOS, Microsoft Windows, NetBSD, Novell NetWare, OpenBSD, OpenSolaris, OS/2 Warp, QNX, Oracle Solaris, SunOS, SCO OpenServer, SCO UnixWare and Tru64.
A port of MySQL to OpenVMS exists. The MySQL server software itself and the client libraries use dual-licensing distribution, they are offered under a proprietary license. Support can be obtained from the official manual. Free support additionally is available in different IRC forums. Oracle offers paid support via its MySQL Enterprise products, they differ in price. Additionally, a number of third party organisations exist to provide support and services, including MariaDB and Percona. MySQL has received positive reviews, reviewers noticed it "performs well in the average case" and that the "developer interfaces are there, the documentation is very good", it has been tested to be a "fast and true multi-user, multi-threaded sql database server". MySQL was created by a Swedish company, MySQL AB, founded by David Axmark, Allan Larsson and Michael "Monty" Widenius. Original development of MySQL by Widenius and Axmark began in 1994; the first version of MySQL appeared on 23 May 1995. It was created for personal usage from mSQL based on the low-level language ISAM, which the creators considered too slow and inflexible.
They created a new SQL interface, while keeping the same API as mSQL. By keeping the API consistent with the mSQL system, many developers were able to use MySQL instead of the mSQL antecedent. Additional milestones in MySQL development included: First internal release on 23 May 1995 Version 3.19: End of 1996, from www.tcx.se Version 3.20: January 1997 Windows version was released on 8 January 1998 for Windows 95 and NT Version 3.21: production release 1998, from www.mysql.com Version 3.22: alpha, beta from 1998 Version 3.23: beta from June 2000, production release 22 January 2001 Version 4.0: beta from August 2002, production release March 2003. Version 4.01: beta from August 2003, Jyoti adopts MySQL for database tracking Version 4.1: beta from June 2004, production release October 2004. Version 5.0: beta from March 2005, production release October 2005. The developer of the Federated Storage Engine states that "The Federated Storage Engine is a proof-of-concept storage engine", but the main distributions of MySQL version 5.0 included it and turned it on by default.
Documentation of some of the short-comings appears in "MySQL Federated Tables: The Missing Manual". Sun Microsystems acquired MySQL AB in 2008. Version 5.1: production release 27 November 2008 Version 5.1 contained 20 known crashing and wrong result bugs in addition to the 35 present in version 5.0. MySQL 5.1 and 6.0-alpha showed poor performance when used for data warehousing – due to its inability to utilize multiple CPU cores for processing a single query. Oracle acquired Sun Microsystems on 27 January 2010; the day Oracle announced the purchase of Sun, Michael "Monty" Widenius forked MySQL, launching MariaDB, took a swath of MySQL developers with him. MySQL Server 5.5 was available. Enhancements and features include: The default storage engine is InnoDB, which supports transactions and referential integrity constraints. Improved InnoDB I/O subsystem Improved SMP support Semisynchronous replication. SIGNAL and RESIGNAL statement in compliance with the SQL standard. Support for supplementary Unicode character sets utf16, utf32, utf8mb4.
New options for user-defined partitioning. MySQL Server 6.0.11-alpha was announced on 22 May 2009 as the last release of the 6.0 line. Future MySQL Server development uses a New Release Model. Features developed for 6.0 are being incorporated into future releases. The general availability of MySQL 5.6 was announced in February 2013. New features included performance improvements to the query optimizer, higher transactional throughput in InnoDB, new NoSQL-style memcached APIs, improvements to partitioning for querying and managing large tables, TIMESTAMP column type that stores milliseconds, improvements to replication, better performance monitoring by expanding the data available through the PERFORMANCE_SCHEMA; the InnoDB storage engine included support for full-text search and improved group commit performance. The general availability of MySQL 5.7 was a
Graphical user interface
The graphical user interface is a form of user interface that allows users to interact with electronic devices through graphical icons and visual indicators such as secondary notation, instead of text-based user interfaces, typed command labels or text navigation. GUIs were introduced in reaction to the perceived steep learning curve of command-line interfaces, which require commands to be typed on a computer keyboard; the actions in a GUI are performed through direct manipulation of the graphical elements. Beyond computers, GUIs are used in many handheld mobile devices such as MP3 players, portable media players, gaming devices and smaller household and industrial controls; the term GUI tends not to be applied to other lower-display resolution types of interfaces, such as video games, or not including flat screens, like volumetric displays because the term is restricted to the scope of two-dimensional display screens able to describe generic information, in the tradition of the computer science research at the Xerox Palo Alto Research Center.
Designing the visual composition and temporal behavior of a GUI is an important part of software application programming in the area of human–computer interaction. Its goal is to enhance the efficiency and ease of use for the underlying logical design of a stored program, a design discipline named usability. Methods of user-centered design are used to ensure that the visual language introduced in the design is well-tailored to the tasks; the visible graphical interface features of an application are sometimes referred to as chrome or GUI. Users interact with information by manipulating visual widgets that allow for interactions appropriate to the kind of data they hold; the widgets of a well-designed interface are selected to support the actions necessary to achieve the goals of users. A model–view–controller allows flexible structures in which the interface is independent from and indirectly linked to application functions, so the GUI can be customized easily; this allows users to select or design a different skin at will, eases the designer's work to change the interface as user needs evolve.
Good user interface design relates to users more, to system architecture less. Large widgets, such as windows provide a frame or container for the main presentation content such as a web page, email message or drawing. Smaller ones act as a user-input tool. A GUI may be designed for the requirements of a vertical market as application-specific graphical user interfaces. Examples include automated teller machines, point of sale touchscreens at restaurants, self-service checkouts used in a retail store, airline self-ticketing and check-in, information kiosks in a public space, like a train station or a museum, monitors or control screens in an embedded industrial application which employ a real-time operating system. By the 1980s, cell phones and handheld game systems employed application specific touchscreen GUIs. Newer automobiles use GUIs in their navigation systems and multimedia centers, or navigation multimedia center combinations. Sample graphical desktop environments A GUI uses a combination of technologies and devices to provide a platform that users can interact with, for the tasks of gathering and producing information.
A series of elements conforming a visual language have evolved to represent information stored in computers. This makes it easier for people with few computer skills to use computer software; the most common combination of such elements in GUIs is the windows, menus, pointer paradigm in personal computers. The WIMP style of interaction uses a virtual input device to represent the position of a pointing device, most a mouse, presents information organized in windows and represented with icons. Available commands are compiled together in menus, actions are performed making gestures with the pointing device. A window manager facilitates the interactions between windows and the windowing system; the windowing system handles hardware devices such as pointing devices, graphics hardware, positioning of the pointer. In personal computers, all these elements are modeled through a desktop metaphor to produce a simulation called a desktop environment in which the display represents a desktop, on which documents and folders of documents can be placed.
Window managers and other software combine to simulate the desktop environment with varying degrees of realism. Smaller mobile devices such as personal digital assistants and smartphones use the WIMP elements with different unifying metaphors, due to constraints in space and available input devices. Applications for which WIMP is not well suited may use newer interaction techniques, collectively termed post-WIMP user interfaces; as of 2011, some touchscreen-based operating systems such as Apple's iOS and Android use the class of GUIs named post-WIMP. These support styles of interaction using more than one finger in contact with a display, which allows actions such as pinching and rotating, which are unsupported by one pointer and mouse. Human interface devices, for the efficient interaction with a GUI include a computer keyboard used together with keyboard shortcuts, pointing devices for the cursor control: mouse, pointing stick, trackball, virtual keyboards, head-up displays. There are actions performed by programs that affect the GUI.
For example, there are components like inotify or D-Bus to facilitate communication between computer programs. Ivan Sutherland developed Sketchpad in 1963 held as the first graphical co