Features

IWA for a Spring Desktop and Web Application

Sat, 20 Mar 2010 09:15:00 EDT

Integrated Windows Authentication (IWA) provides a user-friendly interface for single sign-on. IWA uses ‘Simple and Protected GSSAPI Negotiation Mechanism’ (SPNEGO) to allow the initiators and acceptors to negotiate the underlying protocol to be used for authentication. In this article, we will discuss how to enabled SPENGO to support single sign-on for a two-tier web based application using the popular Spring framework. Even though we only focus on a two-tier application, there are multiple places in these two tiers that SPNEGO needs to be enabled. At the client side, we need the client code to require the use of the SPNEGO protocol; we need to enable the Spring HTTP Invoker to use the HTTP 4.0.1 client, which needs to be SPNEGO enabled. At the server side, we need to configure the application server to support SPNEGO and we need to secure the Spring web application using SPNEGO protocol.

HTML5 Web Sockets: A Quantum Leap in Scalability for the Web

Thu, 11 Mar 2010 10:15:00 EST

Lately there has been a lot of buzz around HTML5 Web Sockets, which defines a full-duplex communication channel that operates through a single socket over the Web. HTML5 Web Sockets is not just another incremental enhancement to conventional HTTP communications; it represents a colossal advance, especially for real-time, event-driven web applications. HTML5 Web Sockets provides such a dramatic improvement from the old, convoluted "hacks" that are used to simulate a full-duplex connection in a browser that it prompted Google’s Ian Hickson – the HTML5 specification lead – to say: “Reducing kilobytes of data to 2 bytes…and reducing latency from 150ms to 50ms is far more than marginal. In fact, these two factors alone are enough to make Web Sockets seriously interesting to Google.” Let’s look at how HTML5 Web Sockets can offer such an incredibly dramatic reduction of unnecessary network traffic and latency by comparing it to conventional solutions.

Browsing Database Artifacts Using Data Source Explorer

Fri, 05 Mar 2010 09:45:00 EST

In Part 1 of this tutorial, I showed how to set up a web project and connect to a database. In this step, you will use the Data Source Explorer to browse database artifacts. You may need to re-open the JPA perspective. In the Data Source Explorer, expand the nodes inside the New Oracle Database Connection node. You can view the individual tables and columns. Observe that the Data Source Explorer denotes which columns have been designated as primary keys. Note that the tables shown below are stored in the JPATUTORIAL schema. While browsing database artifacts, simply expand the tree to view columns, constraints, dependencies, indexes, triggers, and other relevant properties of the selected component. While browsing database artifacts, navigate up the tree to view columns, constraints, dependencies, indexes, triggers, and other relevant properties of the selected component.

Scalable HTTP Session Management with WebSphere Extreme Scale (WXS)

Fri, 26 Feb 2010 13:00:00 EST

This paper will attempt to discuss the usage scenario and demonstrate the use of WXS as a separate in memory data grid to store http sessions. This paper will discuss history and existing technology and introduces WXS as a technology that differentiates itself, by addressing existing scalability challenges in a cost effective manner. We will also discuss the simplification of technical implementation of WXS grid, which makes WXS a compelling yet simple solution to store HTTP session.

Developing a Master-Detail View

Thu, 25 Feb 2010 05:30:00 EST

This tutorial provides step-by-step instructions for creating a Web application that uses the Java Persistence API (JPA) version 2.0 with Oracle WebLogic Server 11g Release 1, Spring, EclipseLink, JavaServer Faces (JSF), and Oracle Database, Express Edition. You will develop this application using Oracle Enterprise Pack for Eclipse 11g Release 1, Patchset 1 (11.1.1.3). During the process of creating this application, you’ll also get a sneak peek at planned enhancements to the Eclipse Web Tools Platform. Application Description The Web application you will develop in this tutorial is designed for a company that sells a variety of products. The application will maintain a list of products for sale as well as a list of customers who placed orders (see Figure 1)

