science

Terminal emulator

Terminal emulator is a science topic covered in the lgStudy science library. This page brings together a partial reference excerpt, illustrations, worked examples, real-world applications and a short study plan, so you can understand Terminal emulator rather than just read about it. In short: A terminal emulator, or terminal application, is a computer program that emulates a video terminal within another display architecture. Though typically synonymous with a shell or text terminal, the term terminal covers all remote terminals, including graphical interfaces.

Key takeaways

Terminal emulator belongs to science; place it in that map before memorising details.
Learn the definition first, then one example that makes the definition concrete.
Connect Terminal emulator to a quantity you can measure, compute or draw — that is where exam questions come from.
Reproduce the core statement of Terminal emulator from memory before moving on to harder problems.

Reference excerpt

A terminal emulator, or terminal application, is a computer program that emulates a video terminal within another display architecture. Though typically synonymous with a shell or text terminal, the term terminal covers all remote terminals, including graphical interfaces. A terminal emulator inside a graphical user interface is often called a terminal window. A terminal window allows the user access to a text terminal and all its applications such as command-line interfaces (CLI) and text user interface (TUI) applications. These may be running either on the same machine or on a different one via telnet, ssh, dial-up, or over a direct serial connection. On Unix-like operating systems, it is common to have one or more terminal windows connected to the local machine. Terminals usually support a set of escape sequences for controlling color, cursor position, etc. Examples include the family of terminal control sequence standards that includes ECMA-48, ANSI X3.64, and ISO/IEC 6429.

Background In the early days of computing, with the advent of interactive computing, the prevailing model involved a central computer connected to multiple terminals. This configuration, known as the centralized or mainframe model, featured a powerful central computer that performed all the processing tasks, while terminals served as input/output devices for users to interact with the system. These systems were initially character based.

Character-oriented terminals

Emulators When personal computers became ubiquitous in the 1980s, they offered the option of running software on the user's personal computer, providing an opportunity to replace the expensive and space consuming hardware terminals with something that had additional functions. Immediately software became available, that could emulate the functions of the hardware terminals on a PC. Examples of such software for DOS were Telix or Telemate, which was published in 1988 and could emulate a DEC VT102 terminal. Workstations, usually running versions of Unix, also became common in the 1980s. Unix systems usually provided access to the command line with locally-attached or dial-up terminals. Unix workstations were designed to be used primarily through a graphical user interface (GUI); to provide access to the command line, the GUI included terminal emulator applications that behaved like locally-attached terminals. During the 1990s, new operating systems like Windows and OS/2 arrived, providing the technical background for more terminal emulators such as Telix for Windows, ZOC for OS/2, or PuTTY, which was initially released for Windows in 1998 and which (together with its derivates) remains a very popular choice to this day. Through the success of Linux on servers, especially running on data centers and cloud servers, the necessity of accessing remote computers through character-based terminal emulators remains.

Examples of terminals emulated Many terminal emulators have been developed for physical hardware terminals such as VT52, VT100, VT220, VT320, IBM 3270/8/9/E, IBM 5250, IBM 3179G, Data General D211, Hewlett-Packard HP700/92, Sperry/Unisys 2000-series UTS60, Burroughs/Unisys A-series T27/TD830/ET1100, ADDS ViewPoint, AT386, Siemens Nixdorf (SNI) 97801, Televideo 925, and Wyse 50/60. Some terminal emulators, such as xterm, implement additional features not present in the emulated terminal. Additionally, programs have been developed to emulate assorted system console "terminals" such as the Sun workstation console and the Linux console. Finally, some emulators simply refer to a set of standards, such as the standards for ANSI escape codes. Such programs are available on many platforms, including DOS, Unix-like systems including Linux and macOS, Windows, and embedded operating systems found in cellphones and industrial hardware.

Implementation details

