No Fluff Just Stuff

Google Chrome - WebKit update ?

Matthias Wessendorf — Wed, 03 Dec 2008 16:00:03 CST

Today I had to download Google Chrome, to work (verify) a bug. Same issue is present in Safari 3.2.1. Perhaps I should mention that both aren’t using the latest greatest WebKit as its core… So, I gave the nightly a shot… The bug wasn’t reproducibly with the nightly WebKit. Nice.

Since there is a huge G in Chrome… folks want to see fixes in there. Kinda more pressure instead of fixing a “Safari only” bug

This all is fine, sure. But it is interesting that the Chrome browser uses an older WebKit than Safari 3.2.1…

Let’s hope there is an update out soon, that bundles the G browser with the latest, greatest WebKit.

.NET Coffee Break Show on IronRuby and Silverlight

Josh Holmes — Wed, 03 Dec 2008 13:00:07 CST

I was just on a cool webcast called the .NET Coffee Break Show. I did a short show on getting started with IronRuby and Silverlight.

Because the show is supposed to be just 30 minutes or so, I didn't get into my usual preaching about the Ruby programming language or why people should use a dynamic language. Instead I just stated the fact that I really like Ruby and I really like Silverlight and I especially like the combination of the two.

To get started with IronRuby, check out the getting started guide with IronRuby by Justin Etheredge.

Now, it's not absolutely necessary to go through all of those steps to get started with IronRuby in Silverlight. Instead, just download the Silverlight Dynamic Languages SDK. Under the Releases tab, there are a handful of downloads. The one that you want is the one that has "Everything". This includes the languages, samples, quick start templates and more.

Steps to get started:

1. Unzip the SDLSDK into a directory. I put mine in my public downloads directory for ease of access.

2. Open a command prompt, cd to the sdlsdk directory and run the script:

script\sl ruby demo

This will run the template to generate a starter Silverlight application with IronRuby as it's language. You could substitute in python or jscript as well.

3. cd to the directory demo and run the script

..\script\server /b

This will run Chiron and then launch a new browser window pointing to the directory. Chiron will first package up the dynamic language files into the XAP and then host a simple web server.

4. Browse to the index.html file. You should see a simple page with "Welcome to Ruby and Silverlight!" displayed in the Silverlight instance.

5. Under demo/ruby, open the file app.xaml. Alter it as follows:

<UserControl x:Class="System.Windows.Controls.UserControl"
    xmlns="http://schemas.microsoft.com/client/2007"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<Grid x:Name="layout_root" Background="White">
    <TextBlock x:Name="message" FontSize="30" />
    <Button x:Name="button_main"
        Height="30" Width="100"
        HorizontalAlignment="Right"
        VerticalAlignment="Top"
        Margin="0,10,10,0"
        Content="Click"
        />
</Grid>
</UserControl>

6. open the file app.rb. Alter it as follows:

require "silverlight"
class App < SilverlightApplication
use_xaml
def initialize
    message.text = "Welcome to Ruby and Silverlight!"
    button_main.click do |sender, args|
        button_main_click
    end
end
def button_main_click
      message.text = "Hello from the click handler"
end
end
$app = App.new

The "do" in this case is wiring up a .NET delegate as the event handler for click event.

7. refresh the browser (or relaunch via Chiron per step 3 if you closed the browser).

There are a lot of other samples that are out there as well. Check out the ones under the sdlsdk/samples directory. Right now there's a simple clock and a Flickr photoviewer that shows a lot of DOM and JavaScript integration.

You can also find samples at:

http://silverline.schementi.com/

If you want to play with IronRuby or IronPython you can get started playing in the DLRConsole found at http://silverlight.net/samples/sl2/dlrconsole/index.html. All the source for that is under the SDLSDK samples as well.

I'll update the post once they put up the recording - .NET Coffee Break Show

How Evo can help Scrum

Ryan Shriver — Wed, 03 Dec 2008 11:00:08 CST