101 on jQuery Selector Performance

Wed, 24 Feb 2010 06:15:00 EST

Last week I got to analyze a web page that spent 4.8 seconds in the onLoad event handler of a custom script file. It turned out that 2.8 seconds were consumed by applying a dynamic menu library (will blog about this one separately). The remaining 2 seconds were spent in jQuery selectors. The analysis showed that most of the selectors didn’t return any object and those that returned objects can be improved by using different selectors. About jQuery Selectors There are some great blog articles about jQuery Selectors and their Performance Impact. As you can see you can select elements by ID, TagName or ClassName. Depending on the select jQuery can use the native browser methods to query elements by id or tag or needs to manually iterate through the DOM in case of class names (as there is not getElementsByClassName in IE).

Myths and Truths About Performance Measurement Overhead

Tue, 16 Feb 2010 21:15:00 EST

In this third article of my Performance Almanac I discuss the role of overhead in performance management. As a performance management solution provider we’re frequently asked “How much overhead does your solution have?” This question is however a bit more complex to answer than just giving a single number. When discussing this topic I have also realized that there are some dogmas on people’s minds which are not necessarily true. I collected the most common myths and truths about performance measurement overhead and will discuss them in this article.

Reflections on Java Command Line Options

Sun, 07 Feb 2010 21:15:00 EST

Abstract

There are many different types of command line options that programs need to recognize. Many languages (e.g.: bash and perl) has built-in processing of command line options; Java does not. The Java Command Line Options (JCLO) package performs this task for a variety of option styles. It also uses Java's reflection capability to automatically assign values to variables in a specified class.

Six Enterprise Megatrends to Watch in 2010

Mon, 25 Jan 2010 06:45:00 EST

Most enterprise technologists should see a continued payoff of the hard work in planning, architecture, documentation, development and configuration work that has been occurring over the last several years. Enterprise technologists were building Service Oriented Architectures (SOA) long before SOA was over-hyped. And most enterprise technologists I know were investigating constructs of scalable, elastic Cloud [...] Related posts:

New CIO Playbook: Positioning IT as Strategic to the Business

Sat, 23 Jan 2010 18:00:00 EST

According to a Smart Enterprise Magazine CIO report, three-quarters of today's CIOs help their companies develop new products or services. Gartner Group's 2008 Worldwide Survey of CIOs, 85 percent of CIOs are now looking toward "IT to make the difference in their enterprise strategy." This move away from "keeping the lights on" to a focus on business strategy and external customer interaction is completely changing the day to day activities of today's CIO. The result of IT's executive leadership becoming a "part of" vs. a "supporter of" the business is forcing a shift of culture and mindset across the IT organization. If CIOs do not approach this change with a sound plan, inertia may set in due to passive/aggressive behavior and create operational risk.

The Proactivity of Troubleshooting

Mon, 18 Jan 2010 11:00:00 EST

Troubleshooting of performance problems is very often - if not almost always - viewed as a reactive activity. Frankly, I have often seen it done in such a reactive fashion as a firefight; however, effective troubleshooting should build upon a solid diagnostic process. If you handle troubleshooting as if firefighting rather than based on solid diagnosis, this inevitably is a sign you have failed to take the right proactive measures.

Whatever Happened to JAAS?

Mon, 18 Jan 2010 09:27:00 EST

Introduced in 1995, Java has firmly established itself as a mature mainstream programming language for enterprises. The Java platform security model has evolved over the years to meet new requirements, and today enterprise Java developers have a large number of APIs and services to choose from to fulfill their security needs.

XPath Support in Oracle JDeveloper 11g

Mon, 18 Jan 2010 07:45:00 EST

