Philip Brittan's Blog

Deployment Archives

The Rich Client Strikes Back

Microsoft is redefining the application interface around rich clients, and if Java does not have an answer, it faces being cut off from end users. The answer lies in matching Microsoft's richness while trumping it on security.

FYI, I just published an article in Java Developers Journal: The Rich Client Strikes Back.

Java vs. .NET, part 5 - Rich thin clients

Let Java play to its strengths and co-opt Microsoft’s advantages

In the previous parts of this series on Java vs. Microsoft .NET, I lay out the threat that .NET poses to the Java ecosystem and the advantages on which Microsoft is relying to carry out that threat.

So…what is the response to this threat? Those of you who know me already know what I’m going to say: rich thin clients. In fact, a month ago java.net readers byronsebastian and d_bleyl forshadowed this entry.

The concept of rich thin client technology is to deliver the user experience of native locally-installed desktop software (co-opting Microsoft’s strength) from server-based applications (playing to Java’s strength). With this approach, Java gives developers a cross-platform method for delivering applications that feature the desktop benefits that users want with the deployment and administration benefits that CIOs are looking for.

I’m not talking about Java Applets, Flash, or other disguised fat-clients. In order to deliver on the full benefits of the server-based model, and to avoid walking into a Microsoft trap, rich thin client technologies must leave 100% of application code on the server. Putting code on the client means putting it in hostile territory where it can be attacked and thwarted by Microsoft. Additionally, rich thin clients need to be browser deliverable, but must also be able to operate independently of the browser.

It may, in fact, be necessary to use Microsoft’s own technology to implement the generic client-side piece of a successful rich thin client framework on Windows PCs/devices. I know that there is a feeling in the purist Java community that applications must be 100% pure Java to be acceptable, but I believe that the most important piece of the chain is that the applications themselves are written in Java -- that’s the part that builds a developer community. If those applications are then displayed by Microsoft technology on the desktop so that they can take advantage of all the desktop benefits, so be it. If Microsoft really does banish Java from the PC, it just won’t matter to rich thin client Java apps running safely on the server. On non-Windows desktops and devices, J2SE, J2ME, or even native technology can be used for the generic client. The desktop technology doesn’t matter -- in the rich thin client world, it’s invisible to the application.

I am also not talking about terminal server technology, like Citrix or X-Windows. Today’s rich thin clients can offer an immediate, responsive native desktop user experience, with no lagging “remote mouse” and with very high server scalability and super low bandwidth usage. They can offer the user experience that Microsoft promises with Smart Clients.

The Java platform must offer compelling benefits beyond simply matching Microsoft. Rich thin clients can do this:

• Write Once, Run Anywhere: I just read this article titled “Java Everywhere”, which stated “To get Java working properly on all devices, we must compromise one of Java's most recognized principles: Write Once, Run Anywhere (WORA).” How sad, and unnecessary. With rich thin client technology, a single Java code base can run on the server and project its UI onto a very wide variety of client platforms. WORA can be preserved.
  
  
• Open Standards: Move the entire balance of power to the server. Then open standards have some teeth.
  
  
• Security: Keeping all your code on the server means that your application cannot be a vector for viruses and destructive bugs to client PCs.
  
  
• Developer Productivity. Writing software that has 100% of its code on the server is easier to architect, debug, and manage than either client/server or multi-layer Web apps. Rich thin clients let developers architect their systems into as many layers as they want, not as many as the technology dictates. And it’s easy to bring standard, best-of-breed tools -- Java IDEs, debuggers, profilers, optimizers, etc., -- to bear on the entire code base.
  
  
• Resource-leveling: Utility computing promises to help companies save costs by virtualizing processor load and other resources across a managed grid. Keeping all the code on the server means all the code can benefit from this.

Rich thin client frameworks are also architecturally amenable to supporting a variety of languages. As I argued in the last part of this series, the Java platform needs to recognize the huge investment companies have in legacy systems and provide a way forward for those companies without requiring that they rewrite their apps in Java. Rich thin clients bring that legacy code into a server-based, network-centric environment and then give developers a way to add new features to those legacy apps in Java. Since all the code is on the server, it’s architecturally easy to deal with big piles of spaghetti (without having to disentangle them) and to mix and match languages and technologies, all under the covers and away from users and hard-to-manage desktop computers.

