Out of my Mind...

Links for 2010-02-09 [del.icio.us]

2010-02-10T00:00:00-08:00

5 Reasons Why Agile Development Must Be Driven from the Top

The Case of the False Blank

2009-12-28T21:43:00.001-07:00

Stu Halloway tweeted about the following Pastie earlier today:

He questioned the counterintuitive result of blank? returning false on an empty Java array. He then asked which whether Ruby, JRuby or Rails were the culprit.

I played with the Rails console a little bit and started to dig into the code. It turns out that Rails adds a blank? method to the Ruby Object class. Here is it's implementation:

It also aliases blank? to empty? on arrays further down. As a result, the expected behavior of calling blank? on an empty array is to return true:

The Java array does not respond to the empty? method:

We can see that the Java native array does not share the same ancestry as the Ruby Array:

None of the classes and modules returned by x.class.ancestors implement the empty? method. Rails has no choice to fall back to the default implementation and to return false to blank? since any instantiated object isn't nil by definition (except for nil, which is always nil).

The real culprit here isn't Ruby as Stu alluded in a later tweet. Rather, it is the lack of an empty? implementation on the Java native array class ancestry that is the root cause of the surprising behavior. The best fix would be to implement the empty? method on the ArrayJavaProxy class to Rails could call it.

Application Performance Improvement Is an Iterative Process

2009-10-09T09:48:00.001-06:00

My first mandate when I joined Project Kenai was to improve it's performance. Kenai wasn't known for being speedy back then. We had some serious performance issues with both page rendering in the browser as well as generating the content on the server side.

I had work on projects before were performance testing (and the resulting avalanche of bug reports from it) were held off until the QA phase of the project. A small team of QA engineers would write scripts that exercised the application to get performance data and generate information on where things were slow. I had a few issues with this approach:

The testing almost always occurred near the end of a release. Many of the performance issues discovered in this process could not be fully resolved in the time frame allocated for the release itself. Most were preempted by other feature bugs as well. Performance always seemed to be job 1.0.1
The data never provided information on where the application was spending it's time. This lead to a fair amount of time spent looking at the application code and database queries to see where the hotspot were.
The performance tests occurred based on a static set of features and actions. Each URL would be tested in isolation. There were none of the interactions that occur from multiple users doing different things in the application at the same time.

Doing performance testing was still valuable. It helped us understand where we needed to do more work. It was just too little too late for many projects that I worked on.

I have tried different approaches in the past. I would instrument the application that I worked on to get data, but that was usually done against a development or QA environment. Reading the logs to find the instrumentation data made it difficult to extract valuable information. The instrumentation had a measurable impact on the response time so it was generally turned off in the production deployments.

Performance testing was different with Project Kenai. Kenai uses the NewRelic Rails plugin to get performance data from the application and generates reports that helps understand where the application is spending it's time and what areas could benefit for further investigation. Here is how we normally deal with performance issues:

We use NewRelic to determine what functions are the slowest and have the most impact to our users.
I go through the web site the morning after a deployment to see how the deployment changed the performance of the application.
I schedule one or two performance issues if nothing stands out of the ordinary. Any serious performance degradation takes precedence of course.
I use the development mode to research the performance problem and work toward a solution. My work environment has different performance than our production and staging sites, so I look for relative improvements rather than absolute measurements.
I review the impact of the change in our staging environments. This helps me understand the performance of the application with a full production-like dataset as compared to the developer dataset. Many performance issues only showed themselves when running against a larger dataset than what was available to me in my development environment.

This cycle allowed the team to continually improve the performance of the application. We still have work to do with regards to performance. Most of the work that is left to do is in areas that are difficult to resolve, but we know where they are and we keep looking for ways to keep improving the performance.

Yes, Developers Should Twitter

2009-08-31T21:52:00.001-06:00

I firmly believe that any developer who doesn't use the different tools available to communicate outside of the bubble that is the people they work with or the company they work for is short changing him (or her) self.

These tools are varied. Twitter is one of them. It is a great way to exchange barbs and keep track of what like-minded (and not so like-minded) developers are doing. It's 140 character format is conductive to bursty exchanges. I certainly enjoy the ongoing conversation that I have with individuals that I respect who happen to hang out on Twitter. The banter might be light at time, but it is still great banter.