XML documents can be used to transfer data. The data in an XML document can be retrieved either with the JAXP (Java API for XML Processing) DOM and SAX APIs, or with the JAXP XPath API. Addressing an XML document with XPath has the advantage of selecting a single node directly without iterating over a node set. In this article, we’ll explore XPath support in Oracle JDeveloper-XDK 11g.

Making the Impossible Easy: Failover for Any Application

Tue, 29 Dec 2009 00:30:00 EST

If your systems require constant accessibility, you know that application failover is an essential function for automatically and transparently redirecting requests to an alternate server in the case of a failure or downtime. Several options exist for ensuring high availability for your mission-critical applications. Those options may be hardware- or software-based, and may also vary considerably in terms of project or enterprise scope and in terms of cost and complexity.

Using Eclipse Memory Analyzers

Fri, 25 Dec 2009 14:45:00 EST

The garbage collector is primarily responsible as a collector to reclaim objects that are no longer used by the application. This is an automatic memory management invented by McCarthy. The garbage collector collects unreferenced objects, objects that are not reached by the reference chain. The starting point of the analysis is the Garbage Collection Root (GCR), which are objects that are reachable by the VM.

Case Study in Secure Software Development

Mon, 21 Dec 2009 13:15:00 EST

Modern inter-networked software architecture created for today’s “on-demand” business needs have fundamentally increased the susceptibility of applications and, more important, data to security-related attacks and compromises. The rapidly changing environment: increased data breach/loss incidents, increased number of regulations and compliance requirements, potential liability/litigation concerns and erosion of reputation and public confidence provides ample drivers for development teams to have a security mindset.

How PowerBuilder Got Its Groove Back

Sun, 20 Dec 2009 02:00:00 EST

One of the main issues that PowerBuilder and PowerBuilder developers have been facing for the last few years is the lack of mind share for the product. All that seems to have changed with Sybase’s announcement of the beta of PowerBuilder 12.0. Articles on the release appeared in a large number of IT-related news outlets, including Darryl K Taft in eWeek (http://xrl.us/eweek), Sam M Fulton III in BetaNews (http://xrl.us/betanews), David Worthington in Software Development Times (http://xrl.us/sdtimes), Eric J Bruno in Doctor Dobbs (http://xrl.us/dobbs), John K Waters in both Visual Studio Magazine (http://xrl.us/visualstudio) and Application Development Trends (http://xrl.us/apdevtrends) and Paul Krill in ComputerWorld (http://xrl.us/compworld),

Is Your JIT Telling You Lies?

Tue, 15 Dec 2009 10:15:00 EST

Writing meaningful Java benchmarks is a tricky business. It's well known that the Java Virtual Machine's just in time (JIT) compilation process means that running an application for a few seconds won't let you predict the performance of the application over hours or days of uptime. In spite of this, developers often rely on micro-benchmarks to set performance SLAs for their applications.

A Light Java Runtime to Bundle with Applications

Fri, 11 Dec 2009 18:00:00 EST

Steve Jobs once said that Java is a big heavyweight ball and chain. Good news: the ball is now optional! In this article, I share results we achieved after implementing a component deployment model, also known as JRE modularity, for the core of J2SE 5.0 and Java SE 6. The technology's been in production use for more than two years and proved effective. This is not a mere "Java gets smaller" message. Given that Project Jigsaw is emerging in JDK 7, I also offer some insights on the challenges that any implementation of modularity for the Java SE core may face, all derived from our practical experience.

101 on Prototype CSS Selectors

Mon, 30 Nov 2009 15:00:00 EST

Performance implications of certain CSS Selectors are not specific to a certain JavaScript Library like Prototype. I recently blogged about the internals of CSS Selectors in jQuery. The same holds true for every JavaScript library that offers CSS Selectors. Certain lookups can be done by using the native browser functions like getElementById or getElementsByTagName. Lookups by class name are not natively supported in IE and are therefore implemented in JavaScript by iterating through all elements in the DOM – which is obviously much slower than a native implementation.

Lockdown My Tool Stack? You’re Kidding, Right?

Mon, 30 Nov 2009 14:00:00 EST

When I first started asking Eclipse developers about provisioning and lockdown – do we need it, what did they think about it, etc. – several things became clear very quickly. First, there are two distinct camps – people who manage people using Eclipse and people who use Eclipse. The people who manage developers and projects using Eclipse expressed great interest in being able to manage the Eclipse tool stack running on the developers’ desktops.

Performance Tuning Essentials for Java

Thu, 26 Nov 2009 02:00:00 EST

In light of today’s compressed development cycles, multi-tiered application architectures and complex technologies, many organizations are challenged to get reliable yet scalable enterprise Java applications out the door in a timely manner. Devoting a small amount of energy throughout the development process to identify, address, and correct performance obstacles can lower the risks and costs associated with poorly performing applications over the life of the code.

Using Ext JS, Servlets, JSON, MySQL and Tomcat on Fedora

Wed, 25 Nov 2009 16:15:00 EST

These days the popularity of Ext JS (a JavaScript library) is gaining momentum. One of the most popular widgets within Ext JS is the DataGrid. The reason – displaying data from a database is one of the most common tasks of a web application. “Out of the box” the DataGrid has functionality (for instance ascending or descending sorting and reordering of columns by dragging it) that otherwise would require some effort from developers.

Showcasing the Key Design Principles of SOA

Wed, 25 Nov 2009 09:30:00 EST

WS-BPEL 2.0 is the dominant specification to standardize orchestration logic and process automation between Web services. The BPEL model is used to assemble a set of discrete, essentially disparate, services into an end-to-end process flow to transform the existing stateless and uncorrelated Web service infrastructure into cohesive, process-centric applications based on a service-oriented architecture. Under this model, new applications are developed “on-the-fly” by wiring together external “partner” services that leverage existing enterprise assets.

JPA Under the Hood

Tue, 24 Nov 2009 13:17:00 EST

I recently gave talks on the behavior of different JPA frameworks at W-JAX(Germany) and TheServerSide Java Symposium (Prague). As some people have asked me, I am publishing the samples as well. I would also give away the eclipse project, however with all the third party libraries I am sure I will end up not doing it legally correct. Additionally I can add some comments on the samples and why they are as they are :-) .

