One of the most important skills of an effective Program Manager is to inspire a vision.  If you can’t paint a story of a better future, then all bets are off.

Change is tough enough.  People need a good reason.  They need to see a better future in their mind’s-eye.   They need to believe in the challenge and the change.  The cause has to make sense.   And, it needs to inspire.

Sure you can throw facts and figures at people.   For some, this is cause enough or inspiring enough.  For most people, it’s not.   They need something that they can latch on to with their minds and their hearts.  In fact, if you win the heart, the mind follows.

I’ve put together my thoughts on How To Inspire a Vision, based on what I’ve learned as a Program Manager at Microsoft.   Metaphors, stories, and pictures are all powerful ways.   That said, you really need to step into the future and walk various aspects to pressure test your vision, and make it real.  Not just for yourself, but for your various stakeholders and for their various concerns, which will range from innovation to market position to financial impact to insider perception, etc.

If you have a proven practice for articulating your vision in a way that works, I’d love to hear about it.

You Might Also Like

7 Habits of Highly Effective Program Managers

Inspiring a Vision

The Operating Model as a Company Vision

Vision Scope Template

There is a popular quote from George Box about all models are wrong, but some models are useful. This quote is many times used by people suggesting some new or innovative approach to a problem that has been around long time.

While this quote has a pithy ring to it, I'm almost certain those using the quote do so without actually reading the book where is was used.

In the early 1970s econometric models had been constructed for a number of countries using time series data. They were largely static, with responses to  change assumed to take place within one period, irrespective of whether it was a year or a quarter.

The time series models of Box and Jenkins stood in stark contrast to these naive and static models. The Box and Jenkins used a single variable in isolation and dynamics played the central role. A few studies compared the two approaches and concluded that univariate time series models provided the more accurate short-term forecasts.

This was a turning point because it implied that dynamics were more important for understanding short-run movements than economic relationships as then understood. The emphasis in time series econometrics therefore shifted from modelling large simultaneous systems to taking account of dynamic interactions.

Box and Jenkins were influential not so much because what they said was new, but because they said it well. Their contribution was to show how the dynamic properties of observed series could be matched to those of theoretical models. 

The Project Management Point

Models are a critical component of any credible forecast of cost, schedule, and technical performance. Without these models it is actually Guessing as so many critics of estimating are fond of stating. With credible models, forecasting becomes a tool used to increase the probability of project success.

So next time some self-proclaimed person uses Box's quote, ask if they have his book in the shelf and on what page that quote appears.

Related articles Models All models are wrong George Box, the Accidental Statistician

On the recommendation of Mike Jones I’ve been reading through Daniel Kahneman’s Thinking Fast and Slow in which the first part of the book covers our two styles of thinking:

• System 1 – operates automatically and quickly, with little or no effort and no sense of voluntary control.
• System 2 – allocates attention to the effortful mental activities that demand it, including complex computations. The operations of System 2 are often associated with the subjective experience of agency, choice, and concentration.

He then uses a series of stories to explain this in more detail but I found an experiment run by Roy Baumeister the most interesting:

A series of surprising experiments [...] has shown conclusively that all variants of voluntary effort – cognitive, emotional, or physical – draw at least partly on a shared pool of mental energy. Their experiments involve successive rather than simultaneous tasks.

Baumeister’s group has repeatedly found that an effort of will or self control is tiring; if you have had to force yourself to do something, you are less willing or less able to exert self-control when the next challenge comes around.

The phenomenon has been named ego depletion.

This particularly resonates with me as I’ve frequently seen people (including myself) let a series of events involving another person to go by before finally snapping over something seemingly innocuous.

Quite frequently the other person had no idea that the way they were behaving was irritating so the reaction comes as a surprise to them!

We can get around this problem to some extent by providing timely feedback but in order for that to happen I think we need to admit to ourselves when we are frustrated rather than pretending that it doesn’t bother us.

It will probably feel silly to address these innocuous events so early on when we don’t think they’re bothering us that much but I think it’s better than the explosive alternative!

By Patrick Copeland, Google.org

Cross-posted with the Google.org Blog

On June 1st and 2nd, thousands of developers from across the U.S. came together at nearly 100 different locations to participate in the first ever National Day of Civic Hacking. Using public data recently released by the government on topics like crime, health and the environment, developers built new applications that help address social challenges.


At the Googleplex in Mountain View, we hosted nearly 100 developers, statisticians, data scientists, and designers, who stayed long into the night hacking together prototypes that show how data on health and the environment can be used to enrich lives. Fusion Tables and Google App Engine were used to prototype, and groups relied on BigQuery as a workhorse to crunch the biggest datasets. Participants used Google+ Hangouts to connect with hackathons in other states and collaborated with Google Apps and platforms.

Here are a few highlights from the hackathon that stood out as useful, visually stunning, and informative ways to use public data:

• Eat Healthy for Less, the winner of our Mountain View hackathon, is a mobile web application that uses the Consumer Pricing Index to suggest healthy recipes that can be made on a budget.
• Data+, a reimagining of how we access data, can make exploring public datasets more intuitive and easily understandable for everyone.
• Detoxic.org is a web experience and Android app that shows you toxic sites and landfills nearby that you might not know about so that you can take civic action against toxic waste.

Many of the ideas have great potential, and we are encouraging participants to continue their work. We hope that the National Day of Civic Hacking will be a catalyst for innovation in this space, and encourage you to keep track of our tools for civic developers at g.co/civicdevelopers.


Congratulations and thanks to everyone who participated!


Patrick Copeland is director of engineering at Google.org, where he works to build systems that leverage Google's reach to help people around the world.

Posted by Scott Knaster, Editor

All Faces Have A Core Set of Characteristics

I have often heard the line, “I will know Agile when I see it.” While that sounds fairly frightening, there are a number of common characteristics of Agile frameworks and methodologies above and beyond the nod to Agile values and principles. All Agile frameworks and methodologies are iterative, team focused, lightweight and provide continuous or incremental delivery.