As you may know, I’m a fan of the principles and practices of the Evo method and Tom Gilb’s work. I got started with XP in 2000, discovered Evo in 2005 and Scrum in the same year. Living in the USA, where Scrum is king, when I get calls to help companies “go agile” or help them “fix agile” because they’re struggling, it’s Scrum we’re talking about.

I like Scrum. I really do. I’ve got my CSM from Cohn and Schwaber and teach the method to my clients. From a project management perspective, I think it’s better than XP. This is primarily due to better defined roles and responsibilities. It does have some areas that I think could be improved, such as business value, requirements, design and development practices. It is purposefully silent on these areas, letting teams “inspect and adapt” and figure things out on their own. In my experience, while some teams can figure things out and thrive, others struggle and need more direction.

Working with the Tom and Kai for the last 3 years, I’m gradually convincing them that Evo + Scrum is much more marketable and realistic than marketing Evo as an alternative to Scrum. Scrum has a large market share, an extensive training network and companies have spent hundreds of millions of dollars on Scrum adoption. Scrum isn’t going away anytime soon. Evo can’t beat ‘em, it might as well join ‘em.

With that said, I do believe that Scrum could benefit from Evo principles and practices and the two can work well together. Tom recently asked me to put together a set of Evo practices that could benefit Scrum and here are my Top 3. I think these could be added to the Scrum method, without fundamentally changing it, and benefit the Scrum community. These practices address specific issues I’ve seen in practice with the Scrum teams and organizations I’ve coached.

So, what do you think? Would these help or not?

1. Solving the Right Problem
Evo can help organizations focus on solving the “right problem” and not just solving the “problem right”. Scrum makes an assumption that the product/project you’re working on is the right for the organization to do now. It doesn’t validate this assumption within the methodology; it just focuses on building features in the right order and assumes a business case was done in advance.
Benefits: If Scrum were to adopt Evo’s approach to identifying and prioritizing stakeholder objectives, and quantifying these before starting projects, then Scrum projects could:
1. Ensure they’re focused on solving the right business problem now
2. Measure progress towards achieving business objectives, as defined by stakeholders
3. Ensure resources are being spent on projects with the best ROI (using impact estimation to guide this process).

2. Measurable Business Value
Evo can help organizations define value through the use of measurable business objectives. Scrum makes the assumption that more “stories” or “features” equals more value. CHAOS report says that ~60% of all features are rarely or never used, so a feature-centric approach to software systems is fundamentally flawed. If Scrum wants to measure “value to the organization”, it needs to rise above the feature-level and figure out how to measure the value it is delivering to organizations. The Scrum world is desperate for a way to measure value (an entire track at Agile 2008 was dedicated to this topic). The agile community can’t agree upon a way to do it and Evo can help.
Benefits: If Scrum had a defined way to measure value using Evo practices it could:
1. Show “progress to objectives” to the business in units other than velocity (pace of team) and number of features built. It could also show value with respect to resources consumed using impact estimation.
2. Help business better spend resources due to incremental funding based on real business results, not just features built. Value could be measured each Sprint (every 2-4 weeks) and stakeholders could make funding decisions based on this.
3. Get teams to focus on satisfying the top stakeholders who are paying for the system, not just the user interface features of the people who use the system to do their job.
4. Help organizations compare Scrum projects in terms of value delivered. Currently there’s no way of comparing Scrum projects to see which one delivered the most value. This could enable better portfolio management.

3. Measurable System Qualities
Evo can help Scrum teams identify and quantify system qualities and document these using Planguage. It can also help teams identify design ideas and use impact estimation to assess how design ideas impact system qualities. Scrum has no mechanism for identifying, specifying and measuring system qualities. User stories handle functional requirements and have testable acceptance criteria, so theoretically we could specify qualities as acceptance criteria. The issue is this level is too low and doesn’t raise qualities to the level of stakeholders who must pay for qualities but rarely review user stories. Qualities like Availability and Recoverability have far-reaching impacts to costs, schedules and the architecture of the system and need attention at the highest levels - they can’t be buried in acceptance criteria of user stories.
Benefits: If Scrum had a way to quantify system qualities using Evo practices it could:
1. Be more adaptable to very large and complex systems (thousands of stories)
Help the analysts, architects and testers think about and negotiate system qualities early in the process, not just focus on building features
Save organizations resources and reduce delivery risk because qualities could be designed in from the start, as opposed to refactored in later when teams “discover” the system doesn’t meet these.

