SpringOne Americas

iPhone Bootcamp Day 2

Scott Leberknight — Tue, 02 Dec 2008 22:37:00 CST

Today is Day 2 of the iPhone bootcamp at Big Nerd Ranch.

See here for a list of each day's blog entries.

Localization

After a nice french toast breakfast — which my dumbass CEO Chris couldn't eat because he is allergic to eggs and complained a lot and made them give him a separate breakfast — we headed down to the classroom and started off learning about localizing iPhone apps. As with Cocoa, you basically have string tables, localized resources (e.g. images), and a separate XIB file for each different locale you are supporting. (Interface Builder stores the UI layout in an XML format in a XIB file, e.g. MainWindow.xib.) This means that, unlike Java Swing for example, you literally define a separate UI for each locale. We localized our DistanceTracker application that we built on day one for English and German locales. To start you use the genstrings command line utility to generate a localizable string resource and then in Xcode make it localizable; this creates separate string tables for each language which a translator can then edit and do the actual translation. You also need to make the XIB files localized and then redo the UI layout for each locale. Sometimes this might not be too bad, but if the locale uses, for example, a right-to-left language then you'd need to reverse the position of all the UI controls. While having to create essentially a separate UI for each locale seems a bit onerous, it makes a certain amount of sense in that for certain locales the UI might be laid out completely differently, e.g. think about the right-to-left language example. Finally, you use NsLocalizedString in code, which takes a string key and a comment intended for the translator which is put into the string tables for each locale - at runtime the value corresponding to the specified key is looked up based on the user's locale and is displayed. If a value isn't found, the key is displayed as-is which might be useful if you have a situation where all locales use the same string or something like that.

View Controllers

After localization we tackled view controllers. View controllers control a single view, and are used with UITabBarController and UINavigationController. We created a "navigation-based application" which sets up an application containing a UINavigationController. The difference between UITabBarController and UINavigationController is that the tab bar controller stores its views in a list and allows the user to toggle back and forth between views. For example, the "Phone" application on the iPhone has a tab bar at the bottom (which is where it is displayed in apps) containing Favorites, Recents, Contacts, Keypad, and Voicemail tab bar items. Tab bar items are always visible no matter what view is currently visible. As you click the tab bar items, the view switches. So, a UITabBarController is a controller for switching between views in a "horizontal" manner somewhat similar to the cover flow view in Finder. On the other hand you use UINavigationController for stack-based "vertical" navigation through a series of views. For example, the "Contacts" iPhone application lists your contacts; when you touch a contact, a detail view is pushed onto the UINavigationController stack and becomes the visible and "top" view. You can of course create applications that combine these two types of view controllers. In class we created a "To Do List" application having a tab bar with "To Do List" and "Date & Time" tabs. If you touch "To Do List" you are taken to a list of To Do items. Touching one of the To Do items pushes the To Do detail view onto the stack, which allows you to edit the item. Touching "Date & Time" on the tab bar displays the current date and time in a new view.

It took me a while to get my head wrapped around combining the different types of view controllers in the same application and how to connect everything together. Since I am used to web app development, this style of development requires a different way of thinking. I actually like it better since it has a better separation of concerns and is more true to the MVC pattern than web applications are, but I'm sure I'll have to try to build more apps using the various view controllers to get more comfortable.

Table Views

We had a good lunch and after that headed back down to cover table views. Table views are views that contain cells. Each cell contains some data that is loaded from some data source. For example, the "Contacts" application uses a UITableView to display all your contacts. The "To Do List" application we created earlier also uses a UITableView to list the To Do items. Basically, UITableView presents data in a list style.

Table views must have some data source, such as an array, a SQLite database, or a web service. You are responsible for implementing data retrieval methods so that when the table view asks for the contents of a specific cell, you need to offer up a cell containing the data appropriate for the row index. Since the iPhone has limited real estate, UITableView re-uses cells that have been moved off screen, for example if they are scrolled out of view. This way, rather than create new cells every single time UITableView asks for a cell, you instead ask if there are any cells that can be re-used. If so, you populate the cell with new data and return it.

UITableView also provides some basic functionality, like the ability to drag cells, delete them, etc. You only need to implement the logic needed when events, like move or delete, occur. Another thing you typically do with table views is respond when a user touches a cell. For example, in the "To Do List" application a new "detail" view is displayed when you touch a cell in the table view. This is probably the most common usage; table views display aggregate or summary data, and you can implement "drill down" logic when a user touches a cell. For example, when a user touches a To Do item cell, a new view controller is pushed onto the stack of a UINavigationController showing the "detail" view and allowing you to edit the To Do item. Another cool thing you can do with table views is to subclass UITableView in order to lay out subviews in each cell. In the "To Do List" app, we added subviews to each cell to show the To Do item title, part of the longer item description in smaller font, and an image to the left of the title if the item was designated as a "permanent" item. The "Photo Albums" iPhone application also uses subviews; it shows an image representing the album and the album title in each cell.

Saving and Loading Data Using SQLite

By this time, it was already late afternoon, and we hiked out to the old paper mill and back. It stared getting colder on the way back as the sun started to set. When we got back, we learned all about saving and loading data using SQLite. First, we learned about the "Application Sandbox" which can only be read/written by your application, for security reasons. There are several locations that each iPhone application can store data. Within you application's bundle (e.g. <AppName.app>) there is Documents, Library/Preferences, Library/Caches, and tmp folders. Documents contains persistent data, such as a SQLite database, that gets backed up when you sync your iPhone. Library/Preferences contains application preference data that gets backed up when you sync. Library/Caches, which Joe and Brian (the other instructor who is helping Joe this week) just found out about before our hike, is new in version 2.2 of the iPhone software, and stores data cached between launches of your application. The tmp directory is, as you expect, used for temporary files. You as the developer are responsible for cleaning up your mess in the tmp folder, however!

After discussing the sandbox restrictions, we learned how you can locate the Documents directory using the NSSearchPathForDirectoriesInDomains function. Finally, we learned how to use SQLite to add persistence to iPhone applications using SQLite, which I continually misspell with two "L"s even though there is really only one! SQLite supports basic SQL commands like select, insert, update, and delete. The reason you need to know how to find the Documents directory is because you'll need to create a copy of a default SQLite database you ship with your application into Documents. Basically, you supply an empty database with your application's Resources — this is read-only to your app. In order to actually write new data, the database must reside in a location (such as Documents) where you have access to write. So, the first thing to do is copy the default database from Resources to the Documents directory where you can then read and write, and where the database will then automatically be backed up when the user syncs her iPhone.