Iterative development builds the projects ultimate deliverable in small increments repeating basic steps over and over and over. Barry Beohm’s spiral model defined in 1986 is a classic (non-Agile) instantiation of iterative development.

A second characteristic of Agile frameworks and methodologies is that they are team focused. Agile teams generally are full-time and persist project to project. The longevity of the team makes building relationships in the team worthwhile. Relationships make communication easier. Teams are provided with decision making frameworks to self-organize and to self-manage.

Agile frameworks and methodologies are lightweight.  Agile processes and flows will represent only those that are needed to deliver value and are generally easy to understand and use. Once upon a time in a land far, far away I was a Software Development Life Cycle (SDLC) Fellow for a major software integrator. The development methodology that we maintained was comprised of 14 large three-ring binders. Lightweight software development methodologies have fewer rules and practices.

Agile framework and methods feature continuous or incremental delivery of functionality. Scrum, for example, delivers functionality at the end of every sprint. Kanban (we can argue whether Kanban is Lean or Agile or if there is a difference later) can provide a continuous flow of functionality.  Incremental delivery of functionality provides stakeholders with the time to provide feedback and adjust their requirements much earlier in the flow of a project reducing rework and increasing client satisfaction.

Can you know Agile when you see it?  All of the characteristics we examined, iterative, team focused, lightweight and provide continuous or incremental delivery are a shaped by the values and principles of Agile.  While the list of characteristics in this Daily Process Thoughts is not an exhaustive list of the common characteristics of Agile frameworks or methodologies but they are the most common and most indicative.

 

Note: Our friend and CEO at Crowd Interactive, David Padilla, wrote this great piece about hash lookup in Ruby. Be sure to check out MagmaConf!

Have you ever noticed that in Ruby looking for a specific key-value pair in a Hash is very fast?

Allow me to explain the logic behind hashes in Ruby with a language that you probably understand: Ruby.

Let's imagine for a second that we want to emulate the functionality in hashes because, for some strange reason, they have not been implemented yet.

If we want to have some sort of key-value structure, we'll have to implement it ourselves, so let's get to work.

First, we'll need a Struc to represent a HashEntry, or the key-value objects that we will add to our hashes.

HashEntry = Struct.new(:key, :value)

Now, we'll need a class that represents our Hashes or (to avoid conflicts with the original Hash class) HashTable.

class HashTable
  attr_accessor :bins

  def initialize
    self.bins = []
  end
end

We add the `bins` attribute to the class. `bins` will be an array where we'll store our HashEntry elements.

Now, let's write a method to add a HashEntry to a HashTable. To follow convention, we'll use the traditional `<<` as method name.

class HashTable
  attr_accessor :bins

  def initialize
    self.bins = []
  end

  def <<(entry)
    self.bins << entry
  end
end

Great, now we can add HashEntry elements to our HashTable like so:

entry = HashEntry.new :foo, :bar
table = HashTable.new
table << entry

What if we want to look for an entry by key? Let's write the `[]` method on the HashTable class to handle that.

def [](key)
  self.bins.detect { |entry| entry.key == key }
end

What we're doing here is simply going element by element comparing the given key until we find what we're looking for. Efficient? Let's figure it out.

Benchmarking

We'll use Ruby's benchmarking tools to figure out how much time we're spending looking for elements on our hash tables.

require 'benchmark'

#
# HashTable instance
#
table = HashTable.new

#
# CREATE 1,000,000 entries and add them to the table
#

(1..1000000).each do |i|
  entry = HashEntry.new i.to_s, "bar#{i}"

  table << entry
end

#
# Look for an element at the beginning, middle and end of the HashTable.
# Benchmark it
#
%w(100000 500000 900000).each do |key|
  time = Benchmark.realtime do
    table[key]
  end

  puts "Finding #{key} took #{time * 1000} ms"
end

When we run this benchmark, we get the following results:

Finding 100000 took 33.641 ms
Finding 500000 took 192.678 ms
Finding 900000 took 345.329 ms

What we see here is that lookup times increase depending on the amount of entries and its position within the array or `bins`. This is obviously very inefficient and unacceptable for real life scenarios.

Now, let's see how Ruby tackles this problem internally.

Bins

Instead of using a single array to store all its entries, hashes in Ruby use an array of arrays or "bins".

First, it calculates a unique integer value for each entry. For this example we will use `Object#hash`. Then, Ruby divides this hash integer by the total number of bins and obtains the remainder or modulus. This modulus will be used as the bin index for that specific entry.

When you lookup for a key, you calculate its bin index again using the same algorithm and you look for the corresponding object directly on that bin.

Let's add an attribute on the HashTable class that will determine how many bins each HashTable will have, and we'll initialize it with 500.

class HashTable
  # ...

  attr_accessor :bin_count

  def initialize
    self.bin_count = 500
    self.bins = []
  end

  # ...
end

Now, let's write a method that calculates the bin for a specific entry depending on the number of bins.

class HashTable
  # ...

  def bin_for(key)
    key.hash % self.bin_count
  end

  # ...
end

When storing the HashEntry in the HashTable, we won't just store it on an array, we'll store it on an array that corresponds to the `bins` index depending on what the `bin_for` method returns:

class HashTable
  # ...

  def <<(entry)
    index = bin_for(entry.key)
    self.bins[index] ||= []
    self.bins[index] << entry
  end

  # ...
end

And last, whenever we want to retrieve a HashEntry, we'll recalculate the bin index again using the `bin_for` method and once we have that, we'll know exactly where to look for our entry.

def [](key)
  index = bin_for(key)
  self.bins[index].detect do |entry|
    entry.key == key
  end
end

When we run the same benchmark that we used earlier, we can see times improve dramatically:

Finding 100000 took 0.025 ms
Finding 500000 took 0.094 ms
Finding 900000 took 0.112 ms

Not only did times improve, but we got rid of the variance that we used to have depending on the position of the element in the bin pool.

There's still room for improvement here. Let's add more bins and see what happens.

class HashTable
  # ...

  def initialize
    self.bin_count = 300000
    self.bins = []
  end

  # ...