If rich thin client technology takes off, then it has the effect of marginalizing the desktop PC, a big strategic win for the Java camp. Rich thin client apps don’t generally care what kind of client hardware is displaying them. Customers can go with whatever is cheap and convenient, not with the platform that happens to support their favorite apps. This paves the way for non-Windows desktop proliferation.

I believe that our industry is shaping up for an epic battle between the Microsoft ecosystem, wielding .NET, and the non-Microsoft vendors, championing Java. The battle will be very hard fought and Microsoft will give no quarter. Already they have put Java into a difficult position. The best way out of the trap is not to fight them on their terms, but to redefine the battlefield. This opportunity is available because the world is moving towards being always connected. Microsoft realizes this and is trying to use our increasing connectedness as a way to drive their platform from the desktop to the server room. The Java world needs to head them off at the pass and make real the fear that Bill Gates had of the Internet in 1995.

Java vs. .NET, part 4 - Java is a language, .NET is not

Java takes a language-specific approach to solving problems, .NET takes a platform-specific one

One of the striking differences between Java and .NET is that Java is, fundamentally, a programming language and .NET is not. .NET is a framework that supports many languages. There has been a lot of identification of C# with .NET, but C# does not equal .NET, and you don’t need to use C# in order to build .NET applications. You can use one of the 20+ other programming languages currently supported by .NET. .NET’s view of the world is from the platform. It is designed from the ground up to leverage specific aspects of the Windows platform to its advantage.

Java, on the other hand, has a language-centric view of the world. Yes, with J2EE, Java has started to create a framework around itself, and extension technologies like Jini and JXTA certainly strengthen Java’s platform, but the way in which Java attacks problems is from a language point of view.

One immediate result of this difference is that it leaves Microsoft with the opportunity to surround Java with other languages. Not only does Microsoft already control the enormously popular Visual Basic and have the ability to make C# very popular, but it can appeal to companies that already have large code-bases in COBOL, C++, Smalltalk, Fortran, and other legacy languages. Java’s answer to those folks is: port your legacy apps to Java or use some kind of awkward connector bridge between the legacy code and Java. It is not natively tolerant of legacy code.

There have been attempts in the past to support other languages with the JVM. Eiffel can compile to Java bytecode. But those efforts have not gained any real support in the Java community. Bertrand Meyer, the creator of Eiffel, writes this in a paper describing his successful efforts to connect Eiffel to .NET:

This ability to mix languages offers great promise for the future of programming languages, as the practical advance of new language designs has been hindered by the library issue: Though you may have conceived the best language in the world, implemented an optimal compiler and provided brilliant tools, you still might not get the users you deserve because you can't match the wealth of reusable components that other languages are able to provide, merely because they've been around longer. Building bridges to these languages helps, but it's an endless effort if you have to do it separately for each one. In recent years, this library compatibility issue may have been the major impediment to the spread of new language ideas, regardless of their intrinsic value. Language interoperability can overturn this obstacle.
….
The language openness of .NET is a welcome relief after the years of incessant Java attempts at language hegemony. For far too long, the Sun camp has preached the One Language doctrine. The field of programming language design has a long, rich history, and there is no credible argument that the alpha and omega of programming, closing off any future evolution, was uttered in Silicon Valley in 1995. Microsoft's .NET breaks this lock.

Everyone will benefit, even the Java community: Now that there's competition again, new constructs are—surprise!—again being considered for Java; one hears noises, for example, about Sun finally introducing genericity sometime in the current millennium. Such are the virtues of openness and competition.

In summary, .NETs multi-language support is another threat to Java. Java needs to blunt this threat. Specifically:

• .NET will surround Java with alternative and legacy-compatible languages. The Java platform needs to become more language neutral while continuing to make Java the best language possible by dynamically incorporating new ideas such as Aspects and built-in support for Web Services.
  
  
• Java's language-specific solutions will isolate it. Make sure technologies mesh with no language assumptions (object layout, data types, calling conventions, runtime context, etc.)
  
  
• .NET as a platform has more hooks into the OS. Java needs to support desktop integration (icons, file linking), which is stuff that happens before any Java code gets run. This is client side, but it's all about what you can deliver end-to-end with Java application code.
  
  
• Deploying server-side J2EE applications is a bear. Java needs platform capabilities to make this much easier. The approach of offering wizards helps, but because they are glued on, they are brittle (hard to change after you’ve gone through the process once) and not compatible between different compilers.

