| A Perspective
on Computing Models: The Thin Cure
By Anwar Haidar - CTO
The IT literature abounds with articles trying to sort out
the pros and cons of the various computing models. Most of
these models are variations on the traditional Client-Server
(C-S) theme, which has been dissected to death. While the initial
C-S architecture is two-tier-based, several tiers have adorned it in an attempt to make distributed computing
even more “distributed” (user interface + business
logic + … + data). This layering enables the different
components making up an application to take advantage of the
processing power of different machines.
By now, everyone is aware that the thin vs. thick (or fat)
argument is really a matter of perspective. It is obvious
that between the “crippled” client (a.k.a. dumb
terminal) and the “enhanced” one (PC + OS + Application
+ … + Data) lies a myriad of nuances, each varying in
the processing power and the “smarts” required
by the client. Thus, the whole architectural design driving
this type of solution is summed up by a simple question: how
thin is thin?
It is unfortunate that most of the thin vs. thick debate
focuses mainly on the financial and managerial aspect of the
subject. Proponents of thin client solutions are keen to advance
the buzzword TCO (Total Cost of Ownership) in defense of their
model. On the other side of the fence, the thick client proponents
quickly defend the richness of the user interface as well
as the processing speed of their model.
Each camp is neither right nor wrong. On one hand, some studies
show that the TCO in a thin client environment is equivalent
to a thick client environment where the PCs are properly managed
(controlled environment). On the other hand, some thin client
solutions offer a very attractive and rich user interface.
While the TCO is an important constituent in the decision-making, it must not be the main driving force in adopting
one model over the other. Since all models are not created
equal, other factors come into play that should be carefully
assessed before engaging in any direction. While some models
work perfectly in a particular scenario, other models with
a substantial lower TCO simply do not work due to performance-related
issues, the nature of the applications, scalability requirements,
or bandwidth limitations. Neither the thin nor the thick model
is a panacea: it all depends on what works best for a particular
setup. In any case, rarely would one encounter a working environment
based solely on one model.
In the thin client world, two variants dominate the market.
The first one, that we dubbed WinThin,
is based on the Terminal Server/Citrix MetaFrame/New Moon
Canaveral iQ implementations assorted with the RDP or ICA
protocols. The second one, dubbed WebThin,
is the HTTP-browser-based model that paved the way to the
“information super highway” revolution.
The WinThin is an old technology – albeit a useful
one – that has its roots anchored in Unix X-Terminal
implementations. The idea is to launch the applications remotely
on a server and to transmit over the wire the graphics, keyboard
strokes and mouse clicks. In essence, it is similar to the
Mainframe/Terminal mode of communications with a slight twist:
it is in graphical mode instead of a text mode.
The rosy picture portrayed by WinThin is that the TCO is
extremely low compared to other models and its centralized
approach makes the day-to-day management easier. In the case
of Citrix MetaFrame it also extends Windows applications to
other platforms such as UNIX or Apple.
The TCO reasoning supposes that once the hardware and the
software licenses have been purchased the only remaining cost
is the “operating cost” of running the system.
It also supposes that the capital expenditure as well as the
staff required to operate the system would be lower. Based
on these assumptions, it appears that a WinThin solution is
a “cheaper” solution.
We think that the WinThin model is not always applicable
and that the TCO reasoning is flawed because it implicitly
assumes that the capital cost is a one shot deal that will
not recur for a long period of time. Nothing can be further
out from the truth.
First, a WinThin solution is usually comprised of two key
components: a network operating system (NOS) as well as a
3rd party shell software. As with any software, these two
components are subject to versioning. Some versions are minor
that do not necessitate heavy investments. Others are major
that would require an overhaul of the current system accompanied
by additional costs. As an example, Citrix had three major
versions: WinFrame, MetaFrame and XP. The need to move to
a new version is dictated by the fact that with time the older
versions would not be supported by the manufacturer.
Second, the hardware required to run a WinThin solution is
not as cost-effective as it seems when we consider the beefed-up
servers required to handle the user/application load. While
at the other end of the spectrum the users can be equipped
with inexpensive Windows Terminals the cost savings is largely
offset by the higher price tag of the servers. In addition,
the equipment lifespan of a WinThin solution is not longer
than that of a regular PC.
Third, the centralized nature of the thin client brings about
the single point of failure problem that unveils other hidden
or unforeseen costs. In this architecture, a network or server
failure will bring all thin clients to a halt. Clustering
and fail over servers as well as redundant communications links
are required to have high uptime and availability. This engenders
more hardware as well as operating costs.
Fourth, not all applications can or should be run off the
server. All applications that support scripting or attachments
should be avoided. As an example, running a mail client off
the server is a recipe for disaster. Any user opening an attachment
containing a virus will bring the server down or compromise
its security. The same applies for any application that supports
scripting (all Microsoft Office Applications are “scriptable”)
where a malicious script can wreck havoc on the server. Another
horror scenario is to publish Internet Explorer on a server.
One can imagine a user lowering the Internet security settings
thus enabling him to download “mobile code” (ActiveX
control, Java Applets, etc). From another standpoint, all
graphic/computational intense applications, are simply inadequate
to run off the server, such as: CAD/CAM applications, Geographic
Information System (GIS), Video Conferencing, Multimedia,
etc. Lastly, some applications will simply not cohabit on
the same server (DLL version dependency) thus requiring more
hardware.
Fifth, WinThin architecture simply cannot scale-out nor scale-up
as easily as the WebThin architecture. Scaling-out a server
by increasing the number of CPU beyond 4 does not give any
noticeable advantage (the process/thread switching and the
I/O overhead become the glut). Scaling-up by adding new servers
is not a trivial task because the administrator has to revisit
the applications partitioning amongst all servers. In this
environment, sizing up a server remains more an art than a
science. The CPU/RAM requirements is dependent on so many
factors such as the number and type of users, the number and
type of published applications, the frequency of use, the
peak use, the backup schedule, and so on, that it is extremely
difficult to determine accurately the required capacity of
a server. On a production site, WinThin servers must be continuously
monitored to verify whether their capacity is able to handle
the current load.
Before committing to a particular technology, it is important
to stop and look where the computing trend is going. A misguided
choice can lock us in a solution that we cannot outgrow without
incurring major costs. In today’s world, the new paradigm
is the Web and the new distributed computing and information
sharing model is based on SOAP, XML and Web services (.NET
is hot, COM and CORBA are not). One would expect more web-based
applications than Win32 applications coming out on the market.
The WebThin model is poised to be the de facto standard for
future applications. It offers better scalability and robustness
while eliminating or reducing manual software installations
on the client side.
Does this mean that the WinThin model is obsolete and should
not be considered? On the contrary, the WinThin model is adequate
for legacy applications or for applications that are not good
candidates to be ported over the Web. These applications must
adhere to a specific profile taking into consideration the
aspects of security, performance and scalability discussed
earlier. Choosing a WinThin model as an alternative to lowering
the TCO is a fallacy that should be avoided. As pointed out,
the cost will be invariably always higher than the projected
one. For regimented applications/activities – e.g. banking,
insurance, manufacturing process – WinThin might be
an adequate choice.
All in all, whether WinThin, WebThin, Thick or Standalone
client, it remains true that none of these models is a common
cure for all IT issues. Favoring a solution over another should
be guided only by its applicability in a particular context.
One must not be fooled by the marketing hype – with
its well-crafted budgetary and benchmark numbers.
As always, there is more than meets the eye…
 Back
to Archives
|