SpringOne - Days 1 and 2

Greg Turnquist — Wed, 03 Dec 2008 08:00:09 CST

I finally found some time to post updates. Whew! It has been busy!

Day 1
================================
On Monday, I hooked up with the SpringSource guys. It seems everyone had something to work on. I wanted to get 0.9.0 completed and working before giving my demo of PetClinic on Thursday. Just about anyone I spoke to was polishing up their slides. It is truly fantastic to be chatting with the guys at SpringSource.

Rod Johnson gave the keynote addresss, focusing on the target goal of SpringSource in reducing the complexity of application development. Complexity means more development, more risk, and in turn, more cost. SpringSource's overarching goal of reducing complexity must be working, because he had several metrics showing how much has been adopted in some degree by the industry.

After the keynote, I was finally able to meet up with Keith Donald. We have been playing email tag for some time, and I was surprised to find out his office is probably 10 minutes away from mine. Hopefully we can get together soon after the conference. It was also great to meet Mark Pollack, Chris Beams, Ben Alex, and of course, Rod Johnson himself. While I enjoy reading their blog entries and source code, there is no substitute for meeting the real person.

Day 2
================================
In the morning, I attended the Grail presentation. That was awesome. Grahame demonstrated building a twitter-like site using Grails in 40 minutes. Okay, he promised 40 minutes, and took 45 minutes, but only because he started adding extra functionality not found at the actual twitter site. In the process, I was realizing the value Grails places on plugins. Grails is good at creating a skeleton application, and then letting you flesh it out. I was starting to get the idea that Spring Python could use a command line utility with plugins to generate a skeleton CherryPy app, Django app, or anything else developed by a plugin. Well, I went to the next session, "Intro to Spring Security 2.5", opened my laptop, and started coding. I managed to write a static skeleton app, and then began working on a command-line utility to dynamically generate this. That is still in progress.

I admit I was only listening with one ear to Ben's presentation. Sorry Ben! 1) I am already somewhat familiar with Spring Security, 2) most of it is geared towards web apps which I don't write, and 3) I was really stoked at the idea of a command-line tool that download Spring Python plugins from a network location. I did catch his question, "who here is NOT writing web apps?" I was the only person in the room who raised a hand to that. When asked what I was using, I answered "Swing desktop apps." That plugged Ben's point that Spring Security uses the same tactics.

After lunch, I attend two sessions about Spring Integration. This is channel based messaging, which is sort of like JMS on steroids in my book. They interface with JMS, but also with other things like file-based systems, web services, RMI, anything. And it is easy to plug in your non-message based service to a chain of processing. This is wiring your app in a different, more decoupled way. I sure could have used this about five years ago.

Later that evening, Russ and I got together to work on his Spring Extensions presentation. Russ is planning to talk about the process Spring has set up to better manage new code, and wanted to compare the process with real life, and Spring Python is his choice target. If you are at SpringOne and can read this before Thursday, I highly suggest you attend that presentation. It will definitely be entertaining (shameless plug).

Original post blogged on Spring Python's blog site.

Rich editor is coming to RichFaces

Max Katz — Tue, 02 Dec 2008 16:00:04 CST

rich:editor is one of the new components in RichFaces 3.3.0 (December 2009) . It’s based on tinyMCE.

GroovyMag #2 is out

Andres Almiray — Tue, 02 Dec 2008 13:00:07 CST

Issue #2 of GroovyMag is out, go get your copy!

On this issue