It's not the only medium that developers should use though. Developers need to establish an Internet footprint. It is especially critical for those who are working on web applications or infrastructure. Blogging is another tool available to help developers to establish and expand this Internet footprint. Contributing to projects on Project Kenai, GitHub or other project hosting infrastructure is another good way of doing so as well.

Finally, developers should reach out and network locally. It is not a big investment to take an evening each month to head out and attend a local user group meeting. Doing so shows that you do care about your craft and are willing to invest some time in expanding your knowledge. It is even better when you actively participate into the meetings by presenting or actively networking with other professionals.

To participate, whether through Twitter, blogs, projects or users group shows that you care. That alone is often enough for an individual to rise above the vast sea of indifferent developers that are prevalent in the so called real world.

Colorado Spring Open Source Users Presentation

2009-07-28T23:12:00.001-06:00

The Colorado Springs Open Source Users Group record the presentation that are given to their group. Here is the recording that was made of my abbreviated introduction to JRuby:

Basic Concepts - Frederic Jean (Intro to JRuby) from Kevin Werner on Vimeo.

I have yet to watch the whole presentation as I cringe each time I hear me speak.

Configuring Multiple Connection Pools with JRuby MemCache Client

2009-07-28T23:04:00.001-06:00

The JRuby MemCache Client uses Greg Whalin's Java based MemCache client to connect to the servers that implement the MemCache protocol. This client uses a connection pool to connect to and communicate with the memcached servers.

There is one pool by default. It is called "default". You do not need to specify a pool name if you only need one connection pool. This would happen if you only need to talk to a group of servers.

This becomes a little more complicated if you need to communicate with multiple memcached server groups for different purposes. A great example would be using both memcached and Kestrel on the same cluster. This is the situation that we find ourselves under on Project Kenai.

The solution is simple. You can pass a :pool_name parameter when you are building the configuration for the MemCache client:

This results in a separate connection pool being created and allows you to use the JRuby MemCache client to talk to both Kestrel and memcached servers.

When You Make a Big Mistake

2009-07-17T15:43:00.001-06:00

You can just feel the panic rising. You were logged into the production database fixing a few records when you made a small mistake with disastrous consequence.

So what should you do next?

Stop.

Step away from the keyboard.

Breath.

Get help.

Odds are that someone who isn't in a near panic state will be able to think clearly about the problem and guide you through a solution that will reduce or even remove the impact of the incident and help you get things back to their normal state.

Of course, you should really ask yourself why you were in the production database in the first place... But that's another discussion.

JRuby MemCache Client Gem

2009-05-06T11:14:00.000-06:00

I wrote a post about using the jruby_memcache_client Rails plugin to manage sessions. Since then, Abhi Yerra made a fork of Ikai Lan's repository and turned it into a gem. I promptly merged his changes into my repository and I am now publishing my own version of the gem (with a few minor changes).

The new JRuby MemCache Client Gem is API compatible with the Ruby MemCache Client. You should now be able to install the gem into your application and use it directly.

Installing The Gem

You need to add github as a source for gems before you can install the new gem. Thsi is a simple one time command to run:

gem sources -a http://gems.github.com The next step is to install the gem as usual:

jruby -S gem install fredjean-jruby-memcache-client --remote Using the JRuby MemCache Client Gem One way to use the JRuby MemCache Client is to add the following to your environment.rb:

memcache_options = {
:namespace => 'fortaleza:production_live:'
}
memcached_servers = [ ENV['MEMCACHED_LOCATION'] || '127.0.0.1:11211']

# Constant used by libs
CACHE = MemCache.new memcached_servers, memcache_options

You will then be able to configure Rails to use the :mem_cache_store for both session and cache store.

Colorado Springs Introduction to JRuby Talk

2009-05-01T17:45:00.000-06:00

I opened up the Colorado Springs Open Source User Group with a very quick introduction to JRuby. The talk was well received and there was a good back and forth with the audience. Many interesting questions were asked and there were a few follow up discussions. Ben Simo (@QualityFrog) had the following feedback on the presentation:

This is pretty much what any presenter could hope for :)

Here are the slides:

Quick Intro To JRuby

View more presentations from fredjean.

Working on One Thing At A Time With Git-Svn

2009-03-22T23:26:00.000-06:00