end

When we run the benchmark we get:

Finding 100000 took 0.014 ms
Finding 500000 took 0.016 ms
Finding 900000 took 0.005 ms

Even more improvement. This mean that the more bins, the less time spent looking for a specific key in a bin.

How many bins does Ruby actually use?

Ruby manages the size of the bins dynamically. It starts with 11 and as soon as one of the bins has 5 or more elements, the bin size is increased and all hash elements are reallocated to their new corresponding bin.

At some point you pay an exponentially increased time penalty while Ruby resizes the bin pool, but if you think about it, its worth the time since this will keep lookup times and memory usage as low as possible.

Further reading

If you want to learn where this algorithm came from and a little more about Ruby internals, I really recommend that you read Pat Shaughnessy's Ruby Under a Microscope book. Pat explains how the Ruby VM works in a way that anyone can understand. No C knowledge required, I really enjoyed reading it.

You can find the working example I used for this example on this gist.

You could also read some of the Rubinius source code. Take a look at their implementation of the Hash class, you'll probably understand a little more of the logic they used after you've read this post and Pat's book.

Thanks for reading.

The post Hash lookup in Ruby, why is it so fast? appeared first on Engine Yard Developer Blog.

I was presenting at the College of Performance Management conference in Florida this week. The topic of credible estimating is always at the top of the list. Here's a phrase that says it all for anyone thinking twice about estimating, not making estimates #NoEstimates, or simply being lazy about how they are estimating

We don't make predictions about the future because we want them to come true. But because we want them to not come true. - Professor Frank Anbari. "Earned Value Project Management Method and Extensions," Project Management Journal, December 2003.

I'll get the attribution from the person who told me this. In the end, to be credible we must manage with our eyes wide open. If you don't have a credible estimate of what it is going to cost, when you are going to be done, and what features you will be able to deliver, in what order, then you'd better find a customer that doesn't really care about those things.

Related articles Probabilistic Cost and Schedule Processes Credible Estimating Processes Measurement of Uncertainty How to be a Master Scheduler

By Pete LePage, Developer Advocate and Boardwalk King

Cross-posted from the Chromium Blog

Last week we launched Roll It, a Chrome Experiment that links phones to computers and gets people out of their chairs and swinging. We wanted to share how we built a physical game experience with no dedicated hardware. It requires just the web, your computer and a phone.

Here’s a look at the APIs and browser-based features we used to create it.


Roll It is a three-dimensional (3D) experience, from the swing of your phone’s accelerometer right up to the virtual models rendered on your computer’s HTML5 Canvas. On the phone side, we hooked into browser events like DeviceOrientation and DeviceMotion to detect the speed and direction of a swing. On the computer side we rendered our scene using Three.js and plugged in Physijs to add physics to the ball and environment.

To sync the phone to the computer we employed WebSockets which enable rapid two-way communication between devices via a central server.

For extra stability we built our backend on Google Cloud Platform:

• Our Google App Engine application, built in Go, dynamically balances users across our relay servers.
• A Google Compute Engine server maintains game state across synced devices.
• Google Cloud Storage speedily serves up the static assets.

We couldn’t have brought this experiment to life without a great team. The theme for Roll It was composed by Mr. Tim Healey. Legwork Studio developed the interfaces and game environment, and teamed up with Mode Set for the development.

To dig deeper into the technology behind Roll It, check out the HTML5 Rocks Case Study, or join the team for a Google Developers Live event this Friday, June 7, 2013 at 5pm GMT for an in-depth discussion.


Pete LePage is a Developer Advocate on the Google Chrome team and helps developers create great web applications and mobile web experiences.

Posted by Scott Knaster, Editor

The more I thought about the idea of walking around, the more I got the feeling that the practice is suboptimal. Years ago I realized that the concept of “being there where the work happens” can be taken a step further. I solved it by picking up my stuff to go and sit with my team, at an ordinary desk, just like everyone else. It might have been the best management decision I ever made, vastly increasing the amount of social time I could enjoy with my team members.

Social time turns out to be deeply critical to team performance, often accounting for more than 50% of positive changes in communication patterns.

- Alex Pentland, “The New Science of Building Great Teams”

After I had moved my desk, whatever happened, I was always around. This allowed me to pick up much more of what was going on, and understand much better what other people cared about. They regularly asked for my opinion, when otherwise they only did this when I happened to be walking around. And I picked up signs of joy and frustration, which I wouldn’t have noticed if I had not been there. This convinced me that MBSA (Management by Sitting Around) can sometimes beat both MBWA and MBFA.

Interestingly enough, not everyone is of the same opinion. Richard Branson, the famous founder and chairman of the Virgin Group, has always practiced the opposite approach. He prefers not to sit with his management teams, because in his view this could inhibit their creativity and self-reliance. Instead, he prefers to leave them to their own devices most of the time, but guarantees regular face-time with everyone by flying around all the time.

But of course, that’s easy to do when you have your own airlines.

This text is part of Personal Maps, a Management 3.0 Workout article. Read more on my mailing list.

The more a man is imbued with the ordered regularity of all events, the firmer becomes his conviction that there is no room left by the side of this ordered regularity for causes of a different nature - Albert Einstein, in Ideas and Opinions, from an address at Princeton Theological Seminary, May 19, 1939.

My film-student daughter is currently working on her fourth movie gig – an indie zombie movie being shot here in Austin. While I admit to really not getting the whole zombie thing, I’m excited that she’s getting so many opportunities to do the work she loves. This time around she is the Production Designer/Art Director. When she started, I wasn’t sure what that would entail, but now that she’s in the midst of the work, I realize that she’s essentially a business analyst. Don’t believe me? Read on….

Project Kick-off:  Before the first meeting with her director (project sponsor) she read through the script and made a list of scenes and locations that she would need to design. Then she met with the director, reviewed this list with him, and ensured that she understood his expectations, budget, and timeframe.

Elicitation:  Next, she met with the other crew members to discover what their requirements were for props and visual design. She also went to the location where filming is to occur to make photographs and measurements and identify what furniture and decorations were already available.