Christopher Judd guides you through iPhone app development with Grails and the iUI plugin.
Shawn Harstock writes about GORM's architecture and its possibilities.
Dave Klein gives the scoop on recent Groovy/Grails news, also demonstrates the new batch of Grails' testing facilities.
Michael Kimsal delivers another interview with a live Grails customer in the wild.
Yours truly continues the Building Rich Applications with Groovy series, laying the ground for Griffon.
and more!

Keep on Groovying!

Tweeting SpringOne

Craig Walls — Tue, 02 Dec 2008 11:00:09 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 08:00:11 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:

Spring Python 0.9.0 is released

Greg Turnquist — Mon, 01 Dec 2008 16:00:04 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 13:00:10 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.

JSF 2.0 Public Review is online

Jason Lee — Mon, 01 Dec 2008 11:00:06 CST

Welcome to SpringOne

Greg Turnquist — Mon, 01 Dec 2008 08:00:07 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.

SpringOne 2.2.1 Release Available

Christian Dupuis — Sun, 30 Nov 2008 08:00:05 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.

Get Comfortable Being Uncomfortable

Scott Leberknight — Sat, 29 Nov 2008 16:00:02 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.

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

Billy Newport — Sat, 29 Nov 2008 13:00:08 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.

JMM and final field freeze

Alex Miller — Sat, 29 Nov 2008 11:00:09 CST

Internally, someone had this question yesterday:

And the question is:

The map is never mutated after construction. The field is declared final. Are the read methods thread-safe and guaranteed to show you the map with all values? If not, is an additional memory barrier required to guarantee this?

I think pretty much everyone agreed that readers are guaranteed to see the map instance but there was some question about whether the puts to the map during init() can be reordered such that they are not thread-safe with respect to the get()s.

After many folks weighed in, the consensus is that yes, the reads are definitely thread-safe even in the absence of an additional memory barrier.

One goal of JSR 133 (which defines the Java Memory Model) is to preserve initialization safety. The JSR 133 FAQ says:

If an object is properly constructed (which means that references to it do not escape during construction), then all threads which see a reference to that object will also see the values for its final fields that were set in the constructor, without the need for synchronization.

I think that’s a pretty good summary of the intent. The concept of whether changes to final fields are visible at end of construction is explicitly talked about in the memory model semantics paper as well in the section on “informal semantics of final fields”:

F1 When a ﬁnal ﬁeld is read, the value read is the value assigned in the constructor.

F2 Assume thread T1 assigns a value to a ﬁnal ﬁeld f of ob ject X deﬁned in class C. Assume that T1 does not allow any other thread to load a reference to X until after the C constructor for X has terminated. Thread T2 then reads ﬁeld f of X. Any writes done by T1 before the class C constructor for ob ject X terminates are guaranteed to be ordered before and visible to any
reads done by T2 that are derived from the read of f.

Java Concurrency in Practice also mentions this in section 16.3:

Initialization safety guarantees that for *properly constructed* objects, all threads will see the correct values of final fields that were set by the constructor, regardless of how the object is published. Further, any variables that can be *reached* through a final field of a properly constructed object (such as the elements of a final array or the contents of a HashMap referenced by a final field) are also guaranteed to be visible to other threads.

For objects with final fields, initialization safety prohibits reordering any part of construction with the initial load of a reference to that object. All writes to final fields made by the constructor, as well as to any variables reachable through those fields, become “frozen” when the constructor completes, and any thread that obtains a reference to that object is guaranteed to see a value that is at least as up to date as the frozen value. Writes that initialize variables reachable through final fields are not reordered with operations following the post-construction freeze.

I find the formal definition of the final field freeze semantics to be fairly impenetrable, so I’ll just trust that they say formally what is stated informally above.

Final fields are ever so important and useful. Whenever possible, strive to make your fields final. One tip for this is to enable a Save Action in Eclipse (or your IDE of choice) that automatically attempts to make fields final if possible so you can’t forget!

