|This article needs additional citations for verification. (July 2008)|
A thin client (sometimes also called a lean, zero or slim client) is a computer or a computer program that depends heavily on another computer (its server) to fulfill its computational roles. This is different from the traditional fat client, which is a computer designed to take on these roles by itself. The specific roles assumed by the server may vary, from providing data persistence (for example, for diskless nodes) to actual information processing on the client’s behalf.
Thin clients occur as components of a broader computer infrastructure, where many clients share their computations with the same server. As such, thin client infrastructures can be viewed as providing some computing service via several user interfaces. This is desirable in contexts where individual fat clients have much more functionality or power than the infrastructure requires.
Thin-client computing is also a way of easily maintaining computational services at a reduced total cost of ownership.
- 1 History
- 2 Characteristics of thin clients
- 3 Thin client variants
- 4 List of protocols used by thin clients
- 5 See also
- 6 References
|This section does not cite any references or sources. (March 2015)|
Thin clients have their roots in multi-user systems, traditionally mainframes accessed by some sort of terminal computer. As computer graphics matured, these terminals transitioned from providing a command-line interface to a full graphical user interface, as is common on modern  advanced thin clients. The prototypical multiuser environment along these lines, Unix, began to support fully graphical X terminals, i.e., devices running display server software, from about 1984. X terminals remained relatively popular even after the arrival of other thin clients in the mid-late 1990s. Modern Unix derivatives like BSD and GNU/Linux continue the tradition of the multi-user, remote display/input session. Typically, X software is not made available on non-X-based thin clients, although no technical reason for this exclusion would prevent it.
Windows NT became capable of multi-user operations primarily through the efforts of Citrix Systems, which repackaged NT 3.5.1 as the multi-user operating system WinFrame in 1995. Microsoft licensed this technology back from Citrix and implemented it into Windows NT 4.0 Terminal Server Edition, under a project codenamed ‘Hydra’. Windows NT then became the basis of Windows 2000 and Windows XP. As of 2011[update] Microsoft Windows systems support graphical terminals via the Remote Desktop Services component.
The term thin client was coined in 1993 by Tim Negris, VP of Server Marketing at Oracle Corp., while working with company founder Larry Ellison on the launch of Oracle 7. At the time, Oracle wished to differentiate their server oriented software from Microsoft’s desktop oriented products. Ellison subsequently popularized Negris’ buzzword with frequent use in his speeches and interviews about Oracle products.
The term stuck for several reasons. The earlier term ‘graphical terminal’ had been chosen to distinguish such terminals from text-based terminals, and thus put the emphasis heavily on graphics - which became obsolete as a distinguishing characteristic in the 1990s as text-only physical terminals themselves became obsolete, and text-only computer systems (a few of which existed in the 1980s) were no longer manufactured. The term ‘thin client’ also conveys better what was then viewed as the fundamental difference: thin clients can be designed with less expensive hardware, because they have reduced computational workloads.
By the 2010s, however, thin clients were not the only desktop devices for general purpose computing that were ‘thin’ - in the sense of having a small form factor and being relatively inexpensive. The Nettop form factor for desktop PCs was introduced, and nettops could run full feature Windows or Linux; tablets and tablet-laptop hybrids had also entered the market. However, while there was now little size difference, thin clients retained some key advantages over these competitors, such as not needing a local drive. However, ‘thin client’ can be a misnomer for slim form factor computers using flash memory such as compactflash, SD card, or permanent flash memory as a hard disc substitute.
Characteristics of thin clients
Single point of failure
The server, in taking on the whole processing load of several clients, forms a single point of failure for those clients. This has both positive and negative aspects. On one hand, the security threat model for the software becomes more focused on the servers. The clients do not run the software; therefore, only a small number of computers (the servers) need to be secured at a software level, rather than securing software installed on every single client computer (although client computers may still require physical security and strong authentication, to prevent unauthorised access, depending on requirements). On the other hand, any denial of service attack against the server will limit the access of many clients. The server software is typically written with virtual machine technology so every client is isolated and a client crash is easily handled and rebooted. The single point of failure can still exist, however. If the server crashes, data loss is possible.
For small networks, this single-point of failure property might be expanded. The hosting server can be integrated with file servers and print servers relevant to its clients. This can simplify the network and its maintenance, but might increase the risk against that server.
In practice, redundancy can be provided both in the form of additional connectivity from server to the network as well as in the servers themselves, using features like RAID, distributed servers (multiple networked servers appearing as one server to the users), clustered filesystems (which allow files to be accessed from multiple servers), VMWare High Availability and Fault Tolerance or Citrix XenApp's load balancing.
Cheap client hardware
While the server must be robust enough to handle several client sessions at once, the clients can be assembled from much cheaper hardware than that of a fat client. Many clients have minimal RAM, some do not even have a hard drive. This reduces the power consumption of those clients, and makes the system marginally scalable, i.e. it is relatively cheap to connect additional client terminals. The thin clients usually have a very low total cost of ownership, but the need for a robust server infrastructure offsets some cost savings. Thin clients also generally use very low power and might not even require cooling fans, but the servers consume high power and almost always require an environmentally controlled air conditioned server room.
Since the clients are made from low cost hardware with few moving parts, they can operate in more hostile environments than conventional computers. However, they inevitably need a network connection to their server, which must be isolated from such hostile environments. Since thin clients are cheap, they offer a low risk of theft in general, and are easy to replace if stolen or broken. Since they do not have any complicated boot images, the problem of boot image control is centralized to the server.
On the other hand, to achieve this simplicity, thin clients sometimes lag behind thick clients (PC Desktops) in terms of extensibility. For example, if a local software utility or set of device drivers are needed in order to support a locally attached peripheral device (e.g. printer, scanner, biometric security device), the thin client operating system may lack the resources needed to fully integrate the needed dependencies. Modern thin clients attempt to address this limitation via port mapping or USB redirection software. However, these methods cannot address all use case scenarios for the vast number of peripheral types being put to use today.
Slow bitmapped/animated graphics
Thin clients tend to be optimized for use with simple lines, curves, and text, which can be rapidly drawn by the client using predefined stored procedures and cached bitmap data. In this regard, thin clients work well for basic office applications such as spreadsheets, word processing, data entry, and so forth.
However, all thin clients suffer performance problems when large areas of the graphics display must be updated rapidly with high detail bitmap graphics, which may also need to be redrawn several times per second for animation purposes. In a few cases it may be possible to use a video stream that was already previously compressed such as MPEG or H.264 video, but many graphical programs such as photo editors, 3D drawing programs, and animation tools require high detail uncompressed bitmaps to be displayed in order for the software to be used effectively. Graphics rich 3D games can be completely unusable on a thin client unless the updated screen area is kept very small or the overall screen resolution is very low, to reduce the amount of data sent to the client.
In an attempt to reduce network bandwidth, the server may try to compress high detail bitmaps on the fly before sending the data to the client, but this adds latency to the client-server communications, and may reduce user interface responsiveness. Many thin clients offer options to turn off various graphics rich user interface effects in order to increase performance, such as not showing the contents of a window while dragging or not displaying a desktop background.
Thin client variants
Repurposing a PC as a thin client
The following options allow a PC to be used as a thin client - in some cases, even if it has no working hard drive:
- Linux Terminal Server Project
- Puppy Linux
- Remote desktop software
Ultra-thin client, zero client, or clientless
Traditionally, a thin client ran a full operating system for the purposes of connecting to other computers. Some thin clients, such as the Sun Ray, use a simpler protocol for communicating display updates, and these are sometimes called ultra-thin clients or zero clients,. Their tiny operating systems merely initialize the network, begin the networking protocol, handle display of the server's output, and transmit user input events. The full desktop is run remotely and the displayed graphics and text are compressed with either a remote display protocol such as PCoIP, or even just a video codec such as VP9 or Daala, and sent to the zero client. The client silicon is now much simpler and lower cost as all it requires is a video decoder and basic I/O.
A Run Time Environment (RTE) client contains task specific applications (e.g. Mozilla Firefox for Internet browsing) and only the minimal (often customized) underlying and supporting code (BIOS, firmware, kernel, libraries, plug-ins, etc.) to run only those applications. It contains all and only the code needed to accomplish its specific task, thus it is more than a zero client but less than a typical thin client computer. The RTE client does not have a general purpose operating system - it usually lacks shells (terminal windows), is not designed to be patched (updated online), has minimal connectivity to external resources, and is often found in read-only media (e.g. tamper resistant ROM chips, CD-ROM, etc.). Attempts to inject or run any other applications/processes/threads results in crashing the kernel (system). Due to the need to physically update the device, RTE clients are mostly found in stable environments demanding high security.
Web thin client
Web thin clients only provide a web browser, and rely on web applications to provide general-purpose computing functionality. However, note that web applications may use web storage to store some data locally, e.g. for "offline mode", and they can perform significant processing tasks as well. Rich Internet Applications for instance may cross the boundary, and HTML5 Web Applications can leverage browsers as run-time environments through the use of a cache manifest or so called "packaged apps" (in Firefox OS and Chrome).
Chromebooks and Chromeboxes also have the capability of remote desktop using the free Chrome Remote Desktop browser extension, which means, other than being a web thin client, they can also be used as an ultra-thin client (see above) to access PC or Mac applications that do not run on the Chromebook directly. Indeed, they can be used as a web thin client and an ultra-thin-client simultaneously, with the user switching between web browser and PC or Mac application windows with a click.
Chromebooks are also able to store user documents locally - though, with the exception of media files (which have a dedicated player application to play them), all such files can only be opened and processed with web applications, since traditional desktop applications cannot be installed in Chrome OS.
Web thin clients are similar to RTE clients, but unlike first-generation RTE clients the operating system can typically be updated. Chrome OS, for example, automatically updates itself if its update servers (which are hosted by Google) are not blocked by a firewall - while still being tamper-resistant due to its use of Trusted Computing technologies.
Applications as thin clients
The notion of a thin client extends indirectly to any client–server architecture, in which case, a thin client application is simply one which relies on its server to process most or all of its business logic. This idiom is relatively common for computer security reasons. A client obviously cannot be trusted with the logic that determines how trustworthy they are, because an adversary can circumvent that logic.
However, in web development in particular, many client applications are becoming fatter. This is due to the adoption of heavily client-side technologies like Flash and Ajax, which are themselves strongly driven by the highly interactive nature of Web 2.0 applications.
List of protocols used by thin clients
- Appliance Link Protocol
- Citrix ICA
- HP Remote Graphics Software (RGS)
- Linux Terminal Server Project
- various video codecs such as VP9
- Remote Desktop Protocol
- Secure Shell or SSH, an encrypted replacement for telnet.
- Virtual Network Computing
- X11, central to traditional Unix graphical windowing systems
- XML, HTML, or JSON over HTTP (Ajax)
- NoMachine NX Software (NX)
- SPICE (protocol)
- Blade PC
- Centralized computing
- Desktop Virtualization
- Dumb terminal
- Fat client
- Hybrid client
- Multiseat configuration
- Smart client
- Terminal services
- Univention Corporate Client (UCC), an Open Source solution for the central management of PCs, notebooks and thin clients
- Windows PE
- X11, central to Unix windowing
- Nieh, Jason; Novik, Naomi &., Yang, S. Jae (December 2005). "A Comparison of Thin-Client Computing Architectures" (PDF). Technical Report CUCS-022-00 (New York: Network Computing Laboratory, Columbia University). Retrieved November 11, 2011.
- t310 Zero Client
|Wikimedia Commons has media related to Thin clients.|