Stakeholder Management & Communication:  She identified that there were some gaps on the crew to perform key tasks, so she found some fellow students who were willing and able to work for free. She identified which ones were reliable and responsive, and is managing those relationships for the director so that he doesn’t have to worry about it.

Requirements Documentation:  Based on what she discovered during elicitation, she planned the decoration of each set and made lists of items that would need to be created by the art team or procured. She estimated the cost of the materials required.

Requirements Validation:  She had the director and other crew members review and approve her plans.

Requirements Management:  As planning for the actual filming continues, there are changes to some sets and locations which she has to accommodate. Right up until filming is complete, she will have to adjust on the fly and still remain within the budget and deliver set designs on time so as not to delay filming.

So…if you think that being a business analyst is all about software, think again. Business analysis skills are applicable to every industry and creative endeavor. Even zombies!

Everybody Loves Zombies! is a post from: http://requirements.seilevel.com/blog

After WWII Toyota started developing its Toyota Production System (TPS); which was identified as ‘Lean’ in the 1990s. Taiichi Ohno, Shigeo Shingo and Eiji Toyoda developed the system between 1948 and 1975. In the myth surrounding the system it was not inspired by the American automotive industry, but from a visit to American supermarkets, Ohno saw the supermarket as model for what he was trying to accomplish in the factor and perfect the Just-in-Time (JIT) production system. While accomplishing this low inventory levels were a key outcome of the TPS, and an important element of the philosophy behind its system is to work intelligently and eliminate waste so that only minimal inventory is needed.

As TPS and Lean have their own principles as outlined by Toyota:

• Long-term Philosophy
• Right process will produce the right results
• Value to organization by developing people
• Solving root problems drives organizational learning

As these principles were summed up and published by Toyota in 2001, by naming it “The Toyota Way 2001”. It consists the above named principles in two key areas: Continuous Improvement, and Respect for People.

The principles for a continuous improvement include establishing a long-term vision, working on challenges, continual innovation, and going to the source of the issue or problem. The principles relating to respect for people include ways of building respect and teamwork. When looking at the ALM all these principles come together in the ‘first time right’ approach already mentioned. And from Toyota’s view they were outlined as followed:

• The right process will produce the right results
  • Create continuous process flow to bring problems to the surface.
  • Use the ‘pull’ system to avoid overproduction (kanban)
  • Level out the workload (heijunka).
  • Build a culture of stopping to fix problems, to get quality right from the first (jidoka)
• Continuously solving root problems drives organizational learning
  • Go and see for yourself to thoroughly understand the situation (Genchi Genbutsu);
  • Make decisions slowly by consensus, thoroughly considering all options (nemawashi); implement decisions rapidly;
  • Become a learning organization through relentless reflection (hansei) and continuous improvement (kaizen).

Let’s do it right now!

As the economy is changing and IT is more common sense throughout ore everyday life the need for good quality software products has never been this high. Software issues create bigger and bigger issues in our lives. Think about trains that cannot ride due to software issues, bank clients that have no access to their bank accounts, and people oversleeping because their alarm app didn’t work on their iPhone. As Capers Jones [Jones, 2011] states in his 2011 study that “software is blamed for more major business problems than any other man-made product” and that “poor quality has become one of the most expensive topics in human history”. The improvement of software quality is a key topic for all industries.

 Right the first time vs jidoka

In both TPS and Lean autonomation or jidoka are used. Autonomation can be described as ‘intelligent autonomation’, it means that when an abnormal situation arises the ‘machine’ stops and fix the abnormality. Autonomation prevents the production of defective products, eliminates overproduction, and focuses attention on understanding the problem and ensuring that it never recurs; a quality control process that applies the following four principles:

• Detect the abnormality.
• Stop.
• Fix or correct the immediate condition.
• Investigate the root cause and install a countermeasure.

Find defects as early as possible

In other words autonomation helps to get quality right the first time perfectly. With IT projects being different from the Toyota car production line, ‘perfectly’ may be a bit too much, but the process around quality assurance should be the same:

• Find the defect.
• Stop.
• Fix or correct the error.
• Investigate the root cause and take countermeasures.

The defect should be found as early as possible to be fixed as early as possible. And as with Lean and TPS the reason behind this is to make it possible to address the identification and correction of defects immediately in the process.

 

Agile is currently the buzz word de-jour in IT departments across the world.  As the frenzy around Agile has built, the definition of the word has Agile has become . .  . fuzzier.  The current level of “buzz” has not appeared instantaneously. Precursors of agile can be tracked into the dark recesses of the 1950’s and 1970’s with a crescendo of light-weight methodology building in the 1990’s that lead to the Agile Manifesto. The Agile Manifesto, developed and signed in 2001, provided a platform to consolidate and link a set of values and principles that defines what Agile is today and guides how Agile is implemented.  I would suggest that the simplest definition of Agile that it is a means of working that embraces the four values and ten principles published in the Agile Manifesto.

There are an unlimited number of frameworks and methodologies, branded and unbranded, that address the Agile values and principles to provide culturally sensitive implementations of Agile.   A quick list some of the popular are Agile frameworks and methodologies include:

1. Scrum
2. Extreme Programming (xP)
3. Agile Unified Process
4. Disciplined Agile Delivery
5. Crystal
6. Dynamic Systems Development Method

The list could easily go on for a number of pages.

As example of the different implementations of Agile values and principles, let’s focus on the principle of delivering working software frequently.  xP delivers software based on a release plan that is fed by short iterations.  Scrum demands that each sprint (iterations) deliver functional software that is potentially releasable.  These are merely examples.  All of these frameworks and methodologies are Agile. Regardless of “how,” each framework or methodology is built to support the Agile values and principles.

The measuring stick for whether any framework or methodology is Agile (since 2001) is how they address the values and principles in the Agile Manifesto. When applying the Agile measuring stick to determine whether a project, framework or methodology is Agile, you need to measure up on all of the Agile values or principles.