(To be continued. And yes, I am about to offer some hope…)

The Internet Has Been Good to Microsoft Office

Standards, and corresponding monopolies, can occur naturally

Believe it or not, there are times when I feel some empathy for Microsoft. After all, I myself was once a small-time monopolist.

My first company, Astrogamma, had a product called FENICS that provided foreign exchange (FX) options pricing and risk management functions for traders. FX options are a particular kind of financial contract that banks and corporations trade as a way of taking bets on the fluctuations in the exchange rates between currencies or to protect themselves from those fluctuations (if you want a full primer in FX options, feel free to write me :) ).

The important thing for this discussion is that trading FX options turned out to be much, much easier if the traders on both sides of the transaction were using the same software. Our system caught on initially because of our focus on the user experience, our aggressive pricing, and the fact that we were able to seed our product into the brokerage houses (who were important market influencers) early on. But once we started to see widespread adoption of our software, the FX options market started to realize the benefits of having everyone use a standard system, which in turn drove further sales of our product until we had cornered over 80% of the global market of banks, brokerage houses, and large corporations that traded actively in FX options. We became, in effect, a monopoly. There was nothing nefarious about it. We didn’t set out to become a monopoly; we just wanted to create the best system on the market. We didn’t engage in any uncompetitive practices (we were actually a much smaller company than all of our competitors, starting out). It just happened that way.

This is an example of the network effect, where the network is of people trading on FENICS-calculated prices. The more people joined the network, the more valuable it became, and the more important it was for everyone else to join.

In discussing Microsoft, people like to point out their monopolies on desktop operating systems and Web browsers. But these are really by-products of their most interesting monopoly: Office. As David Kennedy pointed out this morning, Office is what drives the Microsoft desktop which in turn drives Internet Explorer.

A couple years ago, there was lots of speculation that Microsoft’s monopoly would be severely threatened by the Internet. Even Microsoft bought into this, which launched them into a furious and ultimately victorious battle to control the browser. The great irony is that, far from hurting Microsoft, the Internet has cemented its desktop domination. The further irony is that winning the browser war probably hasn’t helped Microsoft that much (except that it now allows them to keep Java off the client). The part of the Internet that helped Microsoft the most has been email. As email became more widespread, people began to email documents to one another (rather than printing and faxing or snail-mailing). This of course brought the network effect into full swing, and Office moved from being a “nice to have” (because of feature set) and an “easy to have” (because bundling arrangements Microsoft forged with PC makers) to a “must have” (because of file compatibility).

I doubt that Microsoft really set out to achieve this, but now it has happened, and I’m sure they are extremely thankful for it. Sun has made the strongest attempt yet at breaking the Microsoft Office hold by offering StarOffice, which has a high degree of file compatibility with MSOffice. It’s a bold strategy on Sun’s part, but so far has not really had widespread success. It will be very hard/impossible to compete effectively on Microsoft's own turf of the Windows desktop. Price doesn't seem to have been a big motivator for customers so far (StarOffice was free for a long time). StarOffice does help to make Linux desktops a little more realistic as an alternative to Windows, but really Windows and MSOffice now have such a strong symbiotic relationship that they are likely impervious to direct attack. The best strategy may be to try to change the rules of the game.

Java vs. .NET, part 3 - Open Standards

Java’s traditional weapon of choice

The concept of open standards has been the primary weapon of the non-Microsoft camp (which includes the Java community) against Microsoft. And it is a reasonable weapon. Open standards are meant to ensure interoperability between products from different vendors so that customers have the flexibility to put together best of breed solutions and, at least in theory, can swap out one vendor’s products for another’s if they become disenchanted with the first vendor on product quality or price. This means that all vendors are competing on a flatter playing field, and therefore customers and smaller vendors get the benefit of a more efficient market. Cliff Schmidt offers a very nice overview of the why, what, where, who, when, and how of standards.

Major vendors in the non-Microsoft camp push hard on the idea that Microsoft is proprietary and closed, meaning that Microsoft technology interoperates only with other Microsoft technology. A customer who goes down the Microsoft route is “locked in” and can’t choose to swap in non-Microsoft products.

