Manage Learn to apply best practices and optimize your operations.

You can never be too rich or too thin

Learn about the evolution of thin clients.


Guest Commentary
You can never be too rich or too thin
by Ronald Schmelzer, Senior Analyst, ZapThink, LLC

In the early days of computing, the only interfaces to application functionality were text-based terminals and printed output. As personal computers evolved, interfaces became more visually appealing and intuitive. Fundamentally, in these early systems, the interface was tightly coupled to the presentation logic. Simply put, an application controlled both its user interaction as well as the underlying business logic to process that interaction. Any changes to the user interface would necessitate recoding the underlying application, possibly resulting in changes to the business logic as well.

This tight coupling of user presentation to business logic extended through the client/server era as companies sought to separate systems that consumed business logic from those that served up the applications. It was only the emergence of the Web that changed this paradigm by introducing the thin client as a means of providing user interface capabilities on top of distributed computing functionality.

The use of standards to describe a user interface, in this case HTML, combined with general-purpose clients that would consume those interfaces illustrated the power of loose coupling – namely the great amount of flexibility achieved by separating the presentation tier from the underlying business logic tier. In addition, the Web proved that distributed computing was possible at very low total cost of ownership. Web browsers enabled companies to distribute applications without needing to deploy software onto desktops or end devices.

Yet, despite the advancement in architecture that the Web represented, the Web browser interface was severely limited in comparison with the relatively thicker interfaces of the client/server technologies. Users quickly realized that while exhibiting excellent economics, the Web was not an adequate substitute for their existing tightly-coupled client/server technologies, because of user interaction limitations, poor performance, and poor suitability for event-based or real-time interaction.

The need for the rich client
When we talk about user interfaces, we generally talk about clients. A client, in effect, is really the application that resides on an individual's machine that controls the interaction with business logic. In the past, when we spoke about these UI clients, we sorted the kinds of technology approaches into two relative buckets: thick clients and thin clients.

Thick clients generally are applications that directly interact with the user in which business and presentation logic are on the client, and data access can either be resident on the client or on a remote server. A thin client only requires presentation logic to exist at the client, while both data access and business logic can reside on a remote server. One advantage of the typical thin client is the elimination of any download and installation of user interface software on the user's system, while one advantage of a thick client is that since it is a program installed on a user's local machine, it can be made to perform whatever logic and operations are necessary to meet functionality and interactivity requirements.

Clearly, the boundary between what can be defined as a thin client versus what is thick is really a relative judgment call. Until the late 1990's, it was easy to differentiate between thin and thick because thick clients were usually client/server applications that required installation of software on a desktop machine, while thin clients were typically Web browsers that relied on the fact that the application logic was already installed on an end-user's desktop. Yet, this line is increasingly blurred as thin clients require proprietary plug-ins such as Macromedia Flash or runtime virtual machines such as Java or Microsoft ActiveX desktop controls to function properly. As such, the delineation between what is thin or thick is less than obvious.

However, in the context of standards-based, loosely coupled, distributed computing, the terms "thin" and "thick" are not particularly meaningful in any case. What we really care about is whether or not the consumer of a given client can value-add the service with a rich set of user interactivity capabilities or is limited to a poor set of capabilities. In this vein, we are talking about rich clients that define an increasing set of capabilities that thin, thick, and anywhere in between can take advantage of.

The set of capabilities for rich clients include the ability to:

  • Provide advanced capabilities for user interaction, including windowing features and data navigation controls like buttons, check boxes, radio buttons, toggles, windows, palettes, etc., as well as powerful rich-media component objects like animated sprites, multi-track sound, and movies.
  • Integrate local and remote sources of data and business logic, taking advantage of standards-based, service-oriented approaches to integrate all the content, communications, and application interfaces it can physically access.
  • Loosely couple presentation from application logic, giving developers the freedom not to have to make any changes to rich client functionality to make sure that the server and client can communicate. The rich client, like the standards-based Web thin client, can be truly loosely coupled and thus enable independent innovation of the business logic and the user interface to that business logic.
  • Provide greater intelligence and efficiency in distributed computing – Rich clients aren't tethered by specific, tightly-coupled communications protocols as are most client/server thick clients and Web-based thin clients. Rather, rich clients can communicate with a wide range of distributed computing systems using both synchronous and asynchronous communication modes as needed. As a result, rich clients can surpass the inefficient request/response paradigm of thin clients and also not be confined by proprietary protocols, so as to make use of the most cost-effective and productive means to communicate. Finally, rich clients won't need to dynamically generate sets of information simply to transmit large data sets, and can afford to maintain client-side data storage and message queuing. Enable online and offline modes of usage, allowing users to interact with applications while they are offline on occasionally connected devices such as mobile phones, laptops, and personal digital assistants (PDAs).
  • Deployment onto multiple platforms and channels, by abstracting rich clients' underlying runtime platform, users should be able to specify their presentation layer preferences without having to decide on a particular runtime environment. Rich clients also should support a wide range of user interaction channels including telephone, email, and voice interaction.
The ZapThink Take
Businesses today want to gain the operational and cost advantages of deploying applications over the Internet, but don't want the limitations that Web browsers impose on user interfaces. Unfortunately, there has been no practical way to provide rich client capabilities without reintroducing the scalability and manageability limitations of thick clients — that is, until now. What is different in the distributed computing world today as compared with the mid 1990s is, of course, the movement to standards-based, loosely coupled computing based on Web services—what ZapThink calls service-oriented (SO) computing

The resulting new breed of rich client offers more than either the thick or thin client approaches of the past ever have. As companies desire richer interaction between their Web services-based applications and the users of those applications, rich client solutions will increasingly gain prominence in the enterprise. Users will increasingly demand the ability to present very large data sets to a dispersed audience without sacrificing the economics that either Web applications or the rich user experience that traditional client/server applications provide.

This ZapFlash is an excerpt of ZapThink's recent report entitled "Rich Clients for SOAs." To read more detail about rich clients and the impact they are having on Web services and SOAs, please visit https://www.zapthink.com/report.html?id=ZTR-WS111 to download or purchase your copy today!


Copyright 2004. Originally published by ZapThink LLC, reprinted with permission. ZapThink LLC provides quality, high-value, focused research, analysis, and insight on emerging technologies that will have a high impact on the way business will be run in the future. To register for a free e-mail subscription to ZapFlash, click here.

For more information:

  • Looking for free research? Browse our comprehensive White Papers section by topic, author or keyword.
  • Are you tired of technospeak? The Web services Advisor column uses plain talk and avoids the hype.
  • For insightful opinion and commentary from today's industry leaders, read our Guest Commentary columns.
  • Hey Codeheads! Start benefiting from these time-saving XML Developer Tips and .NET Developer Tips.

  • Visit our huge Best Web Links for Web services collection for the freshest editor-selected resources.
  • Visit Ask the Experts for answers to your Web services, SOAP, WSDL, XML, .NET, Java and EAI questions.
  • Couldn't attend one of our Webcasts? Don't miss out. Visit our archive to watch at your own convenience.
  • Choking on the alphabet soup of industry acronyms? Visit our helpful Glossary for the latest lingo.
  • Discuss this article, voice your opinion or talk with your peers in the SearchWebServices Discussion Forums.

Dig Deeper on Topics Archive

Start the conversation

Send me notifications when other members comment.

Please create a username to comment.

-ADS BY GOOGLE

SearchSoftwareQuality

SearchAWS

SearchCloudComputing

TheServerSide.com

Close