The advice to walk around in the organization is often presented under the Japanese name Gemba, which says that one ought to be there where people are working, in order to understand how well they can do their jobs and what they need from you. But you also do it to help solve any problems people might have, using facts and not assumptions.

Other names you may find in literature are Genchi Genbutsu, Go and See, Face-time, and Management By Walking Around. And, in the case of distributed teams, this could easily become Management By Flying Around (MBFA). The practice has more names than His Majesty King Willem-Alexander Claus George Ferdinand, King of the Netherlands, Prince of Orange-Nassau, etc. etc. Therefore you can assume it is pretty important.

Make face-to-face employee contact part of everyday life in your office. The Australian term for it is ‘going walkabout’; many business management consultants call it ‘management by walking around’. Whatever you call it, it works, and if you and your senior staff aren’t doing it, you are missing out on one of the most inexpensive and effective management tools around.

- Richard Branson, Like a Virgin

Some experts suggest that, when moving around the people that are important to you, you should not follow a strict schedule, but you should try and do this randomly. You listen to them, talk to them, consult them, and advise them. At random moments you may decide to attend a team’s planning meeting, stand-up meeting, or demo meeting, or you may catch them near the water cooler. It is important that you do not give the impression you are checking on them, because your aim is better communication and understanding, not better instruction. It’s about managing, not programming. And face-time doesn’t have to focus on just work. Social time (during lunch breaks, near the coffee machine, and after work hours) counts as well.

This text is part of Personal Maps, a Management 3.0 Workout article. Read more on my mailing list.

Posted by Brad Abrams, Product Manager, Google Cloud Platform

Many of the best mobile app experiences are powered by services in the cloud. Top Android developers such as Pulse and SongPop have long taken advantage of the convenience and scalability of Google's cloud platform in their businesses. Now with the Mobile Backend Starter, it's even easier to add cloud services to your apps.

Mobile Backend Starter

Mobile Backend Starter is a one-click deployable, complete mobile backend that allows you to reap the benefits of a cloud backend with none of the headaches. It provides a ready-to-deploy, general purpose cloud backend and a general purpose client-side framework for Android.

Mobile Backend Starter gives you everything you need to rapidly set up a backend for your app, without needing to write any backend code. It includes a server that stores your data with App Engine and a client library and sample app for Android that make it easy to access that data. You can also add support for Google Cloud Messaging (GCM) and continuous queries that notify your app of events you are interested in. To keep user data secure, Mobile Backend Starter also includes built-in support for Google Authentication.

Features of Mobile Backend Starter include:

• Cloud data storage: Users change devices and increasingly use multiple devices. Store any amount of data per user in the cloud to be accessed from anywhere.
• Pub/Sub messaging: Send messages from one device, to any or all other devices. You can easily use 1:1 and 1:many messaging as well as broadcasting. This feature is useful for various applications including social apps, forums, chat, gaming, and group collaborations.
• Push notifications: Data updated on one device is automatically available on all devices with GCM for Android.
• Continuous queries: Create queries that run continuously on the server, automatically feeding updates to the client. These queries are powered by Prospective Search.
• Google authentication and authorization: Keep data isolated per user or shared among users.
• Free to get started, scales with your needs: You can start by handling hundreds of users for free, then grow to any scale.

Quick setup and integration

You can set up and run the Mobile Backend Starter in just few steps:

1. First, go to the Google Cloud Console, and create a project. Then click Deploy.
2. Click on Settings to go to the admin control panel for your new backend. Under Authentication / Authorization, select "Open (for development use only)" and save the changes.
3. Next, download the Android client project and open it up in your Android IDE. Locate the Consts.java file and set the PROJECT_ID to the Project ID of the project you created in the Google Cloud Console.
4. Now just build and run the Android application and you have a cloud enabled Android application.

Check out the complete docs for details on setup as well as information on how to enable authentication, send push notifications, and use standing queries.

The best part is you can download the complete source code of the backend on GitHub and customize it however you want to meet your needs.

See Mobile Backend Starter in action at Google I/O

To see Mobile Backend Starter in action, check out our talk at Google I/O 2013 (embedded below) called "From Nothing to Nirvana in Minutes: Cloud Backend for Your Android Application". The talk shows how to use Mobile Backend Starter to create a new backend server and integrate it with an Android app via Google Cloud Endpoints and the Google Plugin for Eclipse.

We look forward to hearing your questions and learning about the amazing applications you have built. You can find us lurking on the Cloud Endpoints StackOverflow forum.

Join the discussion on

+Android Developers

I'm not sure what I was expecting the stack GOV.UK used at launch to look like. Maybe some messenger owls and lots of cobwebs? But not so at all. So much not so I thought any organization looking at their own stack for ideas could learn something from the considered choices of others.

The diversity of technologies used was surprising. They use "at least five different programming languages, three separate database types, two versions of an operating system." Some may think of this as a weakness, but they think it a strength:

The reason we operate such a diverse ecosystem is that we are focused on solving real problems. Our first task is to understand the problem or need we are solving and then to choose the best tool for the job. If we restrict ourselves to moulding the need to the tools we already have, then we risk not solving the initial problem in the best way possible for the user. By restricting software diversity or enforcing rigid organisational standards on a project, there is a possibility of descending into a cargo cult, where we simply repeat the same patterns and mistakes in everything we make.

This "use the best tool no matter what" policy is outlined in a blog post Benefits of diversity. The only choice that wouldn't be found in a modern startup is the use of Skyscape as their cloud provider. I'm assuming this has to do with legal issues around data sovereignty as this is government site, but otherwise it's all straight out of standard modern web practice: monitoring, dashboards, continuous release, polyglot persistence, distributed source code control, etc. Good to see a government getting it.