We then added SQLite persistence to the "To Do List" application. While I think SQLite is cool in theory, actually using it to query, insert, update, and delete data is painful, as you have to handle all the details of connecting, writing and issuing basic CRUD queries, stepping through the results, closing the statements, cleaning up resources, etc. It feels like writing raw JDBC code in Java but possibly worse, if that's possible. Someone told me tonight there is supposedly some object-relational mapping library which makes working with SQLite more palatable, though I don't remember what it was called or if it is even an object-relational mapper in the same sense as say, Hibernate. Regardless, I persisted (ha, ha) and got my "To Do List" application persisting data via SQLite.

WebKit

Joe apparently gave a short lecture on using WebKit in iPhone applications at this point. Unfortunately I decided to go for a run and missed the lecture. In any case, WebKit is the open source rendering engine used in Safari (both desktop and mobile versions) to display web content. You use UIWebView in your application and get all kinds of functionality out-of-the-box for hardly any work at all. UIWebView takes care of all the rendering stuff including HTML, CSS, and JavaScript. You can also hook into events, such as when the web view started and finished loading, via the UIWebViewDelegate protocol. In our lab exercises after dinner, we implemented a simple web browser using UIWebView and used an activity progress indicator to indicate when a page is loading.

In addition to loading HMTL content in UIWebView, you can also load things like images and audio content. It is ridiculously easy to add a UIWebView to your application in order to display web content.

Random Thoughts

Another long day has come and gone. It is amazing how much energy everyone has to basically learn all day and keep going well into the night hours.

Today we learned about localization on the iPhone. The most important thing is that you need to create a separate UI for each locale you are supporting. This means you should not work on localizing until right before you are ready to ship; otherwise you'll spend all your time continually tweaking all the localized UI after every little change you make.

Tab and navigation view controllers are powerful ways to implement application navigation using a tab paradigm or a stack-based, guided navigation scheme, respectively. Combined with table views, you can accomplish a lot with just these three things.

While I think having a relational database available for persistence in your iPhone apps is nice, I really do not want to write the low-level code required to interact with SQLite; once you get used to using an ORM tool like Hibernate or ActiveRecord you really don't want to go back to hand-writing basic CRUD statements, marshaling result sets into objects and vice-versa, and managing database resource manually. Guess I'll need to check into that SQLite library someone mentioned.

It is surprisingly easy to integrate web content directly into an iPhone application using UIWebView!

Tomorrow looks to be really cool, covering things like media and OpenGL. Until then, ciao!

Tweeting SpringOne

Craig Walls — Tue, 02 Dec 2008 09:03:00 CST

I'm tweeting what I hear/see at SpringOne at http://twitter.com/habuma. Follow along if you like.

Note that I'm not tweeting a lot, but not everything...I'm afraid I could overload the Twitter servers if I were to tweet everything. So, I'll follow up in a few days or when I have time with blog coverage here.

What is Spring Extensions' place in the Spring Portfolio?

Russell Miles — Tue, 02 Dec 2008 06:33:48 CST

After my talk at Spring in Finance on Spring Extensions and Spring for .NET, Jan and I got together to have a quick chat about the relationship between Spring Extensions and the rest of the Spring Portfolio.

You can check out the full video below:

iPhone Bootcamp Day 1

Scott Leberknight — Mon, 01 Dec 2008 21:38:00 CST

Today is the first day of the iPhone bootcamp at Big Nerd Ranch at Historic Banning Mills B&B in Whitesburg, GA. It is being taught by Joe Conway. My goal is to write a blog entry for each day of the class, so we'll see how that goes.

See here for a list of each day's blog entries.

Simple iPhone Application

We started off the course by creating a simple iPhone application using a bunch of UI controls that come out of the box. We dragged and dropped controls onto an iPhone Window application, hooked up some events in Interface Builder, and wrote a bit of event handling code. We ran the application on the simulator (i.e. not on our phones) and played around a bit with it. Cool to get something up and running in the first hour of a five day course!

App Icon and Default Image

After getting the initial iPhone app up and running we added an icon for the application which is what displays on the iPhone "desktop" and added a default image, the purpose of which is to "fool" the user into thinking the application launched immediately without delay. So, in other words, when an iPhone app launches, the first thing that happens is the Default.png image is displayed. Joe mentioned some people use this for so-called "splash" screens, perhaps to display a company logo or some advertising. While this is nice in theory, Joe mentioned this is about the worst thing you can do - when Apple makes the iPhone faster over time, instead of a two or three second splash screen, now you might see something flicker into and out of existence in a split second and users won't know what's going on. In any case the best thing to do is take a screenshot of your application. By the time the user gets around to actually clicking something the Default.png image will have been replaced by the actual application, and your app has the appearance of an immediate startup, which users always like.

Objective-C

Then it was onto a short introduction to the Objective-C language. Having attended the Cocoa bootcamp last April and read through Programming in Objective-C I was already comfortable with Objective-C. You basically learn that Objective-C is a dynamically-typed language built on top of C, adding objects and messaging, i.e. you send messages to objects. We blew through the basics of creating objects, initializing them, and creating accessors. Thankfully Objective-C 2.0 added properties which gets rid of the getter/setter method tedium. We briefly covered some of the basic classes like NSString and NSArray and NSMutableArray. After all that, it was on to memory management. Although Apple introduced a garbage collector in Mac OS Leopard, it is not available to iPhone applications and you must manage retain counts of objects manually using retain, release, and the autorelease pool. This is tedious at best, but Joe provided several concrete and relatively simple rules to follow when writing iPhone apps, which I'm not really going to delve into right now, but suffice it to say that you have to pay a lot more attention to memory issues writing iPhone apps than, say, writing web apps in a garbage-collected language like Ruby, Java, or C#. We wrote several sample applications that demonstrated Objective-C basics, counting object references, and using the autorelease pool.

Using Text Controls