Performance Analysis of Dynamic JavaScript Menus

Mon, 23 Nov 2009 13:00:00 EST

In my previous article I talked about the impact of jQuery Selectors on a page that I analyzed. The page took 4.8 seconds in the onLoad event handler. 2 seconds were mainly caused by the selectors as described in the blog. The other 2.8 seconds were caused by a dynamic JavaScript menu – in that particular case it was the superfish jQuery plugin. A closer analysis showed why it takes so long and this also got me to do some research on these menus.

Three Ways To Completely Screw Up Your Business

Fri, 20 Nov 2009 08:15:00 EST

In this article, we will examine three of the most common and deadly mistakes companies make - mistakes that can be easily rectified. If you recognize any of these mistakes in your business, you can and should take immediate corrective action.

Performance Considerations in Distributed Applications

Mon, 02 Nov 2009 13:45:00 EST

Distribution and communication between applications and services is a central concept in modern application architectures. In order to profit from distribution you have to keep some basic principles in mind – otherwise you can easily run into performance and scalability problems. During development these problems often do not surface. Then suddenly in load testing or production you might then realize that your chosen software architecture does not support the required performance and scalability requirements. In this post we will look at major points to keep in mind when building distributed applications.

Implementing RESTful Services

Thu, 01 Oct 2009 19:00:00 EDT

The RESTful architectural style [1], with its URL addressable, resource oriented approach allows you to define Web services which can have multiple runtime representation in a variety of different media types. You define a Web resource, encapsulating the desired functionality within a business method, accessible via a URI over the HTTP protocol and its different “verbs”: GET, POST, PUT, DELETE [2]. The transferred content may be either HTML, XML, binary data or images, which, depending on the business use case often require to be embedded within the same message.