The ideas behind the open standards movement are laudable, and I believe in them. Product standardization -- of electric outlets, of audio equipment connections, of bolt sizes, of fuel types, etc. -- has greatly benefited customers in general. It should certainly do the same in the world of software.

However, as a weapon against Microsoft, it has several weaknesses:

1. It only matters on the server. At this point in time, at least, Microsoft is the unrivalled king of the desktop. They set the standards there, and there are no major movements to challenge Microsoft as the standards-setter within that domain. This means that the concept of open standards in software really only has value in the server/network environment.



2. Microsoft developers don’t care. Microsoft shops are unswayed by the idea of open standards. For them, the standards that Microsoft sets are as legitimate as standards set by any official standards organization. It is a misrepresentation to say that Microsoft software only works with other Microsoft software. Microsoft has fostered a huge ecosystem of ISVs who conform to the standards that it sets. There is a belief in the Microsoft camp, justified or not, that software from vendors who conform to the Microsoft Standard interoperates at least as well, if not better than, software from vendors who conform to Open Standards.



3. The Open Standards camp is fractured. Standards are meant to foster cooperation, innovation, and customer choice. Unfortunately, in the melee of competition, large vendors are often guilty of using standards to club each other over the heads. They also use them, ironically, to keep smaller vendors out of the running by eliminating the possibility of innovation and reducing any competition to one of superior implementation of the given standard, which clearly favors large established vendors.



4. Microsoft is getting into the open standards game. Microsoft has been one of the loudest champions of open standards for XML and Web Services and has moved agressively to make C# an official standard. And they seem to be having a high time clubbing Sun over the head with various aspects of the Web Services standards process. Now, none of us believe that they truly believe in the philosophy of open standards, and there are even rumors that they will shortly abandon the official Web Services standards when they release Indigo. But in the meantime, their high visibility involvement in standards dulls the open standards arguments of the non-Microsoft camp.

(To be continued)

Blackout

Single points of failure can be entire systems. Prevention may lie in "fencing in".

For those of you on the West Coast, I can assure you that it was pretty dark here in New York last Thursday evening. A little after 4pm, suddenly all our lights, air-conditioners, phones, etc., in our office shut down. The UPS alarms started ringing, letting us know we were operating on battery power. We soon realized that the power was going to take a long time to come back on, hours if not days, and we didn’t have enough battery life for that, so all we could do was execute an orderly shut down of our servers and wait.

The effects of a loss of power are devastating, especially in an overcrowded city. No light, no A/C, thousands of people trapped in subways and on commuter railways, no ventilation in roadway tunnels, no ATMs, no credit card processing, no cell towers to relay our phone calls, no phone systems in our offices, no answering machines, no PCs, no refrigeration, very limited cooking, etc. Life as we know it completely on hold. We are utterly dependent on electricity and the systems that deliver it to us.

The power system -- something I admittedly don’t know a lot about -- seems pretty well distributed. There are a multitude of power plants, operating independently but interconnected through a singular power grid. This grid is supposed to be able to handle changes in local supply and demand, routing extra energy to a hot region where too many people are cooling off in front of the A/C, and seamlessly covering for a downed plant.

But apparently, these independent plants are also susceptible to each other, through the grid. I read that 21 major power plants spread out over 9,000 square miles all shut down within 3 minutes of each other, as a defensive response to some type of surge in the grid, leaving roughly 50 million people without power. Although the grid is supposed to nicely handle failures at any particular power plant, which I assume it does all the time and of which I am thankfully oblivious, it apparently can be a single point of failure itself, leading to catastrophic shut-down of the entire system.

So how can we prevent systems from being single points of failure? The answer may lie in the concept of "fencing in" instead of "fencing out". In my home state of Montana, the law of the land is "fence out". That means that it is incumbent upon any ranch to keep his neighbors’ livestock out of his fields – he is not responsible for keeping his own livestock in. This mechanism dates from the time when most of Montana was open range land, and the occasional farms were responsible for keeping that free-range livestock out of their fields. In this day, when all the land has been claimed and cut up into contiguous ranches, this "fence out" rule seems a little anachronistic, but it remains the rule.