We've all seen people who have 2 or 3 work in progress items within a single workspace. Even the workspace owner doesn't always know what file belongs where, nor can they really prove that their change will integrate cleanly with the rest of the code. I see this more often with people that have used centralized source code repositories to manage their code. Branching is expensive and checking out a fresh repository sometimes takes more time than actually fixing the bug. It is tempting to cut a corner here and there to be able to do this quick fix and move back to the task at hand. It is a dangerous thing to do though.

I find that I do my best work when I am working on one item at a time, whether we are talking about a feature or a bug. This is one of the reasons why I like git. It's local branching capabilities makes it easy to do just that while still being able to quickly go back to a clean slate when reality intrudes and I have to switch to a different task.

My Workflow

Project Kenai still hosts its repository in a Subversion repository. I quickly started using git-svn to managed my workspace and I base my daily workflow on Lennon's daily git-svn workflow. Here is how I approach a task:

I make sure that I am at a clean slate and up-to-date. I checkout my master branch (git checkout master) and bring it up to date with the upstream subversion repository (git svn rebase).
I create a branch against the master branch and switch to it (git checkout -b branch-name). I normally name the branch based on the Jira issue that I'm working against. This makes it easy for me to link the work that I'm doing to the related Jira issue. I do not using any of the git svn commands in this branch. I add files to the index and commit frequently as I work as a safety net. It is easier to revert to a previous state that way.
I then switch to my svn merge branch once work has completed. I make sure that it is up to date (git svn rebase) and run our automated tests. This lets me know that I am working against a clean branch. I then merge my changes from the work branch (git merge --squash branch-name). This condenses all of the commits I did in the branch into one commit that will be merged into the svn merge branch, resolve any merge issues and run the tests again.
I commit the merge into the svn merge branch (git commit) and then push my changes to the Subversion repository (git svn dcommit).
I finally go back to the master branch, update it (git svn rebase) and run the tests to make sure that all is working as expected.

It may seem a little involved, but it gives me many points where I have a chance to run tests and verify that the work will integrate cleanly with the rest of the team's work.

When Reality Intrudes

I don't always have the luxury of a linear workflow. there are times where I have to jump to a different work item (critical bug) and work on a fix. The workflow that I use allows me to do this very easily since I can go back to a clean slate at any point in time by:

Committing the work in progress
Going back to the master branch
Updating the master branch
Creating a new branch for the new work
Complete the new work and commit it to the Subversion repository.
Go back to the work in progress branch and resume work

As a result, my workspace always contains the changes associated with one work item. There isn't confusion on what file needs to be committed nor do I run the risk of having multiple patches applied to a single file and having to sort through them manually when it is time to commit.

The good news is that this very same workflow will work just as well if we switch the Project Kenai's repository to git or Mercurial.

MemCache Session Store with JRuby on Rails

2009-02-18T16:05:00.000-07:00

The JRuby MemCache Client Plugin has been replaced by the JRuby MemCache Client Gem. Details can be found at JRuby MemCache Client Gem

We realized a few weeks ago that we spent a fair amount of time writing Project Kenai's sessions to our database. We already had decided to start using fragment caching and we were exploring different options on the client side.

Project Kenai's front end is a Ruby on Rails web application that is deployed to Glassfish and running under JRuby. We do have multiple JRuby runtimes per domain. There are issues with running the Ruby MemCache client with a JRuby on Rails application, so we paid some attention to Ikai Lan's jruby-memcache-client library. It is a wrapper around a Java based MemCache client that support connection pooling back to the memcached servers.

I quickly discovered that Ikai had focused on the Rails cache store but hadn't put work on the session store. I forked his project and started adding support for a session store.

Using the jruby_memcache_client plugin

Here are the steps to install the client:

Run "script/plugin install git://github.com/fredjean/jruby_memcache_client.git" in the root of your Rails application. This will install my forked copy of the plugin.
Configure the MemCache client by following the instructions located at http://wiki.rubyonrails.org/rails/pages/HowtoChangeSessionStore .
Finally, change the config.action_controller.session_store to use :j_mem_cache_store instead of :mem_cache_store

Make sure that you have a memcached server running and start your rails application.

Making sure that it is running

You can verify that the sessions are sent to the MemCache store by restaring memcache with a more verbose setting. You should then be able to see sessions being put into and retrieved from the session store.

Cloud Computing in Plain English

2009-02-10T16:03:00.000-07:00

From WHAT THE HECK IS CLOUD COMPUTING?