Making Cloud a Reality for Enterprises via SOA Governance

Tue, 21 Jul 2009 08:15:00 EDT

Cloud computing is slowly gaining credibility and traction in the enterprise world. As giants such as Google and Amazon productize their massive cloud infrastructures, moving enterprise applications to the public cloud seems a more realistic possibility. The advantages of an enterprise application leveraging the public cloud sound like utopia – lowered total cost of ownership and overhead costs, ease of maintenance, inherent high availability and scalability that is built into the infrastructure.

Anatomy of a Java Finalizer

Thu, 16 Jul 2009 23:45:00 EDT

A couple of patterns that could cause Java heap exhaustion were identified from years of research at IBM. One interesting scenarios was observed when Java applications generate excessive amount of finalizable objects whose classes have non-trivial Java finalizers. A Java finalizer performs finalization tasks for an object. It’s the opposite of a Java constructor, which creates and initializes an instance of a Java class.

How to Diagnose Java Resource Starvation

Thu, 16 Jul 2009 18:45:00 EDT

We can visualize resource starvation using an elaborate rendition of the Dining Philosophers Problem. This classic metaphor of resource allocation among processes was first introduced in 1971 by Edsger Dijkstra in his paper “Hierarchical Ordering of Sequential Processes.” It’s been a model and universal method for verifying theories on resource allocation ever since.

Flexing Your .NET 3.5 Skillset

Wed, 15 Jul 2009 04:00:00 EDT

With the arrival of .NET 3.5, WPF and the RTM of Silverlight 2, .NET developers have more choices than ever for designing, developing and deploying compelling applications with rich user interfaces. However, there are other mainstream alternatives that don’t fall into the .NET camp. When it comes to the RIA world, technologies such as Adobe Flex and Flash may seem more foreign to some of us then driving on the left side of the road would be to an American.

Oracle 11g Fusion Middleware LiveBlogging and News Analysis

Thu, 02 Jul 2009 16:30:00 EDT

So what does this say about Oracle's strategy for forming SNORKEL, the Sun acquisition? Well, at the risk of reductio ad absurdum, having bought BEA and Sun, Larry Ellison sees Java as the new SQL

Stress & Load Testing Web Apps (Even ADF & Apex) Using Apache JMeter

Wed, 24 Jun 2009 11:00:00 EDT

A couple of years ago I presented Take a load off! Load testing your Oracle Apex or JDeveloper web applications at OOW and AUSOUG. I can't recommend enough the importance of stress testing your web applications, it's saved my bacon a number of times. Frequently as developers, we develop under a single user (developer) model where concurrency issues are easily avoided. When our programs hit production, with just 1 more user, suddenly our programs grind to a halt or fall over in bizarre places. Result, pie on developers' faces, users' faith in new technologies destroyed, and general gnashing of teeth all round. Some simple stress and load tests can head off problems way before they hit production.