I think that that same rule is used in numerous distributed systems. In our recent blackout, each power station acted entirely in its own self-interest and shut down to protect itself from the surge running across the grid, i.e. they each fenced the menace out. If instead, there were cooperation across the grid to isolate the surge, i.e. fence it in, then catastrophic system failure could have been avoided.

Currently viruses are handled by “fence out” methodology. Every individual system attempts to fence viruses out leaving the viruses free to run around the network looking for just one system that fails to fence them out so that they can propagate. If they were fenced in, they would not have the ability to look for a weak node to attack.

The only way to fence viruses in is to make sure that they have no medium for transmission. As we move towards a model of “utility computing” in which compute resources are served up like electricity from a distributed grid, the risks of a systemic failure become greater. However, since servers tend to operate in strictly managed environments, it should be easier to isolate destructive code (viruses and bugs) and its effects. And by connecting to desktop environments without sending executable content to them, we can make sure that destructive code never gets to leave that rigorously managed server grid. Mark Williamson at HP in the UK has been experimenting with using innovative "fence in" techniques to combat viruses.

It is consistent with game theory that the benefit of the whole is maximized by each constituent pursuing their own self-interest and cooperating to pursue the interest of the group. That is what fencing in requires.

ASP.NET and Smart Clients

Microsoft makes money from Windows desktops, not from browsers

In response to the the latest installment of my Java vs. .Net series, a number of you responded with a focus on ASP.NET. ASP.NET is Microsoft's way of delivering browser-based DHTML applications.

Yes, ASP.NET is an important part of .NET, but I actually do not think that Microsoft is interested in promoting browser-based DHTML clients very heavily. Strategically, they need to continue to lock in Windows on the desktop, and fat clients are the strongest way to do that.

I believe that Microsoft's main strategic thrust will be around "Smart Clients". Smart Clients are .NET fat clients that rely on Web Services (served up by Windows Servers) and that can be trickeled to the client machine byte-by-byte (by Windows Servers), to make installation much more seamless to the end user. But they are still locally-installed Win32 applications.

Usability will be a primary driver for Microsoft to promote Smart Clients. Usability doesn't just mean the quality of the GUI or the richness of the controls (although those are very important). It also includes the ability to interact with other applications on the desktop (a big problem for browser-based apps) to provide an overall superior user experience (anyone remember the "Are you experienced?" campaign?).

Here is an excerpt from a newsletter that Microsoft sent around to ISVs this morning:

"ISVs: Get Ready to Deliver Smart Client Applications The Smart Client Readiness Program for ISVs gives you the software, tools, and technical resources you need to start building smart client applications. If your customers aren't asking for them yet, they will soon see the need for the next generation of anywhere, anytime data access. Enroll in the program today! http://go.microsoft.com/?linkid=215945"

Java vs. .NET, part 2 - The Nature of the Beast

What is Microsoft trying to do?

Microsoft is the uncontested champion of the desktop. In the business world, they own essentially the entire client-side market. This is a huge advantage for them. But it is also a limitation. In order to fuel its growth, Microsoft must find new, less-tapped-out markets to go after. The server room is one such market. Microsoft is already strong there, but they still have a lot of share to grow into, and it is a lucrative market.

In my previous post in this series, I claimed that Microsoft has the upper hand when it comes to the quality of the user experience. Microsoft’s user experience leadership is completely bound up with their domination of the desktop. It makes sense for Microsoft to use their hegemony on the desktop to their advantage. The client PC is their solid base, and .NET is the lever to get back to the target. .NET is an expansive strategy with many interlocking parts, and these parts come into play at various stages in Microsoft’s siege of the server room.

The UI layer of .NET is the tip of Microsoft’s spear. Microsoft leverages its usability advantage, combined with its very strong tools offering, to convince developers to adopt .NET as their platform for application development and deployment. .NET apps are delivered either as ASP.NET Web pages or as managed CLR fat clients. The thing is, in order to deploy and power .NET apps on the client or in the browser, you really need to install Windows servers, preferably Windows Server 2003 (formerly known as Windows .NET Server), in the server room. Ideally, you’ll also finally upgrade to XP on the desktops to boot!

From there, Microsoft uses the expansiveness of the .NET strategy to push out Oracle in favor of SQL Server and gets companies to install BizTalk and other Microsoft server technologies. The fact that so many companies already rely on Exchange for email helps in this. Microsoft will demonstrate the power and ease of using a pre-integrated stack from a single vendor to get customers to adopt more and more of their technology.