Next up was the chapter on "text" on the iPhone, which focused on using the UITextField and UITextView controls. For this section we created an application that allowed you to search a large block of text in a UITextView for specific text typed into a text field. During this section we learned how to deal with the (virtual) keyboard and how it automatically becomes the "first responder" when a user touches a text UI control. Joe showed how the Responder Chain delegates events until some object handles it, or if no objects are interested, the event simply and silently drops off into nothingness. (For Gang of Four aficionados, this would be the Chain of Responsibility pattern. Does anyone actually care anymore?) This allows you to delegate events up a chain of objects. When an text-capable object becomes the first responder, the virtual keyboard automatically appears for the user to type something. To remove it you can write code to resign the first responder status. Last in the text section was using notifications and the notification center to observe when the keyboard is about to show (be displayed on screen) and write a log message.

Delegates

Even though it was cold outside (about 40 degrees Fahrenheit) we took a 30 minute hike around 3 o'clock and got refreshed. Then we continued to learn about using delegates and protocols. Basically a delegate handles certain functionality passed off to it by another object. The delegate essentially extends the functionality of an object without needing to resort to all kinds of subclassing everywhere; in other words it is a way to perform callbacks and extend functionality. For example, an XML parser knows how to parse the XML and it might send messages to a delegate object. The delegate object in this case knows what to do when it sees specific elements or attributes, while the parser remains completely generic. This enables re-use of the parser without it needing to know anything about how your application actually responds to various elements and attributes. We extended our text search application using delegates to perform the actual searching logic as well as resigning and becoming the first responder.

Core Location

The last, and coolest, topic today was Core Location, which is the framework that allows your iPhone to figure out where you are in the world. We wrote an application that uses your current location and tracks the distance you've traveled after you enable tracking. Since I have not actually enabled my iPhone device yet, I had to run this only on the simulator which was not quite as cool since it only reports one location (which IIRC was the lat/long of Apple's headquarters but I might have caught that wrong.) Basically you use a CLLocationManager which sends location updates to a delegate (good thing I paid attention to the section on delegates earlier); the delegate does pretty much whatever it wants to. Again, the delegate implements application-specific logic and the CLLocationManager just sends you the updated lcoation information, resulting in a clean separation of concerns. You can configure the manager for the level of accuracy you'd like, for example ten meters, a hundred meters, or "best" possible accuracy. The higher the accuracy, the faster your battery will drain, so setting this to best accuracy and leaving it on continuously might not be the best thing to do. Joe also mentioned that if you turn off the iPhone using the top button, the active application can still be doing things and so you want to make sure you check for the "application will passivate" event and stop updating the location to prevent excessive battery drainage! (Maybe that's what happened to me a few weeks ago when my full battery completely drained overnight.) You can also configure a distance filter if, for example, you only want to receive updates after the phone has moved a certain distance. Cool stuff!

Provisioning Profiles

After dinner we returned to the classroom to set up our provisioning profiles, which is going to allow those of us who have not yet registered with Apple to actually run apps on our iPhones (known as "devices"). I am planning to buy my developer certificate but for now Big Nerd Ranch has provisioning profiles for students since apparently it is now taking a day or two to get your developer certs and other required stuff.

Random Thoughts

After a long day, I have a few random thoughts in no particular order. Interface Builder is really, really nice for building UIs. Of course I already knew this having taken the Cocoa bootcamp last April. Regardless, building UIs using a sophisticated and refined tool like Interface Builder is sooooooo much nicer than the current kludge of web technologies that splatter HTML, CSS, and JavaScript all over the place and various data exchange formats like XML, JSON, or whatever combined with eight different JavaScript frameworks and a potentially very different server-side programming model and finally trying to jam it all together. Can you tell I've been doing web development for a while?

Delegates and Core Location were probably the coolest things from today, and it is really nice that after only one day I can build iPhone apps, even if they are pretty simple. Then again, it is really cool how easy it is to integrate location into an iPhone application. Objective-C as a language is actually not all that bad, and is really easy to read since the methods (at least the ones from the Apple SDK) tend to be very well-named. Of course I like the fact that Objective-C is dynamically typed and I don't have to be told by the compiler what I can and cannot do at every step of the way, e.g. I can send any message to any object and so long as it responds, no problem. Of course the code does still have to compile in the XCode IDE so it isn't a total dynamic language free-for-all. The thing I don't like is having to manually manage memory. After doing malloc and free in C on a VAX for the first several years out of college, I was quite happy to not have had to do that for over 10 years. Oh well, I suppose the autorelease pool and simply sending retain and release messages is better than malloc and free.

Big Nerd Ranch is all about coding. While there is lecture, you code hands-on most of the time, and this is why you learn so much. The hikes really relieve the tendency to want to go to sleep after lunch! It's 10:25 and I've finally got ten my iPhone provisioned and the apps we developed today all working directly on the phone. I also finally got the SDK updated to the latest version as well as update my phone's software to version 2.2. All in all a great first day!

Spring Python 0.9.0 is released

Greg Turnquist — Mon, 01 Dec 2008 13:26:00 CST

Spring Python has just released 0.9.0. This release includes a key update to springpython.security.web module, where authorization has been patched to support CherryPy 3.1. Sylvain helped by providing key patches to integrate Spring Wiki with CherryPy 3.1, and I adapted these to support the PetClinic app. This valuable feature will help demonstrate all the various features of Spring Python during the "Introduction to Spring Python" demo scheduled later this week during the SpringOne conference.
==============================================================================
Release Notes - Spring Python - Version 0.9

Bug

[SESPRINGPYTHONPY-81] - Fix AccessDecisionManager based on CherryPy 3 upgrade

Task

[SESPRINGPYTHONPY-76] - Convert sample applications to new XMLConfig format.

==============================================================================
Links:

* For more information, please visit the website at http://springpython.webfactional.com.

* To download the 0.9.0 release, or an archived release, and for access to sample applications use http://www.springsource.com/download/community?project=Spring%20Extensions

Key Features of Spring Python include:

* Inversion Of Control - The idea is to decouple two classes at the interface level. This lets you build many reusable parts in your software, and your whole application becomes more pluggable. You can use either the XmlApplicationContext or the DecoratorBasedApplicationContext.

* Aspect-oriented Programming - Spring Python provides great ways to wrap advice around objects. It is utilized for remoting. Another use is for debug tracers and performance tracing.

* DatabaseTemplate - Reading from the database requires a monotonous cycle of opening cursors, reading rows, and closing cursors, along with exception handlers. With this template class, all you need is the SQL query and row-handling function. Spring Python does the rest.

* Database Transactions - Wrapping multiple database calls with transactions can make your code hard to read. This module provides multiple ways to define transactions without making things complicated.