What stack are they using? (it's a direct copy so feel free to read the original)

Windows Azure provides a great environment for dev/test.  This is true both for scenarios where you want to dev/test in the cloud and then run the production app in the cloud, as well as for scenarios where you want to dev/test in the cloud and then run the production app using an existing on-premises Windows Server environment.

Windows Azure’s new IaaS and Virtual Networking capabilities make it really easy to enable enterprise development teams to use the cloud to do this.  Using the cloud for dev/test enables development teams to work in a flexible, agile, way without ever being bottlenecked waiting for resources from the IT department.  Development teams can instead use the cloud in a self-service way to spin up or down resources in minutes.  And then when they are ready to deploy their apps they can choose to do so using their existing on-premises servers.  This makes it really easy to start leveraging the cloud even without having to fully bet on it yet for production scenarios.

Today we are announcing a number of enhancements to Windows Azure that make it an even better environment in which to do dev/test:

• No Charge for Stopped VMs
• Pay by the Minute Billing
• MSDN Use Rights now supported on Windows Azure
• Heavily Discounted MSDN Dev/Test Rates
• MSDN Monetary Credits
• Portal Support for Better Tracking MSDN Monetary Credit Usage

Below are details on each of the above improvements.  The combination enables an amazing Dev/Test cloud solution, and an unbeatable offer for all MSDN customers.

No Charge for Stopped VMs

Prior to today, when you stopped a VM on Windows Azure we kept a reserved deployment spot for it inside one of our compute clusters, and continued to bill you for the VM compute unless you explicitly deleted the deployment.  Now, with today’s update, when you stop a VM we no longer charge you any compute time for it while it is stopped – yet we still preserve the deployment state and configuration.  This makes it incredibly easy to stop VMs when you aren’t actively using them to avoid billing charges, and then restart them when you want to use them again.

This is great for a variety of scenarios (including production app scenarios).  It is especially useful for Dev/Test scenarios, though, where you often want to cycle down environments in the evenings or on weekends if they aren’t actively being used.  Now you can do so and not incur any hourly billing fees.

Pay by the Minute Billing

Prior to today, our pricing model for compute resources on Windows Azure billed at the per-hour granularity.  This meant if you ran a VM for 6 minutes in an hour and then turned it off, we would still charge you for a full hour of usage.  Now, with today’s update, we are billing at a per-minute granularity.  So if you run a VM (or Cloud Service, or Web Site, or Mobile Service) for only 6 minutes in an hour, we now only charge you for the actual 6 minutes of compute usage (we pro-rate the hourly price – so the billed price is num_minutes * (hr rate)/60). 

This is great for a variety of scenarios (including production app scenarios).  It is especially useful for Dev/Test scenario where you are often cycling up/down resources in a very elastic way.  Now you can do so and save more money.

MSDN Use Rights now Supported on Windows Azure

Prior to today, it wasn’t (legally) possible to use the dev/test server licenses provided with MSDN subscriptions in a hosted cloud environment.  The product usage rights of the MSDN server licenses didn’t allow them to be used in either our cloud nor anyone else's cloud environment.

Today we are announcing that we are changing the MSDN use-rights so that you can now use your MSDN dev/test software licenses on Windows Azure.  This allows you to install and use your MSDN dev/test server images for SQL Server, SharePoint, BizTalk, etc at no extra charge within Windows Azure VMs.

Heavily Discounted MSDN Dev/Test Rates

In addition to extending MSDN Use-Rights to Windows Azure, we are also today announcing a fantastic new billing rate for customers who have MSDN subscriptions.  You can now spin up any number of Windows Server, SQL Server, SharePoint Server, and BizTalk Server VMs for Dev/Test scenarios using Windows Azure and pay only 6 cents/hr when running them (or if you run them less than an hour the pro-rated per-minute equivalent).

This enables you to yield massive cost savings for Dev/Test scenarios compared to any other cloud option in the market:

The above savings are available to all MSDN customers – and can applied to any number of Windows Server VMs being used for Dev/Test purposes.  We will automatically apply these savings when you create a VM using one of the standard VM images in the Windows Azure VM Gallery (either through the portal or command-line options like PowerShell) and run it using a new Windows Azure MSDN Subscription.

MSDN Monthly Monetary Credits

We are making the above discounted rates even more compelling by also giving every MSDN subscriber up to $150 per month of monetary credits that can be used to run any Windows Azure resource for Dev/Test purposes.  MSDN Professional Subscribers will be provided with $50/month, MSDN Premium Subscribers with $100/month, and MSDN Ultimate Subscribers with $150/month.

These monetary credits can be applied towards any Windows Azure resource being used for Dev/Test purposes.  This includes: Virtual Machines (both Windows and Linux), SQL Databases, Cloud Services, Web Sites, Mobile Services, Hadoop Clusters, BizTalk Services, Storage, Media and more.  The previous per-unit restrictions in place with the old MSDN offer are also being removed – instead you now have a monetary credit that can be applied and mixed/matched on resources however you want.

Below are just a few examples of how a MSDN Premium customer (who will now gets $100/month of credits with their MSDN subscription) could use the monetary credit:

1) A MSDN Premium subscriber can now run 3 Windows Server VMs for 16 hours a day (at 6 cents/hr) every day of the month.  And he or she can run SQL Server Enterprise, BizTalk Server, or SharePoint Server in them using their MSDN use-rights at no additional charge.  And if they ran these 3 VMs for 16 hours a day for 31 days in the month they’d still have $10.32 in credit left over to spend on something else! :-)

2) Alternatively the $100/month credit could be applied towards spinning up 80 Windows Server VMs (with SQL, BizTalk, SharePoint, etc) to use in a load-test for 20 hours:

3) Or the $100 credit could be used to spin up 50 Hadoop cluster nodes for 10 hours of a dev/test MapReduce run:

4) Or the $100 credit could be used to dev/test 100 web-sites with a SQL Database:

The above examples provide just a flavor of the different options now available with this program.  The great thing about the monetary credits is that you can use them with any Windows Azure resource – so you have the flexibility to apply them in whatever combination you want.  The credits themselves reset every month (meaning if you are a MSDN Premium customer the credits will reset to $100/month every month).  So every month you also have the opportunity to change how you allocate them however you want. 