Unix-like systems In the past, Unix and Unix-like systems used serial port devices such as RS-232 ports, and provided /dev/* device files for them. With terminal emulators these device files are themselves emulated by a pair of pseudoterminal devices. These in turn emulate a physical port/connection to the host computing endpoint – hardware provided by operating system APIs, or software such as rlogin, telnet or SSH, among others. In Linux systems, for example, these would be /dev/ptyp0 (for the master side) and /dev/ttyp0 (for the slave side) pseudoterminal devices respectively. There are also special virtual console files like /dev/console. In text mode, writing to the file displays text on the virtual console and reading from the file returns text the user writes to the virtual console. As with other text terminals, there are also special escape sequences, control characters and functions that a program can use, most easily via a library such as ncurses. For more complex operations, the programs can use console and terminal special ioctl system calls. One can compare devices using the patterns vcs ("virtual console screen") and vcsa ("virtual console screen with attributes") such as /dev/vcs1 and /dev/vcsa1. Some terminal emulators also include escape sequences for configuring the behavior of the terminal to facilitate good interoperation between the terminal and programs running inside of it, for example to configure paste bracketing. The virtual consoles can be configured in the file /etc/inittab read by init—typically it starts the text mode login process getty for several virtual consoles. X Window System can be configured in /etc/inittab or by an X display manager. A number of Linux distributions use systemd instead of init, which also allows virtual console configuration.

CLI tools Typical Linux system programs used to access the virtual consoles include:

chvt to switch the current virtual console openvt to run a program on a new virtual console deallocvt to close a currently unused virtual console

Local echo

Terminal emulators may implement a local echo function, which may erroneously be named "half-duplex", or still slightly incorrectly "echoplex" (which is formally an error detection mechanism rather than an input display option).

Line-at-a-time mode/Local editing

… excerpt ends here. Continue reading the full article.

Illustrations

Worked examples

Example 1 — a first encounter with Terminal emulator

Start with the simplest possible case. Write down what Terminal emulator claims or describes in one sentence, then invent the smallest concrete situation in which that sentence is true. In science, the smallest case is usually a single object, a single equation or a single measurement. Check that every symbol or term in your sentence has a meaning in that case.

Example 2 — changing one variable

Take the situation from Example 1 and change exactly one quantity: double it, halve it, or set it to zero. Predict what should happen to Terminal emulator before you calculate. Comparing your prediction with the result is the fastest way to find out whether you understand the idea or only the words.

Example 3 — an exam-style question

Typical questions about Terminal emulator ask you to (a) state it precisely, (b) apply it to given data, and (c) explain a limitation. Practise writing all three answers in under five minutes; the third part is what separates a full-mark answer from an average one.

Applications of Terminal emulator

In research: Terminal emulator appears in science research whenever the underlying quantities have to be modelled precisely. Papers usually cite it as a starting assumption and then explore where it breaks down.
In technology and industry: Engineering practice reuses Terminal emulator in design rules, simulations and safety margins. Knowing the idea lets you read a specification sheet and understand why the numbers look the way they do.
In the classroom: Terminal emulator is common in secondary-school and first-year university syllabi. It links to neighbouring topics Bulletin board systems, Technical communication tools, Terminal emulators, so understanding it makes those chapters shorter.
In everyday life: Look for Terminal emulator outside the textbook — in sport, cooking, traffic, electronics or the sky above you. An example you found yourself is remembered far longer than one you were given.

Affiliate

Preply — study more efficiently by working with a personal tutor. 50% off.

How to study Terminal emulator in 20 minutes

Read the reference excerpt below once, without taking notes.
Close the page and write down what Terminal emulator means in your own words.
Compare your version with the excerpt and mark what you missed.
Work through the three examples above with pen and paper.
Explain Terminal emulator out loud to somebody else — or to Teacher Smith in the lgStudy chat.

Frequently asked questions

What is Terminal emulator in simple terms?

Why does Terminal emulator matter?

Because it connects several science ideas at once: it gives you a definition you can apply, a quantity you can calculate, and a way to check whether a result is plausible.

How should I study Terminal emulator?

Read the excerpt, restate it from memory, then work through the examples and applications listed on this page. The five-step study plan above takes about twenty minutes.

What does this page cover?

It gives you a compact reference excerpt plus original lgStudy explanations, examples, applications and study material on Terminal emulator.