* Security - Plugin security interceptors to lock down access to your methods, utilizing both authentication and domain authorization.

* Remoting - It is easy to convert your local application into a distributed one. If you have already built your client and server pieces using the IoC container, then going from local to distributed is just a configuration change.

* Samples - to help demonstrate various features of Spring Python, some sample applications have been created:
o PetClinic - Everybody's favorite Spring sample application has been rebuilt from the ground up using various web containers including: CherryPy. Go check it out for an example of how to use this framework.
o Spring Wiki - Wikis are powerful ways to store and manage content, so we created a simple one as a demo!
o Spring Bot - Use Spring Python to build a tiny bot to manage the IRC channel of your open source project.

Original post blogged on Spring Python's blog site.

The importance of scaling in units or pods

Billy Newport — Mon, 01 Dec 2008 11:14:00 CST

As some of you have probably heard me say, we have tested Extreme Scale to over a thousand JVMs. Cool, and everyone runs out to build their applications to deploy single grids on lots and lots of boxes.

Now, while you could do this, we don't recommend it. Why? First issue is testing. How will your testing environment fully test a 1000 server grid? The answer is it won't. It'll test a much smaller grid because of budget, noone is going to buy twice the hardware, especially 1000 servers. Plus, what if you need to concurrently test multiple versions of your application. Requiring a 1000 boxes for each testing thread is not practical. This clearly is risky because you aren't testing the same thing as production.

Next issue is risk. Running a database on a single hard drive is risky. Any problem with the hard drive and you're losing data. Running a growing application on a single grid is similar. While we strive for very high quality it's inevitable that bugs will slip out and there will also, of course, be application bugs. Putting all your eggs in one basket is a risky move that almost never pays off. Splitting the application grid in to pods makes a lot of sense. A pod is a group of servers running a homogenous application stack. Pods might be 20 boxes in size. Rather than having 500 boxes in a single grid, now we'd have 25 pods of 20 boxes instead. A single version of the application stack runs on a pod but different pods may be on different versions of the application stack. The application stack is

Operating system level
Hardware level (bios, firmware)
JVM level
Extreme Scale level
Application level
anything else your application needs to work.

Pods are a nicely sized deployment unit for testing. It's easy to imagine QA having 20 servers to test. It's highly unlikely they would have 500. It also means they are testing the same configuration as production. Production uses grids with a maximum size of 20 servers, i.e. a pod. You can stress test a single pod and know what the capacity is, number of users, amount of data, transaction throughput. This makes planning easy and follows the Extreme Scale mantra of predictable scaling at predictable cost. Does a pod have to be 20 servers? No, this is just a number. It can be any number that makes sense. It should be small enough that if a pod has an issue in production, the fraction of impacted transactions is one that the customer is comfortable with until it's resolved. The bigger the fraction is then the less comfortable customers usually are...

A bug will hopefully only impact a single pod. This in the above example only impacts 4% of the application transactions rather than 100%. Upgrades are easier as they can be rolled out a pod at a time. This is just common sense. If an upgrade to a pod goes wrong then switch the pod back to the old level. Upgrades include application and system updates, any change to the application stack. Upgrades should as a rule only change a single element of the stack at once. This makes problem determination much easier. This isn't possible in all cases but should be strived for as a general principle.

You need a routing layer on top of the pods which needs to be forwards and backwards compatible as pods get software upgrades. A directory is needed to locate which pod has some data. Another Extreme Scale grid can be used for this with a database behind it maybe using write behind. This gives us a two tier solution. Tier 1 is the directory and is used to locate which pod handles a specific transaction. Tier 2 are the pods. Once tier 1 identifies a pod then normal Extreme scale routing routes the transaction to the correct server in the pod, this is usually the server holding the partition for the data used by the transaction. Near caches on the tier 1 can be used to lower the impact of the pod look up step.

This looks a little more complex than having a single grid but the operational, testing and reliability improvements will make it worth while.

This blog post doesn't discuss scalability in the normal sense, i.e. does Extreme Scale scale out to a 1000 or more JVMs. It discusses scalability in terms of operations, planning, risk management. These are usually MORE important than product scalability and unfortunately ignored frequently. Buildling highly available systems requires both. You need a reliable product and you need a reliable process for deploying your application.

Welcome to SpringOne

Greg Turnquist — Mon, 01 Dec 2008 05:48:00 CST

Day 0
========================
Well, I'm happy to report I got in last night and was able to meet up with a handful of people. Russ texted me to join them at the bar. After getting settled in the nice Westin Diplomat, I managed to find him along with a few others, despite my phone not having international support. Since the conference doesn't start until Monday evening, I call this Day 0. Russ and I made followup plans. Previously, we were scheduled to speak in parallel during the same time slot, but that now we are scheduled serially. That is definitely a relief. Russ is giving his presentation on Spring Extensions before my Introduction to Spring Python, and there is some possibility of me providing a little "live" feedback during his presentation. We need to hammer out what that is exactly.

I spent time getting my laptop together this past weekend before traveling down here so that I can give a demo of PetClinic. I wanted to be sure I had a copy of the trunk checked out with the handful of Spring Python's dependencies installed so I could run the regression test suite as well as PetClinic. It is all working, and now I can comfortably make this blog entry from my hotel room. Stay tuned!

Original post blogged on Spring Python's blog site.

iPhone Bootcamp Blogs

Scott Leberknight — Sat, 29 Nov 2008 23:00:00 CST

Check out my blog entries this week while I'm attending the iPhone bootcamp at Big Nerd Ranch.

Day 1
Day 2

SpringOne 2.2.1 Release Available

Christian Dupuis — Sat, 29 Nov 2008 20:42:00 CST

Just in time for this year’s SpringOne Americas I released Spring IDE 2.2.1 to the update site at Amazon S3. This version is mainly a bug fix and maintenance release, but there are three changes that I’d like to highlight in this post.

But before I go into detail here are the usual download links:

Update site: http://dist.springframework.org/release/IDE (this link does not work in a browser, but in your Eclipse update manager!)
Archived update site: spring-ide_updatesite_2.2.1_v200811281800.zip
Changelog: Release 2.2.1

Support for Workspace external configuration files

Since early versions Spring IDE wasn’t able to recognize XML configuration files from workspace external resources like JARs from classpath containers. Only JARs that were sitting inside a project could be searched for configuration files. This limitation is due to the fact that the Eclipse resource abstraction has no knowledge of external resources and provides no access to those. But Spring IDE heavily relies on this abstraction like so many other Eclipse plug-ins.