You can optionally choose to pay additional money on top of the monetary credit (meaning if you need $200 of resources in a month, the MSDN Premium Monetary Credit will cover the first $100 of usage and then you can pay the rest).  Note that any overages will still take advantage of the MSDN Discount Rate (meaning the VMs will only be charged at 6 cents/hr) so you still benefit from a major price discount on that as well. 

By default we enable a “spending limit of $0” on MSDN based subscriptions to ensure that customers are never accidentally billed for usage above their MSDN credits.  You can turn this of if you want to use more resources than the built-in credits support and pay for overages.

Portal Support for Better Tracking MSDN Monetary Credit Usage

One of the asks we’ve had in the past from Windows Azure Free Trial and MSDN customers has been for us to enable integrated UI support within the Windows Azure Management Portal that makes it easy for customers to better track where they are with their free credit usage.

Today’s release now makes it easy for Windows Azure customers to track their monetary credit usage.  The top of the Windows Azure Management Portal now includes “Credit Status UI” that enables customers to quickly check their current status:

Clicking the Credit Status UI will display a summary status within the portal that shows how much credit remains (and how many days until the credit will expire):

Clicking the “View More Details” link in the UI above will then take you to a detailed usage page that shows the usage so far during the month, as well as estimated remaining credit based on current usage patterns:

The above support is now available to both MSDN subscription customers as well as those signing up with our Free Trial, and should make it much easier to track free benefit resources.

Summary

The above enhancements make Windows Azure a fantastic environment in which to do dev/test, and an unbeatable option for all MSDN customers.  All of these improvements are now available to start using immediately.

If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using all of the above features today.  If you are a MSDN subscriber make sure to sign-up using the same Microsoft ID (formerly LiveID) that is registered with your MSDN subscription.  The Windows Azure sign-up wizard will then detect that you are a MSDN subscriber and automatically setup a subscription with the above improvements for you to use. 

If you already have an existing MSDN Subscription on Windows Azure you will be automatically migrated to the new benefits above in August.  If you wish to opt-into using the new benefits before August you can visit the accounts center on the www.windowsazure.com web-site, and next to your subscription you’ll find the option to transfer to it earlier.  If you’d prefer to continue using the existing MSDN benefits offer, you can also optionally opt-out of the automatic conversion and elect to continue to use that for the next 12 months.

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

This morning we released some fantastic enhancements to Windows Azure:

• Dev/Test in the Cloud: MSDN Use Rights, Unbeatable MSDN Discount Rates, MSDN Monetary Credits
• BizTalk Services: Great new service for Windows Azure that enables EDI and EAI integration in the cloud
• Per-Minute Billing and No Charge for Stopped VMs: Now only get charged for the exact minutes of compute you use, no compute charges for stopped VMs
• SSL Support with Web Sites: Support for both IP Address and SNI based SSL bindings on custom web-site domains
• Active Directory: Updated directory sync utility, ability to manage Office 365 directory tenants from Windows Azure Management Portal
• Free Trial: More flexible Free Trial offer

There are so many improvements that I’m going to have to write multiple blog posts to cover all of them!  Below is a quick summary of today’s updates at a high-level:

Dev/Test in the Cloud

Windows Azure provides a great environment for dev/test.  This is true both for scenarios where you want to dev/test in the cloud and then run the production app in the cloud, as well as for scenarios where you want to dev/test in the cloud and then run the production app using an existing on-premises server environment.

Windows Azure’s new IaaS and Virtual Networking capabilities make it really easy to enable enterprise development teams to use the cloud to do this.  Using the cloud for dev/test enables development teams to work in a flexible, agile, way without ever being bottlenecked waiting for resources from their IT department.  Development teams can instead use Windows Azure in a self-service way to spin up or down resources in minutes.  And then when they are ready to deploy their apps they can choose to do so either in the cloud or using their existing on-premises servers.  This later option makes it really easy to start leveraging the cloud even without having to fully bet on it yet for production scenarios.

Today we are announcing a number of enhancements to Windows Azure that make it an even better environment in which to do dev/test:

• No Charge for Stopped VMs
• Pay by the Minute Billing
• MSDN Use Rights now supported on Windows Azure
• Heavily Discounted MSDN Dev/Test Rates
• MSDN Monetary Credits
• Portal Support for Better Tracking MSDN Monetary Credit Usage

The combination enables an amazing Dev/Test cloud solution, and an unbeatable offer for all MSDN customers.  Read my detailed blog post on the new Dev/Test offering to learn more.

BizTalk Services

I’m excited to announce a new Windows Azure service we are launching into preview today - Windows Azure BizTalk Services.

Windows Azure BizTalk Services provides Business-to-Business (B2B) and Enterprise Application Integration (EAI) capabilities for cloud and hybrid integration solutions.  It includes built-in support for managing EDI relationships between partners, as well as EAI bridges with on-premises assets – including built-in support for integrating with on-premises SAP, SQL Server, Oracle and Siebel systems.  You can also optionally integrate Windows Azure BizTalk Services with on-premises BizTalk Server deployments – enabling powerful hybrid enterprise solutions.

BizTalk Services runs on a secure, dedicated per tenant, environment that you can provision on demand in a matter of minutes.  It does not require any upfront license, and supports a pay only for what you use billing model.  Click here to learn more about how to setup and starting using the Windows Azure BizTalk Services preview today.

Per Minute Billing and No Charge for Stopped VMs

Prior to today, when you stopped a VM on Windows Azure we kept a reserved deployment spot for it inside one of our compute clusters, and continued to bill you for the VM compute unless you explicitly deleted the deployment.  Now, with today’s update, when you stop a VM we no longer charge you any compute time for it while it is stopped – yet we still preserve the deployment state and configuration.  This makes it incredibly easy to stop VMs when you aren’t actively using them to avoid billing charges, and then restart them when you want to use them again.

Prior to today, our pricing model for compute resources on Windows Azure billed at the per-hour granularity.  This meant if you ran a VM for 6 minutes in an hour and then turned it off, we would still charge you for a full hour of usage.  Now, with today’s update, we are billing at a per-minute granularity.  So if you run a VM (or Cloud Service, or Web Site, or Mobile Service) for only 6 minutes in an hour, we now only charge you for the actual 6 minutes of compute usage (we pro-rate the hourly price – so the billed price is num_minutes * (hr rate)/60). 

