Oracle WebLogic: past, present and futurePublished on: Author: Michel Schildmeijer Category: Oracle
Oracle WebLogic is for quite some years the key platform for Enterprise Java Applications. Through its long history of development and building, it has become the most complete, mature and stable application server platform, ready to serve old technology but more than ready for the coming new technologies which are following up each other in a speed that no one would ever thought of. This article will give you an overview of how WebLogic started, how it became the platform as it now is, and what to expect in the future. Enjoy reading!
This article was published in OTech Magazine #8 summer 2015
WebLogic: ancient history
If you browse on the internet and enter “weblogic” (Myself, I prefer, as a WebLogic geek, always to type its original Camel Case written name WebLogic) you will find some Wikipedia pages with a timeline and history about the versions that has passed, up to the latest versions ( if the Wikipedia pages are updated). But how did it all begin? I was eager to hear it in person from one of the founders of WebLogic back in 1995, before the BEA era, Laurie Pitman.
Four young people, Carl Resnikoff, Paul Ambrose, Bob Pasker, and Laurie Pitman, became friends and colleagues about the time of the first release of Java in 1995. They all had a Master Degree in various areas of expertise, and they had come together kind of serendipitously, interested in building some web tools exclusively in Java for the emerging Internet web application market. They found many things to like about each other, some overlap in our interests, but also a lot of well-placed differences which made a partnership particularly interesting. They made it formal in January 1996 by incorporating.
The four of them were always committed to building exclusively in Java, and never considered using any other language. It’s hard to understand today what that meant back then; Java then was perceived as a cute but basically useless early web language for hand-waving applets. Nobody was building real applications in Java in 1995 or 1996; maybe not even in 1997. But the group saw its potential: that it was a first-class programming language, remember the famous quote “write-once, run-everywhere”, which at the advent of Internet computing was incomprehensibly powerful . . . that one could write a single app that could run on a whole platform of otherwise unrelated, incompatible servers located in multiple physical places. As they began to construct this integrated multitier platform, the beginnings of what would eventually be called the “application server”, they still didn’t know how to sell it. Everyone called the stuff they were doing “Java tools,” and at that time, “tools” were boring and extremely unlikely to attract any serious investor money.
Surviving these days was easy, because there was no need to take huge investments. At least at first (in 1996), it didn’t matter that investors were not interested; each of the founders had enough financial independence so that they were willing to work on an almost non-profit base, and that got them through the first year or so of development. One of the things that made it different from other startups was that they were already selling some very successful products – think JDBC drivers for Oracle, Sybase, and MSSQL. Still, they believed that the lifecycle for those drivers was short, and needed to get a visionary product out. (As it turns out, the WebLogic JDBC drivers are still in use, almost 20 years later.)
Their skills were various: Paul and Carl both had extensive database experience; Bob had written sophisticated transaction processing and networking apps in the late eighties for DEC in the financial district in New York City, and Laurie had GUI design and writing experience. In that period they talked endlessly, experimenting, writing, and tossing ideas back and forth. Either remote, or when in person, it was often at Caffe Roma on Columbus Ave.
In San Francisco, because they didn’t mind if they spent hours plugged into a wall socket for a laptop (which was unusual in 1996). It got to be so regular that to this day, a whole host of early adopters call the place “Cafe WebLogic.”
Paul and Carl had written really good, bullet-proof JDBC drivers that were spreading like wildfire over the Internet. It was marketed as “dbKona,” after the coffee (Java) theme. Then they began to integrate the drivers into a bigger application, a 3-tier server that separated the application layer from the transportation and session layers. Lots of ideas came up about extending the functionality of what already existed. For example, they knew that just being able to pull database data wasn’t much use unless you could display it on a web page, so they wrote a set of Java classes for generating HTML (HTMLKona).
Then it seemed like a good idea to include a Java server to process the servlets as well. But you needed security, and a management console, etc. etc. The first real server release was T3Kona in early 1996, which included a webserver with security and transaction processing, the JDBC drivers for interacting with databases, and the HTMLKona classes to create servlets. From the first release, it was always their aim to create a plug-and-play environment to make it easy to build vertical enterprise apps on top of the multitier server infrastructure.
Back in 1996 and 1997 when they were developing the initial WebLogic software, Java EE was not yet invented. There was basic Java, and JDBC, but everything else was as of yet uninvented. In fact, some of the later development of the Java language spec came out of how they were pushing the Java envelope for enterprise apps at WebLogic. They wrote classes to do transaction processing, threading, concurrency, security, and memory management before Sun designed J2EE. They wrote classes that did what EJB and RMI did long before Sun released them, and rewrote all of the code to incorporate the changes in the language.
They were always committed to total integration with the most current Java release, because in the long run, that made their jobs easier. Their aim was always to build easy-to-use, off-the-shelf software for creating very reliable web apps, and integrating the latest version of the Java spec always brought with it interoperability, enhanced networking, security, better performance; and it reduced our company need to write those things into our software – and then support them. They always opted to support whatever Sun added to the Java spec. Sometimes they actively participated in making sure that certain things got added. But it was a really good collaboration.
The team moved into first office space in the financial district of San Francisco in late 1996 at 180 Montgomery St. It consisted of 4 offices and a conference room, and no desks, but a few chairs. As they began to grow, they started hiring; within a few months about 10 engineers, and those early WebLogic hires were some heavy hitting talent: Peter Seibel, Sam Pullara, Anno Langen, Dean Jacobs (deceased a few months ago). Dave Parker became President to run the business, and he saw potential for success.
The company kept growing and growing, so by February of 1997 they moved to some office space at 417 Montgomery, and it became home for almost a year. About that time they hired Scott Dietzen, and they really began trying to market more effectively. New people came in like Dave Brown from the Java group at Sun, and Adam Messinger, and a dozen other really talented engineers. They acquired a sales department, including a satellite office on Park Avenue in NYC, another in Austin, TX, and another in Boston.
At the time, their huge customer base primarily existed of engineers and developers all over the world, particularly in the financial and information processing industries.
“Customers” were not end-users, but software engineers. They treated their customer base of engineers as friends and collaborators, and many of them became loyal and vocal enthusiasts of the WebLogic platform. This could be one reasons the product became so successful. Paul Ambrose was still spending hours a day on the phone and in email answering engineering questions. They also had thousands of pages of Javadoc’s and documentation, hundreds of sophisticated code examples, written for engineers by engineers.
By late 1997, engineers named Sam Pullara, Dave Brown, and Peter Seibel drifted in and admitted they had come up with a WebLogic server plug-in for thin-client “push” apps-which was the sole product offering that one of them extremely overfunded, marketing-rich and software-thin competitors were selling for a huge licensing fee. Sam, Brown, and Peter had packaged that functionality into a few WebLogic classes over the weekend.
During the 1998’s, the market was changing. There was a lot of consolidation going on. WebLogic owned about 70% of the application server market, but Sun had just bought NetDynamics, and IBM WebSphere was becoming a heavy hitter. WebLogic needed to partner with an 800-pound gorilla if it was going to have any long-term staying power in the coalescing market.
This was the beginning of the BEA acquisition. BEA, among others, came to them. In a period of 2-3 weeks all was set. It was a very amiable transaction; they all had the same goal in mind, which was to enable WebLogic to go to the next level of authority and influence in the software world.
For quite some long time BEA managed to bring WebLogic to a mature Java EE Application Server Platform, serving BEA’s ThinkLiquid product line such as AquaLogic ServiceBus and AquaLogic BPM. Around 2004, BEA started this product suite were AquaLogic stood as a concept for a complete SOA technical framework. In this suite there were several products such as AquaLogic ServiceBus (Now Oracle’s Service Bus) and also AquaLogic Business Process Management. These were all parts of companies acquired by BEA, and formed BEA’s SOA Suite.
Oracle also acquired the complete “ThinkLiquid” stack and integrated it into various product suites.
Note: Above is an extract of an interview with Laurie Pitman and the author of this article
WebLogic in the present time
At time of writing this article, WebLogic has reached the level of 12c (12.1.3) Oracle has made a move in aligning all version numbers of its product. Before 12c it could be quite confusing to determine which version number you we’re running. As an example if you we’re running WebLogic 11g PatchSet 5, it was actually version 10.3.6. Same as products like SOA Suite: 11gR5 was 22.214.171.124.
WebLogic 12.1.1 – December 2011
The first 12c release was launched at December the 1st 2011, but the most important change was that it finally supported Java 6. This WebLogic 12c implements the JAVA EE 6 standards, which supports all kinds of JAVA EE 6 specifications. 12.1.1 also supported the latest JDK’s 7 from that , and support for Java SE 7 (and Java SE 6) which includes:
- Java language optimizations and Internationalization
- Client and server support
- SSL/TLS 1.2 in JSSE to support JAVA Socket Transport security
For the rest, in general this release does not differ from its 11g companions; all infrastructure features such as GridLink for RAC already existed in 10.3.4. With every new release Oracle introduce some small parts and include other components that already were released and offers it as “brand new”
WebLogic 12.1.2 – 2013
This version was really a bigger change than its previous one, which was only more commercial driven. This is the first release in the Cloud Application Foundation, where WebLogic is the key platform for serving Cloud technology and applications with special focus on:
- Performance and extended High Availability capabilities
- Support for mobile platforms ( HTML5, WebSockets)
- Continued support on Java EE 6, Maven, Spring, Classloading, Open Source
In every newer release you see more and more integration of components and techniques which Oracle acquired by buying technology (e.g. take over a technology company). As an example, Coherence, which Oracle acquired from Tangosol, went from a standalone container more into an embedded feature in the WebLogic infrastructure. It now is accessible through the Admin Console and can be monitored because it’s integrated in the MBean infrastructure of WebLogic.
In this version the concept of Dynamic clustering is introduced. Dynamic in here basically means you can add managed servers to your cluster without doing extra configuration; just create one and start it.
Also other standalone features, such as Oracle’s WebTier Infrastructure (which is based on Apache software) becomes more and more part from, as Oracle names it, Fusion Middleware Infrastructure. Administration console, such as the standalone Enterprise Manager is fully based and built in ADF screens, where the WebLogic Administration console in the base still relies on old WebLogic Portal technology. However, more control functions also appear in Enterprise Manager.
Furthermore, Oracle says goodbye to the ‘old school’ BEA installation and patch upgrade framework and start to make use of the Oracle Universal Installer and the OPatch instead of using BSU utility. And last but not least, JRockit (at least its name) disappears and will continue to live under the name Oracle HotSpot which is a converged Sun’s HotSpot and BEA JRockit features into one JDK JVM Platform.
WebLogic 12.1.3 – 2014
WebLogic 12.1.3 is an even more important release, and is, at time of writing this article the current release. It is important though, because Oracle releases a lot of their layered products on this version, such as:
- Oracle Service Bus 12.1.3
- Oracle SOA and BPM Suite 12.1.3
- Oracle ADF 12.1.3
- Oracle JDeveloper 12.1.3
So there you have your complete new 12c stack!
Also the support for new Java versions continues, such as Java EE7, but also more extension on communications like REST interfaces for CRUD operations and some restricted interface management; loos similar to client/server architecture of the past, where Web/HTTP is the glue that connects client and server; Data format is usually JSON, and WebSockets protocol for lightweight events in HTML5.
Database integration and HA capabilities are getting more and more extended in a bundled 12 driver package with support for RAC of course and Pluggable Databases, Multi-Tenant Database, more scalability with Database Resident Connection Pooling and global Availability with Global Data Services. Seamlessly is a main item in this release; seamless scaling on components such as JDBC, JMS and managed servers fits into Oracle Cloud strategies.
WebLogic in the future
Oracle will continue to build on what there is now. Next release to be expected will be version 12.2.x and will come out somewhere in 2016. Now, there are a lot of speculations on what to expect, but although Oracle already showed some of the possible new features, their “safe harbor statement” prevents that it will be officially confirmed.
One of these speculation is that WebLogic domains will have the possibility to be partitioned. This means, there will be a base Fusion Middleware Infrastructure, with several domain partitions. Applications and resources deployed for each partition which can be tenant. These partition isolations will have appropriate levels with memory and CPU isolation at the JVM level, Virtual host per partition for application access, dedicated JNDI tree for resource isolation and a dedicated work Manager for partitioned thread management. In the previous releases there one could only make use of one security realm in runtime domain, but per domain partition is possible to make use of several realms. The elasticity concept is getting more and more extended in every server infrastructure component (JMS Server, Managed Server).
These components will get their own management interface so it’s easier to administer them separate, either with the well know JMX interface, or the new and more extended REST interfaces.
WebLogic is ready for the next stage of its evolution, with more and more important improvements, either it is about availability, stability, flexibility or simplicity. Offering WebLogic as a Service (PAAS) will make it simpler to run applications on WebLogic, without knowing all the underlying technology.
For technicians though it is still a very complex matter and more deep specialization is required in building complex but solid solutions for end-customers.
Still I do think WebLogic is the nr 1 Java Platform, as, where it once began, still rest on those very first concepts: serving Java application technology.