I think it does a great job of introducing the concept of Cloud Computing without going into the technical details that makes it tick.

Advice for Uncertain Times

2009-02-10T15:49:00.000-07:00

Here are two things that you can do to help yourself and your career in these uncertain times:

Upgrade your skills. Continuing to educate yourself is going to be key in standing out from the herd and adding value to your current or future employer. Now is a great time to learn a new language or get exposure to a new technology. The best part is that it doesn't have to be expensive. There are plenty of resources that are low cost or even free on the Internet or in books that will give you a head start on upgrading your skills.
Network. Seek out other people in your industry that share similar interests. Find places where great programmers or designers meet in order to exchange information and tips. Don't wait to need a job to network either. It's never too early to establish relationships with individuals outside of your organization or company.

Users Groups in general give you the ability to do both. You do have a chance to meet other individuals that are willing to take some time to learn about technology and to network with other individuals of like mind. They are usually free and will often bribe you to attend with food (Pizza being a favorite around here) or door prizes. Many groups do go out for drinks afterward, extending the networking opportunity.

The Boulder JUG and the Denver JUG are going to host Scott Davis of ThirstyHead.com who will present on Lizard Brain Web Design and how to implement DSLs using Groovy. Make your way down to either meetings, learn a new thing or two and network with some of the brightest and motivated developers in the Denver area.

Groovy Unit Testing Presentation

2009-01-15T08:57:00.000-07:00

I gave a talk on Groovy Unit Testing to the Boulder JUG and the Denver JUG this week. The talk was well received, and I got some helpful comments that I will certainly incorporate into future version of the talk. The talk covered:

How to use Groovy to author JUnit 4 test cases
How to use closure and map coercion to mock dependencies
How to use JMockit to mock classes with final or static methods

I tried something different this time. I used the Codex presentation tool put together by Dave Thomas and Chad Fowler to author the slides. It was a great fit since they are very code heavy. This also allowed me to version the talk and keep a copy of the source up on a github repository. The tool chain generates S5 presentations which can be run in a browser.

The slides themselves are posted on my web site. It certainly doesn't have the same impact as attending the presentation but there's a lot of material available and there are 2 sample NetBeans projects that illustrate the techniques that I presented on.

How to Speak at a Java Users Group

2009-01-13T15:20:00.000-07:00

How do you speak at a local Java Users Group? It's really simple actually...

Pick a topic relevant to the group. Talk to your friendly local coordinator to see whether your topic is appropriate or of interest to the group. It is very likely that the topic is relevant to the group. Some topics may get some overlap which is why it's best to chat about it first.
Prepare your talk. This is actually the harder of speaking at the JUGs. You need to do your research, organize your thoughts and put your presentation together. It is best to start early and do a few practice runs before hand.
Get ready for your talk. I find it best to show up early, hook up to the projector and take the chance to relax a little. It is much easier to present when focused and centered than when rushed. It also allows you to test to make sure that you have access to the relevant sites (if needed), that you can interface to the projector and that the batteries in your remote haven't died yet.
Give your talk. This is the fun part. Present your topic. Interact with the audience, have some fun with them (not at their expense though). Answer questions as they come. You never know when this will lead the talk into an unexpected detour.
Stick around after the talk. Many people will have follow up questions and observations. You might learn something from that conversation.

It's really that simple. You don't have to be The Expert on a topic and you don't have to be a polished public speaker. You just need an interesting topic, some slides and to show up.

BTW, the Boulder Java Users Group is always looking for speakers. You can contact me if you are interested in presenting. We always welcome local speakers.

Groovier Selenium Presentation

2008-12-14T10:20:00.000-07:00

Here are the slides of my Groovier Selenium presentation that I gave at the Boulder JUG, the Denver JUG, the Denver Open Source Users Group and at the Colorado Springs Open Source Software Meetup group:

Groovier Selenium (Djug)

View SlideShare presentation or Upload your own. (tags: groovy selenium)

The presentations went pretty well and were well attended in all the groups. The audience in all the groups were engaged and had great questions that helped reshape the presentation for the follow up groups.

Powell's Endorsement of Obama

2008-10-19T14:36:00.000-06:00

I find this year's election very interesting as a Canadian living in Colorado. I am merely a spectator since I have yet to become an American citizen. Still, I do see this as a pivotal moment in the history of this nation. Americans get to decide what direction they want this country to take.