I finally ended up implementing a thin layer to integrate JARs from external locations into the resource abstraction to make Spring IDE able to open and parse those files.

Ignore missing NamespaceHandler warning

Although Spring IDE can easily be extended to support custom namespaces, there are a lot of frameworks out there that don’t ship or provide an integration. Normally that would end up in a “Unable to locate Spring NamespaceHandler for element 'node name' of schema namespace 'uri'” warning in Eclipse or the SpringSource Tool Suite.

There is now a setting to disable this warning on the Project properties dialog.

Refactoring of Content Assist Infrastructure

If you are already in the business of extending Spring IDE’s namespace support you might want to take a closer look at the work that has been done for making the implementations of the IContentAssistCalculator more reusable. This refactoring will most likely break your extension depending on the extension approach you choose.

Making your extension compatible with the new API is not hard and should not involve a lot of changes. Please let me know if you run into any problem or need advice on how to migrate.

Compatibility with SpringSource Tool Suite

SpringSource Tool Suite 1.1.1 is not yet compatible with the 2.2.1 release of Spring IDE. Please don’t update!. We will release an updated version of STS shortly after SpringOne that will come with recent Spring IDE and will also feature lots of new Spring-related tooling.

Free tools for analyzing heap usage, winner is Eclipse Memory Analyzer

Billy Newport — Fri, 28 Nov 2008 19:55:00 CST

I've been analyzing some heaps lately and am still very disappointed at the tooling for doing this kind of thing in Java. The first step is creating a heap dump. I am using a Sun Java 6 JVM so I used jmap to dump the heap.

The file was pretty big, 650MB. Next step is analyzing it. First attempt was to use jhat in the Sun JVM. This is pretty much useless. It just lets you walk the heap but I can't figure out how to get it to tell me which objects have the most instances etc. I don't see what that is useful for as a result.

Next was the IBM Alphaworks heap analyzer. First issue there was just loading the file. We failed to load it on our Laptops (4GB). Next I used one of my Mac Pros (32GB RAM) using a 64 bit JVM with a 16GB heap and now it loads but it was pretty buggy and was spitting exceptions in the console like nobodies business. We had a lot of trouble just getting it to respond to right clicks for displaying parents etc. So, this isn't great either.

Next, we downloaded the Eclipse Memory Leak Analyzer and this was the best of the lot by far and is what we're using now. You download this and it runs as it's own private eclipse instance. It loaded the file with no issues using defaults so this works on a laptop. It lets you get at all the information and doesn't spit exceptions at you so this is a huge (HUGE) step up on the Alphaworks heap analyzer. This is what we're using now for checking heap usage dumps.

We prefer a dump a file approach rather than live checking with commercial profilers just because it seems to be more stable. Attaching profilers seems to usually cause a crash etc so dumping the heap and then examining offline seems more useful.

Building web applications using Spring for .NET podcast now available

Russell Miles — Thu, 27 Nov 2008 11:26:24 CST

Missed my talk on Spring for .NET last week in London? No problem, Skills Matter have kindly supplied the video for anyone who couldn't make the live event.

What's Next

Matt Raible — Wed, 26 Nov 2008 16:19:00 CST

It's been three weeks since I joined the realm of the unemployed. Fortunately, I didn't stay unemployed for long. In fact, after writing the aforementioned post, I received 5 offers the next day. Of the opportunities I received, the most interesting ones were those from companies interested in hiring the whole team. Not only that, but LinkedIn hired me back as a contractor through the end of the year. The goal of the LinkedIn contract: finish up projects that my team had started in the previous months.

At the end of the first week after the LinkedIn layoffs, we all had individual opportunities, but we also had two team opportunities. The following week (last week), I flew to NYC to meet with one potential client while the other potential client flew to Denver to meet with the rest of the team. After flying to NYC, I traveled to Mountain View to do some on-site work at LinkedIn. At the end of the week, it seemed like most of the remaining tasks at LinkedIn could be done by someone else. I told them I thought it was best that I move onto other things, while staying available for support questions. On the way to the airport, I spoke with both our team opportunities. Following those conversations, I was very pumped about both projects and confident about pending offers. You can imagine my disappointment when my flight was delayed for 5 hours.

After a fun weekend with Abbie, Jack and friends, I woke up Monday morning without a job and it felt great. However, things changed quickly. Monday morning many opportunities landed in my inbox: a 3-day gig this week (helping write open-source training), a 1-week gig in December (evaluating how well Tapestry 5, Wicket and Struts 2 integrate with Dojo/Comet for a client in Europe), a 1-week training gig in Europe next year and a 3-month gig for the whole team. I accepted all these opportunities and am very happy I'll get to work with Jimbo, Country and Scotty again next year. The 3-month gig should be a lot of fun. We're helping build a SOFEA-based architecture that leverages appropriate client technologies (to be determined) to build a kick-ass web application. I look forward to talking about the technologies we use and things we learn along the way.

So the good news is I've entered The Golden Period. The Golden Period is when you don't have a job, but you do have a start date. Unemployment is absolutely blissful during this time. The Golden Period exists a couple times for me over the next 6 weeks.

I'll be traveling to Costa Rica tomorrow for a best friend's wedding. I'm leaving both my laptop and my iPhone at home. Next week, I'll be loving life with my parents in Costa Rica and Panama. The following week, I'll be working on AppFuse all week and hope to make great progress on developing 2.1. Then I have the 1-week Web Framework Analysis gig, followed by 2 weeks of vacation in Oregon. My Golden Period begins this afternoon (for 3 weeks) and happens again over Christmas (for 2 weeks).

Yeah, life is good. Damn good.

350k transactions/sec for fault tolerant stock price quote service on 2 commodity boxes.

Billy Newport — Tue, 25 Nov 2008 15:44:00 CST

I'm helping develop an order quote service for a customer in financial markets using WebSphere Extreme Scale (ObjectGrid). The application simply pulls the current quote for a particular stock from a feed and maintains the current price and the 20 minute history in memory for each stock. The price updates arrive at 200k/sec(!!) so it's quite a pace. There is a lot of data as there is 230k stocks to keep the quotes with history for. Clients can request the current live price for a stock or the 20 minute delayed price for a stock if they haven't paid for the live service.

