-
Subscribe to this feed:
-
ATOM
Posted on 2008-07-23 18:01:00.0 by Andrig T Miller
[ View original post ]
Recently, I have noticed that companies are asking about SPECjAppServer2004 results for our Enterprise Application Platform. While this isn't entirely new, it seems like it is happening more. In most cases prospective customers don't actually understand that what they are asking for isn't necessarily relevant to their environment. So, exactly what's wrong with this benchmark?
Well, before answering that question directly, let's first talk about benchmarks in general. Industry standard benchmarks are created through a consensus process within the respective organization. They involve the vendors that all have a stake in the outcome, so they all bring their agenda that includes their products strengths (they also try to avoid their products weaknesses). Of course, no one vendor gets everything they want, but they are not independently created without regard for any individual vendors products. The vendors have influence, and that skews the benchmark from the beginning. Besides the vendor influences in the creation of benchmarks, the actual implementation of the benchmarks is not very realistic to a business application. At least not any business application that I have ever written or seen.
I was in IT, developing custom business applications for over 21 years, before joining JBoss (now the middle-ware business unit of Red Hat), and I can tell you from experience, that benchmarks do not reflect real world business applications. In fact, they rarely have anything but trivial business logic in them. They also don't reflect the technology that gets used by customers. They reflect the technology that is either in a specification, or the technology that particular vendors would like to push. This is especially true, when the vendors don't have other alternatives of their own.
The other problem with benchmarks, in general, is that the numbers that any vendor creates with them will not translate directly to anything meaningful in your business. Is something that holds no direct meaning to your business a criteria that you should use in making a decision?
After contemplating my last, albeit rhetorical question, let's get back to the initial question. So, what is wrong with the SPECjAppServer2004 benchmark?
The SPECjAppServer2004 benchmark, suffers from all the ills that almost all benchmarks suffer from. First, it looks a lot like TPC-C, as it appears to be modeled after it, but written in Java, using J2EE 1.4 technologies. So, its not a realistic representation of a business application. Second, its business logic is trivial, and in no way compares to the typical complexities of business logic in real world applications.
All the real-world applications that I have worked on had millions of lines of business logic, along with millions of lines of code that were more technical in nature, for interfaces to other systems, persistence, transaction processing, etc. Third, it is clear that the author, or authors, of this benchmark have never written a business application in their lives. Or if they had, it would have been a very poor one indeed. The code uses floating point numbers to represent dollars and cents! Ouch! Real world business applications written in Java would use the BigDecimal class to represent dollars and cents. Using native types certainly will make the benchmark faster, than using BigDecimal, which uses arbitrary precision arithmetic, but it will create results that aren't correct. The more complex the real world calculations are in your business application, the larger the calculations errors will be. For example, I developed an application where there was complex discounting schemes with discount percentages carried out to four decimal places. The calculation had to be applied back to the original charges (not just a total), and in doing that you had to go back over every detail charge (could be millions and millions per account). In order to do that you had to truncate values, and roll the remainder down, and only round at the end, so that it came out correctly, and no matter what kind of slicing and dicing you did, reporting wise, the totals would always foot. You simply cannot do those kind of calculations with floating point numbers with any accuracy at all! Finally, the benchmark is heavily dependent on EJB 2.x Container Managed Persistence (CMP).
This is the perfect example of a benchmark utilizing technology that is not relevant to customers. With the extreme limitations of EJB QL for EJB 2.x CMP, there aren't many real world applications that can use CMP. In our own customer based the vast majority have turned to alternative ORM technology like Hibernate. We also know that this is true in WebSphere and Weblogic shops as well. I think its also illustrated by the fact that BEA (years before the acquisition by Oracle), announced support of Hibernate with Weblogic! Do you think they would do that, if their customers were using CMP? Just like us, their customer base turned their back on EJB 2.x entity beans with CMP a long time ago.
When you wrap all these things up, what value does a SPECjAppServer2004 result actually provide? Well, I think we can safely say that it doesn't provide any value. In my experience, the best thing that any customer can do is run their own application against the various middle-ware platforms, and compare those results. It is what I always did, when I was in IT. Industry standard benchmarks might be a tempting short-cut, but in this case, it really isn't going to tell you anything meaningful.
There simply is no substitute from seeing your own workload running on the potential solutions!
Posted on 2008-06-05 14:12:00.0 by Andrig T Miller
[ View original post ]
In my last post, I talked about some reasons to adopt JBoss enterprise platforms, versus our jboss.org software. My main focus was on the additional testing that we do for the software, and I mentioned the stability and support as an aside. In this post, I would like to address the issue of stability and support.
So, what do you get as a subscriber in terms of stability and support? Let's start by addressing stability. For a lot of customers, stability is very important. They make a large investment in a custom developed application, and it is expected to be used in production for many years. Some companies capitalize this work, from an accounting perspective, and then amortize it over three, five or even seven years! Over that time period, even if they are doing regular upgrade releases to the software, they need the middle-ware to be as stable as possible. API and even configuration incompatibilities, can cause major problems. Typical cycles for upgrading middle-ware in an enterprise setting can also take six to nine months, or longer! With these types of cycle times in mind, our products have to be stable.
So, just how do we keep the products stable? We have instituted a quarterly cumulative patch process within the enterprise platforms. On a quarterly basis, we take defects and fix them and roll them together in a release (no new features). Some of these defects might have been delivered to customers prior to the quarterly cycle as hot fixes, depending on severity. We leverage the test suites that I detailed in my earlier post, and make sure there are no regressions. Also, the defects come from our customers, as a priority, but we may also fix issues that we know affect the enterprise platform that may have been caught in our upstream jboss.org releases. This gives us a measure of additional stability, that even though a customer has not seen this issue, we have proactively fixed it knowing that it will probably crop up down the road. Of course, this is the real power of an open source model. You have the widest and most varied deployments to flush out issues, and address them proactively. This cumulative patch process goes on for three full years, where customers can be assured that if they upgrade to any of these releases their applications will not break. For another two years, we will still produce these cumulative patch releases, but they will contain only security errata. This is vastly different than the jboss.org releases that we used to support in the old model, where an upgrade from one release to another might have feature enhancements, configuration changes, and occasionally API changes between dot dot dot releases, making it very difficult for customers. So, what does this mean for support?
Without going into details of exactly how we structure our support organization (there are better people than me to explain that), the model of supplying cumulative patch releases, and not changing API's and configuration, makes the support engineers jobs a lot easier. This, in turn, leads to much higher quality support. With this model, the support engineers don't have to wonder what possible combination of components have been thrown together. They don't have to worry about configuration or API changes that may be different from customer to customer. This all makes reproducing and fixing issues much simpler. In fact, its a win-win situation for us as a company and for the customer. It allows us to scale our business much more affectively, and at the same time delivers a much better customer experience. Customers don't have to worry about support quality suffering as we grow (and we are growing rapidly).
In summary, stability and quality support is important to our customers, and we deliver that better than any other vendor! I know this from personal experience as well, as I was a JBoss customer prior to joining the company.
Posted on 2008-04-18 14:40:00.0 by Andrig T Miller
[ View original post ]
Since we started releasing our Enterprise Platform offerings, there has been some confusion as to why would someone become a subscriber and adopt the enterprise platforms, such as the Enterprise Application Platform or the Enterprise SOA Platform, versus just downloading the jboss.org bits and using them for free?
This is certainly a legitimate question, and one that I get a lot. It also has some history behind it, since our original product model was every release on jboss.org was a supported product that you could purchase a support subscription for. With this split between having jboss.org releases be just for community consumption, and not for paying customers, confusion has reigned supreme. With that, let's talk about the reason we even went down this path.
One of the biggest issues our customers faced was stability. Under the old product model, there were fairly major changes and/or feature enhancements even in dot dot dot releases, which had the potential for breaking customers applications. That was certainly the number one problem our customers were facing, and we had to address that. While there are other issues that drove us to the new product model, stability was the number one reason. Many of our customers want a product that they can deploy, and that they know will guarantee compatibility over many years. We just didn't deliver that under the old model.
With that in mind, what are the differences between the enterprise platform releases and the jboss.org releases?
I will use our JBoss Application server, and Enterprise Application Platform as an example. With the JBoss AS project, we release based on passing two test suites (unit tests and compatibility matrix tests) which are a part of the open source project. When we have the features and fixes targeted for that release, and the test suites are 100% passing, we release the code to the community. Now, the test suites are substantial, with getting close to 4,000 tests in them. Having said that, it is run with one JVM, the Sun 1.5 JVM, on one OS platform, which happens to be Red Hat Enterprise Linux (this has actually been the case for many years, even before the Red Hat acquisition of JBoss). Now, let's contrast that to what we do for the Enterprise Application Platform.
We still do use the aforementioned test suites, but we run them on a combination of JVM's and OS's. For example, with EAP 4.3, we have run the test suites against the following JVM and OS combinations:
- BEA JRockit 1.5 JVM on RHEL 4 x86
- BEA JRockit 1.5 JVM on RHEL 4 x86_64
- BEA JRockit 1.5 JVM on RHEL 5 x86
- BEA JRockit 1.5 JVM on RHEL 5 x86_64
- BEA JRockit 1.5 JVM on Windows 2003 x86
- BEA JRockit 1.5 JVM on Windows 2003 x86_64
- HP 1.5 JVM on HP-UX 11i IA64
- HP 1.5 JVM on HP-UX 11i PA-RISC
- Sun 1.5 JVM on RHEL 5 x86
- Sun 1.5 JVM on RHEL 4 x86_64
- Sun 1.5 JVM on Solaris 9
- Sun 1.5 JVM on Solaris 10
- Sun 1.5 JVM on Windows 2003 x86
- Sun 1.5 JVM on Windows 2003 x86_64
- Sun 1.5 JVM on RHEL 4 x86
- Sun 1.5 JVM on RHEL 4 x86_64
This is our tier 1 set of platforms, and post the release we have continued to test other combinations, such as the IBM 1.5 JVM (EAP 4.3 was released in January, 2008). Through this testing we catch issues both with the test suite, and with our code that never makes it to our customers. Besides this testing, we also incorporate some of the individual component test suites, such as:
- EJB 3
- JBoss Web Services
- JBoss Remoting
- Hibernate
This in and of itself is a big step forward in our quality, but that isn't were we stop.
We have created another set of tests for performance and scalability. We do performance and scalability testing for:
These are our two most important parts of the Enterprise Application Platform, from a performance perspective, for our customers. Therefore, we want to make sure that there aren't any inherent performance and scalability problems with these features of the platform. We also use these tests for reliability testing, in the form of a soak test.
In the soak testing, we run at high-load, for an extended period of time (24 to 36 hours). This allows us to make sure there aren't issues that our customers will face that affect uptime of their deployments. Once again, we don't stop there.
With Hibernate we test against the following set of databases:
- Microsoft SQL Server 2005
- MySQL 5.0
- PostgreSQL 8.2
- Oracle 9i
- Oracle 10g
Against the above databases, we also use the database portion of the J2EE 1.4 TCK to make sure our EJB 2.x implementation works appropriately across these databases as well. This is also our tier 1 list of databases, just like the JVM and OS combinations. Since release, we are also doing testing with DB2 and Sybase. Again, we aren't done yet.
We also do testing around our clustering technologies, such as:
- HTTP Session Replication
- JMS Clustering
- JMS Fail-over
With the introduction of JBoss Messaging in the EAP 4.3 release, we now have clustering and fail-over capabilities that were not in the old JBoss MQ that it replaces, and hence we have added testing specifically for these new capabilities. Finally, there are a set of tests that cover installation and management, which include:
- GUI Installer
- JBoss Operations Network (JON)
- RPM testing
Whew! As you can see this is a lot of testing that is new with the Enterprise Application Platform, that never existing with our old product model, and is only applied to the platform products. Now what do we do with all the fixes that result from all this new testing?
Fixes go directly onto the appropriate branch for the enterprise platform, and they also go upstream into the community. Of course, the fixes that go upstream don't have any SLA associated with them and the code branches are substantially different from each other. Also, the upstream jboss.org releases may also have new features in them that aren't in the enterprise platforms. Post release of the enterprise platforms, we also do quarterly cumulative patch releases, and over time, because we don't add new features, the code continues to diverge from the upstream jboss.org releases. This goes right to the heart of the stability our customers want, and we deliver these platforms with a quality level that is unmatched in our old model.
If you want a stable platform to develop your applications on, that won't break your applications over time (3 year full support, with 2 year of security errata support), then the JBoss Enterprise Platforms are for you!
-
Subscribe to this feed:
-
ATOM