These two changes are great for a variety of scenarios.  They are especially useful for scenarios where you are often cycling up/down resources in a very elastic way (for example: Dev/Test or other elastic workloads).  Now you can do so and save more money.

SSL Support with Web Sites

With today’s update, Windows Azure Web Sites now support Secure Sockets Layer (SSL) for custom domains.

SSL encryption is the most commonly used method of securing data sent across the internet, and you can now upload your own SSL Certificate that you can use to enable with custom domains hosted via Windows Azure Web Sites.  With today’s release we now support the ability to setup both IP Address Based SSL Bindings as well as SNI Based SSL Bindings. 

Active Directory: Directory Sync Tool, Manage existing Directories

Today’s update brings a number of improvements to Windows Azure Active Directory. 

Among the more significant updates is a free new directory sync utility that you can download.  It makes it super easy to sync existing on-premises Active Directory deployments with Windows Azure Active Directory.  The directory sync tool works with Windows Server 2003 and above, and enables you to securely sync your directory without having to setup ADFS.  This dramatically simplifies the steps required to enable your directory in the cloud.

Today’s update also includes support to manage an existing Windows Azure Active Directory (such as the one that your organization already uses with Office 365) with a Windows Azure account.  Included as part of this support is the ability to manage an existing Active Directory with a Windows Azure account that is setup using a Microsoft ID account (assuming you have also been made an admin of the active directory tenant).  This makes it even easier to integrate your Windows Azure and Office 365 resources together.

Free Trial

With today’s update we are also updating our Windows Azure Free Trial to provide an even simpler and more flexible free trial experience.

Prior to today, our free trial used to include a fixed quantity of individual resources (for example: 750 compute hours).  We heard feedback from trial users that:

• Trial users had to keep track of usage for each of these resources
• If they went over one of the resource quotas, their subscription was disabled
• Inadequate notifications were given when they were about to exceed their quotas

With today’s release we are making substantial changes to how Windows Azure Free Trials are experienced by customers. With a free trial, you now get a monthly Windows Azure credit of $200. This credit can be applied to any service of your choice. This makes it much easier to try out the services of your choice – and means there are no individual resource quotas on what you can do.  You can instead spend the $200 however and on anything you want.

Both the Windows Azure Management Portal as well as Accounts Center will also now provide built-in UI that lets you know the current status of your remaining Windows Azure Credit balance and the number of days remaining to use your free credit.  This makes it really easy to see what you’ve consumed so far, and how much you have to go before it is all used up. 

Summary

I am really excited about today’s release – there a ton of great new improvements for everyone to take advantage of.  If you don’t already have a Windows Azure account, you can sign-up for a free trial and start using all of the above features today.  Visit the Windows Azure Developer Center to learn more about how to build apps with it.

Hope this helps,

Scott

P.S. In addition to blogging, I am also now using Twitter for quick updates and to share links. Follow me at: twitter.com/scottgu

Podcasts are a passion of mine. I love to listen to them, and I love to create them. But, not unlike writing, what I love even more is thinking about creating podcasts. I’m a natural born procrastinator, but I’m recovering. That is why I’ve volunteered to reboot the Xebia Podcast by Serge Beaumont and Robert van Loghem.

The Xebia KnowledgeCast will be a bi-weekly podcast about software architecture, software development, lean/agile, continuous delivery, and big data. Also, we’ll have some fun with stickies!

In this first episode, Guido Schoonheim explains why he has high hopes for the Xebia KnowledgeCast Reboot, before sending me off in search of content.

Then, Jacqueline Evers shares her views on work-life balance. For some reason, a lot of lean/agile coaches seem to suffer from a lack of it. Why is that? And what can you do about it?

Third up is our first regular section in the Xebia KnowledgeCast: Fun With Stickies by Serge Beaumont. In this episode, Serge talks about the ISAS acronym he uses when coaching lean/agile teams. The acronym stands for Identity, Stability, Autonomy, and Scientific.

Then, DevOps guru Mark van Holsteijn explains the gist of his session on On Demand Infrastructures For Continuous Delivery. According to Mark, we need those infrastructures for something like DevOps to really succeed.

Finally, Olav Maassen shares some information about his new book “Commitment,” a graphic novel about Real Options he wrote with Chris Matts and Chris Geary.

The feed is currently being vetted by Apple. Within a few days you’ll probably be able to find the XKC in iTunes and other podcast directories. Can’t wait? Get the feed now!

Your feedback is appreciated. Please leave your comments in the shownotes. Better yet, use the FiRe field recording app from Audiofile Engineering to send in a voicemessage as an aiff, wav, or flac file so we can put you ON the show!

The jingles used in the Xebia KnowledgeCast are made by audionautix.com.

All interviews are recorded in double mono with a Marantz Pro PMD661 recorder using an AKG D230 dynamic mic or a Rode NTG2 condenser mic on a boompole resulting in a 96.0 kHz, 24-bit wav file. The fun with stickies section is recorded using the FiRe field recording app from Audiofile Engineering and transferred through SoundCloud.

Post production is done on a Macbook Pro using LogicPro with a light voice over filter resulting in a 44.1 kHz, 16-bit mp3 file.

Frameworks, methodologies and systems are tools to create value.  They provide guidance for practitioners.  It is easy to become convinced that you need the newest, shiniest framework, methodology or system.  The means becomes as, or more important, than the end.  While having the right framework is important, in the end, it is the product that gets delivered that is important.

As you begin a project remember that the goal of the project is to deliver value to the organization that is funding the project.  When delivering a project the ends and the means are clearly related, however the means can’t become the goal.  Focusing on the end product, business goal, makes delivering value much more likely.

FYI – The picture today is a close friend’s new brewing system.  The beer is great and that is what really counts!

Note that the Software Process and Measurement Podcast features an interview this week with Bob Ferguson on Product Development  - check it out!