The application is currently running on a pair of older dual socket quad core Intel servers connected with Gb ethernet. Thats 8 cores each or 16 cores in total. The two boxes are currently handling this service at 350k/sec price updates in total, 175K per server. All updates are asynchronously replicated for high availability. Scaling up is a matter of running the application on more hardware. 4 such boxes would deliver 700k/sec, 8 such boxes 1.4m/sec and so on. With no replication then I'm getting well over a million per box but no surprise there, if you do nothing then it goes real fast :)

Anyway, just thought I'd share. If anyone wants the application we provided as a sample then please email me.

Get Comfortable Being Uncomfortable

Scott Leberknight — Tue, 25 Nov 2008 15:03:00 CST

Renae Bair's post on The Ranting Rubyists hits a lot of nails on the head. I will freely admit to being a developer who is interested in continually learning new technologies - perhaps even at the expense of the ones I currently develop in - and I try to contribute a little back by blogging and speaking at conferences like No Fluff Just Stuff on a semi-frequent basis. But Renae's point is that many people in the development world seem to be all about the New, New Thing and ready to dismiss the old things without a second thought. My feeling is that the old things don't go away, often we just end up piling more things on top. (It's new technologies all the way down.) Sometimes there certainly is wholesale replacement, but from what I've experienced usually you just mix in the new things and things become that much more heterogeneous.

I think it's fine to continually push "forward" to newer and better technologies that help you do the same thing in half the time, or in half the code, or allow things to execute on twice the processors, or scale twice as much. But at the same time it is simply not cool or very intelligent to dismiss the very tools that get you paid and perhaps got you where you are today. Sometimes the intent is just that; to dismiss the old in favor of the new for the purpose of making money. Sometimes the intent is merely the intellectual curiosity the best developers usually possess, and in fact the best people in any field possess. A few years ago I told a friend "Get Comfortable Being Uncomfortable." What I meant was to learn new things and push yourself to think about doing things better and more efficiently than you currently are doing them. Sometimes this means switching or advocating a new tool; sometimes it means using your existing tools more effectively. And always it means you can't rest on your laurels and you are always challenging the status quo. Many people don't like this. Well, too bad, because reality is that things change and Resistance is futile.

My day job is still mainly Java and web applications, though I also have managed to squeeze Ruby, Groovy, and Python in there (and of course realized the power of JavaScript) over time. I speak on mostly Java-related stuff like Hibernate and Spring and Groovy a bit. And currently I'm learning about new things (to me anyway) like functional languages such as Lisp and Clojure and Scala. Not because I think I'm going to rewrite the application I'm currently working on in a different language and/or framework, but because over time I feel learning new and different things makes me a better developer, architect, designer, etc. I know that the Java code I write today, while still crap, is way better than the crap I wrote several years ago, and has been influenced by learning Python and Ruby and Groovy and others. While it is still Java, I don't try to write overly generic, overly engineered things like I used to (well, perhaps not as much as I used to anyway). I just try to get the tasks I need to get done, done. If I need to make something more generic later, I can do it. But in addition to the power of just learning new things, I think the more well-rounded you are the better off you are and the better equipped you are to solve new problems. And maybe you'll find a much better way to solve them because you have a more diverse knowledge "portfolio" at your disposal.

So, getting back to Renae's post, I think it's a great idea to continue learning new things and pushing better ways of doing things, if for no other reason than to ensure your own relevance and marketability as a developer but hopefully because you enjoy it! But while it's OK to voice your opinion and seek new and better things, don't just rip to shreds the things that got you to where you are. In the past I've made comments to people like "Java sucks" and "I'd rather be doing Blub programming" and I've tried to curb that and realize that things change, we know more today than yesterday, and to just "Get Comfortable Being Uncomfortable." You might not always get to program in Blub but that shouldn't stop you from expanding what you know, and by the way the sphere of your knowledge should include more than just technical knowledge and probably should include things like economics, finance, culture, art, literature, sports, etc. Whatever. Just make yourself more well-rounded and you'll be better for it, in all aspects of life.

Interview with me on Grails Podcast

Graeme Rocher — Tue, 25 Nov 2008 11:08:42 CST

Those crazy guys over at the Grails podcast interviewed me about various things ranging from being part of SpringSource to the upcoming Grails 1.1 release to my deep hatred of all things Maven. Check it out.

It's Winter, but a Spring buzz is in the air

Pratik Patel — Mon, 24 Nov 2008 18:52:00 CST

There's been a 'backlash' of sorts brewing in the Java developer community over the past 2 years. From talking to my developer buddies around the world, and the usual suspects at AJUG here in Atlanta, there is definitely some under-tow with regard to what's been happening in the Spring community.

Before I go onto to explain the aikido move that has actually happened, it's important to explain why this perception exists. Some of it is technical, some not, but nonetheless, here's some points to ponder:

Spring moved well beyond what I call the "shiny new toy" phase of its maturation. This level of maturity for any tool/project/product/technology is followed by reflection and a re-thinking as people hit against the edges of said technology.
Commercialization. As Interface21 turned into SpringSource, got VC money, and started down the path of becoming more than a boutique consultancy, people take notice. Folks get worried since this changes the status quo.
No longer "cool." Spring ain't cool anymore, rather it's not the coolest thing out there. As a tech geek, I like to play with the latest thing. As an enterprise software developer, I need rock-solid technology.
Shift in thinking. As Ruby-on-Rails smacked down Java in terms of web application development velocity, people took note. Convention-over-configuration, truly rapid development, and relegation of XML from the developer's toolbox to the trashcan opened many eyes to a new way.

The great thing about running a software company as a consultancy first is that you're in the field learning from your customers. It looks like the Spring guys learned a few things along the way. They've taken the energy from the competition around them and turned it into their favour slowly over time. Of course, they haven't been perfect - I still wonder why it's taken so long to refactor the Spring MVC framework, for example. From the recent presentation of Spring MVC last week at the AJUG, it looks like it's coming along nicely, and it's something I am going to be playing with soon.

As an enterprise developer, though, the real excitement is in the Spring Integration, JMS, Security, and Batch modules. There was a real buzz at last week's AJUG about all the interesting stuff in development at SpringSource. Next week, I'll be at Spring One Americas and I'm looking forward to checking it all out.