This morning, Colin Powell publicly endorsed Barack Obama. This in itself is an event in itself. He took time to explain the rationale behind his decision to vote for Obama on Meet the Press on MSNBC.com. Take a few moments to listen through the interview if you haven't already.

His explanation mirrors in many ways my impression of the campaign run by both candidates. It is a thought through, mindful exposition of why Obama is the better choice for President of the United States of America. Powell's rationale is very powerful and in many confirmed why I would vote for Obama if I could.

The Me Meme

2008-10-03T13:49:00.000-06:00

Why not...

Take a picture of yourself right now.
Don’t change your clothes, don’t fix your hair…just take a picture. (should be super-easy with Photobooth)
Post that picture with NO editing.
Post these instructions with your picture.

blog.obiefernandez.com/content/2008/10/the-me-meme.html

Elegant Code

2008-09-24T08:50:00.000-06:00

I spent some time going through the Elegant Code blog after Jared blogged about his latest interview. I was very impressed with the content and added it to my subscription list. I strongly recommend it to anyone who are interested in increasing the elegance and quality of the applications they write.

What I Publish

2008-08-04T12:44:00.000-06:00

Here is what I publish through this blog's RSS feed. It's not bound to what I actually write...
This was created using Wordle and is licensed under a Creative Commons By Attribution License.

What Peeks My Interest

2008-08-04T12:41:00.000-06:00

Generated by Wordle and published under a Creative Common "By Attribution" license.

Back on blogs.sun.com

2008-07-17T15:09:00.000-06:00

I have been back at Sun for almost a year now. Still, there are a few things that I have yet to take care of. Things like unsubscribing from the Sun Alumni Yahoo! group. Or moving my RSS feed back to blogs.sun.com.

Well, one of these things have been taken care of since I am now syndicated on blogs.sun.com instead of alumni.sun.com. It will be interesting to see how this affects my FeedBurner numbers...

Released REM 1.5.0 for NetBeans 6.x

2008-05-30T10:06:00.000-06:00

I just pushed REm 1.5.0 for NetBeans 6.x. This releases adds the following features:

Bundles ZK 3.0.5
Provides basic syntax highlighting for ZHTML files.
Provides basic syntax highlighting for DSP files.

You can download the plugin from Sourceforge.net.

Do You Really Need That Jar File?

2008-05-06T17:31:00.000-06:00

Many Java projects accumulate Jar files. Their numbers just grow until you are not exactly sure why or whether a Jar file is still in use. Traditionally, you answer the question of whether you still need a specific file by removing it from the class path, attempting to build your project, deploying it and seeing whether the application works or not.

Kyrill Alyoshin has released a beta version of his loosejar project. The goal is to determine what jar files are not being used by your application. It does so by analyzing what classes are loaded by which class loader. The result is a report that is presented via JMX or through the console (once the VM is shutdown).

The project is hosted on Google Code and it is released under the Apache Software License v2.0.

Groovy Fizz and Buzz

2008-02-28T05:57:00.000-07:00

The FizzBuzz programming interview question raised it's head again. I've managed to resist the temptation to implement it in any languages so far. Until this morning that is...

So I fired up the Groovy Console and played a little. A nice feature of the console is that it displays a history of the scripts it ran. This allows me to present an evolution of my FizzBuzz program.

I first started with a rather naive implementation:

(1..100).each { 
  def out = "" 
  if ((it % 3) == 0) { out += "Fizz" } 
  if ((it % 5) == 0) { out += "Buzz" } 
  if (out == "" ) { out = it } 
  println out
}

Not bad for something that I came up with in about 10 minutes. It doesn't really take advantage of Groovy's features though. So I refined it a bit by using the ternary operator:

(1..100).each {
  def out = (it % 3) == 0 ? "Fizz" : ""
  out += (it % 5) == 0 ? "Buzz" : ""
  println (out == "" ? it : out)
}

This is a slight improvement over the first version. I still didn't feel that this was Groovy enough for me. I decided to play with the List collect method. This applies a closure to all items in a collection. The first pass was the following code segment:

println ((1..100).collect {
  def out = (it % 3) == 0 ? "Fizz" : ""
  out += (it % 5) == 0 ? "Buzz" : ""
  out == "" ? it : out
})

This ended up printing the list returned by the collect method. Really close, but not quite what I was hoping for. After all, the challenge is to print the results, not quite a string representation of a list. It was easy then to go from the code above to the code below:

