IBM has a new article on Enterprise Service Buses (ESBs) on Computerworld
Also, here are some other SOA materials:
There's a neat technique for figuring out who's really working with whom in an organization: social network analysis (SNA).
Just to add an SOA twist on all this: It seems to me that in a suitably complex SOA, you could use SNA to analyze the relationships between services. You might be surprised to learn what services use and are dependent on each other.
My colleague James Governor
has pointed me to a couple of industry articles that you may find interesting and funny as well.
In I Pity The Fool
, Niel Robertson critiques the recent Oracle event "Half Way to Fusion" by comparing it to the A-Team. It's harsh, but funny. Describing the TV show, Neil says:
Here's the basic plotline:
The A-Team stumbles across someone in distress. They take them under their wing only to find themselves in a pickle for doing so. To get out of this pickle they end up building some vehicular monstrosity out of spare parts, broken appliances, and slightly chewed bubble gum. Relying only on their ingenuity and chutzpah, then end up prevailing against all odds.
Does this by any chance sound strikingly familiar to Oracle's game plan of late?
has a new analyst, Cote Bushwald. His latest blog posting is The Exciting World of Middleware!
, which tries to figure out industry terminology:
One meaning of the phrase "enterprise software" is "confusing as hell!". To that end, I thought I'd look up how a few companies pitch their middleware offerings. Here we go!
So have fun.
Let's start talking about the component model in WebSphere Process Server and WebSphere Enterprise Service Bus.
I've talked about the Origins of WPS
. I've also talked about how WPS is built on WESB, which is built on WAS (Russian doll view
, stack view
). So what are the parts in WPS and WESB?
The model is shown pretty nicely in this picture from "WebSphere Process Server: IBM's new foundation for SOA
WebSphere Process Server platform
The picture is still accurate but has changed a little with the introduction of WESB. Imagine a new layer or row, above SOA Core but below Supporting Services, called "mediations." Mediations were in WPS v6.0 somewhere but are now a distinct new feature in WESB v6.0.1 and therefore WPS v6.0.1.
So again, this picture shows that everything's built on WAS. With the imaginary Mediations layer, it also shows again the difference between WESB and WPS. WESB contains the Mediations and SOA Core layers (on top of WAS). WPS adds the Supporting Services and Service Components layers on top of WESB (and WAS).
So if you want the features in the Service Components and Supporting Services layers, you don't get them with WESB, you need WPS.
In future postings, I'll discuss what these individual components are.
There's quite a conversation going on which those of you interested in SOAP, WSDL, and REST may be interested in.
The conversation is in the comments
to my posting Interoperability vs. Integration
. The commenters are Richard Brown
) and Mark Baker
). Richard and I are in the same department, ISSW
; Mark is an independent consultant, old object war horse like me (although we're actually not that
old), and frequent commenter on my blog.
Their comments on interoperability vs. integration have turned into a comparison and debate between explicitly-declared and strongly-typed interfaces vs. simpler ones that are more implied. Richard likes explicit, Mark likes implicit.
This brings me back to the thread I had back in August on Web 2.0 and comparing SOAP with REST. Looking back, maybe the comparison is more between WSDL and REST, which is what Richard and Mark are debating. Check out Web 2.0: APIs Instead of GUIs
through Which is Most Common: SOAP or REST?
, especially Web Services: REST isn't OO
OO may not have been a good description, but I was trying to describe what Richard is pointing out with WSDL: With explicit interfaces, you get a description of what operations are available and what their parameters and return types are. This is something the compiler can enforce. With implicit interfaces, the caller has to just know what the performer expects.
One difference is that WSDL supports multiple operations at a single address (HTTP URL or JMS queue), whereas REST uses a different URL (HTTP only, I think) for every operation. I tend to prefer multiple operations per URL; to me, that's more OO--a single object whose interface conains many domain-specific, intention-revealing method names.
If I understand what Mark and other REST proponents are describing, they're saying that the advantage of REST's implied-interface approach is that you can change what the performer expects without having to change an explicit interface, one which the caller will then no longer match, so changes are easier and therefore the model is more flexible. But if what the performer expects changes, it seems to me that the caller needs to change accordingly. At least with an explicit interface, the caller can see that what it expects is no longer what the performer supports; with implied interfaces, the invocation stops working but it's not apparent why.
Both approaches support adding
to the interface without needing to change the caller, unless and until the caller wants to invoke the new stuff. But I don't see how either approach enables a caller to keep working if the performer's interface changes
So thus far, I have to side with Richard in this debate. But it's an interesting debate, and I'm glad Richard and Mark are having it and documenting it publicly so that we can all benefit from it. So go check it out; you can even jump in if you'd like.
to parse the XML data?
I havn't written any Ajax code, but my colleague Brian Paskin has been doing so. He ran into this problem and found out that Internet Explorer
In hopes that Brian's difficulties may save you some trouble, here are the details.
if (document.implementation && document.implementation.createDocument)
parser = new DOMParser();
xmlDoc = parser.parseFromString("John Johnson", "text/xml");
else if (window.ActiveXObject)
xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
alert("Your browser can\'t handle this script");
There're (at least) three options: interoperability, converting between standards, and free-for-all integration.
As discussed in Interoperability vs. Integration
, interoperable systems work together because they implement a common standard, so they use agreed upon interfaces. Integration fills in the gap when there are no agreed upon interfaces.Richard comments
with a good NTSC/PAL TV/VCR analogy. If the TV and VCR are designed for two different standards, you need an adapter that converts between the standards.
Because of the two different standards, one can design a converter between them which itself is fairly standard and reusable. I'd say this is an example of a converter case, a case that's midway between interoperability and integration. Because the converter is going between agreed upon standards, I'd say it's closer to interoperability than integration.
In many (most?) integration projects, none of the systems implements any standards. So the converter is a bunch of stuff that need to be very customized and often isn't reusable.
Another random example of the difference: Back in the good old days of MS-DOS, each application needed its own driver for every printer. Each app would come with diskettes containing dozens of different printer drivers, and the same printer would need different drivers for different apps. Windows helped unify this by developing a standard (within Windows) printer API. Each app would use this API to print, and each printer vendor would implement a driver for this API. Windows made apps and printers interoperable.
So the moral is, perhaps: If you can't develop to an agreed upon standard for interoperability, at least develop to some standard. Odds are that this will make integration simpler, perhaps as simple as sticking in some reusable converters.
What's the difference between interoperability and integration?
I found this question in "Outstanding questions regarding BPEL and ESB
" on the Richard Brown's Gendal World
blog. Richard Brown is an ISSW
coworker of mine in the UK and, from what I hear, quite smart. (Then again, he says he reads my blog. But maybe he's still smart anyway!) His blog is really good, BTW. Richard gets the question from James McGovern
in a post with the same title, "Outstanding questions regarding BPEL and ESB
So, what's the difference? Wikipedia says "Interoperability
: the capability of different programs to exchange data via a common set of business procedures, and to read and write the same file formats and use the same protocols" and "Integration
allows data from one device or software to be read or manipulated by another, resulting in ease of use." Yuck, those aren't much help.
To me, interoperability means that two (or more) systems work together unchanged even though they weren't necessarily designed to work together. Integration means that you've written some custom code to connect two (or more) systems together. So integrating two systems which are already interoperable is trivial; you just configure them to know about each other. Integrating non-interoperable systems takes more work.
The beauty of interoperability is that two systems developed completely independently can still work together. Magic? No, standards (or at least specifications, open or otherwise); see Open Standards in Everyday Life
. Consider a Web services consumer that wants to invoke a particular WSDL, and a provider that implements the same WSDL; they'll work together, even if they were implemented independently. Why? Because they agree on the same WSDL (which may have come from a third party) and a protocol
(such as SOAP over HTTP) discovered in the binding. How does the consumer discover the provider? Some registry, perhaps one that implements UDDI (which sucks
, BTW). So SOAP, HTTP, WSDL, UDDI--all that good WS-I
stuff--make Web services interoperable.
Another example I like is the "X/Open Distributed Transaction Processing (DTP) model" (aka the XA spec); see "Configuring and using XA distributed transactions in WebSphere Studio
." With it, a transaction manager by one vendor can use resource managers by other vendors. Even though they weren't all written for each other, they still work together because they follow the same spec. They're interoperable.
Now consider two systems that weren't designed to be interoperable, or perhaps interoperable but with different specs. This requires integration. The integration code--could be Java, Message Broker
, etc.; I co-authored a whole book on this
--takes the interface one system expects and converts it to the one the other system provides. This is why WPS
has stuff like Interface Maps and Business Object Maps.
So, you want interoperable systems; integrating them is simple. Otherwise, you have to integrate them yourself.
Where did WebSphere Process Server come from?
I've talked about WPS as a stack
and as a Russian doll
: WPS is built on WESB which is built on WAS.
But what functionality is in WPS? That's a long discussion, 'cause WPS contains a whole lotta stuff. Where to begin?
WPS is a merger of three previous products:
So the common theme here is workflow. WPS, as much as anything else, is unifying WebSphere
's different workflow products, taking the best features of each, combining them with BPEL standardization
, to form a best-in-breed workflow product.
This also means that if you use any of those three products, you should start thinking about migrating to WPS. If you're starting significant development of a new application, you should look into whether you'll be better off in the long run developing for WPS instead of one of these other products.
Here's one article that you may find helpful: "Migrating WebSphere Business Integration Server Foundation V5.1.x projects to WebSphere Process Server V6
Enterprise Integration Patterns
is #2 on a Top 10 list of enterprise books.eWeek Magazine
has a series of articles called "Pings and Packets." It seems to be kind of a blogish recap of recent news tidbits. In any event, it has started to include a list called "Amazon.com's Top 10 Enterprise Books." There are lists for December
, and October
Looking at the list, it seems to include any computer books with "enterprise" in the title. So an architect study guide and an EJB book make the list, but Core J2EE Patterns
does not. In any event, Patterns of Enterprise Application Architecture
is #1 on the list and EIP is #2. Pretty cool.
Rational IDEs are built on a foundation called the Rational Software Development Platform.
In The WebSphere/Rational IDE Stack
, I talked about how WID and RAD are both built on top of the ASTK, which is built on top of Eclipse 3.0. That's correct, but there's more to the story.
As Bill points out in his comment
, the ASTK and so on are actually built on top of what we call the IBM Eclipse SDK (IES). You can see a good picture of it in the IBM Redbook Patterns: Implementing Self-Service in an SOA environment
on page 76: "Figure 5-4 Rational Software Development Platform products."
IBM Eclipse SDK is really an internal name. Publically, we usually refer to it as the "Rational Software Development Platform." Problem is, the IBM Rational Software Development Platform
) is also the term we tend to use for the family of Rational IDE products
. So, when we use the term, are we referring to the common code base these products are built on, or the collection of products that are all built on this code base?
In any event, if I were to redraw my WebSphere/Rational IDE stack and wanted to be more complete, like Bill describes, I would show a IBM Eclipse SDK layer between Eclipse and the ASTK. This represents the stuff we add to Eclipse. Some of the parts of the IBM Eclipse SDK are optional Eclipse packages. One example is the Eclipse Modeling Framework
(EMF), which I kind of assumed was part of the Eclipse 3.0 base but which is actually an extra optional module. The EMF itself contains other parts, one of which is the Service Data Object
(SDO) framework, which is gaining acceptance
So, nothing's ever simple to explain, is it? I hope this helps.
One way to look at WebSphere Process Server is as a Russian doll architecture.
A Russian doll
(or Matryoshka doll
) is a doll which opens to contain another doll and so on. In this way, one big doll actually contains many progressively smaller ones.
I've already talked about The WebSphere Process Server Stack
, how WPS is built on top of WESB which is built on top of WAS. To be even more specific, they're built on top of WAS ND, which in turn is built on top of WAS Base.
Another way to look at this is as what we call the "Russian doll" architecture, shown here (again, my picture, not Marketing's):
The WebSphere Process Server v6.0.1 Contains Relationship
This is really just a different way of drawing the stack from before:
The WebSphere Process Server v6.0.1 Stack
What the Russian doll perspective emphasizes is that WPS has WESB built in, which it turn has WAS built in. WAS isn't just a predecessor that evolved into WESB and WPS; WAS is actually contained in them. They're running on WAS, so to speak.
This is significant for IBM because it means that we're not reinventing software servers from the ground up; we're building WPS on the proven WAS foundation. What's significant for you as a WebSphere customer is that all of your skills in administering WAS and deploying applications to it are still relevant and useful for WPS and WESB. Many WebSphere customers have invested significantly in building well designed WAS server farms; rather than needing to replace these, they can use these and build onto these to add WPS and WESB servers as well.
So WPS and WESB provide lots of new functionality, but they build on what you already know (and hopefully love) about WAS.
What are the set of products that go together to create WebSphere Integration Developer and how do they fit together?
I've already talked about The WebSphere Process Server Stack
. Now let's consider WebSphere Integration Developer
, part of the WebSphere Business Process Management
suite and the main IDE
for WebSphere Process Server
and WebSphere Enterprise Service Bus
. Where does WID fit in with the other IDEs?
Like last time, I have a crude diagram I drew myself that shows the parts.
The WebSphere/Rational IDE v6.0 Stack
OK, very impressive; what's that mean? The stack works like this:
Notice that WID is not built on top of RAD; they're seperate and designed for two different types of developers. RAD is for application developers whereas WID is for integration developers, the people who design how apps will fit together and talk to each other. IBM expects these to be different people with different skill sets and thus needing different tooling. For developers with both application and integration skill sets that wish to do both, you can buy both RAD (or RSA) and WID and install them in the same Eclipse install so that you'll have one large IDE with both sets of tooling.
WID is the IDE for developing "applications" (really SCA modules
) deployed into WPS and WESB.
The January 2006 issue of IBM WebSphere Developer Technical Journal
is now available.
This month's issue has:
Lots of good stuff, so start reading up.
What are the set of products that go together to create WebSphere Process Server and how do they fit together?WebSphere Process Server
, the flagship product in the WebSphere Business Process Management
suite, is built on top of WebSphere Application Server v6.0
Here's a picture to show the relationship. I drew it myself, so it's really bare bones because I don't draw well, and so that no one will mistake it for an official item from WebSphere marketing.
The WebSphere Process Server v6.0 Stack
Now the latest version of WPS, v6.0.1, is built on top of WebSphere Enterprise Service Bus
v6.0.1, which is built on top of WAS v6.0. So it looks like this:
The WebSphere Process Server v6.0.1 Stack
Thus you can deploy J2EE/WAS apps to WPS or WESB just as if you're deploying them to WAS because, in fact, you really are. For that matter, you can deploy WESB apps to WPS. The products are built on top of each other, so the more basic products are really inside the more sophisticated ones.
What is WebSphere Business Process Management?
WebSphere Business Process Management (WBPM) and WebSphere Process Integration (WPI) are two terms IBM uses for its new suite of SOA
integration servers and development IDEs. These products are:
For some of the main documentation, see the IBM WebSphere Business Process Management information center
. I've talked about these products in WebSphere Enterprise Service Bus
, WPS and WID Now Available
, and New WebSphere Integration Products
There are also some related products that aren't officially part of the WBPM suite. Rather, they're considered part of the WebSphere Business Integration suite. These products are:
For some of the main documentation on these products and others, see the IBM WebSphere Business Integration information center
There's even a hardware component to all this, the DataPower
integration appliance. DataPower is what's commonly called an application-oriented networking device, which I've talked about in IBM Acquires DataPower, AON Vendor
and Application-Oriented Networking (AON): The Future of SOA?
WebSphere Enterprise Service Bus v6.0.1 is now available.WebSphere Enterprise Service Bus
(WESB) is a new product that implements (IBM's take on) the ESB pattern
. There's a general marketing overview
(PDF) and a set of PDF documentation
. The InfoCenter docs are a part of the WebSphere Business Process Management InfoCenter
, which includes docs for WebSphere Process Server (WPS) and WebSphere Integration Developer (WID) as well.
The WESB release coincides with new v6.0.1 releases of WPS and WID. The v6.0 versions of those products were released
back in September 2005. The v6.0 numbering can be a bit misleading; rather than these being the sixth major release of these products, this is actually the first (essentially v1.0). The version 6 numbering coincides with the numbering of the current versions of WebSphere Application Server
and Rational Application Developer
. v6.0.0 is the first release of WPS and WID; v6.0.1 is the first release of WESB.
Like this blog
? Please nominate it--as well as your other favorite developerWorks blogs
--for the 2006 Bloggies
: The Sixth Annual Weblog Awards. Thanks.[Read More
Raleigh, North Carolina has made Forbes' list of the richest cities in America at #7. It's also the #13 most literate city.Raleigh
is the biggest city in North Carolina's Research Triangle
that includes the Research Triangle Park
. IBM, including the Software Group
that helps produce WebSphere and Rational products, has a large presence
and long history
in the Triangle.
The Forbes article is "Richest Cities In The U.S.
" Raleigh is #7 in terms of income. Another publisher has picked up the story and shows a helpful summary table
. Raleigh's median income is $47,878, and its median home price is the lowest in the list at $185,200. Other cities in the list are San Jose and San Francisco and Seattle, Washington and Virginia Beach, Anchorage and Honolulu.
In a seperate but perhaps related story, Central Connecticut State University has published a list, "America's Most Literate Cities
." The study ranks cities by indicators of literacy: "newspaper circulation, number of bookstores, library resources, periodical publishing resources, and educational attainment" as well as Internet use. Raleigh ranked at number 13
. The study, and Seattle's #1 ranking, is discussed in "Seattle reaches literacy peak
IBM has announced their conferences for this year.
You can see the list of most (not all) of them at IBM Conferences & events
Here are the ones of most interest to this blog:
What's wrong with requirements? Why are use cases better?
Yesterday I talked about how use cases aren't just for user interactions anymore
. I see them as being useful for documenting how services work
, and even how your business works
. Seems to me that anytime one thing uses another thing, you can describe the interaction with use cases.
So whatever happened to good old requirements? I don't know, but I never liked them, I don't use them, and I'm glad. I remember requirements like (if I'd been working on e-commerce
apps 10 years ago) "must be able to add a product to the shopping cart" and "must be able to check out." These things would go on for pages, usually you'd end up finding two requirements twenty pages apart which directly contradicted each other, and you'd end up needing requirements lawyers to interpret the darn things. The worse part was that when the users and developers agreed to a final set of requirements, neither side really knew what they were agreeing to and probably had very different ideas in mind.
|Use cases are much more, well, useful. They describe different ways the users will use the app (or consumers will use the service, or customers will use the business, etc.). Customers and developers can actually understand what's being described and actually have the same idea in mind how the app will work (at least until you start mocking up the GUIs). This is because you're describing not what the app will do, but how users will use the app. It puts the focus back on the user and what the app will do for them.|
All is not perfect, though. Use cases often become too dang complicated too quickly. When your template has ten or twenty sections, that's too hard. The use case is supposed to be about what works right, yet too many get too lost describing preconditions, post conditions, error paths, dependencies, inheritance, and a whole lot of other stuff that confuses more than clarifies.
Perhaps the worst thing to ever happen to use cases is use case diagrams, the things that show which stick figure actors interface with which use case ovals. People will spend forever trying to get these things right. Do they really help you understand the app any better? I've repeatedly worked with developers new to use cases that keep asking me, "Is this right?" It's supposed to be intuitive; you shouldn't have to worry about right, you should worry about useful. Is it describing how users will use the app? Then it's right enough. If not, then all the templates and diagrams in the world aren't going to help you.
Special mention goes to XP user stories
. Stories get use cases back to their basics: Tell me what it'll be like using some part of the application to perform some typical task. No template, no prereqs, no error paths ... just a simple description of how things work. If the description happens to mention what's already in place, what could go wrong, etc., fine, but that should be a natural part of the explanation, not a necessity forced by the template.
So forget requirements, use use cases. And if your use cases are getting too complicated, use XP stories. It's all about communicating and agreeing upon what you want the application to do.
There's a new Insight and outlook
column in the developerWorks Architecture Zone
: "How do I translate business needs into IT requirements?
|The question this month is:|
How do I translate the business needs of my organization to IT requirements so that they can be addressed within my system architecture?
My answer is: One word: use cases (OK, two words).
I'm on a bit of a use cases kick these days. Everything starts to look like an opportunity for use cases. In this case (ugh!), my take is: Why just use use cases to model how your software app ought to work? Why not also use them to model how your whole business works (or at least ought to)? Use cases for your whole business may be excessive, so concentrate on some part of your business you want to automate and model as an SOA. The business use cases model the way the users of this part of your business (customers, employees, etc.) use the business.
This is the second article in the Insight and outlook
series. The first one is "Why and when should you choose SOA?
Fortune magazine has published some excerpts from Peter Drucker.
The article is Advice From the Master
. It's listed online as part of Fortune's "How to Become a Great Leader" issue
(but it doesn't seem to be in the printed magazine).
Drucker's take is that executives should look for collegues with specific strengths, not generalists that tend to be mediocare. I think that applys to technical people as well, that good teams tend to have people with different strengths; as long as the people work together well (and that's a big if), the team's total talent is greater than the sum of its member's talent.
I would take this one step further. It's easy to attend a meeting of whatever development team you happen to be part of, look around the table at your teammates and think "He's good. That guy's terrible. She's good. She's not." and so on. It's tempting to look at people that way, but not very helpful. Good managers I've worked for try to figure out what each team member is good at, then see how to apply those abilities to benifit the project. That way, everyone contributes. Given, sometimes you have a team member with little talent or a lousy attitude, who consistantly contributes little to any project. That's a person who needs to re-evaluate their career choice, before their employeer does it for them. But most people have something good to contribiute; good managers look for slots that fit their talents and preferences. This works better than trying to force fit staff members into slots that fit the project better than the people staffing the project.
So look around the table and think about what each team member is good at. And think about what you're good at. Then think about how you can work with them to put what you're good at together with what they're good at. I think you'll find you'll wind up with a team capable of producing much more than you could yourself, even if everybody isn't good at everything.
Norman Richards describes How JEE was Saved
Norman (a JBoss guy, BTW) contends that Hibernate and Spring helped bring needed improvements to JEE (see Java SE 6 and Java EE 5
). Now that EJB 3.0 is pretty much final
, and incorporates the best parts of Hibernate and Spring, Norman contends that their necessity has passed and their importance will wane. (For some history, see Persisting Domain Objects
and Unnamed Persistence Specification
I agree with him that standards are good, that having these features built into EJB and JEE will provide a consistent foundation for using these features.
Norman also points out an interesting purpose that these alternative/extension frameworks may serve: Not so much a basis for long term (many years) software development, but a temporary fix that shows how the standards can and should be improved. Once the standards are improved thusly, the frameworks are no longer needed and should go away. For example, Struts was the basis for JSF; once you have JSF, do you still need Struts? Probably not.
Ultimately, I still contend that IBM clients
who have spent money on products like WebSphere Application Server and Rational Application Developer are better off sticking with the related J(2)EE programming model as much as possible, so as to maximize their use of standards and of IBM support.
Fortune magazine has published an interview with Frederick Brooks.
The interview is "Quoted Often, Followed Rarely
" in Fortune's "How to Become a Great Leader" issue
is the author of the seminal book The Mythical Man-Month
. "The book detailed Brooks' experience managing IBM's bet-the-company System/360 computers and OS/360 software ..." Thirty years later, Brooks discusses the book, whether its advice is being followed, and why the same mistakes keep getting made over again.
Brooks reflects on how some people consider his book the "bible of software engineering." He agrees in this regard: "everybody quotes it, some people read it, and a few people go by it."
The Motley Fool
discusses corporations using blogging in "IBM in the Blogosphere
The article quotes Brian Doyle, director of Corporate Affairs for IBM. "We're really interested in blogs and podcasts for a number of reasons: As an employer of 329,000 people worldwide, we want IBMers to familiarize themselves with these tools. ... [A]ny time we come across a powerful new way for our global workforce to communicate and exchange information, we're going to go beyond tacit endorsement and actively work to give our employees access to this technology." Speaking for myself, I've "met" (via e-mail and instant messenger) a number of IBMers who have read my blog and contacted me, so it is helping us communicate at least a little bit better.
I also like this quote from the article: "The company is more than just approving -- it's actually enabling employees to, say, blog." Hey, my ears are burning
! Actually, it's mostly talking about the facilities we have for creating blogs and wikis internally, stuff which the public outside of IBM can't see. It's cool that the article is discussing blogging, but a little disappointing that it fails to distinguish between strictly internal communication and external communication from IBM to our customers, which I've found can benefit us internally as well.
The December 12th issue of Fortune magazine
is titled "How to Become a Great Leader."
|The cover article, "The Education of Andy Grove," is excerpts from a forthcoming book. Some of the episodes described are interesting, like deciding not to license the 386 to other chipmakers ("The Reality Shifter") and deciding not to scrap the CICS design for RISC (the first episode in the article); but most of the episodes are a bit tedious and short on insight. I hear Grove's autobiographical books (High Output Management and Only the Paranoid Survive) are really good; the forthcoming The American: The Life and Times of Andy Grove doesn't look nearly as good, judging by the Fortune article. Likewise, "10 Top Leaders Tell Their Secrets" isn't real helpful for us J2EE developer types.|
However, two other articles interview Fred Brooks and discuss insights from Peter Drucker. Those are good (IMHO), so I'll discuss them next.Dec 22 Update
: My colleague Dave Artus has added a good comment (disagreeing with me, no less!), so please click on that link.[Read More
IBM has introduced a new programming model for SOA: SCA
. Several leading companies have endorsed the specs
. Now the industry is starting to comment on this vision.
James Governor has a mildly skeptical yet amusing posting with lots of good links, Why SCA has a lot to prove: J2EE all over
. One link is to All I want for Christmas is a new SOA component model
, where he compares SCA to another layer on the onion (I'd say programming stack). The commentary is interesting and a dose of cold water on all the hype.
Myself, I'm pretty excited about SCA and SDO. It truly is a programming model for SOA. Everything is an SCA invoking services in other SCAs, passing data as SDOs; that's the complete model. SCAs host/implement/provide services, and can do so in part by invoking other services. SCA clients can invoke services in SCAs. SCA and SDO are specifically designed to be technology-neutral, so that different ones can be implemented in different technologies (J2EE, .NET, PHP, Ruby (w/ or w/o Rails), whatever) and can interoperate. Integration developers can design apps very high level at first, focusing simply on what services they need and who invokes what. Yet the service interfaces are defined, so there's still strong typing and enforcement that the client and provider agree on the service (that the SOA-SC and SOA-SP agree
). Once you've got the services laid out, then you start worrying about how to implement the individual SCAs and how they'll use the SDOs internally.
It's a compelling vision. Is it perfect yet? I doubt it. This is SCA/SDO 1.0 (the specs actually have real version numbers, 0.9 and 2.0 respectively), and 1.0 of anything is always a little rough. Versions 2.0 and 3.0 will probably be significantly better. The tools and engines we have in the future will probably be significantly better than those we have today. But we've got to start somewhere, and IBM at least has a pretty good start with WPS, WESB, and WID
. Should you convert all of your IT to SCA/SDO immediately? Probably not. But you should be exploring SOA, and while you're at it, you should look at how SCA/SDO can help.
Somewhat like Dana at ZDNet, I'm somewhat amused yet concerned about adding yet another layer to the onion/stack. I remember how CORBA
was the only distributed object model you'd ever need; and we distributed objects everywhere, and it was just too hard. Then when Sun introduced Java, it would be the only programming language you'd ever need because it was write one, run anywhere; and Java RMI and remote EJBs made CORBA usable. But Microsoft wasn't on board; invented their own object models (COM
), then their own Java/J2EE (C#/.NET). So then we got Web services, with SOAP and WSDL, the programming model that covered everything: the Web, J2EE, .NET, and any other technology. But just because you want services doesn't mean everything should be a Web service, and SOA is more than just Web services. So now we have SCA/SDO, a neutral programming model that works with hopefully any service implementation: WSDL Web services, J2EE (both stateless session beans and plain-old POJOs), BPEL workflows, business rules, human tasks--hopefully even PHP, .NET, Ruby, whatever floats your boat.
So is this really the final layer? Is anything ever really the final layer? Guess we'll just have to find out. But in the meantime, this looks pretty good.
Rational has a Pattern Solutions
web site, from which you can download tools to generate implementations of common software patterns. It includes new patterns by IBM for SOA and ESB.
The tools are packaged as Reusable Asset Specifications (RAS)
(an OMG standard for what are basically executable templates) for Rational Software Architect (RSA)
. For more info about RAS, check out Bill's RSA mentoring
Here are some developerWorks articles with more information:
Here are some related resources that may be helpful:
Newsweek is running an article, "Google: Ten Golden Rules
." It focuses on the care and feeding of knowledge workers.
Getting the most out of knowledge workers will be the key to business success for the next quarter century. Here's how we do it at Google.
The golden rules are:
- Hire by committee
- Cater to their every need
- Pack them in
- Make coordination easy
- Eat your own dog food
- Encourage creativity
- Strive to reach consensus
- Don't be evil
- Data drive decisions
- Communicate effectively
Check out the article; I think it's real good stuff.
For more Google posts, see Google users wealthier, more Net savvy
, Google Video of the Day
, and especially Google Base
(which links to more posts). For some discussion on IBM's values, see IBM Values
, IBM Customers Are Clients
, and Collaborative Influence
I've published a new article, featured as the Top Story in the developerWorks SOA and Web Services zone
, titled "Streamline SOA development using service mocks
Simplify SOA development -- especially if your project involves multiple teams -- and raise SOA application quality with use cases and mock objects.
This article explains an approach to let separate development teams developing the two parts of an SOA application
work independently--one team developing service providers and another developing coordinators that consume those services--and to develop these parts concurrently.
What do you think? Does this approach make sense? Is this what you do on your projects? Is it what you'll do now?
has just published an article, "Java? It's So Nineties
." It asks: "Can it possibly be that Java--once the hippest of hip software--has become a legacy technology?"
The article talks about competition to Java from LAMP
, and AJAX
. It points out that popular sites like Google and Yahoo don't use much Java.This information may be correct, but it's also missing (a lot of) the point. The question is whether you need business logic in your Web site, or whether your Web site just shows users your database.
The article talks about tasks that don't require much business logic. Google just displays search results, e-mail, and map images. Yahoo is the poster child for portals, aggregating existing info and integrating it on the glass. They both use read-only data that can be highly replicated; users can configure the display. Those tasks require minimal programming logic, so PHP scripting and a simple SQL database be all you need (plus a Web server and OS). Even then, huge sites like Google and Yahoo must be doing much more than just using PHP.
But a lot of sites need more than scripting. Do your users need to: Find airline tickets? Trade stocks? Does your implementation need to: Integrate with EIS
s? Enforce security? Coordinate multiple users updating the same data concurrently? Good luck with PHP scripts. You're gonna need J2EE or .NET for that. I can tell you that this is what WebSphere
) customers are doing.
This is an old argument. I remember in the early '90s when Smalltalk
would compete with tools like PowerBuilder
. PB would let you CRUD
your data, but not much more. Smalltalk would give you business logic. Which was better? Depends on what you need. If you just need to CRUD your data, PB was easier. For more sophisticated apps, Smalltalk was more sophisticated and capable.
So LAMP may well work if you want open-source everything and just want to display (and CRUD?) your database. But for full-blown applications hosted on the Web, LAMP won't cut it. AJAX is a cool display technology (see Ajax and Java
), but it's only a display; you still need a server behind it running something (LAMP, Java, .NET, etc.). .NET is on the same level as J2EE, and c# is very Java-like, so then that comparison is the old Microsoft-only vs. semi-open-standards and write once, run everywhere argument.
The article seems to miss a lot of emerging trends. It fails to distinguish between Java and J2EE (aka Java EE
), comparing Java to .NET. It doesn't discuss the biggest trend in IT today, SOA
; much less IBM's new SOA programming model, SCA
. It seems like Java and J2EE have grown a lot since Peter Yared was an exec at Sun.
So yeah, Java may not be the technology of choice for displaying your database. But hopefully your Web apps are doing a lot more than that.
I've talked about how IBM Powers the Xbox 360
. Now there's a paper about it on developerWorks.
|The article has the rather cryptic title "Just like being there: Papers from the Fall Processor Forum 2005: Application-customized CPU design." The abstract is more descriptive.|
This Fall Processor Forum paper explores the customized IBM PowerPC processor designed for the Microsoft XBox 360, designed and optimized for high-volume production, low cost, and quality -- with an array of testing and debug features to reduce system time-to-market. It boasts three 3.2GHz high-frequency PowerPC processor cores, and it's like no chip you've ever met before. Read why.
I gotta say, these CPU details are a little low level for the work I usually do, but interesting nonetheless.
This article too has been Slashdotted
. (The Slashdotters seem to be real on top of developerWorks articles lately.)
So what is Ajax? How do you use it with Java and J2EE? developerWorks has an introduction, and there's a lot more going on.
The next question (for us) is:When is Ajax going to be built into Java?
The simple question may be "never" since Ajax at its heart is just servlets running little services that produce bits of XML data. However, having said that, it'd probably be handy to have some sort of Struts
Looks like some people are already getting a start. Sun has some Ajax Java Blueprints
that include a discussion, "Using JavaServer Faces Technology with AJAX
." Direct Web Remoting
(DWR) is a framework for "easy Ajax for Java." Apache Cocoon
can render Ajax Forms
. Apache MyFaces
has an Ajax DataTable
feature. There's an article, "Ajax using XMLHttpRequest and Struts
." The AjaxTags taglib
is a JSP taglib for Ajax functionality, and an apparently unrelated Sourceforge AjaxTags project
. AJAX-JSF Framework
aims to render any JSF
GUI using Ajax. So far, no one seems to be working on tooling.
developerWorks has published "The future of HTML, Part 1: WHATWG
In this two-part series, Edd Dumbill examines the various ways forward for HTML that Web authors, browser developers, and standards bodies propose. This series covers the incremental approach embodied by the WHATWG specifications and the radical cleanup of XHTML proposed by the W3C. Additionally, the author gives an overview of the W3C's new Rich Client Activity. Here in Part 1, Edd focuses primarily on two specifications being developed by WHATWG: Web Applications 1.0 (HTML5) and Web Forms 2.0.
The Web Hypertext Application Technology Working Group (WHATWG), a "loose unofficial collaboration of Web browser manufacturers and interested parties who wish to develop new technologies designed to allow authors to write and deploy Applications over the World Wide Web," is working to improve HTML.
This article has been Slashdotted
Must you authenticate your identity to board an airline flight in the US?
This is the question considered in "Airport ID checks legally enforced?
" which discusses a court case brought by John Gilmore of the Electronic Frontier Foundation. The government admits that there is no public law requiring identification. But the Constitution does not necessarily guarantee any right to travel anonymously. So is the requirement legal? Is it a violation of privacy?
developerWorks now has a blog on WebSphere XD, were the development team discusses the product.
I've previously talked about WebSphere Extended Deployment
(WXD) and the latest version
, WXD 6.0.
The new blog is Inside WebSphere Extended Deployment (XD)
. The welcome message
introduces the authors.
Another posting, XD Presentations Online
, has the link for some new presentations: IBM Education Assistant: WXD 6.0
The December 2005 issue of IBM WebSphere Developer Technical Journal
is now available.
We've got articles on:
IBM's SDKs for Java 5 are now available for AIX, Linux, and z/OS.
Previously the Java 5 SDKs were beta releases
. As usual, the SDKs are available from the IBM Java Developer Kits
section of the developerWorks Java zone
. You can download SDKs for AIX
(32-bit and 64-bit), Linux
(6 different flavors), and z/OS
(31- and 64-bit; yes, 31-bit!). We do not seem to have a Java 5 SDK for Windows, just JRE 1.4.2
for PCs from IBM/Lenovo.
The AIX overview
page also has some more info about the SPEC JBB2005 performance benchmarks, related to the SPECjAppServer2004 benchmarks
I discussed recently.
InfoWorld: Study: Google users wealthier, more Net savvy
U.S. residents who prefer Google Inc.'s search engine tend to be richer and have more Internet experience than those who primarily use competing search services from Microsoft Corp., Yahoo Inc. and America Online Inc., a new study has found.
Some more quotes from the article:
- People who have been using the net longer prefer Google more
- Google users have higher household incomes
- 52% of respondents prefer Google
Dec. 12th update: This article has now been Slashdotted
(three days after me).[Read More
Next time you're bored and looking for something to do (hopefully that's not why you're reading my blog now), check out this blog: Google Video of the Day
So what can you do with SOA
? IBM has some ideas: Five SOA Projects that Can Pay for Themselves in Six Months.
The ideas are stuff like a delivery-date notification service and a document verification service. They help show that your company can start to adopt SOA without necessarily having to turn your company upside-down in a multiyear project that totally revamps your IT department. Rather, just think of some useful functionality that multiple parts of your company could use, implement and deploy it as a service, tie the relevant apps into using the service, and boom--you've gotten started on using SOA.
Get the paper: Five SOA projects that can pay for themselves in six months
Read the brochure: Five SOA projects that can pay for themselves in six months
Register for the Webcast: Five SOA Projects that Can Pay for Themselves in Six Months
Buy the T-shirt: No, I'm just kidding. That'd be silly!
This is interesting: Public Image Monitoring Solution is a new IBM service that helps companies monitor what's being said about them on the Web.
PIMS "[helps] clients gain a real-time view of commentary and opinion about their business," namely what's being discussed on social networks on the Web like "blogs, news feeds, consumer review sites, newsgroups and [daily] articles."
A related product, WebSphere Information Integrator OmniFind Edition
, is semantic search software for searching within an enterprise. (See "The case for semantic search
.") The PIMS service uses OmniFind to search the Internet to see what's being said about the enterprise.
For more info:
The Service Component Architecture
(SCA) specification from IBM has now been endorsed by several leading industry companies: BEA, IONA, Oracle, Sybase, and others. A couple of significant companies missing from the list: Sun Microsystems and Microsoft.
From the Oracle press release
BEA Systems, IBM Corporation, IONA Technologies, Oracle, SAP AG, Siebel Systems, Sybase, Xcalia and Zend Technologies today announced an effort to develop specifications and resulting collaborative technologies that simplify how organizations create and implement applications in a Service Oriented Architecture. ... The SOA Programming Model specifications include the Service Component Architecture (SCA) to simplify the development of creating business services and Service Data Objects (SDO) for accessing data residing in multiple locations and formats.
The specs are available on developerWorks at Specifications: Service Component Architecture (SCA) and Service Data Objects (SDO)
Agreement amongst these companies is significant because it means SCA and SDO won't be proprietary IBM-only technologies. Previously, only IBM and BEA supported SDO (see the CommonJ Specification
), and only IBM supported SCA. Now, not only are these other companies agreeing to support SCA, all are now agreeing to support SDO as well (all but BEA, which already had agreed but is reaffirming its support). Support by all these vendors means that developers will be able to design and implement SCA components and clients using Java, then deploy that code into any compliant application server, not just IBM's WebSphere Process Server
. Also, services will be interoperable: An SCA client could be deployed in a BEA product and use an SCA component deployed in an IBM product. So developers can take advantage of SCA and SDO without fear of vendor lock-in, and will have freedom to choose the best vendor's product for the job.
There is already a JSR for SDOs: JSR 235: Service Data Objects
. There is no JSR for SCA yet, but I imagine these companies intend to start one. Why formalize a spec as a JSR? Once a JSR is approved, it can then be added to J2EE.
The lack of endorsement by Sun will probably make it harder for the JSR(s) to get traction, but the JCP
is supposed to support adoption of new Java features even if they're not supported by Sun. The lack of endorsement by Microsoft is significant too. If Microsoft would add SCA and SDO support to .NET, then SCA clients and components implemented in .NET would be interoperable with those implemented in J2EE (or at least J2EE app servers with SCA extensions).
At some point down the road, it may be possible to combine SCA with MDA
. Then you could design your SCA components and clients, then tag each with the implementation technology of choice and each connection with the invocation protocol
of choice, then use MDA to generate the parts. You could tag one as .NET for example and generate its code, then change your mind; just retag it as J2EE and regenerate. Wouldn't that all be amazing?!
Here's press coverage of the announcement:
(Disclaimer: Forward looking statements, may not all come true, don't bet the farm quite yet, etc.
WebSphere Process Server
introduces a new component model for modeling services in an SOA
, the Service Component Architecture
SCA is not (yet) part of J2EE; it is a custom extension which is currently only available in WPS. SCA is a way of modeling a service interface, the separation between the two parts of an SOA application
. The service interface specifies what the provider (SOA-SP) has to implement and what the coordinator (SOA-SC) can invoke. By modeling the SOA-SPs as each being an implementation of a service interface, and by modeling the SOA-SCs as each being a client that invokes a service interface, a designer can more easily develop a high level design of his SOA composite app, focusing on the services involved and deferring the implementation decisions until later.
An SCA service interface is a fell-fledged interface, ultimately realized as a WSDL document or as a Java interface.
The service provider implementations in an SCA
are called service components
. A service component implementation
can be a:
Because they are all service components, initially you just model it as a service component to be used by service clients; later, you decide how to implement it. Perhaps it starts out as a human task, but later you automate it as a Java object or business process. Through it all, the service component interface stays the same.
The parameters passed into a service component operation and the result value passed out are modeled as service data objects
s). SCA and SDOs enable a service and its data to be modeled in an implementation-independent way, one which may later be implemented using a variety of technologies, the main choices currently being either a Web services provider or a Java class.
Here are several resources where you can learn more about SCA:
IBM has gotten podcast
developerWorks has a neat series on WebSphere, SOA, etc.: WebSphere Technical Podcast series
IBM has a general series on where it thinks the world is going: IBM and the Future of ...
Finally, the IBM System Storage and TotalStorage department has a podcast too: IBM TotalStorage Podcast
Check the various pages for links on how to subscribe, get subscription software, etc.
There's lots of talk about the new Xbox 360
game console. What's not as well known is that the new Xbox, like the original, is powered by a CPU from IBM.
A lot of the industry commentary is on how Microsoft is selling the Xbox at a loss. However, they later discuss how the IBM chip set is key to the Xbox, and to the PlayStation 3 and Nintendo Revolution as well. And why is Microsoft willing to sell Xboxes at a loss? It's more than just marketshare; it's a desire to make the Xbox the digital entertainment console at the center of your livingroom; see "Microsoft's Xbox 360 does a lot more than just play games
"Do you want to know more?
Also, here's an article and whitepaper on the hardware chip set partnerships like this that IBM offers: "Understanding BPTS: Engineering & Technology Services - A new model for creating value in a commoditizing world
The new developerWorks Architecture Zone
features a column, "Insight and outlook."
The Insight and outlook column is where "IBM technical leaders answer pressing questions about IT architecture." The topic of the first column: Why should you care about SOA, and when is it the right choice and when is it the wrong choice?
The question is answered by eleven of IBM's leading thinkers, including two IBM Fellows
, Grady Booch
and Don Ferguson. The other contributors are leaders in IBM's efforts to help customers with SOA
. In there somewhere is even a contribution by me, "The good, the bad, and when to be careful
." (Scroll down to the bottom of the article!)
I'm amused that I'm the only contributor that talks about technical details like service orientation and distributed objects, interfaces and security. Most of the others talk about aligning IT with business objectives, open standards
, how SOA is not just Web services (JaBoWS
), and an emerging favorite whipping boy--service governance. Guess I still think like a programmer; I work with the people who are having difficulty making it all work. Perhaps that's why I'm the only contributor who talked about not only when to use SOA, but when not too.
Anyway, I hope the column will help to give you a better idea of what this SOA stuff is all about. Enjoy.
BTW, we'd like feedback on the column: What you think of the question itself, of the various answers in general, and of my answer specifically. If you have some thoughts, positive or critical (but constructive), please add a comment here or shoot me an e-mail. Thanks.
There's a new service called the Amazon Mechanical Turk
. It lets you submit tasks to be performed by Amazon users.
Phil Wainewright describes the service in Fine-grained tail of the Mechanical Turk
and Wetware as a service
. Whereas Web services, and services in general, are supposed to be coarse-grained, Phil describes this as a rare example of fine-grained Web services. Apparently because the tasks often only take a few seconds to perform. I don't really get where that conclution comes from, but the Turk sounds interesting nevertheless.
I'm tempted to say that the Turk is just workflow
. You decide on work categories or task types, then create a worklist
for each. Then someone with a task to be performed adds it as a work item to the proper worklist. Someone wishing to perform a task selects an appropriate worklist, then acquires a work item from the worklist and performs it.
But can this be done as Web services? You'd need one for browsing and selecting a worklist, one for adding a work item, one for acquiring a work item, and one for receiving notification that your work item has been completed. Perhaps this is what the Turk does.
I'm not clear on why Amazon users are supposed to want to perform these tasks for free, but what the heck.
There's a rumor that Google
is considering opening an office in Research Triangle Park
, to tap into the local engineering talent.
Sam Ruby has linked to
a Marketing Pilgrim posting
, with commentary that links to the root Southeast VC posting
(also picked up by Triangle Tech Journal
It looks like Google has U.S. engineering offices
in Mountain View (headquarters), New York, Kirkland WA, Santa Monica, and Phoenix. RTP would be a nice addition.NEW:
Apparently Google is in fact looking for real estate in RTP. From the News and Observer
, Raleigh's local newspaper: "Google looks for local offices
(you've heard of them?) has yet another new service, Google Base
. Will Google use it to replace eBay
, and Craigslist
Basically, Base seems to be a place to post bits of info you don't have anyplace else to post--people without their own Web sites, wikis, blogs, etc., or at least without sites that are appropriate for the info they want to post. To keep all this info from being a complete hodgepodge, you use lots of tags on your posting to help categorize it. So this lets you post classified ads, job postings, stuff you want to sell, etc. I would look for a way to link into existing Web pages, and just categorize the link while the content remains on your own site, but I don't know if you can do that.
For external evaluation: Search Engine Watch has a thorough review ("Google Base Live, Accepting Content
") as does a blog on Google ("My Experience With Google Base
"). There are articles on CNet ("Google Base service goes live
") and a PC World blog ("Google Base is Live
For commentary: Infoworld talks about security ("Google Base launched with security hole
") and Internet News talks about how this could become a private Google WWW ("Google Base: Toward a Walled Garden
IBM has started to discuss its next major release of its DB2
database, codenamed Viper
. IBM is also releasing a beta.
Besides its histroical support for relational data, the new product will have native support for XML data
, as well as for other data types like images, and strategies for handling unstructured data. Of course, this is all designed to help support SOA, part of IBM's SOA flurry
. CRN reports
that IBM is, in part, targeting the PHP market
by bundling the database beta with Zend Core
Seperately, here's something interesting: "IBM may offer free DB2 database
." Perhaps this is a reference to DB2 Personal Developer's Edition
. Also check out Attack of the Open Source Databases: The (Brief) Q&A
, by another one of the brains at RedMonk
, Stephen O'Grady
For more info about Viper:
Martin Fowler has made a cool discovery
, Stef's Free Online Smalltalk Books
. These are Smalltalk books that are out-of-print, but you can download them for free.
Speaking of which, I wonder how long my first book, The Design Patterns Smalltalk Companion
, will remain in print. According to my royalty statements, it's still selling, and has sold over 4700 copies. The publisher only printed 5000 copies, and has probably given away about 100 copies, so there are probably only about 100 copies left. After that, the publisher may not want to print anymore copies, so the book will go out of print. Then maybe it'll end up on Stef's site.
Check out this Dilbert cartoon
on agile programming
If you're reading this after December 17th, the cartoon is probably gone. (I would copy the cartoon into this post, but United Feature Syndicate might not like that
Also, check out the Dilbert Blog
by Scott Adams. (Thanks, Bob
I've added Irving Wladawsky-Berger's blog
to my "blogs I read" list.
, Meet the Experts
) is IBM's Vice President of Technical Strategy and Innovation, which makes him one of the company's most senior spokespeople on its technical direction. As he says in About me
, "I am responsible for identifying emerging technologies and marketplace developments that are critical to the future of the IT industry, and then organizing activities in and outside IBM in order to capitalize on them." He was a big part of getting the whole "e-business on-demand
" thing started. So it's cool to hear what he's thinking about.
I've just discovered that Irving and I are thinking about some of the same things. (Which is really no coincidence. He helps originate ideas that IBM starts disseminating and then I eventually pick up on). For example, we've both been blogging about values (him
). Some other interesting posts: The Economic and Social Foundations of Collaborative Innovation
, The "Outside-In" Enterprise
, and On Demand Three Years Later - A Personal Reflection
which includes "What is an On Demand business and why should I become one?"
As you can see, Irving talks more about business issues whereas I usually talk about how WAS
works (so you can see why he's a vice president and I'm not). All the same, I think these sorts of business issues are important and should be of interest to a J2EE- and WAS-oriented audience like you. So, check it out.
Bill picked up on Irving's blog
as soon as it started. Now that I see some of his discussion tying into some of mine, I think you'd be interested, so I've added to my "blogs I read" list. BTW, you can see the list in the right column of my blog page
I've talked about Sharing a Test Environment Configuration
in RAD. Here's another idea to try.
Check out Exporting a server configuration
and Importing a server configuration
. I believe you can use these steps to copy a config from one machine's server to another.
This approach is probably better than using OS commands to copy the files in the profile directory. Those files may contain machine-specific values, like the machine's IP address. Export and import should filter out those specifics.wsadmin scripts
are probably still the best approach, because ultimately you'll need those for deploying your app in test and production. But the export and import approach is simpler in the short run.
Some patterns don't seem to really be patterns, they just seem to define common
terms. So are they really patterns?
What reminded me of this issue is a post concerning Enterprise Integration Patterns
. The author, Mark Carlson, states:
So far, I've found that many of the "patterns" in the book fall into what I would have normally called definitions. Examples of these foundational patterns include Message (66), Message Channel (60), Message Endpoints (95), Point-to-Point Channels (103), Publish-Subscribe Channels (106) and others.
However, I don't want to pick on Mark. Since Gregor and I started working on the book, I've heard several people express that concern. I'm just quoting Mark as an example.
This debate has occurred for years, and I probably won't settle it today, but here's my $0.02 worth
Not too surprisingly, I contend that these items are patterns, not just definitions. What's the difference? A definition tells you what an item is. A pattern tells you not only what it is, but what to use it for and how. The definition of a Message Channel tells you that it transmits messages from senders to receivers. OK, that's nice to know, but so what? The Message Channel pattern
tells you when to use separate channels, so that you start to get some idea of how many you need and why you can't use just one. The definition of a Message tells you that it contains data to be transmitted between a sender and receiver. The Message pattern
tells you why you can't simply dump a data structure or a bunch of bytes into a message channel and hope to have it come out the other end properly, how you need to design your messages to have a format that the sender and receiver agree on. As pattern documents, these sets of prose should (and hopefully do) have some Therefore, BOOM!
to them, which helps you understand why the problem is difficult to solve and then solves it anyway.
I often feel like one person's pattern is another person's "obvious solution that we use all the time." This discussion comes up a lot at PLoP
. The sentiment Mark expressed seems similar; one person's pattern is another person's "definition of the term." It probably seems more like a definition to readers who already know the term, but it's new news to readers who are still learning these terms.
If it's a language or product feature, is it still a pattern? The JMS names for Message Channel and Message are Destination
. A Point-to-Point Channel
is what JMS calls a Queue
, as do most messaging products such as WebSphere MQ
. But these are still patterns because you need to know not just that they are features, but when to use those features. Sean Neville addresses this issue
when he says, "When a pattern's tactic or implementation strategy is standardized, the pattern does not wane in usefulness, replaced by that standard; instead, quite the opposite occurs." A pattern that is a product feature is a pattern that's much easier to apply!
Patterns are decisions: What should you do and when should you do it? Many definitions do not make good patterns because they don't represent decisions. As discussed, Message is a pattern because you need to decide when to use one and how many. Our pattern document explains that a message is composed of two parts, a header and a body, thereby defining what those terms mean. Header and body are not good patterns because you don't decide when to use them; you get them whenever you decide to use a message. OTOH
, a good pattern might be "header field," because sometimes you have to decide whether and how to put a value in the message header. You might need your own custom header fields for a request ID to be used as a Correlation Identifier
, or as a flag to be used by a Content-Based Router
. Notice that I'm not talking so much about what a header field is--that's a definition; I'm talking about what a header field is used for--that's a pattern.
So don't think of patterns as definitions. A pattern document that just defines a term shouldn't call itself a pattern. Think of them as the fundamental building blocks of a pattern language, the parts we've all got to agree on before we can get to the harder stuff.BTW
, I wonder whatever happened to the webMethods paper Mark was working on? It sounds interesting; I'd like to take a look at it.
There's been some discussion of how to implement a service in J2EE: use a stateless session bean (SLSB), a plain old Java object (POJO), or a combination thereof.
Awhile back, I discussed How to Implement a Service in J2EE
. (Where I abbreviated "stateless session bean" as "SSB". And the abbreviation for "stateful session bean" would be ...?! I meant to use the abbreviation SLSB (which is not a SFSB). Duh!) Synchronous clients could invoke the service by calling the method in the SLSB's local or remote interface. Asynchronous clients could use JMS messages; an MDB would receive the request, invoke the method in the SLSB's local interface, then return the result in a reply message. For HTTP clients (such as a Web service), the MDB would be a servlet. I go on to say that the object could be a POJO, but making it a SLSB adds the advantages of being an EJB.
Eugene Kuleshov has discussed this further on his blog
on BEA's dev2dev
. In Implementing J2EE-based services for a real world
, Eugene shows a design whereby the service is implemented as a POJO, which can then be invoked by a SLSB or a MDB. He points out that this is more dependency injection
(IoC) friendly. I agree.
My bias is that I use WAS
and I don't use enterprise Java w/o EJBs
frameworks like Spring
(which also supports EJBs for good measure). So my first pass at an implementation is usually to go ahead and put the code in the EJB. Nevertheless, if I see or later discover the need to use code separately without going through an EJB (perhaps because I'm already going through another EJB), I would certainly refactor the code to move the logic into a separate POJO class. Whether that should always be done preemptively, just in case--I rarely (never?) do.
I will say that I believe it's a good practice to pretty much always have an MDB delegate to a SLSB, not directly to a POJO as Eugene shows. This way, synchronous and asynchronous clients will always experience the same QoS, whatever you configure in the SLSB--security, transactions, etc. An MDB or servlet calling the same access point that synchronous clients do--usually a SLSB--is the typical implementation of the Service Activator pattern (EIP
, Core J2EE
So, Eugene makes some good points. His approach and mine are pretty similar, but with a little difference that depends on one's desire to fit into frameworks like Spring. If you're interested in this stuff, check out what Eugene has to say.
Whatever happened to the Gluecode acquisition
anyway? Gluecode SE has been reborn as WebSphere Application Server Community Edition (WAS CE).WAS CE
has been announced
) and is now available
. You can read about the features and benefits
, and also the system requirements
); the supported platforms are Linux and Windows. You can also keep up with the recommended updates
. And of course there's a WAS CE Infocenter
and support docs
. The download includes an Eclipse 3.1 plug-in "that enables you to use [WAS CE] as a test environment while you develop J2EE assets."
WebSphere Application Server Community Edition zone
|While WAS CE and WAS Base are both J2EE application servers, WAS CE is being positioned as the simpler, more introductory product, primarily for smaller businesses which may not (yet) need the full power of WAS Base and ND. I see it as an easier path for a development team new to J2EE to give it a try. WAS Base is still the better production platform, but because they both support J2EE 1.4, a team can use WAS CE for development and defer the cost of WAS Base licenses until testing and production.|
It seems to me that even a WAS CE development team will be more productive if they have a J2EE IDE like RAD 6.0. I assume the Eclipse plug-in for the WAS CE test server works in RAD as well.
is the new developerWorks product zone for WAS CE, under the WebSphere zone
. Some of the interesting articles in the new zone:
Like Gluecode SE, WAS CE is built on Apache Geronimo
, specifically the M5 build, the first Geronimo J2EE 1.4 certified release
. Unlike Geronimo, WAS CE runs on IBM's JRE
and includes the Cloudscape
embedded database. For more info, see:
For commentary on IBM's WAS CE announcement, see:
2005/11/26 Update: Check out Michael O'Connell's posting
on WAS CE.
, home to some of the best blogs
around, has a new zone: the developerWorks Architecture zone
The Architecture zone contains resources for software architects, many of which are not necessarily language or product specific. For example, check out the IT Architecture Resource round-up
, with advice on how to become an IT Architect and what to do once you are one.
I'd heard Ward Cunningham had left Microsoft, but now I've found confirmation.
I first heard the confirmation on Bill's blog, Mini-microsoft on Ward Cunningham
. It points to Goodbye Ward
, which points to So Long Ward!
. It's also on Waynes blog, I couldn't be more excited!
, which links to Ward Cunningham Joins the Eclipse Foundation
. Also see "Father of Wiki Quits Microsoft; Moves to Open-Source Foundation
Ward is an influential guy wherever he goes; Microsoft will miss him. He invented wikis
, helped invent software patterns start the PLoP conferences
, helped make CRC cards
popular, started PatternShare
, and a lot more. He even has his own Wikipedia page
Ward has now gone to Eclipse, obviously one of IBM's favorite open source groups and one that seems to be on the move these days. They've also just hired Wayne Beaton
IBM has announced the results of the SPECjAppServer2004 performance benchmark. In it, WebSphere Application Server beat the competition (BEA) by 64 percent.
The press release is IBM Software Smashes Java Performance Record
, which discusses the SPECjAppServer2004 Results
, which include the Fourth Quarter 2005 SPECjAppServer2004 Results
In the results, the best time came from WAS 6.0
ND running on a IBM eServer p5 550
with SUSE LINUX Enterprise Server
9 and DB2 Universal Database 8.2
). This configuration clocked in at 2921.48 JOPS (jAppServer Operations Per Second). By comparison, the other configuration benchmarked this quarter was BEA WebLogic Server 9.0 running on a Sun Fire X4100 Cluster, which produced 1781.47 JOPS. (2921.48 - 1781.47) / 1781.47 = 63.99%, so WAS did 64% better.
So what is SPECjAppServer2004? From SPEC
's home page:
The Standard Performance Evaluation Corporation (SPEC) is a non-profit corporation formed to establish, maintain and endorse a standardized set of relevant benchmarks that can be applied to the newest generation of high-performance computers. SPEC develops benchmark suites and also reviews and publishes submitted results from our member organizations and other benchmark licensees.Members
include IBM, BEA Systems, Sun Microsystems, Oracle, Hewlett-Packard, JBoss, and Microsoft. You can learn more about the benchmark itself from the SPECjAppServer2004 User's Guide
.Dec 16, 2005 Update
: IBM, at BEA's request, has asked me to modify this blog posting from its original content to no longer discuss the BEA press release. The use of and comparison of the CPUs/1000JOPS was a violation of the SPEC organization's SPECjAppServer2004 benchmark rules as outlined in SPECjAppServer2004 Run and Reporting Rules V1.02
. IBM wishes to emphasize their desire to support the rules of the benchmarking organizations it belongs to. Although I am hesitant to make major changes to historical blog postings, it is important that IBM cooperate with other industry organizations and it is always my intention to support that; this includes remedying statements that are later found to be inconsistent with agreed upon rules. Accordingly, as per my employer's request, I have struck out the paragraphs in question.
For its part, BEA's press release--BEA WebLogic Server(R) 9.0 Continues to Set Performance Records--declares that their app server (WLS) is more efficient, "providing the best hardware utilization in the industry" and "setting a new performance record" which "requires fewer CPUs per JOPS" therefore "reducing total cost of ownership (TCO)." Whereas IBM focuses on total JOPS, BEA focuses on CPUs per 1,000 JOPS. The "Recent SPECjAppServer2004 results" table lists how their product performed in the October 2005 round but (shockingly!) they seem to have forgotten to list the results for WAS.
Incredibly, the BEA table actually shows that their results are getting worse!?! Whereas they achieved 7.21 CPUs per 1,000 JOPS (CPU/KJ) back in the Aug 05 benchmark, they've now fallen to 11.23 CPU/KJ in Oct 05. They didn't include the latest WAS benchmark in their table, but the figure is (32 / 2921.48) * 1000 = 10.95 CPU/KJ. So WAS in Oct 05 actually did better than WLS in Oct 05, though neither did as well as WLS in Aug or Sept. At least WAS is better now than the figures listed for Jan 05 and Dec 04 (11.99 and 14.89, according to BEA).
So BEA isn't really bragging that they're more efficient now, but that they were two months ago; except their efficiency is getting worse whereas WAS's is getting better. Is this really what BEA is saying?! Gotta love statistics!
For more commentary, see:
IBM has published a set of values that help guide the company, namely its employees, and how we work with clients.
As documented in Our Values at Work on being an IBMer
and elaborated on in Corporate profile: Values
, the values are:
- Dedication to every client's success -- IBM's relationships with its clients are no longer based on product sales, but often on deep, long-term partnerships built around our knowledge of each client's business and the market environment.
- Innovation that matters, for our company and for the world -- At their best, IBM's innovations transcend the technology industry, enabling others to innovate as well. We also pursue innovation in education, work/life balance, environmental protection, and all the ways a company organizes and runs itself.
- Trust and personal responsibility in all relationships -- The heart of IBM is the personal commitment each IBMer makes to building and preserving trust even if things don't go smoothly with all the constituencies of our business: clients, partners, communities, investors and fellow IBMers.
Yeah, hoopla, but I can tell you, IBM reminds us employees of this stuff all the time and really expects us to live it. It's the basis of our Business conduct guidelines
. It guides us on making sure to treat our clients
right, work on what's important, and stay out of trouble.
These values are discussed in--you guessed it, my favorite year-old article that I just discovered this week--"IBM's Management Makeover
" (Nov. 2004) in Fast Company
magazine, the article that also discusses how IBM Customers Are Clients
and Collaborative Influence
. The article casts the values as "IBM's New Leadership Traits," which ties in nicely to the leadership stuff I've been thinking about.
These values seem to have spawned imitation, if not word-for-word duplication. A company called BizAtomic
appears to have cribbed our values
. Ditto for the CEMA Territory Champion award
, and for ProGroup
. Two of the three values of JSB Intelligence
seem familiar (guess they don't innovate). But I guess that's the sincerest form of flattery
. Although I might quibble about the irony of apparently plagiarizing the wording of a value espousing trust and personal responsibility. D'oh!
(Disclaimer: I'm not trying to talk trash about any of these companies, and I don't know for sure where they got their wording from. But they
appear to be copying IBM, and not giving IBM credit.
Here's where you can do some more reading about these values:
Say that you're nobody's boss, you're just a cog in the big machine (so to speak). How do you get anything done? A technique IBM (and others?) terms "collaborative influence."
Collaborative influence is another topic discussed in "IBM's Management Makeover
" (Nov. 2004) in Fast Company
magazine, the same article that discussed how IBM Customers Are Clients
The 33 leaders [who had been identified as outstanding leaders in the new on-demand era] were also adept at a skill IBM calls "collaborative influence." In a highly complex world, where multiple groups might need to unite to solve a client's problems, old-style siloed thinking just won't cut it, and command-and-control leadership doesn't work. "It's really about winning hearts and minds -- and getting people whose pay you don't control to do stuff," says Mary Fontaine, vice president and general manager of Hay's McClelland Center for Research and Innovation.
So collaborative influence is how you work with people you have no direct control over, yet persuade them to do what you'd like, what is hopefully beneficial for the group.
I wasn't familiar with this term, but as a consultant to some of IBM's WebSphere clients
, I often feel like this sort of persuasion is the only real power I have. I can't fire anyone; in fact, if anything, they can "fire" me (from their project, not IBM). Yet I need to convince them to stop doing some of what they're doing, since apparently that's limiting their success with WebSphere products, and start doing things differently, even though they may well not want to.
I'd argue that in our modern workplaces, and in life in general for that matter, the only real power any of us really has is collaborative influence. We all work with lots of people we can't fire, yet whom we need to persuade to take certain actions to help all of our success. Even bosses have pretty limited authority: Yeah, they can fire you; but if you have good skills, you'll just go get another job somewhere else, and now your boss and his/her team are without the benefit of your skills. D'oh!
The best bosses, I find, are those who attract the best people they can find to their teams, encourage everybody to work together, and then get out of the way. That's collaborative influence.
I think collaborative influence is an important component of leadership
, a quality we all need to get better at. Many of the non-programming books I read are on leadership, teamwork, and that sort of thing; I'd suggest you should too.
I'm pleased to find that IBM has an article on collaborative influence called "Changing Minds
You can upgrade your IT. You can rewrite your processes. But you won't change your business if you can't change your people--how they think, how they work together and how they use the resources around them.
Changing the culture of your company isn't easy. It takes time, effort and a very specific kind of leadership. To learn more about it, we spoke to IBM's Senior Vice President Linda Sanford and General Manager Ross Mauri.
It's on a section of our web site called "Boost team performance
," kind of a developerWorks
for workplace skills. It has articles, case studies, and executive guides. (Shockingly enough, we even have some services
we'll sell you to help you achieve this.) The theme of boost team performance:
Bring your people, departments and partners together to boost productivity, streamline the workload and sharpen employee training for a constantly changing world.
So not only is your IT on-demand, your whole company and workplace is an On Demand Business
. Yeah, this gets kind of hypish, but the focus here is on helping people to work together, and I think that's important.
So, do you have collaborative influence? What can you do to get more? How can you use it to do your job better?
For a while now, we've had this thing going on inside of IBM. We're not supposed to call the people who buy our stuff "customers" anymore, we're supposed to call them "clients." What's that all about?
It's explained in "IBM's Management Makeover
" (Nov. 2004) in Fast Company
To begin with, the best executives no longer thought of the folks to whom they sold stuff as customers; they saw them as clients. The difference? "A customer is transactional," says Harris Ginsberg, IBM's director of global executive and organization capability. "A client is somebody with whom you have a longstanding relationship and a personal investment." It's no longer enough to sell a customer a server. An IBMer should be so focused on becoming a long-term trusted partner that she might even discourage a client from buying some new piece of hardware if it's in the client's best interest to hold off.
So a customer is a one-time sale. A client is an ongoing relationship, with additional sales from time-to-time as needed. We want a buyer to be customer again and again; that's a client. And check out that last part: We don't want to sell you something if we think you don't need it! Such a sale might be good for a customer, but not a client.
Personally, the term "client" kinda messes me up, because it makes me think of client/server and EJB clients. Then again, maybe IBM is and should act that way to its buyers, acting as a server providing services (hardware, software, knowledge workers). Anyway, I guess I'm just getting too caught up in computer-speak and need to adjust more to business-speak in this case.
Our CEO, Sam Palmisano
, talked out the customer/client difference in this article in Fortune magazine, "Can IBM Get Great Again?
" (but you need a subscription). Here's some guy talking about very much the same thing: What You Call Your Customers Matters.
, one of the brains over at RedMonk
, has been blogging a lot about IBM lately.
In SOA is going to need mainframe skills and disciplines
, his general theme is that mainframe development skills will be helpful for developing SOA apps; perhaps so, perhaps a new career opportunity for some people. I really like this line from the posting: "The last few years have not been about SOA, but JBOWS (just a bunch of web services).
" JaBoWS (I like my spelling better); I like that; have to'll keep that in mind.
Most of the postings on that Mainframe blog
are about z/OS and IBM. (Gee, I wonder why?!) The postings seem to be by a number of people, not just James.
On his MonkChips blog
, James has been blogging a lot about IBM lately:
I haven't had time to digest all that yet, but it looks like interesting stuff, so check it out.
I've discussed the IBM Java Developer Kits
that you can download and use, including the new J5SE betas
. We now have a JDK for the Apache Harmony project.IBM Development Package for Apache Harmony
is for use with Apache Harmony
, which IBM is participating in
. IBM says this JDK can be used with the Harmony code but is not (yet?) part of the Harmony code (which I think explains why you have to download it from our site instead of Apache's). The JDK is free, but unsupported.
I've discussed the IBM Java Developer Kits
that you can download and use. Some people asked, "What about JDK 1.5?"
IBM now has a Java 5 Standard Edition JDK beta
available for download. There are builds for a couple of Linux platforms, AIX, and z/OS.
Sometime back, I discussed how you Can't Use MessageListeners in J2EE
. Turns out that how you're supposed to do this in a client container
isn't exactly obvious either.
Turns out there are two setMessageListener(MessageListener
So, which to use? Well, the Javadocs for the
version say that this method is optional and an expert facility that is not used by regular JMS clients. Hmm, that doesn't sound so good. Indeed, if you try to use it in WAS
, you get a runtime error:
WSCL0100E: Exception received: java.lang.reflect.InvocationTargetException
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
Caused by: javax.jms.IllegalStateException: CWSIA0045E: The optional JMS operation Session.setMessageListener is not supported by this implementation.
... 14 more
Turns out that
is a hook for application servers to use to set up message-driven beans (MDBs). So that's not what we're looking for.
The method in
is a better bet. As advertised, it sets the message consumer's
This makes sense. A single session can have multiple message consumers, and each can have its own message listener. So, remember to use the right method.
Antipatterns should be ameliorative. For that matter, patterns should be too. For that matter, so should you, at least in the way you do your job.Ameliorate
(verb): to make a situation better or more tolerable
I've been talking about antipatterns
. It's not just enough for an antipattern
to give a common solution, to say "Bet you did this, didn't you? D'oh!" It then needs to offer a preferred solution. This makes the document ameliorative; it helps the reader understand not just why their situation sucks, but also figure out how to make their situation better.
Any pattern should be ameliorative. It tells the reader what to do to make their situation a good one, perhaps better than it was, in any event better than it would be if they applied a less-than-best practice. If a pattern documents an approach which is not ameliorative, whatever it's documenting is not much of a pattern.
When you're doing your job, are you ameliorative? Are you making the situation better? Or worse? Perhaps you're trying to make it better but the situation fights back; that's just a bad (but common) situation. But in a reasonable situation, if you're not helping to make things better, why not? See the importance of leadership
. Leaders ameliorate.
So, be ameliorative. Get out there and ameliorate.
Back when I was talking about test servers in RAD 6, this question kept coming up in the comments: "How would you address the issue of many developers wanting to share a common server configuration?" Let me try to address this issue (finally!).
For context, see:
First off, let me say that I've never done this. If I had, I would have documented this a long time ago. But I've been thinking about it and conferring with my co-workers, and here's what I think will work.
The simplest approach is to copy the profile directory and distribute that. See WAS 6: Application Server Profiles
and "Easier system management with profiles
The best approach is to write wsadmin
scripts to create the configuration you want. Each developer can run it on his test server to config it, and you can use it as the basis of deployment scripts when you're ready to go into production (but test them first!). For help, see:
Another suggestion: In RAD, go to the Windows --> Preferences --> Server page
and check the Create server resources in workspace
box. You can then copy and share these files.
So, hope that gets you going. If you find that one of these techniques works especially well for you, please add a comment to this posting.
BTW, let me say thanks to my ISSW colleagues Roland Barcia
, Paul Glezen
, and Saravana Chandran
for their help with this posting.
Also see: Sharing a Test Environment Configuration (part 2)
Way back in The Relationship between RAD 6 and WAS 6
, I talked about test environment servers in RAD 6
, a feature from WSAD 5.x. According to comments on that posting, there seems to be some confusion about how to create a test environment server for WAS 6
I guess this is not obvious (enough), but simply put, WebSphere 6.0 Server is the test server; see Creating a WebSpherev6.0 server
. RAD distinguishes between a WAS 5.x Test Environment server
, used for testing in RAD, and a WAS 5.x server for publishing
, used for deploying to a WAS install outside of RAD. The WAS 6.0 server option can be used for both (which I don't think is actually explained anywhere).
Also, be sure to create a separate profile for each of your test servers, so that you can admin them independently; see RAD 6: How to Create a Server
. Those instructions are a little out of date now; I think the latest versions of RAD now have a menu choice for running the profile wizard. Anyone want to add a comment on what that menu choice is?
A well written pattern has a style we call "Therefore, BOOM!" We've now decided that a well written antipattern has a style we've christened
Last week, I helped run a conference on antipatterns
. We ran it very much like the PLoP conferences
. It's given me the opportunity to teach a new group of people about patterns and pattern languages, writer's workshops and shepherding--all good stuff that I learned at PLoP. It's always fun to be a member of a smart group of people who are eager to learn.
A lot of what I talked about at the conference was my ideas and experience with how to write good patterns, that is, how to write patterns well. I've learned this over several years working with many knowledgeable people at PLoP, and through practice, practice, practice
One practice we've found for writing a pattern well is "Therefore, BOOM!
" I wasn't sure how well this idea would go over in an antipatterns conference, but it took quite well indeed. Being that an antipattern is the opposite of a pattern, we found the opposite of "BOOM!" as well.
We call this quality of an antipattern "Therefore, D'OH!" (And no, I didn't coin the term, but I loved it as soon as I heard it.) It's where the antipattern paper makes you, the reader, realize how stupid (i.e. uninformed, misguided, naive) you were to apply this common but misguided solution. The writing style makes you realize, "Darn, why did I do that?!"
Where does the name come from? "D'oh!
" (listen to 32 Dohs
)) is the sound Homer Simpson
makes when he realizes that he's made a mistake. It signifies his sudden realization of his own stupidity.
Much like suddenly realizing that in your actions, you've followed an antipattern.
One quality a well written pattern has, a style that separates it from not-so-well written patterns, is what we call "Therefore, BOOM!"
We figured this out at the first couple of PLoP conferences
--writing patterns, reading each others' patterns, and discussing what seemed to work best. Ken Auer
has documented this well in "Therefore, BOOM!
" It's already described in Sun's Java Patterns Community
, so I'll let you read about it there.
Simply put, as a pattern author, to the extent you can write your document to embody this "BOOM!" quality, the better your pattern is. I believe that it makes your pattern better in at least two respects; it makes your pattern explanation:
- More interesting -- If readers are going to have to read through dozens of patterns, if you can make the writing a little more entertaining and a little less dry, the easier it will be for those readers.
- More memorable -- The "BOOM!" quality provokes an emotional response in the reader that makes the pattern reading experience much more significant than it would be at a purely intellectual level. The reader will internalize your pattern better and remember it more easily.
"BOOM!" is one of, if not the, major reasons why well-written patterns work so much better than just using standard prose. A pattern is not an experience report, and it's not an account of a cleaver trick; it's a mind-meld
from an expert to a novice of what works well. It's a best practice that you know not just in your head, but in your heart and your gut as well. "BOOM!" gets that gut feeling across in a way that words alone cannot.
Think about a pattern you've read that really resonated with you, where you knew as soon as you read it that the author knew exactly what he was talking about. (And if you've never had this experience, you need to read more and better patterns.) Remember how you felt (not what you thought, but how you felt) when you read that pattern? That's "BOOM!"
Alfred Spector, CTO of IBM's Software Group, gave the opening keynote today at WebSphere Technical Exchange. The topic was "IT Evolution: Limitless Horizons."WebSphere Technical Exchange
is running this week in Miami, Florida. (Its European equivalent, WebSphere Technical Conference
, ran two weeks ago.) WTE, one of the IBM WebSphere conferences
, is run by IBM for WebSphere customers, to teach them about the products and how to use them. Alfred Spector
is the chief technology officer of IBM's Software Group
Here's some of what Alfred talked about:
- The world is flat, flattened not by airplanes, but by IT
- Innovation: The intersection of invention and insight, leading to the creation of social and economic value
- Companies need to look for strategic approaches that drive transformational changes in operational performance
- The IT mission is to architect a better world
- SOA builds flexibility on your current investments: A migration from a messaging backbone to enterprise application integration (EAI) to SOA (with an ESB)
- Five aspects to SOA: runtime, information, infrastructure management, development tools, and people. These just so happen to map nicely to the five software brands: respectively: WebSphere, DB2, Tivoli, Rational, and Lotus.
- SOA is an extension of the distributed computing architecture in two dimensions: technology and business
- An event-driven world forces innovation in middleware
- Unparalleled opportunities remain in IT
- The main challenge in our future: Managing complexity
I've recently been reminded of what a great set of conferences the PLoP conferences are. Let me take this opportunity to explain why.
The PLoP conferences
were started by the Hillside Group
, a collection of visionary computer guys. They wanted to take Christopher Alexander's ideas
about patterns and pattern languages and figure out a way to apply them to our jobs of developing computer software. They decided a good way to do it was to start a conference. The focus of the conference would be not to talk about patterns, not to present patterns, but to write them. And the focus would be not to talk about the patterns they'd written, but to help each other improve the patterns they'd written. The focus would be on the writing, and the writing would produce a library of patterns, literature on how to do software development well.
So how does PLoP work? First, you don't submit an abstract of an idea, or a presentation (a la PowerPoint
) of an idea, or a paper that discusses your idea; you submit a paper that is the idea. It's not "This is a paper about what you should do," it's "You should do this!" Second, when you submit a paper, it's neither accepted nor rejected, it's shepherded
. An experienced author helps you improve you paper to make it good enough for the conference. If a submitter is undedicated, uncommitted, or simply lacks the necessary time and effort, this gets rid of him pretty quickly. But for those dedicated to the task, good shepherding can take an idea expressed awkwardly and make the expression (the paper) much better.
Third, the conference itself is run as a set of writer's workshop
s. In these workshops, the participants are all authors who have submitted papers they want feedback on for improvement. Non-authors and non-submitters are generally not welcome; experience as a writer is what you bring to the group; you're committed to the group knowing that your paper will be one of those reviewed. There's a workshop per paper, whose purpose it to review the paper (see "How to Hold a Writer's Workshop
" and a Writer's Workshop Pattern Language
). The paper's author listens silently while the readers discuss what's good about the paper and make suggestions for improvement. As an author, you often wonder what readers are thinking when they read your paper; this workshop lets you know. The focus of the workshop is on helping the author improve his paper.
Notice that so far, I haven't said anything about patterns. Yet the purpose of PLoP is to help with writing patterns
) and pattern languages
. This is the purpose of PLoP. Shepherding and writer's workshops are the method. The focus is on helping interested authors write good patterns papers.
It's a great process, one I must admit that I'd grown accustomed to and bored with over the years. But I've recently become more interested again, as I'll talk about next.
It seems to me that there are two main aspects to doing a good job in a technical role: Technical proficiency and leadership ability. Many of us tend to focus on the first one; we need to focus on the second one as well.
By "leadership," I don't necessarily mean "being in charge," I mean being influential and persuasive. You've probably at some point worked for a manager who was a poor leader but nevertheless was still your boss. Leadership is not a title that can be bestowed upon you by your company or community; it's a quality of how you conduct yourself and work with others. Many development teams have someone who, when he/she speaks up, everyone listens to what they're saying and is inclined to go along because they're usually right; such a person may be "just a programmer" like everyone else, not a project lead or a manager, but they are a leader because they suggest a course of action that the rest of the team tends to follow. That's leadership.
There's a fairly extensive thread on leadership
on Ward's wiki
. For example, see What is leadership?
and Books on leadership
. Another Web site, The Art and Science of Leadership
, looks pretty good.
In my author spotlight
, about half of my recommended reading list
is non-technical books, many of them on leadership and related topics: see Becoming a Technical Leader
, The Fifth Discipline
, and The Servant
. Heck, even The Pragmatic Programmer
has a lot of leadership aspects to its technical advice; so does Extreme Programming Explained
So maybe this sounds great but unrealistic. Maybe you feel like just a lowly programmer on a lowly team; what can you do? Here are some concrete suggestions:
- Be honest and reliable. Do what you say you're going to do.
- Surprises are bad. If things are going wrong, let others know sooner rather than later so that they can help or at least plan accordingly.
- Be good at your job. But don't just do your job, help others do their jobs.
- Don't ignore problems but don't invent them either. Help find real problems, and help find solutions.
- Lead by example. Do what you would have others do.
It's really just that simple. Think about it: Aren't these the kind of people you'd like to work with? Think about someone you do like to work with: I bet they do these things.
Some organizations may not be very supportive of this. For example, when you report problems like you ought to, the organization may avoid addressing the problem and instead shoot the messenger
(which is you). In this case, you have an even more challenging leadership opportunity; as one friend of mine likes to put it, "You can either change your organization, or you can change your organization."
I've talked about application-oriented networking
(AON), billed by some as the future of SOA. Not to be left out, IBM has acquired DataPower, a leading provider of AON appliances.
For the press release, see IBM Acquires DataPower
. This seems to be part of IBM's SOA flurry
. Interestingly, although the DataPower products are hardware, it looks like the company will be integrated into the IBM Software Group
, which develops the Tivoli and WebSphere products the DataPower products work with and which is spearheading the products side of IBM's SOA push (like WPS, WESB, and WID
). (IBM Global Services can help you develop your SOA apps; see How to identify, specify, and realize services for your SOA
and the SOMA link.)DataPower Technology, Inc.
is already an IBM partner:
Here's some commentary on the acquisition:
From IBM's press release
: "According to IDC, IBM has the highest percentage of worldwide portal market share for 2004 ..." IDC
is a top market analyst firm.
For general info about Portal, see What is WebSphere Portal?
Here are some articles on the IDC ranking:
Another WebSphere product I've mentioned but not talked about a lot is WebSphere Portal.WebSphere Portal
(aka WebSphere Portal Server, the original WPS
) is "a framework for integrating your enterprise into a single, customizable interface called a portal." (WebSphere Protal zone
; also see the Portal catalog
A typical portal screen is a Web browser screen composed of multiple panels, implemented as portlets (JSR 168
; "Introduction to JSR 168 - The Portlet Specification
"), each of which is relatively independent, reusable, and may in fact be built from data and services of otherwise independent applications. One panel might show current stock market conditions, another might show your local weather, and another might show your current investment portfolio positions and values. You can do all this without Portal, but Portal makes it much easier. Portal runs on top of WebSphere Application Server
.A company portal
Here's where you can learn more about Portal:
Here's an interesting article in USA Today
: "Techies: They're everywhere
The most interesting part is a graphic, Techie people
, which shows "a county-by-county analysis of 'early adopters' of technology." It shows where in the United States have the highest concentrations of people who are quick to try new technology and gadgets like DVRs
, etc. They're not just in Silicon Valley
, and they're not just wealthy people, just people who choose to spend a lot on tech.
A totally separate trend I hadn't seen before: The states in the western United States are much larger (in geographical area) than those in the east. This is in part because the east was settled first, then over time settlers moved west and divided the land into larger and larger chunks. What I hadn't seen before is that the counties in the western states also have much more area than those in the east. Perhaps states tend to have a similar number of counties, but bigger states have bigger counties. I don't know what that means particularly, but it's interesting. Another example of Graphical Statistics
, which USA Today
is famous for.
I've been talking about serialization (see Serial Version UID and Eclipse 3.1
, Serialization and Serial Version UID
, and even Serialization: Binary or XML?
). I've heard from several people who describe scenarios where they use serialVersionUID just to make serialization work. I'd never heard of needing to do this, but apparently it can happen, at least with older versions of Java.
The key to making serialization work is that the target JVM deserializing the object should have the same class files (which may be in jars) in its classpath as had the source JVM that serialized the object. As long as the same set of classes are used on both ends, serialization works quite well.
Or at least so I thought. Some readers described scenarios where two JDKs computed two different SUIDs for the same class! This isn't supposed to happen, according to spec. Some people described this with using two different versions of Java, like JDK 1.1 and 1.2. Well, if those are incompatible for serialization, I'm not surprised; they are different versions, after all. When the versions were the same, it sounds like the problem was mostly back in the JDK 1.1 and 1.2 days, not recently, so hopefully the latest specs have resolved the problem. (Let me know if you've run into it in J2SE 1.4 or JSE 5.) So two JDKs implementing the same spec and using the same class files should agree on the SUID.
In any event, if you need to use serialization between two JVMs which compute the SUID differently, I see no choice but to set the class' serialVersionUID manually. Probably best to set it to whatever value your favorite JDK calculates. (Eclipse's Java editor has a menu option to do this.)
As I've said, the problem I've encountered is that someone updates the class files on one end and forgets to update the other end. As long as you don't set serialVersionUID manually, the deserializer will catch this error if the two class versions are incompatible (or simply work successfully if they are compatible). If you set serialVersionUID manually, you override this check. Thus if/when you change the class, it's up to you to update the SUID. Again, the Eclipse Java editor is helpful for this, but you've got to remember to run it after you change the class.
So, ideally, compatible JVMs should calculate the same SUIDs for the same class; if not, they're not so compatible. If you run into this problem, you can overcome it by setting serialVersionUID manually, but then you have to remember to update it manually as well. If you're not running into this problem, you shouldn't set serialVersionUID manually; let the JDK(s) handle it.
has introduced a new compiler warning, Serial Version UID
. (The code review tools in RAD 6
have a similar feature.) This new warning seems to be causing lots of confusion and, as far as I can tell, provides little real value and potentially will badly mislead Java novices who don't know any better.
This new feature in Eclipse seems to have begun as Eclipse Bug #69942
, which claims "Serializable classes that do not declare serialVersionUID are a serious problem ..." That's debatable; see Serialization and Serial Version UID
. In any event, Eclipse now has such a warning. But no documentation, mind you, which has lead to a fair bit of confusion and discussion that is not necessarily more clarifying:
A couple of points of clarification seem to be in order. (These are my informed opinions; I happen to think they're well-founded, at least until proven otherwise.):
So if you get the warning and you want to "fix" your class, what should you do?
- Eclipse (3.1) does not somehow require serialVersionUID. The Java IDE is simply warning you about a possible quality problem with your code. Eclipse will work fine even if you don't fix your code.
- Unfortunately (IMHO), when the Eclipse folks introduced this check, they defaulted it to on and provided no explanation as to what the warning meant. So suddenly your old code has all these new warnings, and novices don't know what it means or what to do about it.
- You can turn off the check. Go to: Java > Compiler > Errors/Warnings > Potential programming problems.
- If you don't know what the warning means and don't know what serialVersionUID is, and if you've been happy with your code in the past, you should probably just turn the check off.
You have a couple of options:
- Add this line of code to your class:
private static final long serialVersionUID = 3487495895819393L;
The value can be any valid long integer value.
- Press CTRL-1 in the Java editor and it'll insert a line like that for you.
But should you "fix" your code this way? I think not; again, see Serialization and Serial Version UID
. So my advice: Either ignore the warnings, or since having a bunch of warnings that you're always going to ignore isn't such a good idea either, just turn off the check. You're generally better off letting serialization manage itself.
Here's an oldie but goodie that's reared its ugly head again: Should a Serializable specify its serialVersionUID?
Before you can even weigh the pros and cons, you have to understand the basics of Java serialization. You might as well go to the source, Sun's documentation: Object Serialization
, specifically the Java Object Serialization Specification
Keep this simple definition in mind: If you serialize and deserialize an object, the old and new instances should be equal (though not identical). Equal means that they should be equivalent and indistinguishable; each (non-transient) instance variable in the two instances should contain equivalent values/objects. (See "Equality versus identity (PDF)
," one of the articles I've written
.) BTW, making a class serializable is usually easy, but it can get tricky. For some problems to watch out for and how to handle them, see another article of mine, "Designing For Object Serialization
Some say any serializable class (that you actually plan to serialize and deserialize instances of) should set its serialVersionUID because that'll improve performance. I tend to be very skeptical of dubious programming practices that supposedly have performance benefits (see Problem with Service Locator Pattern
), and this is one; see "Into the mist of serialization myths
The real question is this: If I change a class, will serialized instances of the old version be able to deserialize as instances of the new version?
In general, no. That's because the computed serialVersionUID is based on lots of parts of the class' code (the so-called Stream Unique Identifiers
), so if you change any of the code, the serialVersionUID changes. (This is the value that's recomputed the first time a JVM serializes or deserializes an instance of a particular class, hence the supposed performance hit.) This change in the serialVersionUID is by design, so that the deserializer (an ObjectInputStream
) won't deserialize an object from one version of the class into another version, presuming that because the versions have different code, this means they're incompatible (or at least that's the safest assumption the deserializer can make). If the two versions are indeed compatible, then that's why you would explicitly specify their serialVersionUID, and set it to the same value for both versions of the class.
For example, to explicitly specify a class' serialVersionUID, add a line of code for a new instance variable like this
private static final long serialVersionUID = 3487495895819393L;
The value can be any valid long integer value.
But while people offer lots of opinions about all this, especially when offering this as quickie advice to people who are apparently Java novices, what they fail to discuss is the dangers of explicitly specifying a class' serialVersionUID. The problem isn't when you first set serialVersionUID, but later when you change the class. (And presumably you're going to change the class, or else the serialVersionUID doesn't matter!) In my experience, programmers often set a class' serialVersionUID, then change around the code, but forget to change the serialVersionUID. In this scenario, serialization gets really weird and unreliable (because you made it so!). As long as you serialize and deserialize from the same class version, things work. But if you do so between class versions, the deserializer will try to make it work (because the classes' serialVersionUIDs are the same!), but the new instance may well be messed up because of the changes to the class structure. What do I mean by messed up? Well, at the very least, the two instances aren't equivalent like they're supposed to be (see above).So should programmers specify serialVersionUID in their serializable classes?
I think not. It just leads to trouble. If you really understand what you're doing with serialization, and you're convinced that two class versions are truly compatible for serialization and deserialization purposes even though their code is different, and if you've tested this well to validate your assumptions, then you can use serialVersionUID to override the deserializer's assumptions and specify that the two versions are compatible. But otherwise, the safe move is that whenever you change a class' code, you should change its serialVersionUID value. But since this is how Java works by default anyway, just don't bother with serialVersionUID and let Java take care of things for you.
Three new authors have been added to WebSphere: Author spotlight
: Joey Bernal
, Steph Parkin
, and me
The Author Spotlight highlights people who have published a lot of articles about WebSphere products
. Each author usually has his or her themes, so it's good to find an author whose themes match your interests. For example, Joey writes about Portal, and Steph writes about how to use tooling like RAD 6
The spotlight on an author is useful in two ways. One, it lists in one place all of his/her articles and other publications, so that you can more easily find what all he/she has written. Two, it lists other publications the author finds helpful, which makes a good reading list of other stuff for you to go check out. For example, both Joey and Steph recommend The Soul of a New Machine
, so that sounds like a good book to go check out.
In my recommended reading list, I've listed the books I think any J2EE developer should have on his bookshelf. Need to learn UML? I've listed a book for that. Use cases? A book for that too. Lots of patterns books. And some books on leadership too, because I'm finding that ability to be as important to a project's success as technical ability.
I'll be making two presentations at WebSphere Technical Exchange.WebSphere Technical Exchange
, an Upcoming IBM Conference
, will be held the first week of November in Miami, Florida. As listed in the agenda (PDF)
, I'll be presenting two sessions, both part of the WebSphere Development track:
- D31 J2EE Application Architecture Using Patterns
- D32 Transaction Hardening: WebSphere Transaction Management Architecture, with Gang Chen
So, if you're going to be at the conference, and these talks sounds interesting to you, please attend.
Happy birthday, not to me, but to my blog.I started my blog
one year ago this week. Since then, I've posted over 250 times; hopefully most of the entries have been interesting to at least someone.
At the time, I planned to use this blog to discuss J2EE issues, and in large part I have. Yet, not too surprisingly in retrospect, the blog has also taken more of a WebSphere bent. This evolution occurred for a couple of reasons. For one, a lot of J2EE documentation already exists, especially on Sun's Java web site
. For another, new news on J2EE has been somewhat sparse; the J2EE 1.4 spec
came out nearly two years ago (Nov 2003), and J2EE 5 (JSR 244
) may not be final before the end of the year.
Meanwhile, the organization I work in, IBM Software Services for WebSphere
, has a mission of teaching current and potential WebSphere customers more about WebSphere products
. So I get exposure to a lot of good information about our products, information IBM is trying to communicate to our customers, but without any perfect approach to get the right information to the right people whenever they need it. So this blog has evolved into an opportunity to help with this effort. Thus I've covered customer relationship topics like Working with IBM Support
, new capabilities like WAS 6 high availability
, new features like the Service Integration Bus
, and new products like WebSphere Extended Deployment
. A very early theme has been What You Should Be Reading
, which has now lead to a whole article, "Where can I learn about WebSphere?
So if you keep up with this blog, hopefully it helps you keep up with new products, what's new in the products, and gives you a better understanding of the products and how to use them. Meanwhile, we'll continue to talk about basic technologies like J2EE and JMS, and technology trends like SOA and ESBs. Thanks for joining.
JBoss and Microsoft are announcing a partnership. Surprising for two companies that seem so different: JBoss -- Small, open source, J2EE; MSFT -- Just the opposite.
The companies plan to cooperate on Web services and identity management. JBoss's app server will work better with Windows and other Microsoft software.
For more info:
Let's just hope JBoss doesn't get embraced and extended
There's a new article in the developerWorks WebSphere zone
, "Introducing XMS -- The IBM Message Service API
." XMS brings a JMS
-like API to non-Java clients.
XMS, the IBM Message Service API, provides a consistent messaging API across client languages and across messaging products. The messaging products currently supported are WebSphere MQ
(duh!), WBI Message Broker
, and Default Messaging
(part of the SIB
) in WAS 6
. The client languages supported are C/C++ (see IA94: IBM Message Service Client for C/C++
) and .NET (see IBM Message Service Client for .NET Beta
). So if you're using the XMS API, even as you switch languages or messaging providers, your API stays the same, helping to minimize code changes. Much like the way JMS enables Java/J2EE programs to more easily switch messaging providers.
So far, XMS is just an IBM thing. However, I think IBM hopes that other vendors will adopt it for their messaging products. Then customers will be able to develop code that is more product- and vendor-independent.
The WebSphere MQ API (called MQI) also supports C/C++ and C#/.NET clients (as well as a slew of other languages). But XMS has some advantages: The pub/sub support in XMS is better, because you have methods to subscribe and unsubscribe, whereas with MQI you have to send those requests as messages. Meanwhile, Message Broker and Default Messaging don't really support C/C++ and C#/.NET at all, but now they do via XMS, and in a way such that the client doesn't really care which provider it's using.
So if you're using C++ or .NET and want to use the IBM messaging products, check out XMS, it'll make your job easier.
WebSphere Process Server
and WebSphere Integration Developer
are now available. (WebSphere ESB
is not yet available.) See More Info on WPS, WESB, and WID
for a little recent history.
For WPS: Check out the announcement letter
) and data sheet (PDF)
for details. There is also some product documentation
For WID: There will be an announcement letter
(but it's not yet available). The data sheet (PDF)
is already available.
Last but not least, the Info Center
for both WPS and WID is now online.
The September 2005 issue of IBM WebSphere Developer Technical Journal
is now available.
I wrote this month's Comment Lines (but you may want to read it anyway): "Where can I learn about WebSphere?
" These resources should already be well known by frequent readers of this blog, but now it's all gathered in one place.
And, of course, there's other good stuff:Allow me a moment to pat myself on the back:
If I may say so myself (and I guess I am), I'm kinda impressed that the topics that are coming up in these articles are topics that I'm already discussing on this blog, often several months ago. Regular readers of this blog should already be pretty in tune with what's going on of interest and better prepared to digest the material in the Tech Journal. OK, I'm done now.
So, lots of good stuff to go read. Enjoy.
When we talk about communication between computers, we tend to use the word "protocol" a lot. But what is a protocol?
Here are some takes on the term:
- Wikipedia: A protocol is a convention or standard that controls or enables the connection, communication, and data transfer between two computing endpoints.
- Webopedia ISP Glossary: The protocol defines a common set of rules and signals that computers on the network use to communicate.
- AIX Information Center: A set of rules for handling communications at the physical or logical level.
OK, those definitions are mostly talking about wire protocols like Ethernet
. So what makes Internet Protocol (IP)
, for example, a protocol? These definitions don't really help.
I can't find a reference for this, but here's the best definition I've ever heard: A protocol is a format over a transport.
What does that mean?
- format -- The structure of the data, as represented sitting in a memory space. Examples: XML, CSV.
- transport -- The means for moving data between computers over a network.
Many (most? all?) protocols are packet-based, so the data must be divided into pieces and each piece must be put in a packet; that's the format the transport can transport.
A funny thing about protocols is that what looks like a protocol at one level merely looks like a transport at another level. IP is a protocol--its data must be IP packets that are moved over a transport like Ethernet. But when getting data over a protocol like FTP
, or SMTP
, IP looks like just a transport. In turn, each of those protocols looks like just a transport for the file, HTML document, or e-mail message you're sending across the network.
So, a protocol is a format over a transport, and a protocol at one layer is a transport for the next layer.
Oracle and IBM are announcing an agreement to work together so that appliations developed for the Oracle Fusion Middleware
platform will run natively in WebSphere products, including WebSphere Application Server, WebSphere Portal, and WebSphere Process Server.
Here's the press release:
Here are some articles on the announcement:
Among other things, this announcement shows the two companies--Oracle and IBM--working together, which is significant considering how much they compete against each other.
IBM has now posted product pages for its New WebSphere Integration Products
The products and their pages are:
WID is the Eclipse-based IDE
for WPS and WESB, the successor to WebSphere Studio Application Developer Integration Edition
(WSAD-IE) (analogous to RAD
's relationship to WAS
). The WESB materials include a WESB FAQ
There's also a new article on WPS: "WebSphere Process Server: IBM's New Foundation for SOA
." The lead author, Wolfgang Kulhanek, has been featured in a Meet the Experts
: Wolfgang Kulhanek on WebSphere Business Integration
Of course, all of this ties into the recent Flurry of IBM SOA Announcements
and IBM's SOA Materials