Oh, did I mention I was invited to present my "Enterprise JPA and Spring" session at SpringOne? If you want to learn some real-world tips for developing JPA based apps using Spring and the advantages of developing EJB3 "entity beans" using Spring, come to my session. Hey, it may not be the "coolest" topic... but you'll learn something interesting or gain a different perspective on how to build, test, and manage large projects that use JPA. I'll be sipping mojitos by the beach or at the bar as time allows, stop and say 'hi' if you see me!

Video podcast on handling inconsistencies when using WebSphere Extreme Scale

Billy Newport — Mon, 24 Nov 2008 18:10:00 CST

This video podcast covers the issue when an application uses cached data in WebSphere Extreme scale and then a third party application updates that data without going through Extreme Scale. It covers how the inconsistency arises and then how the application must be coded mechanically to deal with the inconsistency. It also covers whether using a database trigger with invalidation messages solves the inconsistency or not.

You can watch a streamed version here.

Download websphere_extreme_scale_weekly_podcast_medium.m4v

Spring Python isn't a simple port of the Spring Framework

Greg Turnquist — Sun, 23 Nov 2008 16:49:00 CST

While surfing across Google, I spotted a conversation where a couple guys were commenting on Spring Python. The only commentary was based on the Wikipedia entry, and showed no delving into official documentation or our website. Well, I can't help but respond to the some of the assumptions that were made.

Spring-Python. A port of the Spring framework to Python. It's like people haven't read http://tinyurl.com/3jv3m

Uhh, I HAVE read Python is Not Java. In fact, I found it soon after I started this project, and took many of the points they were making to heart. If you look at the code, you will notice that a) there aren't getters and setters all over the place typically found in Java, and b) I cleaned up the code base to better conform with PEP-0008. I have had other pythonistas look at my code and give me feedback so I can make this project as pythonic as possible.

That is, of course, a little unfair. They might be writing it in a Pythonic style. But still, aren't there enough web frameworks?

Thanks for sticking up for me. I certainly appreciate that. And to clarify, yes, I am trying to writing this in a pythonic fashion. That is why I welcome other pythonistas to visit my code and seeing what I'm doing. Please send me patches or comments. However, please understand that Spring Python is NOT purely a web framework! This must one of the most frustrating things for the Spring folks. Spring MVC and Spring Web Flow may be web frameworks, but the whole framework isn't just for web apps. In my daytime job, I use Spring all the time while NOT writing a web app! The stuff they have written is universal. Web app or not, there is good leverage inside their code, and I wanted the same power when writing python apps.

And reading the definitive source (Wikipedia, natch), I don't see anything in there that isn't done better in, say, Django.

Okay, how do I say this? Wikipedia is NOT the definitive source. While I admit that I wrote most of what's in there, it is a NPOV, quick description of things. The definitive source is http://springpython.webfactional.com. I'm not trying to compete with Django or replace it. Again, Spring Python is NOT a web framework. I have written samples of how it can enhance your CherryPy app. I want to study the other python web frameworks, and see if Spring Python can help out.

Sure, but doesn't everyone already have an ORM layer with a better description than "the SQL query and row-handling function"?

I have supported a particular application for several years, and it now has 200+ queries. I'm not about to migrate it to an ORM solution because I don't have the time. I didn't know that ORMs were the final answer to database access. It seems people are still debating the impedance mismatch between objects and relational databases. Sometimes, the technology-neutral language of SQL is the most portable, expressive way to communicate. Got an ORM? Do you enjoy using ORMs like SQLObject or SqlAlchemy? Great! Spring Python won't get in your way. Frankly, I haven't spotted ANYTHING where we can help them, either. But do you use pure SQL queries? We DO have something for you.

Reading from the database hasn't required "a monotonous cycle of opening cursors", etc. in a long time.

Again, if you are using an ORM, then Spring Python doesn't have anything today. But if you are writing some pure SQL, you need to manage your cursors correctly. Have you read PEP-249 Python Database API Specification v2.0? The spec defines two method calls, one for connection objects and one for cursor objects: close. It clearly indicates that you can use this to close the connection before the object itself goes out of scope. If you are writing a tiny python app that exits after a bit, your connections and cursors will be garbage collected and these things will close automatically. But if you want to write any type of enterprise app that stays up ALL THE TIME, then you need to be correctly closing result sets.

I have worked on enterprise level Java apps, and one of the first pitfalls is failure to close cursors and connections when you are done. JdbcTemplate solves this problem for you. Python has the same issue to deal with, and DatabaseTemplate provides the same solution.

And I fully admit I'm being unfair. (Although having said that, XML config files are another thing I'm more than happy to drop.)

Thanks for being honest. I don't mind someone putting in their $0.02. Regarding XML configuration files, I have two angles of approach: 1) make it easy for existing Java developers who have used Spring to migrate to Python and 2) support new Python users. The XML configuration option is to help support the Java developers. But I totally grasp the concept of avoiding XML situps. It's why I rapidly wrote a pure python, decorator based IoC container after I had a working XML container. BTW, the key reason I started with XML was the fact that someone had already created one, and it helped me jump start things. Once again, in all tradition of Spring, the choice is yours.

XML may not be the most tasteful thing to pythonistas, but we still have to deal with it. For that, I gladly recommend Amara. We used it to rapidly rewrite our XML parsers. It works wonders.

I just ask that you visit our website, read our documentation, read the source code, and learn what this project is trying to accomplish before you make too many assumptions.

Original post blogged on Spring Python's blog site.

j.u.c ExecutorrService gotcha

Shay Banon — Sun, 23 Nov 2008 06:28:00 CST

java.util.concurrent ExecutorService allows for a simple way of using a thread pool within a java application. I have seen the following happens in more than one place (including some quite known open source projects) that I thought it make sense to blog about it.

One of the most common scenarios of using a thread pool is creating an unbounded thread pool with minimum and maximum number of threads. With the executor service, you can create the following quite simply:

A fixed size thread pool with unbounded queue. Problematic in our case since we want to set the minimum and maximum thread pool size.

// similar to j.u.c.Executors.newFixedThreadPool(int nThreads)
new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>())

A cached thread pool that creates threads as needed and reuses threads when possible (problematic with bounded maximum threads so can’t be used in our case):

// similar to j.u.c.Executors.newCachedThreadPool()
new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());

The problem starts when one needs to create an unbounded thread pool with minimum and maximum threads. What most people do is the following:

