Thin Clients and Fat Clients



  • History and Definition

    In the beginning, computer systems were centralized - there was just one computer for all of the users in an organization. To access the computer, people would work from terminals (originally teletype machines or TTYs, later terminals with screens) that were all tied to the central computer. These terminals were dumb, they had no logic processing power of their own. They were simply remote displays and remote input devices and the central computer did all of the thinking or processing. In essence, these were nothing more than monitors and keyboards over very long extension cables.

    Here is an early terminal that was a true teletype (output was actually on paper instead of a screen and input was modified from a traditional typewriter!)
    0_1486817434851_ASR-33_1.jpg

    And here is a slightly later screen-based terminal that uses the same basics but has a screen instead of a printer to display text coming from the central server and has a more modern style keyboard. This is the DEC VT-100, probably the most popular and definitely the most famous traditional terminal that was ever made. It had much of the look of what computers would later look like, but did not have a CPU of its own at all, it is still nothing but a remote display and had no networking, it connected over a serial connection directly a peripheral of the main server.0_1486817583896_DEC_VT100_terminal.jpg

    Later, the concept of the personal computer (not the PC per se just individual computers that would be on a desk) with its own CPU, RAM and storage was introduced. This came decades after centralized computing had been well established. The idea was that these new micro-computers could be used to run their own applications so that users would be able to do their own work without needing to tax the central server, at least part of the time. In some cases, such as running a calculator application, this could be done completely on the micro-computer; but for the majority of business use cases the data would still need to be stored on the central computer (often in what would now be termed a database) and this caused the rise of what is now known as a client - server application. The micro-computer sitting on the desktop was the client and ran local processing, accepted input, handled the display and did some amount of the work while the centralized computer mostly focused on just storing the resulting data.

    This new client for the client - server concept where there was a network for communications and processing done on both sides of the connection and software to be installed at the end user's location became known as a fat client because it required a lot of technology and support at the end point and the former terminal-style computing client where the client was very, very "thin" on technology became know as a thin client.

    Over time, of course, the use of long run serial cables has become archaic and the desire for all end user computing to be graphical, have alternative inputs like a mouse or touchscreen, to have sound, and so forth has led to the demise of the traditional TTY interface but conceptually thin clients still remain.

    Today, and really since the late 1990s, fully logical computers have become so cheap that it is literally more expensive to make a traditional terminal than to simply use a full computer today, but the need for thin client or centralized computing remains as it always has. Today, in fact, the use of centralized computing is on the rise again, but is generally an ebb and flow that has gone on for decades in the industry as changes in technology favour one design over the other at any particular time. For example, thin clients are far easier to secure as data is not stored on remote end points, whereas fat clients are more mobile as they can work offline.

    Today we still define a thin or fat client based on how computation is handled, only the manner of display has changed. The application itself defines which model is used. The physical server or end use device are not factors in whether something is considered thin or fat. Thin and Fat Client computing are logical terms in computing, not physical ones. If the application remains centralized and does not require any portion of the application to be installed on the end user device, it is considered to be a thin client. If the application has components installed on the end user device, those devices are fat clients.

    Because of the manner of modern remote application access there is still computation done on thin clients, but it is only computation of the "view" of the application, not running the application itself. The application remains ephemeral and not installed. Or, the business logic remains centralized, not distributed.


    Terminology

    Thin Client: A client that accesses computational resources remotely but does not handle the processing of the business logic locally. The application in question is not installed on the client. It is a remote "view" of an application.

    Fat Client: Also commonly called a thick client, is the client side of a client - server architecture system where the business logic of an application is split between a centralized resource or set of resources and end user systems that handle their own processing and commonly storage. Fat clients have application code installed on them.

    Zero Client: Marketing term for certain types of thin clients. Zero clients are generally designated by a set of protocols supported and some trivial system behaviour but are truly only a marketing term as they attempt to imply that they are lighter than a traditional thin client when, in fact, they are heavier (require more hardware capability) than the original thin clients did or still do.

    HTTP Thin Clients: HTTP has arisen as the new darling of thin computing as it provides a universally standard protocol with a simple display protocol (HTML) that is highly efficient and works across many types of devices well. The majority of thin clients today use HTTP and HTML rather than more traditional graphical or text-based protocols. HTTP is a "markup" display protocol rather than bitmap. HTTP can be used with fat clients as well, but would not be connected to a browser in that case.

    Typical Protocols of Thin Clients: While thin client computing can happen over a great many different protocols, the standard protocols associated with thin client computing would include RDP, VNC, PCoIP, SSH, NX, X, ICA, Spice, HTTP.


    Examples

    Microsoft RDS Server Remote Desktops: Or any traditional terminal server, this is the most standard example of thin client computing and uses protocols like RDP to remotely view and entire desktop environment. Answer: thin client

    VDI: The entire concept of VDI (Virtual Desktop Infrastructure) is a thin client one. This is exactly the same as a traditional terminal server but with trivial delineation around one to one virtualization. Answer: thin client

    Exchange Server with OWA: All logic resides on the central Exchange server and only display data goes to the end user device. Answer: thin client

    Exchange Server with Outlook: Outlook is an application that gets installed on the end user device. Answer: Fat client

    Exchange Server with Outlook Client on VDI: This one is complex as there is more than one connection. But following our rules, it is still easy to deduce. Answer: Fat client between Exchange and VDI Desktop and thin client for final desktop display. The end user experience is thin, but there is fat behind the scenes.

    PowerShell Remoting: This one is very traditional as it is not even graphical. Answer: thin client

    SSH: Again, like PSR, very straightforward. This is a simple layering of modern security controls onto one of the oldest terminal protocols. Answer: thin client


    FAQ

    Doesn't a thin client refer to the hardware used, such as an HP or Wyse Thin Client? No, that would be a physical description and not a logical computing one. The terms thin and fat client refers purely to the logical concepts of the computing model.

    But vendors sell things called thin clients? Yes, they do. The name has to do with their intended purpose, but most thin client hardware can trivially be used as fat client hardware. It normally has a full CPU, RAM and local storage and runs and OS. It's just a computer like any other. There is some hardware, like a traditional TTY, that cannot be used as a fat client, but it is still its use case, not the hardware, that strictly defines what it is. You can install software designed for use as a thin client (e.g. Thinstation) onto "thin client hardware" or onto the most powerful workstation hardware and it becomes a thin client through use, not processing power.

    Can a single machine be both thin and fat? Yes, very easily. This is almost ubiquitous, in fact. A pretty typical business desktop in use today will use a few fat client applications like MS Outlook and other components of the Office Suite (although it is important to note that those can be delivered in several thin manners as well) while having other business applications like CRM, Accounting, or whatever delivered over RDP, ICA or HTTP. Mixing, because end user machines are so powerful today even when intended as thin clients primarily, is very common.

    Can a single business application be both thin and fat at the same time? Yes, and this is also common. Microsoft Exchange or Zimbra email systems would be great examples. Their standard server installs deliver both a thin model (web based) and a thick model (client side application based) by default. And users often just pick which they want to use, or even which they want to use at any given moment. Many CRM and ERP applications are like this as well. This is very common - one model for ease of use, one model for offline or low bandwidth conditions. Or one for light users and one for power users.


    This article is part of a series of Foundational IT Knowledge - SAM IT Basics.