This is the threat that non-Microsoft vendors and the whole Java community faces. This plan is ambitious, but it is by no means easy, even for a company with the resources and advantages of Microsoft. Its success hinges largely on Microsoft’s ability to convince developers to adopt .NET. Therefore, the Java community’s challenge is to keep the tip of Microsoft’s spear from getting in by convincing developers and sys admins (and the companies that employ them) that Java has a more compelling answer for applications delivery than .NET.

(to be continued)

Docs >> Forms >> Apps

There is a natural evolution of platform technologies from document publishing to forms processing to application delivery. The Web is the leading example of this, but Adobe Acrobat PDF and Microsoft InfoPath are on their way.

The W3C has finally published its specification for XForms 1.0, after much delay and without the participation of Microsoft (not surprisingly). XForms is intended to make Web-based forms more usable by doing a better job of separating data values from form description and supporting cascading style sheets. The main benefit of these improvements is to make forms more reusable and easier to change and maintain with less re-coding.

There is an interesting evolution of platform technologies that start out as simple document publication frameworks (displaying read-only text and graphics to users), then, presumably under pressure from users, these platforms get extended to support forms (meaning that users can enter data which is then written back to a database on the server). The next logical step is to make these forms increasingly dynamic until they come to resemble full-fledged application delivery platforms.

This is exactly the evolution that the Web itself has undergone over the past 10 years. Most people agree that the Web does a fine job for publishing documents -- the truly revolutionary paradigm shift that the Web has delivered to date has been allowing all businesses to have universally accessible marketing materials on-line and to let anyone in the world do research through Google rather than the much, much more tedious means available before the Web. Web forms have allowed e-commerce to start to get a firm foothold. But Web technology is not as strong at forms processing as it is at doc publishing, as evidenced by the need for XForms at all. In the past few years, companies have tried hard to shoehorn full-blow applications into browsers using Web technologies, but these efforts have had very mixed results. Many vendors and standards groups have come out with a large stack of add-on technologies designed to patch up the problems that HTTP/HTML present for application developers. Other companies, like my own, have tried to rethink the application delivery problem from the ground up.

Now both Adobe and Microsoft are headed down the same road with the new forms-processing capabilities in Acrobat and XDocs/InfoPath. The question on everyone’s tongue now is how these products will compete with each other. A deeper question is how they will compete with HTML/XForms and whether they will indeed progress towards being full application delivery platforms.

It seems that there is market pressure for a platform to provide a continuum of capabilities from document publishing to application delivery. Maybe docs, forms, and apps are really all meant to be the same thing. But how we’ll achieve that is still far from clear.

Server-Based

Before I get much further in my Blog, I just want to make one thing perfectly clear: I love servers. Or more accurately, I love having my applications and data on servers, and then I like to just forget about those servers. I want them to be someone else’s concern. I simply want my applications and my data to be wherever I need them. I want them to be backed up without my thinking about it. I don’t want to install them or upgrade them.

That’s all about me as a user. As a developer and system administrator, I also love servers. I’d much rather debug a problem in my data center than out on a user’s desktop machine. In fact, I’d love to take a server out of rotation on my load-balancer and spend as much time as I need fixing and testing the problem there, without having a user looking over my shoulder, sighing heavily, and tapping a pencil impatiently on her desk. If my apps need more memory, I’d rather plug it into my servers all neatly arranged in a rack rather than running around and lifting the hood on each individual user’s desktop machine.

As a business owner, I also love servers. Servers give me a good price/performance ratio. I can almost think of them as disposable. I certainly can’t do that with my desktop PCs – but I’d like to! My sys admins are more productive when fixing problems or upgrading software and hardware. My employees can access our corporate apps from home and on the road (so I can work them around the clock!) And perhaps if the promises of On Demand / Utility Computing are realized, my server-based systems will be able to take full advantage of the cost savings and efficiencies of virtualizing my processor load across a grid. If I’ve got a lot of client-side application code -- in fat clients (VB, Swing, SWT…) or fat browsers (DHTML, JavaScript, Applets, Flash…) -- I can’t do that.

Yes, I do love servers.

This work is licensed under a Creative Commons License.