// similar to j.u.c.Executors.newCachedThreadPool()
new ThreadPoolExecutor(coreThreads, maximumThreads,
                                      60L, TimeUnit.SECONDS,
                                      new LinkedBlockingQueue<Runnable>());

This construction of thread pool will simply not work as expected. This is due to the logic within the ThreadPoolExecutor where new threads are added if there is a failure to offer a task to the queue. In our case, we use an unbounded LinkedBlockingQueue, where we can always offer a task to the queue. It effectively means that we will never grow above the core pool size and up to the maximum pool size.

OK, so this does not work, lets try and build one that works. The first thing that we want to do is create a blocking queue that is aware of the ThreadPoolExecutor:

public class ScalingQueue<E> extends LinkedBlockingQueue<E> {
 
    /**
     * The executor this Queue belongs to
     */
    private ThreadPoolExecutor executor;
 
    /**
     * Creates a <tt>TaskQueue</tt> with a capacity of
     * {@link Integer#MAX_VALUE}.
     */
    public ScalingQueue() {
        super();
    }
 
    /**
     * Creates a <tt>TaskQueue</tt> with the given (fixed) capacity.
     *
     * @param capacity the capacity of this queue.
     */
    public ScalingQueue(int capacity) {
        super(capacity);
    }
 
    /**
     * Sets the executor this queue belongs to.
     */
    public void setThreadPoolExecutor(ThreadPoolExecutor executor) {
        this.executor = executor;
    }
 
    /**
     * Inserts the specified element at the tail of this queue if there is at
     * least one available thread to run the current task. If all pool threads
     * are actively busy, it rejects the offer.
     *
     * @param o the element to add.
     * @return <tt>true</tt> if it was possible to add the element to this
     *         queue, else <tt>false</tt>
     * @see ThreadPoolExecutor#execute(Runnable)
     */
    @Override
    public boolean offer(E o) {
        int allWorkingThreads = executor.getActiveCount() + super.size();
        return allWorkingThreads < executor.getPoolSize() && super.offer(o);
    }
}

As you can see, we are going to reject the addition of a new task if there are no threads to handle it. This will cause the thread pool executor to try and allocate a new thread (up to the maximum threads). If there are no threads, the task will be rejected. In our case, if the task is rejected, we would like to put it back to the queue. This is a simple thing to do with ThreadPoolExecutor since we can implement our own RejectedExecutionHandler:

public class ForceQueuePolicy implements RejectedExecutionHandler {
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        try {
            executor.getQueue().put(r);
        } catch (InterruptedException e) {
            //should never happen since we never wait
            throw new RejectedExecutionException(e);
        }
    }
}

Last, as a way to increase performance of additions of tasks to the queue, we can enhance the built in getActiveCount method in ThreadPoolExecutor to be faster (by default it obtains a lock and runs on the current workers):

public class ScalingThreadPoolExecutor extends ThreadPoolExecutor {
 
    /**
     * number of threads that are actively executing tasks
     */
    private final AtomicInteger activeCount = new AtomicInteger();
 
    public ScalingThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
                                     long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }
 
    @Override
    public int getActiveCount() {
        return activeCount.get();
    }
 
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        activeCount.incrementAndGet();
    }
 
    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        activeCount.decrementAndGet();
    }
}

That is it. Now, we can construct our thread pool (a simple factory method is provided here):

public static ExecutorService newScalingThreadPool(int min, int max,
                                                   long keepAliveTime) {
    ScalingQueue<Runnable> queue = new ScalingQueue<Runnable>();
    ThreadPoolExecutor executor = new ScalingThreadPoolExecutor(min, max, keepAliveTime, TimeUnit.MILLISECONDS, queue);
    executor.setRejectedExecutionHandler(new ForceQueuePolicy());
    queue.setThreadPoolExecutor(executor);
    return executor;
}

Thanks to Moran, a fellow GigaSpaceyan for creating such a clean implementation.

Comments are welcomed, Enjoy!

Diagnosing OSGi uses conflicts

Rob Harrop — Sat, 22 Nov 2008 15:47:00 CST

In his recent blog entry, Glyn provided an introduction to the OSGi "uses" directive. In this blog, I want to dig a little deeper into the causes of uses constraint violations and present some tips for diagnosing uses problems in your applications. For most of the examples I'm going to be using raw Equinox and not [...]

JarAnalyzer in Google Code

Kirk Knoernschild — Thu, 20 Nov 2008 11:01:00 CST

JarAnalyzer now has it’s own Google Code location. You can browse the source code online, check the source code out, and do all of the other exciting things that you can do with a subversion repository. The source in the google code repository is the same as can be found at the JarAnalyzer homepage (which is also where the binary is still found), except that the Google Code location also contains the JarAnalyzer XSLT.

Eventually, I hope to move the documentation over to the Google repository. Yeah…right! Update the documentation? I don’t think so!

I’m on Twitter

Kirk Knoernschild — Wed, 19 Nov 2008 21:06:00 CST

I’ve jumped on the Twitter bandwagon. Possibly a little slow, but better late than never. I’ve started following a few people, and so far I find it fun and interesting. I intend to post mostly on tech stuff. I’ve also included my tweet feed on the right sidebar of this blog. Or you can subscribe to my tweet feed separately. Or you can start following me now! You decide.

SpringOne Americas 2008

David Winterfeldt — Wed, 19 Nov 2008 16:25:02 CST

I'm presenting this year at SpringOne Americas 2008. I'm really looking forward to it and have been working on examples and the slides for the conference. That's why I haven't posted much lately. I'll be presenting a Case Study of my investigation of GWT, Comet, and Bayeux integration with Spring for developing a trade monitor. I'll be posting the examples soon and will also write about them, but the slides will just be for those that the attend the conference. It should be a very good conference. I really enjoyed it last year. It's one of the more technical conferences I've been to.

Speaker Profile

OSGi interest via MarkMail

Kirk Knoernschild — Wed, 19 Nov 2008 08:39:00 CST

An image I swiped from MarkMail showing the increase in OSGi related posts on various mailing lists. No surprise that the most popular lists are Felix Dev and Spring-OSGi. The traffic shows the rise in interest in OSGi the past couple of years. Again, no surprise. It does appear, however, that most of the posts are closely tied to development of OSGi products (like Felix and Spring dm) and not from developers leveraging OSGi within their applications. OSGi hasn’t achieved deep enterprise penetration yet, and won’t until we get support from product vendors along with better tooling.