Next
Previous
Contents
There are various conflicting definitions of "dumb terminal" but
as time goes by, more and more terminals are called dumb. This
document mainly covers text terminals which display only text on the
screen. It could have been titled "Dumb-Terminal-HOWTO". But in
some magazines articles, any terminal, no matter how smart, including
ones which present a full graphical user interface (GUI), are called
dumb. If all terminals are "dumb" then there is no point of prefixing
the word "dumb" to terminal (except as a sales pitch to sell computers
or the like instead of terminals). Due to the ambiguous meaning of
"dumb terminal" it is not classified here as a type of terminal.
For a text terminal, a 2-way flow of information between the
computer and the terminal takes place over the cable that connects
them together. This flow is in bytes (such as ASCII) where each byte
usually represents a printable character. Bytes typed at the keyboard
go to the computer and most bytes from the computer are displayed on
the terminal screen. Special control bytes (or sequences of bytes) from the
computer tell the terminal where to move the cursor to, what to erase,
where to begin and end underlining and/or blinking and/or bold, etc.
There are often hundreds of such special commands and most terminals
can even change fonts.
The communication uses characters (letters) encoded using a code chart
for the character set being used. Usually, the first 128 bytes out of
256 possible bytes use ASCII codes. Terminals for Unix-like systems,
normally connect to computers via a cable running between the
asynchronous serial ports (RS-232-C = EIA-232-D) of the host computer
and the terminal. Sometimes the connection is via modem or terminal
server, etc.
Other names for "text terminal" are "serial monitor", "serial console"
(if it's used like a console), "serial terminal", "dumb terminal",
"character-cell terminal", "character terminal", "ASCII/ANSI
terminal", "asynchronous terminal", "data terminal", "video terminal",
"video display terminal" (VDT), and "green terminal" (since many used
green displays). These names (especially "dumb terminal") are
sometimes used to mean emulating a text terminal on a PC with a
command line interface such as Linux. In olden days "video display
unit" (VDU) meant text terminal but strictly speaking, it excludes the
keyboard.
"Block mode" was used exclusively by old IBM mainframe terminals but
many modern terminals also have this capability (which is not used
much). In block mode, the characters you type are temporarily
retained in the terminal memory (and may possibly be edited by a
built-in editor at the terminal). Then when the send key (or the
like) is pressed, a block of characters (sometimes just a line of
characters) is sent to the computer all at once. Block mode (as of
late 1998) is not supported by Linux. See section
Block Mode.
Many text terminals can display bit-mapped images, but not in
color. Unfortunately, the popular image formats used on the Internet
are not supported. The protocols for terminal graphics include:
Tektronix Vector Graphics, ReGIS (DEC), Sixel (DEC), and NAPLPS (North
American Presentation Level Protocol Syntax).
Even without bit-mapped images, ordinary text terminals can sort of
display images. One may form arrows <--- and draw boxes with |__|,
etc. With special graphic character sets that have a lot of special
characters for line drawing, much more is possible. But even without
a graphic character set, one may produce "ascii graphics" art. The
term "graphics terminal" usually means a terminal that can display bit
mapped images. However, this term is sometimes applied also to
text-only terminals since text is a limited form of graphics.
Graphics GUI displays
There are two basic types of graphics displays: raster and vector
(rarely used). Raster graphics (bit-mapped) puts dots on the screen
by horizontal scan lines drawn by an electron beam (or by activating
pixels or dots on a flat screen). Vector graphic displays were
intended to be used for monochrome screens that don't have any dots.
They use smart electronics to draw lines and curves with an electron
beam that can continuously move in any direction (just like a pen or
pencil). True vector graphics draws high quality lines without
noticeable zig-zags but is both rare and expensive. For more details
see
http://www.cca.org/vector/. Raster graphics is almost
universally used today for both PCs and text terminals. For PCs,
images encoded in vector graphic format can't be drawn as continuous
lines due to the electronic limitations but they can be translated to
raster graphics format for display (with a resulting drop in image
quality).
Introduction
Since "thin clients" are not text terminals, this HOWTO only
provides a brief overview of them. There are other HOWTOs that cover
them in more detail. See
Related HOWTOs, etc.. Thin clients are thin (minimal) client computers that
behave something like terminals. Since text terminals (except for
very old ones) run an embedded operating system, they are also like a
computer. Thin-clients need more computing power. In contrast to
text-terminals thin clients all display a modern high-speed GUI. They
are dependent on more powerful computers (servers) for their
operation. For a true thin client terminal, the computing work and
disk storage will all be done on the server. At the other extreme,
most of this work and storage is done at the thin client but some
things such as administration, still depend on the server. Since such
a client is not really "thin" it may more correctly be called a "fat
client".
Such clients may be created from an ordinary PC by using software or
may be a stand-alone piece of hardware. But the stand-alone hardware
will often use a conventional PC monitor plus a small box for the
computer part of the hardware. Linux seems to favor the use of PCs as
a client.
Some claim that text-terminals are also thin clients but they are not
really since they don't conform to the client-server model. However,
connecting a terminal via telnet does invoke the client-server model
in the use of telnet as a means of transport of data. But the
relation of the text-terminal to it's host is not one of
client-server. The text-terminal is just another means of access to
the computer just like the monitor and its keyboard is. One could
apply this same reasoning to a thin client and say that the
client-server relationship is only for the transport of data.
Thus a thin client is like a terminal. It has a GUI with a mouse that
makes it seem like you are using a computer. You are, but that
computer may be far away and have many other people using it at the
same time you are. Communication is over a high speed network cable
or even over the Internet. Some thin clients can, in addition,
emulate a text terminal and have a serial port connector for that
purpose. One even has a USB interface.
There are various types of thin clients. One type is the "Window
Terminal" which runs under MS servers (and software). Another
type is the "network computer" which is supposed to be platform
neutral. This implies they should work with both MS Windows and Linux
but early models may not be easy to use with Linux. For Linux, the X
Window protocol is used. See
Thin clients and NCs under Linux
MS Window terminals
These are true terminals since all the computing work is done by
a server running Windows. They are also called "Window-based
Terminals" (WBT). These terminals (clients) are something like
computers since they often run an embedded operating system such as
Linux or Microsoft's CE, NT, or XP. It's often stored in flash memory
so that it may be updated. Also, ordinary PCs can be used as clients
(including, in some cases, Linux PCs) with the appropriate software,
Some clients can support X Window (from a Linux server) and some can
emulate text-terminals. Many so called "network computers" can also
run X Window. This will be discussed in the next section.
The server for these clients usually runs MS's Terminal Services (for
Windows 2000 servers). Prior to this there was Windows NT Terminal
Server Edition (starting mid 1998 with codename "Hydra"). MS uses RDP
(Remote Desktop Protocol) which is based on the ITU T.120 protocol.
In addition, there is an optional ICA protocol (with added features)
which can inter-operate with RDP.
Prior to this there was a modified Windows NT 3.51 (1995) called
"WinFrame" by Citrix using the proprietary ICA protocol (Independent
Computing Architecture). After MS came out with its own terminal
server, Citrix still remained on the scene. It created MetaFrame
software (formerly pICAsso) as an add-on to MS's Terminal Server (or
Services) so that it could support ICA-based terminals and provide
other additional features. Before MS got into the act, there were
other proprietary systems for terminals that could display the MS
Windows GUI but later on they all switched to support Microsoft's
system.
PCs running Linux can be turned into ICA based client terminals using
"free" (in price only) proprietary ICA client software from Citrix:
Citrix Systems, Inc.. Unfortunately, MS requires that you
purchase a license to cover the clients, even if the clients all run
Linux. So if you want to save money on software costs by using Linux,
you'll have to go all-Linux and use both Linux servers and clients
using the free X-Window protocol.
The above is sometimes called "network computing" since the terminals
and servers connect to each other over a network (such as the common
TCP/IP based network used by both Linux and MS). Network computers
may be somewhat different as described below.
Network computers (NCs)
These are neither true computers nor true terminals but are
something in-between. One type of network computer (NC's) is a
computer with a CPU but no hard Disk. The OS it needs to run is sent
to it over a network. NCs are full-graphics and use the services of a
server computer. They are a little different from terminals since
some (or most) of the programs they run may execute on their own CPU
chip. Running a browser was supposed to be one of their primary
functions and thus Java code applets may be sent to them for
execution. Many NCs support X Window so that one may use a Linux
server to support it. Such a server may be called a "Linux Terminal
Server". IBM called their NC a "NetStation" but now calls it
"NetVista". They should work on Intranet type networks and NetVista
can run the Linux OS.
Wintel came out with a "NetPC" which, unlike the above, is almost a PC
computer. However, it has no removable disks so users can't install
their own software or obtain copies of anything.
Thin clients and NCs under Linux
There is a "Linux Terminal Server Project" (LTSP or ltsp) to use
Linux as a server for diskless thin clients. They use X Window and by
default, applications run on the server. But with additional effort,
one can set it up so that some or all applications run on the
"terminal". See
http://www.ltsp.org/.
"Terminal" in LTSP is actually a thin (or fat) client. This
project's client can also run a telnet session and thus behave like a
text-terminal. A software package named "lts" for the LTSP is
available in the major Linux distributions.
It's claimed that if one has only a few "terminals", they will work
without the ltsp software. But if one has many "terminals", ltsp
software is needed. So use ltsp if what you want to do is to use old
PCs, etc. as diskless thin clients. It works OK on systems with over
100 thin-client workstations.
Linux provides NFS (Network File System) so that if ordinary computers
are connected to each other via a network, then a person on one
computer can run programs on another computer. Such a program sends
messages over the network so that it appears just like a program was
being run by your local computer. But such a program is actually
being run on another computer on the network. It works also with
X Window so that one may see GUI images generated on another
computer.
Linux also allows a computer to be diskless and boot over a network.
See the "Terminal Server Project" above which has special software for
this purpose. Network-boot-HOWTO gives an overview. Older documents
are Diskless-HOWTO and Diskless-root-NFS-HOWTO. Thus using a diskless
computer which runs NFS enables you to run programs on another
computer (the server). This is just like using a NC (Network
Computer). It's not really a NC but it's emulating a type of NC.
It's also often called a "terminal" and in some sense it is.
Thus if you have an old PC with an ethernet card (NIC) you may be able
to use it as a NC. One source of info on this is Thinclient-HOWTO.
Even if your old PC doesn't have a NIC, you could still use it to
emulate a text-terminal. See
Terminal Emulation.
There are also a number of genuine Network Computers (NC) that will
work with a Linux server. Today some NCs run the Linux OS inside the
NC. Before Linux became popular, NCs didn't run the Linux OS but
required some other OS. But even if the NC uses a non-linux OS, it's
often possible to make it work with a Linux Server. The non-linux OS
is simply stored as files on the Linux Server. Then when the NC
starts up it sends a message to the Linux Server asking for the
non-linux OS files. This non-linux OS is thus sent to the NC over the
network and the NC boots.
The Linux Server runs the NFS and X Window both of which must be
supported by the NC. This enables one to use the NC as if it were an
X Window terminal.
There are some Linux HOWTOs for certain brands of NCs:
- JavaStation-HOWTO (by Sun)
- NC-HOWTO (IBM NetStation)
- NCD mini-HOWTO (NCD-ThinSTAR)
- NCD-X-Terminal mini-HOWTO
- XDM-and-X-Terminal mini-HOWTO
Hardware hookups
There are 3 different types of hardware arrangements for thin
clients. The first type just uses a PC computer as a thin client by
emulating a thin client. It really isn't a thin client but it behaves
like one. The second type looks just like a text-terminal. It just
looks like a monitor, with a connector for a keyboard and another
connector for a network cable. It's a dedicated thin client and can't
be used for anything else. The third type looks like a tiny computer.
It uses a standard PC monitor and keyboard both of which plug into a
small box which is a "thin" computer. This box provides an interface
between the monitor/keyboard and the network.
History and the future
Promoters of NCs and related Window-Terminals projected that they
would soon replace millions of PCs. In 1998 about .7 million thin
clients were sold worldwide with (about 27% of them being NCs). In
1999 it dropped to .6 million but went up to .9 million in 2000 (vs.
1.3 million predicted). In 2001 it reached 1.09 million with 1.4
million predicted for 2002.
Microsoft servers (as of 2003) still dominate the market, but the
clients may run Linux for which users still have to pay license fee
for each Linux client to Microsoft. Thus free all-linux systems are
gaining ground.
A major reason why growth was not as rapid as predicted is that PCs
have come down in price in recent years so that they are often not
much more expensive than a thin client. However, it's argued that
even though thin clients may cost the same as PCs, the maintenance and
administration costs are less. Note that thin clients sometimes
replace text terminals instead of PCs.
Since a PC has a screen and keyboard (as does a terminal) but also
has much more computing power, it's easy to use some of this computing
power to make the PC computer behave like a text terminal. This is
called "terminal emulation". They usually emulate text-terminals.
See
Terminal Emulation
Next
Previous
Contents
|