(For the remainder of this post I'll infer "stress testing" and "load testing" as the same thing, though strictly speaking one tests for your application falling over, and the other how fast it responds under load)

So how to go about stress testing a web application?

There are numerous tools available to stress test web applications, paid and free. This post will look at the setup and use of Apache's JMeter, my tool of choice, mainly because it is free! ... to undertake a very simple stress test. Apache JMeter is available here, version 2.3.3 at time of writing.

On starting JMeter (<jmeter-home>/bin/jmeter.bat on Windows) you'll see the following:

Creating a Thread Group

From here what we want to do is set up a Thread Group that simulates a number of users (concurrent sessions), done by right clicking the Test Plan node -> Thread Group option. This results in:

As you can see the Thread Group allows us to set a number of threads to simulate concurrent users/sessions, loop through tests and more.

Creating HTTP Requests

From here we can create a number of HTTP requests (Test Plan node right click -> Add -> Sampler -> HTTP Requests) to simulate each HTTP request operation (Get, Post etc), HTTP headers, payloads and more. However in a standard user session between server and browser there can be a huge array of these requests and configuring these HTTP requests within JMeter would be a major pain.

Configuring the HTTP Proxy Server

However there's an easier way. Apache JMeter can work as a proxy between your browser and server and record a user's HTTP session, namely the individual HTTP requests, that can be re-played in a JMeter Thread Group later.

To set this up instead right click the Workbench node, Add -> Non-Test Elements -> HTTP Proxy Server:

To configure the HTTP Proxy Server do the following:

* Port – set to a number that wont clash with an existing HTTP server on your PC (say 8085)
* Target Controller – set to "Test Plan > Thread Group". When the proxy server records the HTTP session between your browser and server, this setting implies the HTTP requests will be recorded against the Thread Group you created earlier, so we can reuse them later
* URL Patterns to include – a regular expression based string that tells the proxy server which URLs to record, and those to ignore. To capture everything set it to .* (dot star). Be warned that during recording however, if you use your browser for anything else but accessing the server you wish to stress test, JMeter will also capture that traffic. This includes periodic refreshes by web applications such as Gmail or Google Docs that you don't even initiate; I'm pretty sure when replaying your stress test, Google would prefer you not to stress test their infrastructure for them; stick to your own for now ;-)

The end HTTP Proxy Server setting will look something like this:

You'll note the HTTP Proxy Server has a Start button. We can't use this just yet.

Configuring your Browser

In order for the JMeter HTTP Proxy Server to capture the traffic between your server and browser, you need to make some changes to your browser's configuration. I'm assuming you're using Firefox 3 in the following example, but same approximate steps are needed for Internet Explorer.

Under Firefox open the Tools -> Options menu, then Advanced icon, Network tab, Settings button which will open the Connection Settings dialog.

In the Connection Settings dialog set the following:

* Select the Manual proxy configuration radio button
* HTTP Proxy – localhost
* Port – 8085 as per the JMeter HTTP Proxy Server option we set earlier
* No Proxy for – ensure that localhost and 127.0.0.1 aren't in the exclusion list

The above setup makes an assumption that the server you want to access is accessibly without a further external proxy required.

Recording your HTTP session

Once the browser's proxy is setup, to record a session between the browser and server do the following:

1) In Apache JMeter hit the Start button on the HTTP Proxy Server page
2) In your browser enter the URL of the first page in the application you want to stress test

Thereafter as you navigate your web application, enter data and so on, JMeter will faithfully record each HTTP request between the browser in server against your Thread Group. This may not be immediately obvious, but expand the Thread Group and you'll see each HTTP request made from the browser to server:

As can be seen, even visiting 1 web page can generate a huge amount of traffic. Ensure to stop recording the HTTP session by selecting the Stop button in the JMeter HTTP Proxy Server page.

Configuring the Thread Group for replay

Once you've recorded the session in the Thread Group there are a couple of extra things we need to achieve.

For web application's that use Cookies and session IDs (JDeveloper's ADF uses a JSessionID for tracking sessions) to track each unique user session, we cannot replay the exact HTTP request sequence with the server through JMeter, as the session ID is pegged to the recorded session, not the upcoming stress test sessions.

To solve this in JMeter right click the Thread Group -> Add -> Config Element -> HTTP Cookie Manager. This will be added as the last element to the Thread Group. I usually move it to the top of the tree:

Next we need to configure the Thread Group to show us the results of the stress test. There are a number of different ways to do this, from graphing the responses, to showing the raw HTTP responses. In this post we'll take the later option.

Right click the Thread Group -> Add -> Listener -> View Results in Tree, which will add a View Results in Tree node to the end of the Thread Group:

Finally save the Thread Group by selecting it in the node tree, then File -> Save.

Running the Thread Group