(1..100).collect {
  def out = (it % 3) == 0 ? "Fizz" : ""
  out += (it % 5) == 0 ? "Buzz" : ""
  out ?: it
}.each { println it }

This printed the list just like the first pass. It's definitively Groovier (in my opinion) than the original implementation. It still does fall short of the capabilities of Groovy.

So here's my final implementation:

(1..100).collect {
     ((it % 3) == 0 ? "Fizz" : "") << ((it % 5) == 0 ? "Buzz" : "") ?: it
}.each { println it }

This takes full advantage of Groovy's power. It is a little harder to read, which is a downside. It does take full advantage of many of Groovy's powerful features:

A range to generate the list of numbers to process. Ranges return an iterator that iterates from the start of the range to the end of the range.
The collect method which applies a closure to each item in the collection (or iterator) and returns the results as a list.
The each method, which iterates through a list and applies a closure to it. It returns the collection that it iterated through.
Closures, which are implemented quite well in Groovy.
Operator overloading. The << operator is overloaded on the String class to concatenate two Strings together.
The brand new Elvis operator (?:) which returns the alternate value if the expression evaluates to false.
Groovy returns the last expression of a block as the result of the block. This includes closures and methods.

I do think that I'll incorporate this question in future interviews. It has quite a few interesting subtleties and implementations that are only rivaled by the Singleton pattern. I guess that the last group of interviewees got it a little easier...

New Countertops and Sink

2008-01-20T18:02:00.000-07:00

Our old countertops where in really bad shape, and it was driving my wife to insanity (or so she claims). We had done everything we could think of to extend their life. We painted them, we glued the old formica in place. But the paint started to chip and the formica didn't stay glued on very long. So we decided that we had to address the countertop situation.

We remembered passing by a booth at the Flatiron Mall advertising an engineered granite solution by Granite Transformations. It happens that I occasionally drive by their local franchise. We stopped by on a Saturday afternoon, got some information and scheduled an estimate. We did have a little sticker shock at first so we decided to compare other options before going ahead. It turns out that they were competitive with other options from Lowes and Home Depots.

I had to take out the sink before the installation could occur, so we decided to upgrade the sink at the same time.

The installation itself is a two step process. First, a template is built to facilitate the fabrication process. The team showed up right on time for the appointment and created the template. Three days later, they showed up for the installation proper. There was very little demolition involved. The old countertops didn't need to be ripped out since this is an overlay product. They were done right on time for lunch.

I decided to install the sink myself. It did turn into a bit of a saga, like any home improvement projects that I take on. It was promptly resolved once I found the right feed lines for the sink. Within a few hours the sink and new faucets were installed and tested.

My lovely wife is simply in love with the new kitchen and raves about it. I love it too and feel a lot of pride in having installed the sink myself. We are already compiling a list of projects to do next. It never really stops...

Links for 2009-03-30 [del.icio.us]

2009-03-31T00:00:00-07:00

The Ugly American Programmer
English is already the lingua franca of the hacker culture. Being able to understand it and express yourself in it is a basic requirement to be effective as a programmer.

Links for 2009-03-02 [del.icio.us]

2009-03-03T00:00:00-08:00

Comic for March 2, 2009

Links for 2009-02-24 [del.icio.us]

2009-02-25T00:00:00-08:00

Ben Rockwood: LinkedIn Replaced The Resume; or 21st Century Relevance
Your online presence and "searchability" is a big factor when it comes to getting hired to do interesting work. You handicap yourself severely if you aren't active and present on the Internet.

Links for 2009-02-09 [del.icio.us]

2009-02-10T00:00:00-08:00

FOSS Windows
This pretty much fits my opinion...

Links for 2009-02-06 [del.icio.us]

2009-02-07T00:00:00-08:00

Agile Testing: Load Balancing in Amazon EC2 with HAProxy
How to use HAProxy to load balance between multiple EC2 instances.

Links for 2009-02-05 [del.icio.us]

2009-02-06T00:00:00-08:00

Nexus Professional: What is Staging?
While this is obvious marketing, the approach described can be implemented using currently available tools. It does describe one way to decouple development teams and reduce the impact of working with a monolithic code base.
The Canonical Cloud Architecture
Discusses the basic architectural patterns for applications that target the cloud.