NetBeans 6.5, Python Support, and Mac OS X

Jason Lee — Sat, 29 Nov 2008 08:00:08 CST

RichFaces - filtering with custom function

Max Katz — Fri, 28 Nov 2008 16:00:04 CST

In my previous post, I have shown how to use built-in filtering in RichFaces. The basic filtering uses startsWith() method to filter. This is fine but you might have a situation where you need to write your own custom filtering method.

To keep things simple, let’s apply custom filtering to Name column only. For Location column we will keep the standard filtering.

<h:form>
   <rich:dataTable value="#{wondersBean.sevenNewWonders}" var="wonder"
      id="table">
      <rich:column filterMethod="#{wondersBean.filterWonders}">
         <f:facet name="header">
            Name
	     <h:panelGroup>
	        <h:outputText value="Name" />
		<br />
		<h:inputText value="#{wondersBean.filterValue}" id="input">
		   <a4j:support event="onkeyup" ignoreDupResponses="true"
			 requestDelay="700" reRender="table" focus="input" />
		</h:inputText>
	     </h:panelGroup>
	 </f:facet>
	 <h:outputText value="#{wonder.name}" />
      </rich:column>
      <rich:column filterBy="#{wonder.location}" filterEvent="onblur">
          <f:facet name="header">Location</f:facet>
	  <h:outputText value="#{wonder.location}" />
       </rich:column>
       <rich:column>
	   <f:facet name="header">Image</f:facet>
	   <h:graphicImage url="#{wonder.imageUrl}" />
       </rich:column>
   </rich:dataTable>
</h:form>

Most of the stuff happening inside the first rich:column tag starting at line #4. First I define the actual custom filtering method via filterMethod attribute. I will come back to is shortly. The rest is just an input field with a4j:support with onkeyup event. One the filtering is done, we return the focus to input field with focus attribute.

The changes to managed bean are minor. We have to add the filtering method and the filterValue property (this property holds the value we enter on the page).

...
private String filterValue = "";
// getter and setter method for filterValue
 
public boolean filterWonders(Object current) {
   Wonder currentWonder = (Wonder)current;
   if (filterValue.length()==0) {
      return true;
   }
   if (currentWonder.getName().startsWith(filterValue)) {
      return true;
   } 
   else {
	return false; 
   }
}
...

The method returns boolean value. The value entered from the page is checked against each value in the list. Value of true means include the current object in the filtering result. The filterWonders is not much different from using the built-in starsWith() method, however, you are free to add more interesting filtering in this method as you see fit. One thing different is that the method requires exact case. In other words, entering ‘A’ or ‘a’ is not the same. This is just to show you to get setup custom filtering.

An alternative approach is to use filterExpression instead of filterMethod. It basically works the same way. It has to evaluate to either true or false. true means the value is included in the filtering result.

<rich:column filterExpression="#{..}">
...
</rich:column>

What's Next

Matt Raible — Fri, 28 Nov 2008 13:00:10 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.

Avoiding “Open Source” with JSF and Facelets

Matthias Wessendorf — Fri, 28 Nov 2008 11:00:03 CST

When using Facelets it is normal to use XHTML files to describe the view. Also in your web.xml configuration mostly you find a mapping of the FacesServlet to something like “/faces/*” or “*.faces”, so that you have URLs like:

http://myserver:port/context/coolPage.faces (or .jsf)

Now, it is easy to view the source code of the page, when the application is written with Facelets’ XHTML files. Just do the following:

http://myserver:port/context/coolPage.xhtml

You now see the page structure, what libraries are used etc. This type of “Open source” you definitely want to avoid, when using Facelets. You could write a security filter or something similar, but the soultion could be really really simple.

Use the following servlet-mapping in your web.xml:


...
  <servlet-mapping>
    <servlet-name>faces</servlet-name>
    <url-pattern>*.xhtml</url-pattern>
  </servlet-mapping>
...

No more “Open Source” of your Facelets application