To commence your first stress test run, it's best to leave the number of spawned sessions to 1, just to see the overall test will work in it's most basic form. The default Thread Group number of threads is set to 1, so there is no need to make a change to do this.

To run the test, simply select the Run menu -> Start. On running the Thread Group, you'll see the top right of JMeter has a little box that tells if it's still running, and the number of tests to go vs total number of tests:

Once the tests are complete, this indicator will grey out.

We can now visit the View Results Tree:

This shows the HTTP requests that were sent out and on selecting an individual request, you see the raw HTTP request and the actual response. You'll note the small green triangles showing a successful HTTP 200 result. If different HTTP errors occur the triangles show different colours. Also remember that sometimes application errors don't perculate up to the HTTP layer in your web application, so you should check your application's logs too (in the case of a JEE application, this will be your container's internal logs).

Running a Stress Test

The obvious step from here is to change the Thread Group number of threads to a higher number.

From here take time out to explore the other features in JMeter. It includes a wide range of features that in particular make it useful for regression testing.

Caveats

Firstly remember when doing this you're not only stress testing your application, your stress testing a server, potentially stress testing databases, stress testing your networks and so on. Therefore you can have an affect on anybody sharing those resources. "Hard core" stress tests should be on separate infrastructure, after hours, aiming for as little impact on those around you!

Also keep in mind, besides seeing your application fall over at 2 users, 10 users, 100 users, which is an important test, try to be realistic about your stress tests. Stress testing you're brand-new-application to a 1 million concurrent users is probably not being realistic. How many concurrent user requests do you really expect and what response times do you need? Normally when I ask managers this question they'll answer with, "oh we have 1000 concurrent users, the application must support that many at any one time". However what they really mean is the application has 1000 users, potentially all logged into the application (ie. sessions) at the same time, but not necessarily hitting the server with HTTP requests at any onetime.

A Multi-Core Optimized Software Appliance

Fri, 12 Jun 2009 07:00:00 EDT

In the enterprise IT environment today, modern middleware technologies make it easier to expose existing or new business applications as sets of services. However, with the mashup of cloud-based services and enterprise data center services, the visibility of how a service created today will be used in the future gets murkier.

Butterfly Effect in Virtualized Environments

Wed, 10 Jun 2009 12:15:00 EDT

In 1969 Edward Lorenz, the famed meteorologist and Chaos Theory proponent, introduced the concept now known as the “Butterfly Effect” when he posed the famous question: “Does the flap of a butterfly’s wings in Brazil set off a tornado in Texas?” The Butterfly Effect theory describes the phenomenon of how small variations in a dynamic system can subsequently cause larger and more complex variations over the long term.

Transforming Internet Datacenters

Tue, 09 Jun 2009 12:45:00 EDT

With the explosive growth of Web-based businesses and applications, datacenter workloads have increased exponentially. IT managers are finding it difficult to meet the accelerating demands for performance, capacity, scalability and reliability, while at the same time meeting budgets, maintaining service-level agreements and driving green initiatives.

More SOA Transition Bang for Your IT Bucks

Mon, 08 Jun 2009 18:15:00 EDT

This article explains how an Open Source SOA Roadmap can use a typical Web application project’s funding as the basis for a successful SOA transition effort. It is the first of three articles that explains how open source technologies and techniques can be leveraged to successfully deliver SOA solutions given the current economic downturn.

Why SOA Is a Good Fit for CRM Solutions

Sun, 07 Jun 2009 10:15:00 EDT

Online commerce is no longer just for consumer products, but also for direct and indirect goods and services. As a result, new demands are placed on classic customer relationship management (CRM) applications. While most have successfully automated customer-facing interactions (such as order capture, configuration, pricing, and order query), they still rely on external systems to process subsequent steps (such as invoicing, fulfillment, and pick-pack-ship), which are completed in a back-office enterprise resource planning (ERP) application.