One of the most common questions I get is "Now that I've taken a CSM class, what should I look out for when I return to the office?" While every situation is different, most new ScrumMasters should be aware of the following three issues.

First, remember the values and principles, the why-we-do-what-we-do portion of agile. Without a good set of principles and values, people will often flail because they lack a clear understanding of the why, the meaning behind the practices. 

Common indicators of a failure to grasp the principles behind the agile activities include:

• The team holding weekly "standup" meetings
• Teams not updating their task status on a Scrum board or tool
• Burndowns that are flat and suddenly drop to finish on time
• Not holding grooming meetings

For a refresher on the values and principles, watch my Scrum for Managers video - about the first 20 minutes - and reacquaint yourself with the why of Scrum and agile.

Another common issue has to do with architecture and design. In CSM classes, I discuss design and architecture but I don't go very deep on it. What I do say, however, is...

• Build incrementally
• Grow features over time
• Do the simplest thing possible
• Value feedback over "getting it right the first time"

The one people seem to struggle the most with is breaking the "getting it right the first time" mindset. One of my teams was able to build a system that supported millions of users and put it into production after a month by valuing feedback and throwing away the "getting it right the first time" mindset. How did we do this? Check out this talk from Microsoft TechDays in Sweden in 2011 for more information.

Lastly, many teams lack a clear definition of done. The DoD is a list of sorts that includes the product owner’s and team’s criteria for declaring a product backlog item as potentially shippable, or done. It's important for several reasons.

• It sets a common understanding throughout the organization on what "done" means
• It is a communication tool for stakeholders
• It helps remove technical debt

Creating a DoD is not as easy as it might sound. I have a detailed chapter in my book, The Scrum Field Guide, on this topic - and I have the chapter online as well. Check out how to create your own Definition of Done here.

They say an ounce of prevention is worth a pound of cure—this adage definitely applies to new ScrumMasters and teams. All ScrumMasters will encounter obstacles and challenges as they guide their teams. If you focus on resolving these three issues right away, however, you can avoid many of the common dysfunctions that plague agile efforts.  

By Pete LePage, Chromium team

Cross-posted with the Chromium Blog

You may have seen our recent demo of Racer at Google I/O, and wondered how it was made. So today we wanted to share some of the web technologies that made this Chrome Experiment “street-legal” in a couple of months. Racer was built to show what’s possible on today’s mobile devices using an entirely in-browser experience. The goal was to create a touch-enabled experience that plays out across multiple screens (and speakers). Because it was built for the web, it doesn’t matter if you have a phone or a tablet running Android or iOS, everyone can jump right in and play.
    Racer required two things: speedy pings and a consistent experience across screens. We delivered our minimal 2D vector drawings to each device’s HTML5 Canvas using the Paper.js vector library. Paper.js can handle the path math for our custom race track shapes without getting lapped. To eke out all the frame rate possible on such a large array of devices we rendered the cars as image sprites on a DOM layer above the Canvas, while positioning and rotating them using CSS3’s transform: matrix().

Racer’s sound experience is shared across multiple devices using the Web Audio API (available in latest iOS and Android M28 beta). Each device plays one slice of Giorgio Moroder’s symphony of sound—requiring five devices at once to hear his full composition. A constant ping from the server helps synchronize all device speakers allowing them to bump to one solid beat. Not only is the soundtrack divided across devices, it also reacts to each driver’s movements in real time—the accelerating, coasting, careening, and colliding rebalances the presence of every instrument.

To sync your phones or tablets, we use WebSockets, which enables rapid two-way communication between devices via a central server. WebSocket technology is just the start of what multi-device apps of the future might use. We’re looking forward to when WebRTC data channels—the next generation of speedy Web communication—is supported in the stable channel of Chrome for mobile. Then we’ll be able to deliver experiences like Racer with even lower ping times and without bouncing messages via a central server. Racer’s backend was built on the Google Cloud Platform using the same structure and web tools as another recent Chrome Experiment, Roll It.

To get an even more detailed peek under the hood, we just published two new case studies on our HTML5 Rocks site. Our friends at Plan8 wrote one about the sound engineering and Active Theory wrote one about the front-end build. You can also join the team at Active Theory for a Google Developers Live event this Thursday, June 13, 2013 at 3pm 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 Ashleigh Rentz, Editor Emerita

By Felipe Hoffa, Cloud Platform team

Google BigQuery is designed to make it easy to analyze large amounts of data quickly. Today we announced several updates that give BigQuery the ability to handle arbitrarily large result sets, use window functions for advanced analytics, and cache query results. You are also getting new UI features, larger interactive quotas, and a new convenient tiered pricing scheme. In this post we'll dig further into the technical details of these new features.

Large results

BigQuery is able to process terabytes of data, but until today BigQuery could only output up to 128 MB of compressed data per query. Many of you asked for more and from now on BigQuery will be able to output results as large as the largest tables our customers have ever had.

To get this benefit, you should enable the new "--allow_large_results" flag when issuing a query job, and specify a destination table. All results will be saved to the new specified table (or appended, if the table exists). In the updated web UI these options can be found under the new "Enable Options" menu.

With this feature, you can run big transformations on your tables, plus get big subsets of data to further analyze from the new table.

Analytic functions

BigQuery's power is in the ability to interactively run aggregate queries over terabytes of data, but sometimes counts and averages are not enough. That's why BigQuery also lets you calculate quantiles, variance and standard deviation, as well as other advanced functions.

To make BigQuery even more powerful, today we are adding support for window functions (also known as "analytical functions") for ranking, percentiles, and relative row navigation. These new functions give you different ways to rank results, explore distributions and percentiles, and traverse results without the need for a self join.

To introduce these functions with an advanced example, let's use the dataset we collected from the Data Sensing Lab at Google I/O. With the percentile_cont() function it's easy to get the median temperature over each room:

SELECT percentile_cont(0.5) OVER (PARTITION BY room ORDER BY data) AS median, room
FROM [io_sensor_data.moscone_io13]
WHERE sensortype='temperature'

In this example, each original data row shows the median temperature for each room. To visualize it better, it's a good idea to group all results by room with an outer query:

SELECT MAX(median) AS median, room FROM (
  SELECT percentile_cont(0.5) OVER (PARTITION BY room ORDER BY data) AS median, room
  FROM [io_sensor_data.moscone_io13]
  WHERE sensortype='temperature'
)
GROUP BY room

We can add an additional outer query, to rank the rooms according to which one had the coldest median temperature. We'll use one of the new ranking window functions, dense_rank():

SELECT DENSE_RANK() OVER (ORDER BY median) rank, median, room FROM (
  SELECT MAX(median) AS median, room FROM (
    SELECT percentile_cont(0.5) OVER (PARTITION BY room ORDER BY data) AS median, room
    FROM [io_sensor_data.moscone_io13]
    WHERE sensortype='temperature'
  )
  GROUP BY room
)

We've updated the documentation with descriptions and examples for each of the new window functions. Note that they require the OVER() clause, with an optional PARTITION BY and sometimes required ORDER BY arguments. ORDER BY tells the window function what criteria to use to rank items, while PARTITION BY allows you to define multiple groups to be analyzed independently of each other.

The window functions don't work with the big GROUP EACH BY and JOIN EACH BY operators, but they do work with the traditional GROUP BY and JOIN BY. As a reminder, we announced GROUP EACH BY and JOIN EACH BY last March, to allow large join and group operations.

Query caching

BigQuery now remembers values that you've previously computed, saving you time and the cost of recalculating the query. To maintain privacy, queries are cached on a per-user basis. Cached results are only returned for tables that haven't changed since the last query, or for queries that are not dependent on non-deterministic parameters (such as the current time). Reading cached results is free, but each query still counts against the max number of queries per day quota. Query results are kept cached for 24 hours, on a best effort basis. You can disable query caching with the new flag --use_cache in bq, or "useQueryCache" in the API. This feature is also accessible with the new query options on the BigQuery Web UI.

BigQuery Web UI: Query validator, cost estimator, and abandonment

The BigQuery UI gets even better: You'll get instant information while writing a query if its syntax is valid. If the syntax is not valid, you'll know where the error is. If the syntax is valid, the UI will inform you how much the query would cost to run. This feature is also available with the bq tool and API, using the --dry_run flag.

An additional improvement: When running queries on the UI, previously you had to wait until its completion before starting another one. Now you have the option to abandon it, to start working on the next iteration of the query without waiting for the abandoned one.

Pricing updates

Starting in July, BigQuery pricing becomes more affordable for everyone: Data storage costs are going from $0.12/GB/month to $0.08/GB/month. And if you are a high-volume user, you'll soon be able to opt-in for tiered query pricing, for even better value.

Bigger quota

To support larger workloads we're doubling interactive query quotas for all users, from 200GB + 1 concurrent query, to 400 GB of concurrent queries + 2 additional queries of unlimited size.

These updates make BigQuery a faster, smarter, and even more affordable solution for ad hoc analysis of extremely large datasets. We expect they'll help to scale your projects, and we hope you'll share your use cases with us on Google+.

The BigQuery UI features a collection of public datasets for you to use when trying out these new features. To get started, visit our sign-up page and Quick Start guide. You should take a look at our API docs, and ask questions about BigQuery development on Stack Overflow. Finally, don't forget to give us feedback and join the discussion on our Cloud Platform Developers Google+ page.

Felipe Hoffa has recently joined the Cloud Platform team. He'd love to see the world's data accessible for everyone in BigQuery.

Posted by Ashleigh Rentz, Editor Emerita

If posed with this question, leaders of most organizations will put their own companies into the minority camp that actually measure project success. And in a vast majority of cases, they would be wrong. As I pointed out in a prior post on this topic, there are unfortunately as many ways of measuring success as there are projects being delivered. The lack of a standard way of measuring success results in most organizations not focusing on the one thing that truly matters – “Did the software deliver the targeted dollar returns by way of cost savings and / or revenue increases that were initially planned for?” This is the Seilevel definition of success for commercial software implementation, and one that we are urging the industry to standardize on.

Measuring project success is not the same as evaluating the success or failure of development and delivery of a given piece of software with a set of features. If the software is never delivered or very poorly adopted, then we have an automatic and default measurement – failure. In these cases, it really does not matter whether the organization explicitly measures project success because we know that none of the financial goals will be met by software that never saw the light of day or is barely used. Failed projects are analyzed and either abandoned because they never made business sense to begin with or resurrected for redevelopment. The problem of measuring success then ironically lies with the projects that are actually delivered, deployed and in wide use! By default, we have defined success as the “absence of failure.”

So why then do most organizations not measure true project success – the economic value delivered by the software? Here are the top six reasons based on my observations of working on many large implementations.

1. Lack of Understanding  the Importance of Measurement
The use of the default measure of success – “not a failure” – is largely the result of lack of understanding and a false assumption. The belief is that, if a project is actually delivered and used, by extension, it must have delivered the desired financial returns. This is a dangerous assumption to make and one that is impossible to validate unless measurements are actually made.

2. Lack of Understanding What to Measure
This goes directly to the heart of the problem – most organizations do not use the financial returns generated from a software deployment as the only valid measure of project success. Without this knowledge, most measurements if they are made, do not truly measure success.

3. Lack of Understanding How to Measure
This is a non-trivial problem even for organizations that measure project success by attempting to nail down the financial returns to the business as a result of a software development exercise. Ascribing causality to software, especially when it comes to measured revenue that is impacted by a wide range of external and internal factors, is not easy to do. In a lot of cases the means to measure performance have to be developed before a measurement can even be taken. For example, if a financial target of reducing support costs by $100,000 is predicated on 5,000 problems being solved by an online interactive knowledge base, we must first be able to measure how many problems are actually solved using the online tool in addition to the actual dollars saved. If there is no way to measure the number of problems solved online, it has to be developed in conjunction with the original feature or after the fact to permit measurements and readings to be possible.

4. Not Part of the Development Process
Most good Development Processes I have seen start with some kind of justification for a feature or application – typically in the form of a Cost Benefit Analysis or, if they are using Seilevel Methodology, a Business Objectives Model – and culminate with a Lessons Learned Exercise for future improvement once the software has been delivered and deployed. There is NO formal process step for measuring success at any time after the delivery is completed. Unless success measurement gets baked into the actual business processes around delivering software, they will almost certainly never get done.

5. No Budgets for Success Measurement
In Corporate America, it is not possible to even buy a pencil unless a budget exists for the purpose, the needed funds have been requested and approved, and made available to be spent. In my experience, I have never seen any formal budgets set aside for success measurements. Project Managers will include the personnel needed and an estimate of the time they will spend on a Lessons Learned or Formal Sign Off process step when they create their project plans and budget estimates. There will however never be a budget request in terms of manpower and time needed for project success measurements. If no one is paying for it, trust me, it will never get done.

6. No Person or Team is Responsible for Measuring Success
I do not believe that success measurement is the responsibility of any person, department, or team in either the IT or Business groups of most organizations. It is entirely possible that both IT and Business measure success in their own unique ways once software has been delivered, but it is never done holistically. Unless these measures of success are defined at the beginning of a project and measured systematically at a later time, no meaningful and actionable information will be available to either team once a project is complete. If no specific person or team in an organization is tasked with measurement, it simply will not get done.

The bottom line is that success measurements do not get done because we have a systemic failure. First, most organizations are unaware of the importance of measurement, do not know what to measure or how to measure it. This lack of understanding is clearly manifested in their organizational structure and budgetary actions – no one is responsible for measuring project success or, assuming that there is someone who wants to do it, there is no money to perform the measurements.

Organizations throughout the world spend billions of dollars a year on development projects. Yet no one can tell us if they really got their money’s worth. Is it just me, or is that crazy?

Six Reasons Organizations Don’t Really Measure Project Success is a post from: http://requirements.seilevel.com/blog

A dam releasing water is a release plan in action.

I have been involved with very few projects that did not have to answer the age old questions: “When are you going to deliver?” and “What are you going to deliver?” In standard waterfall projects, we would answer those questions with requirements documents, charters and project schedules. In an Agile project a release plan answers the same what and when questions based organizational vision, project needs and team capabilities.

Organizational vision provides the goals and frameworks that guide product decisions. Goals describe what the organization aspires to and frameworks such as architectures describe the constraints teams operate within.

Project needs, whether they are called user stories, backlog items or just plain requirements describe the business and technical needs the teams develop. Agile recognizes that needs evolve based on experience and business direction therefore release plans will change and need to be iterative.

Project information and team capabilities is reflected in estimates and the team’s velocity or productivity (how much work the team can accomplish per sprint). The size, complexity and team’s ability will influence how fast the team will deliver if the plan is focused on scope or how much the team can deliver if focused on calendar time.

Agile release plans pull together vision, project needs and capabilities together to answer the infamous questions that all project face. What will be delivered and when will it be delivered are not questions that can escape. An Agile release plan is a mechanism for providing an answer to those age old questions.

 

 

In the moral realm there may be 7 deadly sins, but scalability maven Sean Hull has come up Five More Things Deadly to Scalability that when added to his earlier 5 Things That are Toxic to Scalability, make for a numerologically satisfying 10 sins again scalability:

1. Slow Disk I/O – RAID 5 – Multi-tenant EBS. Use RAID 10, it provides  good protection along with good read and write performance. The design of RAID 5 means poor performance and long repair times on failure. On AWS consider Provisioned IOPS as a way around IO bottlenecks.
2. Using the database for Queuing. The database may seem like the perfect place to keep work queues, but under load locking and scanning overhead kills performance. Use specialized products like RabbitMQ and SQS to remove this bottleneck.
3. Using Database for full-text searching. Search seems like another perfect database feature. At scale search doesn't perform well. Use specialized technologies like Solr or Sphinx.
4. Insufficient Caching at all layers. Use memcache between your application and the database. Use a page like cache like Varnish between users and your webserver. Select proper caching options for your html assets.
5. Too much technical debt. Rewrite problem code instead of continually paying a implementation tax for poorly written code. In the long run it pays off.
6. Object Relational Mappers. Create complex queries that hard to optimize and tweak.
7. Synchronous, Serial, Coupled or Locking Processes. Locks are like stop signs, traffic circles keep the traffic flowing. Row level locking is better than table level locking. Use async replication. Use eventual consistency for clusters.
8. One Copy of Your Database. A single database server is a choke point. Create parallel databases and let a driver select between them.
9. Having No Metrics. Visualize what's happening to your system using one of the many monitoring packages.
10. Lack of Feature Flags. Be able to turn off features via a flag so when a spike hits features can be turned off to reduce load.

One of the best books I’ve read lately is, What Keeps Leaders Up at Night, by Nicole Lipkin.  I wrote my review at:

What Keeps Leaders Up at Night

The book is all about how to be at your best, when things are at their worst.

By learning a core set of leadership skills and psychology tools, you equip yourself to deal with the tough stuff, no matter what’s going on.

It covers a huge amount of space in terms of psychology theories, terms and related concepts.   Here’s a sampling: 

Confirmation Bias, Transactional Model of Stress, Social Exchange Theory, Norm of Reciprocity, Extrinsic Motivation, Intrinsic Motivation, Cognitive Dissonance, Group Conformity, Social Identity Theory (SIT), Social Loafing, Collective Effort Model (CEM), Polarization, Groupthink, Shadenfreude.

Lipkin also covers communication styles, stress coping skills, dealing with envy, how to build better group dynamics, how to resolve conflict, how to build better self-perception, how to build constructive core beliefs, and more.

Overall, the book is a great guide on how to keep our cool when things get hot, and Lipkin reminds us that others only see our behavior:

“To paraphrase an old adage, ‘We see ourselves as a combination of our thoughts, fears, and intentions, but others just see our behaviors.’”

Aside from learning how to be more influential, another bonus of the book is that it will help you recognize and label thinking errors and cognitive distortions, which often lead to bad behaviors.

You Might Also Like

7 Habits of Highly Effective Program Managers

10 Free Leadership Tools for Work and Life

Best Leadership Books

Inspire a Vision with Skill

Leadership Development in a Box

I gave a talk last week at Better Software/Agile Development, called Exploding Management Myths. This is my first talk based on some of my management myths. Yes, the ones I’ve been writing for the last 18 months. Yes, I have more in me :-)

I have posted the slides and the audio from my talk at slideshare. I still cannot understand how to properly sync the slides and audio at slideshare. I don’t talk evenly, which is what slideshare expects. I tried to separate the slides and audio. Can’t do that either. Grumble, grumble. However, it’s posted, and if you download the slides and then listen to the audio, you can manually sync the slides and the audio :-)

If you have a favorite myth that I have not yet addressed, please let me know. I will write about it.

I really need help from you. I need a title for the eventual book. Everyone talks about debunking myths, so I don’t think I want to go with debunking. I thought it might be “Exploding Management Myths.” Maybe. Doc List suggested it might be “Blowing Up the Bullshit.” Maybe :-) Do you have ideas for the eventual title for this management book? I would like at least a few more options.

See the management myths on Stickyminds here, and on my site.

As I mentioned in my previous post last week I needed to scan all the jar files included with the neo4j-enterprise gem and I started out by finding out where it’s located on my machine:

$ bundle show neo4j-enterprise
/Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-enterprise-1.8.2-java

I then thought I could get a list of all the jar files using find and pipe it into zipinfo via xargs to get all the file names and then search for HighlyAvailableGraphDatabaseFactory:

Unfortunately when I tried that it didn’t quite work:

$ cd /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-enterprise-1.8.2-java/lib/neo4j-enterprise/jars/
$ find . -iname "*.jar" | xargs zipinfo
caution: filename not matched:  ./lib/neo4j-enterprise/jars/logback-classic-0.9.30.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/logback-core-0.9.30.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/neo4j-backup-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/neo4j-com-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/neo4j-consistency-check-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/neo4j-ha-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/neo4j-udc-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/org.apache.servicemix.bundles.netty-3.2.5.Final_1.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/server-api-1.8.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/slf4j-api-1.6.2.jar
caution: filename not matched:  ./lib/neo4j-enterprise/jars/zookeeper-3.3.2.jar

I switched ‘zipinfo’ to ‘echo’ to see what was going on which resulted in the following output:

$ find . -iname "*.jar" | xargs echo
./log4j-1.2.16.jar ./logback-classic-0.9.30.jar ./logback-core-0.9.30.jar ./neo4j-backup-1.8.2.jar ./neo4j-com-1.8.2.jar ./neo4j-consistency-check-1.8.2.jar ./neo4j-ha-1.8.2.jar ./neo4j-udc-1.8.2.jar ./org.apache.servicemix.bundles.netty-3.2.5.Final_1.jar ./server-api-1.8.2.jar ./slf4j-api-1.6.2.jar ./zookeeper-3.3.2.jar

As I understand it, xargs expects arguments to be separated by a space and I thought it would apply the command to each argument individually but it seemed to be including the space as part of the file name.

I’ve previously used the ‘-n’ flag to xargs to explicitly tell it to call the corresponding command with one argument at a time and that seemed to do the trick:

$ find . -iname "*.jar" | xargs -n1 zipinfo
Archive:  ./log4j-1.2.16.jar   481535 bytes   346 files
-rw----     2.0 fat     3186 bX defN 30-Mar-10 23:25 META-INF/MANIFEST.MF
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/
-rw----     2.0 fat    11366 bl defN 30-Mar-10 23:14 META-INF/LICENSE
-rw----     2.0 fat      160 bl defN 30-Mar-10 23:14 META-INF/NOTICE
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/maven/
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/maven/log4j/
...

Of course to solve this particular we don’t actually need to use find and xargs since we can just call zipinfo with the wildcard match:

$ zipinfo \*.jar
Archive:  log4j-1.2.16.jar   481535 bytes   346 files
-rw----     2.0 fat     3186 bX defN 30-Mar-10 23:25 META-INF/MANIFEST.MF
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/
-rw----     2.0 fat    11366 bl defN 30-Mar-10 23:14 META-INF/LICENSE
-rw----     2.0 fat      160 bl defN 30-Mar-10 23:14 META-INF/NOTICE
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/maven/
-rw----     2.0 fat        0 bl defN 30-Mar-10 23:25 META-INF/maven/log4j/
-rw----    
...

I’m curious why xargs didn’t work as I expected it to though – have I just misremembered its default behaviour or is something weird going on?

Happy Birthday! Time for introspection and cake.

Every day progresses one day at a time, the minute hand of life making an inexorable progression always forward. Once a year, however, the big hand moves forward marking a whole year that has gone by, metaphorically at least. The event is momentous enough that it provides a chance to step back, reappraise the past year and lay plans for the future. Introspection is the act of calmly reviewing one’s thoughts, sorting through the clutter. Events provide a trigger and cut through the noise of day-of-day life.

Most introspection tends to be triggered by events. Abrupt, explosive events like the death of someone close or a major change in life like an involuntary job change can trigger deeper and sometimes darker introspection. Equally, introspection can be triggered by less abrupt events like New Year’s and birthdays. The later set of events facilitate a more reflective form of introspection. The event acting as a catalyst.

Even with an event that shock us into looking at our accomplishments and plans, the noise of day-to-day life normally overwhelms quiet reflective thought. Which is why major events are easier triggers. Occasionally it is appropriate to sit on the patio with a glass of wine or a cup of steaming coffee with your phone and MP3 player off – listening to the wind, watching the sunset and thinking about what has been and what can be.

Twice a year I like to look back on the successes and failures I have been part of and on my plans for future. We live in exciting, thrilling times with all sorts of possibilities. I am another year older and wiser and ready to tackle the world! But first I will listen to my favorite song, eat a slice of cake with ice cream and dream of tomorrow!

Welcome to the Software Process and Measurement Cast 241   

The Software Process and Measurement Cast 241 features my on essay Agile Coaches. Coaches can have a major impact on process implementation and on project success.  What are they? What aren't they? What do they do?

The Software Process and Measurement Cast has a sponsor . . .

As many you know I do at least one webinar for the IT Metrics and Productivtity Intstiute (ITMPI) every year. The ITMPI provides a great service to the IT profession. ITMPI's mission is to pull together the expertise and educational efforts of the world's leading IT thought leaders and to create a single online destination where IT practitioners and executives can meet all of their educational and professional development needs. THe ITMPI offers a premium membership that gives members unlimited free access to 400 PDU accredited webinar recordings, and waives the PDU processing fees on all live and recorded webinars.  The Software Process and Measurement Cast recieves a fee if you sign up this link.  All revenue our sponsors goes for bandwidth, hosting and new cool equipment to create more and better content for you!  Support the SPaMCAST and learn from the ITMPI!

THe Software Process and Measurement Cast is a proud member of the Tech Podcast Network.  Check out the Software Process and Measurement and other great casts like The ElegantWorkflow.Com!  http://ow.ly/lQO1r 

Do you have a Facebook account?  If you do please visit and like the Software Process and Measurement Cast page on Facebook. http://bit.ly/16fBWV

The Daily Process Thoughts is my project designed to deliver a quick daily idea, thought or simple smile to help you become a better change agent. Each day you will get piece of thought provoking text and a picture or hand drawn chart to illustrate the idea being presented. The goal is to deliver every day; rain or shine, in sickness or in health or for better or worse! Check it out at www.tcagley.wordpress.com. 

Shameless Ad for my book! 

Mastering Software Project Management: Best Practices, Tools and Techniques co-authored by Murali Chematuri and myself and published by J. Ross Publishing. We have received unsolicited reviews like the following: "This book will prove that software projects should not be a tedious process, neither for you or your team."

NOW AVAILABLE IN CHINESE! 

Have you bought your copy?

Contact information for the Software Process and Measurement Cast

Email:  spamcastinfo@gmail.com
Voicemail:  +1-206-888-6111
Website: www.spamcast.net
Twitter: www.twitter.com/tcagley
Facebook:  http://bit.ly/16fBWV

Next:

The Software Process and Measurement Cast 242 will feature my interview with Timothy Grayson.Timothy is the author of The Spaces In Between. We discussed discovery and innovation!

neo4.rb is a JRuby gem that allows you to create an embedded neo4j database and last week I was working out how to setup a neo4j 1.8.2 HA cluster using the gem.

There is an example showing how to create a HA cluster using neo4j.rb so I thought I could adapt that to do what I wanted.

I had the following Gemfile:

source 'http://rubygems.org'
 
gem 'neo4j', '2.2.4'
 
gem 'neo4j-community', '1.8.2'
gem 'neo4j-advanced', '1.8.2' 
gem 'neo4j-enterprise', '1.8.2'

And the following code copied from the example to start up the cluster:

require "rubygems"
require "bundler"
require 'fileutils'
require 'neo4j'
 
def start(machine_id)
  # override this default config with this machine configuration
  Neo4j.config['enable_ha'] = true
  Neo4j.config['ha.server_id'] = machine_id
  Neo4j.config['ha.server'] = "localhost:600#{machine_id}"
  Neo4j.config['ha.pull_interval'] = '500ms'
  Neo4j.config['ha.discovery.enabled'] = false
  other_machines = [1,2,3].map{|id| "localhost:500#{id}"}.join(',')
  puts "ha.initial_hosts: #{other_machines}"
  Neo4j.config['ha.initial_hosts'] = other_machines
  Neo4j.config['ha.cluster_server'] = "localhost:500#{machine_id}"
 
  Neo4j.config[:storage_path] = "db/neo#{machine_id}"
  Neo4j.start
end

As per the example’s instructions I started up an irb session and tried to start up an instance:

$ bundle exec install
$ bundle exec irb
irb(main):001:0> require 'myapp'
=> true
irb(main):002:0> start 1
ha.initial_hosts: localhost:5001,localhost:5002,localhost:5003
I, [2013-06-09T17:23:09.110000 #33848]  INFO -- : starting Neo4j in HA mode, machine id: 1 at localhost:6001 db /Users/markhneedham/projects/neo4j-rb-ha/db/neo1
NameError: cannot load Java class org.neo4j.graphdb.factory.HighlyAvailableGraphDatabaseFactory
	from org/jruby/javasupport/JavaClass.java:1225:in `for_name'
	from org/jruby/javasupport/JavaUtilities.java:34:in `get_proxy_class'
	from file:/Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/jruby.jar!/jruby/java/java_package_module_template.rb:4:in `const_missing'
	from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j-core/database.rb:188:in `start_ha_graph_db'
	from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j-core/database.rb:62:in `start'
	from org/jruby/ext/thread/Mutex.java:149:in `synchronize'
	from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j-core/database.rb:53:in `start'
	from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/lib/ruby/gems/shared/gems/neo4j-core-2.2.4-java/lib/neo4j/neo4j.rb:41:in `start'
	from /Users/markhneedham/projects/neo4j-rb-ha/myapp.rb:21:in `start'
	from (irb):2:in `evaluate'
	from org/jruby/RubyKernel.java:1066:in `eval'
	from org/jruby/RubyKernel.java:1392:in `loop'
	from org/jruby/RubyKernel.java:1174:in `catch'
	from org/jruby/RubyKernel.java:1174:in `catch'
	from /Users/markhneedham/.rbenv/versions/jruby-1.7.1/bin/irb:13:in `(root)'

A quick scan of the neo4j code indicated that the class HighlyAvailableGraphDatabaseFactory didn’t actually exist in any of the neo4j 1.8.2 jars and Max then pointed out the neo4j.rb change log which indicated that the clustering example was based around a neo4j 1.9 cluster.

If we want to create a neo4j 1.8 cluster then we need to tweak the settings a bit.

The instructions are available from an earlier revision of the neo4j.rb repository but I’ve cloned the repository and created a 1.8HA tag for future reference.

Essentially we’d need to revert back to the ’2.2.1′ version of the neo4j.rb gem and then run a script to startup some Zookeeper instances before following a similar process as described at the beginning of this post.

Do you consider yourself a good salesman?

If you are like most programmers, you probably don’t.

But have you ever stopped to consider what “selling” and “sales” really are?

Have you ever taken the time to dissect the process of marketing and making a sale and tried to see how it applies to your own life and career?

It’s OK if you haven’t—most people haven’t.

I’m selling you right now

If you’ve made it this far, it is going well for me.  You probably decided to read this article because of the headline I created for it, “The One Thing You Don’t Know How To Do That You Do Every Day.”  Then, the questions I asked in the paragraphs above must have held your interest long enough for you to get to my sub-heading telling you that I am selling you right now.

You see, unless I am actively selling you with my words, you aren’t going to be reading this blog.  And, if you aren’t reading this blog, there really isn’t a point in me writing it.

This may not seem important, but the effects of a good sale are profound; especially when you magnify them by a huge number.

Imagine for a moment that this article lands in mainstream media and is featured on national media outlets—yes, a pipedream, I know, but bear with me for a moment.

What would happen to those ads over there on the right or at the bottom of this article?  How valuable would they suddenly become?

How many people would subscribe to this blog?  How many people would follow me on Twitter or check out the other things I am doing?

The difference between a thousand page views and a million page views is huge!

If I had the ability to “sell” these free words to millions of people each day, even my $0 priced product would have immense value.

When I am writing this blog post, it doesn’t “feel” like I am selling anything, but it is a mistake to think I am not.

I am selling you my ideas, my brand, my name and more.  You are paying me with the single most valuable asset you have… your time.  CHA-CHING!

You’re selling too

You may not think so, but everything you do in your life, every interaction, every word you speak, and even the clothes you wear are all part of one big sale.

It doesn’t even matter what your profession is, even if you are a programmer, you are selling something each and every day.

Take for instance the last conversation you had with your boss or your coworkers about what technology to use or what direction you should take to solve a certain problem.  If you had an opinion at all on what to do, you were in the process of negotiating a sale.  In this case you were selling your ideas.

Even the code you write is selling something.  The code you write should be conveying something about what it does and how it works.  If you can write the code elegantly, the reader of the code might not even be aware of the “selling” taking place.  Great code sells itself, it seems apparent, like there was no other way to write it.  Just like certain tech companies sell their products in a way that seems like they are obvious and your life wouldn’t be complete without them.

(If you lack the elegance of selling your code naturally, you may have to resort to hard sale tactics and add some comments to the code to describe in detail to the user what the code is doing and what its intent is.)

Your sale might not even be successful at all, as your reader may simply delete your code and replace it or ignore it completely.

Your code is also selling something besides meaning and understanding, it is selling your programming skills.  When someone reads code they know you have written, they are making certain judgments about you as a programmer, and even you as a person, believe it or not.

Now, you may not think this amounts to much or is very important—and it may not be—but most sales calls aren’t.  Professional salesman face a lot more “no”s than “yes”es, but for some salesman it only takes a couple of “yes”es to pay their whole years salary.

But it goes far beyond this as well.  Even the subtle things like the clothes you put on in the morning and how you sit in your chair, are influencing people around you and shaping their acceptance of everything you are selling.

What you post on Twitter, even what you like on Facebook, are all either working for or against the image you are trying to sell.

Why selling matters

So, you may be thinking, “ok that’s nice and all, and I kind of agree, but seriously, why should I even care?  So what if I am selling my “ideas” or my “personality” or something else, it doesn’t make a difference to my daily life.”

And that would be where you are wrong.

Do you know those kinds of people which seem to have everything go right for them?

Those people in which opportunity just seems to open its floodgates and rain on them pelting their heads with hailstones of success?

Guess what, most of those kinds of people happen to be excellent salesmen.

You see all those hundreds of sales calls that happen unconsciously every day of your life add up big over time.

If you are consistently “knocking it out of the park,” you are going to make a big impact and have huge amounts of influence.

This “influence,” which is really what sales is all about, will permeate all areas of your life.

If you have a large amount of influence, people will tend to like your ideas and agree with what you say.  They will want to follow you and they’ll be buying into your personal brand and your message, whether it be “save the whales” or “give me a promotion.” (Which is exactly why so many companies hire celebrities to represent their brand or product.)

If you lack influence, you can actually have the opposite effect and create a repulsion.  Think about the worst salesman you ever met.  Did he make you want to buy the products he was selling or did he actually turn you off from them and make you never want to buy those products?

It is the same with us, we can actually become repulsive to the point that we are working completely against ourselves.  We can get in situations where the more we try to promote our ideas or our vision of reality, the further away we actually push others from it.

Even if you are not trying to sell, you have to be good at it

So the bottom line is that we all need to learn how to sell and be better salesman, because even if we aren’t actively trying to sell something, we are still participating in the process of hundreds of sales transactions or more each day.

If we aren’t doing something to help make those sales transactions a positive influence for our interests, we may be inadvertently making them a negative influence.

You can be doing everything else right, but if you are selling wrong, you could be spinning your wheels or even going in reverse.

Now obviously, I’m not the best salesman I could possibly be, otherwise you’d probably be reading this post on the New York Times or CNN.com and not on simpleprogrammer.com, so you shouldn’t turn to me for sales advice.  (I’m just telling you that you need to develop the skill.)

But, I do have a few suggestions of where to get started.

First of all, a book that I always recommend over and over again that doesn’t seem to have anything to do with sales, but in actuality has a lot to do with sales is “How To Win Friends And Influence People” by Dale Carnegie.

And second, the place that makes sense to me to look next is Amazon’s Best Sellers in the Sales and Selling category.  (If you can’t figure out why to check this list, you may need more help than I can provide.)

By the way, I am working on a top secret specifically to help programmers and IT people learn to promote and sell themselves to help them increase their opportunities.

YouTube video for the week

And before I let you go, let me sell you on my YouTube video for the week about getting “punched in the stomach.”

Get Up and CODE: Episode 5, How to get 6-pack abs

And I’ve got one more free thing to sell, my latest podcast episode here:

jQuery(document).ready(function($) { $('#wp_mep_2').mediaelementplayer({ m:1 ,features: ['playpause','current','progress','duration','volume','tracks','fullscreen'] ,audioWidth:400,audioHeight:30 }); });

Follow @jsonmez !function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0],p=/^http:/.test(d.location)?'http':'https';if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src=p+'://platform.twitter.com/widgets.js';fjs.parentNode.insertBefore(js,fjs);}}(document, 'script', 'twitter-wjs');

The post The One Thing You Don’t Know How To Do That You Do Every Day appeared first on Simple Programmer.

Shim has asked a question - a recurring question - about having a PMP. Since everyone is selling all the time - it's part of being human. There are those in the community that encourage a PMP. There are those who oppose the PMP on principles. There are those selling alternatives.

Here's my sales pitch for a PMP

1. If you are willing to read a boring set of study guides, sit for a really boring test that may or may not be applicable to your domain, pay some money, and get a certificate that demonstrates you have “some” level of commitment to learning how to do your job from a broader set of practices — You’ve stated to everyone that you’re not a lone wolf, making things up, creating your own version of how to manage projects, redefining terms and processes and claiming they are applicable to “projects in general.”
2. With that certificate, you’re now connected to a community of others like you. If you don’t like that community, or you disagree with how that community works, then don’t join. Standing on the side of the road being a Blustering Bully about how evil that organization is, or how that organization is somehow not doing it right, is pretty much consider “bitching” here in the US. Get over it and get back to work. Unless you of course are “selling the alternative,” and need to slam the competition as part of your sales strategy. Having an MBA, allows me to understand that is a bad sales tactic and makes you look naive and uninformed about the selling process.
3. No one can connect certification with competency. I have personal experience with my mother-in-law and the misdiagnosis of a brain tumor from a renowned neurosurgeon here in Boulder County. Board certified, head of the department. He was fundamentally incompetent. We went back to Toronto and got a second opinion. She was born with that small mass in her head, get back to work. The symptoms had nothing to do with the mass. Certification does not mean competency in exactly the same way a PhD does not mean anything in the absence of tangible contributions to the professional referenced and acknowledged by peers. I know this from graduate work in Physics. Count the number citations of your thesis in the citation databases to see if anyone on the planet acknowledges your “thesis” (a hypothesis by the way) has been accepted or verified by others. This is the basis of the physics world and it likely the same in all research based PhD’s, including the soft-science domain of project management.
4. Everyone is selling all the time. Test the message the seller is selling against the broader background of your own experience, the experience of trusted others, and the rationality of the message. “You can lose weight in 10 days, with my special diet,” “You can take 6 strokes off your golf game with my special utility wood,” “You can ride much faster on your bike if you only adopt my training program.” You don’t find many used women’s golf clubs in the “play it again” stores, because women know you can’t “buy a game,” so they rarely trade up. You can’t “buy” competency, but a certificate says you are at least trying to understand a few things about the “game.”
5. In the end having more knowledge may not help, but it can't hurt. Being a member of a group with similar background let's you test the question every month - do I have sufficient experience to do my job?

I’ve been playing around with how you might model Premier League managers tenures at different clubs in neo4j and eventually decided on the following model:

The date modelling is based on an approach I first came across in a shutl presentation and is described in more detail in the docs.

I created a dummy data set with some made up appointments and dismissals and then tried to write a query to show me who was the manager for a team on a specific date.

CREATE (year2013 { name: "2013" })
CREATE (january2013 { name: "January" })
CREATE (january012013 { name: "1st" })
CREATE (january022013 { name: "2nd" })
CREATE (january032013 { name: "3rd" })
CREATE (january042013 { name: "4th" })
CREATE (january052013 { name: "5th" })
 
CREATE (chelsea { name: "Chelsea", type: "team" })
CREATE (joseMourinho { name: "Jose Mourinho"})
CREATE (mourinhoChelsea { name: "Mourinho tenure at Chelsea" })
 
CREATE (manUtd { name: "Manchester United", type: "team" })
CREATE (davidMoyes { name: "David Moyes"})
CREATE (davidMoyesUnited { name: "Moyes tenure at Manchester United" })
 
CREATE (year2013)-[:`January`]-(january2013)
CREATE (january2013)-[:`01`]-(january012013)
CREATE (january2013)-[:`02`]-(january022013)
CREATE (january2013)-[:`03`]-(january032013)
CREATE (january2013)-[:`04`]-(january042013)
CREATE (january2013)-[:`05`]-(january052013)
 
CREATE (january012013)-[:NEXT]-(january022013)
CREATE (january022013)-[:NEXT]-(january032013)
CREATE (january032013)-[:NEXT]-(january042013)
CREATE (january042013)-[:NEXT]-(january052013)
 
CREATE (mourinhoChelsea)-[:HIRED_ON {date: "January 1st 2013"}]->(january012013)
CREATE (mourinhoChelsea)-[:MANAGER]->(joseMourinho)
CREATE (mourinhoChelsea)-[:TEAM]->(chelsea)
CREATE (mourinhoChelsea)-[:FIRED_ON]->(january032013)
 
CREATE (davidMoyesUnited)-[:HIRED_ON {date: "January 2nd 2013"}]->(january022013)
CREATE (davidMoyesUnited)-[:MANAGER]->(davidMoyes)
CREATE (davidMoyesUnited)-[:TEAM]->(manUtd)

START team = node:node_auto_index('name:"Chelsea" name:"Manchester United"'), 
      date = node:node_auto_index(name="5th") 
MATCH date<-[:NEXT*0..]-()<-[hire:HIRED_ON]-tenure-[:MANAGER]->manager, 
      tenure-[:TEAM]->team, 
      tenure-[fired?:FIRED_ON]-dateFired
RETURN team.name, manager.name, hire.date, dateFired

The query starts from January 5th, then gets all the previous dates and looks for a ‘HIRED_ON’ relationship and then follows that to get the manager and the team for which it applies to.

We then traverse an optional ‘FIRED_ON’ relationship as well because we don’t want to say a manager is currently at a club if they’ve been fired.

It returns the following:

==> +----------------------------------------------------------------------------------+
==> | team.name           | manager.name    | hire.date          | dateFired           |
==> +----------------------------------------------------------------------------------+
==> | "Manchester United" | "David Moyes"   | "January 2nd 2013" | <null>              |
==> | "Chelsea"           | "Jose Mourinho" | "January 1st 2013" | Node[5]{name:"3rd"} |
==> +----------------------------------------------------------------------------------+
==> 2 rows

In this data set Jose Mourinho gets fired on the 3rd January so Chelsea shouldn’t have a manager on the 5th January.

One way to exclude him is to collect all the dates that our ‘NEXT’ relationship takes us to and then check if the ‘dateFired’ is in that collection. If it is then the manager has been fired and we shouldn’t return them:

START team = node:node_auto_index('name:"Chelsea" name:"Manchester United"'), 
      startDate = node:node_auto_index(name="5th") 
MATCH startDate<-[:NEXT*0..]-day 
WITH team, startDate, COLLECT(day) AS dates 
MATCH startDate<-[:NEXT*0..]-day<-[hire:HIRED_ON]-tenure-[:MANAGER]->manager, 
      tenure-[:TEAM]->team, 
      tenure-[?:FIRED_ON]-dateFired 
WHERE dateFired IS NULL OR NOT dateFired IN dates
RETURN team.name, manager.name, hire.date, dateFired

That returns the following:

==> +----------------------------------------------------------------------+
==> | team.name           | manager.name  | hire.date          | dateFired |
==> +----------------------------------------------------------------------+
==> | "Manchester United" | "David Moyes" | "January 2nd 2013" | <null>    |
==> +----------------------------------------------------------------------+
==> 1 row

Unfortunately we now don’t get a row for Chelsea because the WHERE clause filters Mourinho out.

I couldn’t think how to get around this so Wes suggested using neo4j 2.0 and the CASE statement which makes this very easy.

I eventually ended up with the following query which does the job:

START team = node:node_auto_index('name:"Chelsea" name:"Manchester United"'), 
      startDate = node:node_auto_index(name="2nd") 
MATCH startDate<-[:NEXT*0..]-day 
WITH team, startDate, COLLECT(day) AS dates 
MATCH startDate<-[:NEXT*0..]-day<-[hire:HIRED_ON]-tenure-[:MANAGER]->manager, 
      tenure-[:TEAM]->team, 
      tenure-[?:FIRED_ON]->dateFired 
RETURN team.name,    
       CASE WHEN dateFired is null THEN manager.name 
            WHEN dateFired IN dates THEN null 
            ELSE manager.name END as managerName,       
       CASE WHEN dateFired is null THEN hire.date 
            WHEN dateFired IN dates THEN null 
            ELSE hire.date END as hireDate

Here we’ve introduced the CASE statement which works pretty similarly to how the SQL CASE statement works so it should be somehow familiar. That query returns the following:

==> +----------------------------------------------------------+
==> | team.name           | managerName   | hireDate           |
==> +----------------------------------------------------------+
==> | "Manchester United" | "David Moyes" | "January 2nd 2013" |
==> | "Chelsea"           | <null>        | <null>             |
==> +----------------------------------------------------------+
==> 2 rows

which is exactly what we want. Now I need to import a real data set to see what it looks like!

Leadership and technical practices must be balanced

 

Hand Drawn Chart Saturday

 

What is Agile?  It is easy to be lulled into believing that Scrum (leadership) and the practices encompassed by that framework is all that is need to be a mature Agile organization.  I would suggest that a broader view of Agile requires a balance between both leadership practices and technical practices.

In Eastern Philosophy, Yin and Yang reflect the two complementary forces that make up the aspects of life; male and female, heaven and earth, chocolate and peanut butter or planning and construction. Leadership practices include planning, control and collaboration activities.  Scrum, the most popular Agile framework, fits into the category of leadership practices.  Technical practices include automated testing, build scripts, user stories, emergent design, pair programmer and other activities needed to create functionality. Extreme Programming and Test Driven Development are methodologies that have significantly more technical focus. The combination of Yin and the Yang of leadership and technical practices yields a more complete development environment.  Just doing one or the other set of practices does not deliver a project.

To be a mature Agile organization, both the technical and leadership aspects of the development process have to be addressed.  The leadership practices such as planning and collaboration help synchronize and focus the technical processes in order deliver the most value possible.

 

The #NoEstimates notion has merit in the right domain. If you're looking for motivation for estimates outside of the domain where the customer doesn't really care about the final cost, just the final product developed inside a "level of effort" budget, look here and remember.

When you are spending other people's money - billions of dollars of other people's money - you'd better have a credible answer when they ask "how much is this going to cost and when will you be done? This is separate from "will I get what I asked for?" That's another topic all together.

There are several things we need to remember about agile:

• Agile means paying to discover the requirements as we go. No problem if you know that up front.
• #NoEstimate means you don't have an Estimate At Completion (EAC) other than the passage of time multiplied by the total labor load. No problem if you understand that.
• When there is a budget cap, and deadline for delivery, and a minimal set of useable features, then some notion other than we don't make no stink'in estimates probably needs to be in place.

Related articles No Estimates of Costs and Schedule? Unrealistic Cost and Schedule Estimates

Little “a” Agile is like dominoes, there are rules but the game is reactive.

What is the difference between Agile and agile?  Big “A” Agile is branded and process-focused Agile while little “a” agile is collaborative and outcome focused. In a recent interview of Tobias Mayer for the Software Process and Measurement Cast, we talked about the concept of big “A” Agile versus “a” agile. Tobias pointed out that branding is an artifact of commercialization. I would suggest that commercialization is important to a healthy, growing eco-system but branding has consequences. The consequences include process-driven brittleness and a focus on big changes versus incrementalism.

Experimentation has been hallmark of the Agile movement – practitioners trying out new ideas. The philosophy of kiazen, a focus on continuous improvement, was part and parcel of Agile. Branding and certification tends to lead to a hardening of frameworks and methodologies so they can be taught and tested. Implementations in the big “A” world are about following and doing the process. Practitioners will perceive that rate of change in how Agile is practiced in big “A” Agile will be slower than if individual teams had control of their own process.  The slower rates of incorporating change into how work is done at the team level tends to mean that organizational processes will atrophy.

Big “A” Agile tends to be initially implemented as whole units (I am tempted to use the words big bang) and then rolls out as whole units. Changes are implemented in a similar manner because big “A” Agile needs to be more controlled to conform to brand standards. An example of this kind of stickiness (resistance to deviations of the status quo) is exemplified by those in the industry that get up in arms when someone says I am doing Scrum with a twist or I am doing Scrum but . . .

Whether an organization embraces big “A” or little “a” Agile, is probably a reflection of each organization’s culture. Organizations that feel they need greater control will tend to find solace in big “A” Agile.  My professional opinion is that little “a” Agile is more responsive to change and reflects needs of teams to a greater extent.

Things are pretty busy right now as we ship a bunch of customer enhancements on Engine Yard Cloud and continue with our planned infrastructure abstractions and cluster model improvements. Exciting things to come! In the meantime, here’s what’s available as of this week.

--Tasha Drew, Product Manager

Engineering Updates

Now in GA: Application takeover preferences. Based on your application's customizations, you might not want to use the default application takeover behavior we've developed to automatically promote your application slaves when the app master goes away or becomes totally unresponsive for some reason.

Engine Yard Cloud now provides two automated options for replacing capacity in an application takeover situation. We also provide alternatives if you need to handle part or all of an app takeover yourself.

We now have Provisioned IOPs and EBS Optimized instances available for customers to use in Early Access! To enable them for your environment from your cloud dashboard, click the Tools menu -> Early Access, and then enable “EBS Optimized Instances” and “Provisioned IOPs.”

Keep in mind that they work best in tandem, and they will only be an option on instances booted after you enable the feature.

Data Data Data

Databases love I/O and provisioned IOPs and EBS optimized instances are very well suited for applications where the database can use more performance (think backups and snapshots too).  

You can enhance the performance of your application by having a volume with provisioned IOPs on the database master. If your application has been already deployed you can add new replicas to the environment (that have this performance boost) and have them promoted to master.
As usual don’t hesitate to ask us if PIOPs or EBS optimized instances can give your database a boost.

Social Calendar (Come say hi!)

Tuesday, June 11th: Our Buffalo office will be hosting the WNY Ruby Meetup Group. Mark Josef will be providing us with some code katas.

Wednesday, June 12th: Our PDX office will be hosting the weekly CoderDojo K-12 night, ably assisted by one of the San Francisco sprint teams, who will be on site for an off site (as it were).

Wednesday, June 12th: Girl Develop It will be doing a Code and Coffee night in our Buffalo office. The participants be focusing on honing their skills and working in groups. Swing by for the whole thing or just for a part of it.

Friday, June 14th: DevOps Day Amsterdam will be happening! Be sure to meet our own Slava and Richard and let them tell you about how Engine Yard can make your lives easier.

Articles of Interest

Mozilla's John O’Dunn discusses how to use release engineering as a force-multiplier!

David Padilla explains why hash lookups are so fast in Ruby on the Engine Yard blog.

The post June 7, 2013: This Week at Engine Yard appeared first on Engine Yard Developer Blog.

At php[tek] 2013, Engine Yard sponsored the Mentorship Summit, a special forum to discuss the value of mentoring to create more connections and advancement opportunities for developers. A common theme that came out of the summit was that speaking at conferences is a great way to further oneself both personally and professionally. During the discussion, inevitably someone said they've submitted numerous times but had never been accepted to speak, then someone else said they don't know how to write a good proposal, and many discussions were had about what it means to write a good talk proposal.

I've had this conversation many times over the past few years with those I mentor, but this year something was different: I was a member of the selection committee for Distill, Engine Yard’s first developer conference.

Being on the other side for once has changed how I think about what is important when submitting for a talk and I thought it might be helpful to share how my perspective has evolved.

Questions and Answers

A proposal typically consists of a title, a short abstract, and sometimes a larger body of text to give the reviewers more detail about what to expect in the talk.

The first two items are really important because in addition to helping your talk stand out to the reviewer, they are also how an attendee will choose your talk over others on the schedule.

It's important to understand that there is an implicit question being asked in the title of your talk. For example, the two talks I presented at php[tek] were:

1. "PHP 5.5: The New Bits"

2. "MySQL High Availability, Disaster Recovery and Load Balancing"

The first one has an implicit question along the lines of: What's new in PHP 5.5? and the second: How do I make my database more robust and more scalable?  How do I make it easier to recover from failures?

Your abstract will then further inform the attendee (and the reviewer) of that question, and more importantly, create an expectation, or even a promise of what the talk will cover.

Most negative feedback I hear about talks isn't that the speaker was terrible or didn't know what they were talking about; it’s simply that the talk wasn't what the attendee wanted. Communicating the intent of your talk clearly is essential. If an attendee is disappointed, it’s often either because he misinterpreted the intention of the talk, or the speaker failed to properly set his expectations.

For example, if my MySQL talk focused mainly on using memcache (as a means to reduce load on the DB and therefore reducing the need to scale) it would have been a terrible talk — though a worthwhile topic, it's not addressing the question posed by my title and therefore not meeting the promise of the talk.

However, a talk is not always a matter of simply answering a question. Sometimes you are teaching people how to better ask their question. If the talk had been titled "High performance websites with MySQL", then memcache would certainly be answering some of the implicit question by teaching them how to ask a better question: "How do I make my website faster when using MySQL?"

Is Your Question Relevant?

One of the more important things to remember is to ask the right question. What do people care about? Look at schedules from previous years for the conference (if they exist) to get an idea of what experience level the conference targets, and observe the associated community to see what people are interested in — what are emerging trends and topics that people are fascinated by?

Are you the right person for the job?

A very important thing to realize about your proposal is that who you are matters. To be more specific: why are you qualified to speak on a specific subject, or why do your opinions about it matter?

When selecting talks for Distill, I ran into mostly speakers I was unfamiliar with. So I Googled them.

If you want to establish yourself as a possible speaker, you need to be part of the larger conversation on the subject on which you want to speak. This can take many forms:

• Blog posts

• Tweets with people about the subject (yes, that's right, your tweets can matter!)

• Any other media (podcasts, books, magazine articles)

• Code contributions

The last one takes the longest to verify and is a last resort — if the reviewer hasn't been grabbed by your title/abstract then they may or may not even bother.

If you are contributing code to projects but doing nothing else, then you should start blogging about what you're contributing.

Submit Early, Submit Often

This one seems like it will be quite controversial to communities other than the PHP community which has made this the norm: submit many proposals.

When I submit to a conference, I will propose no fewer than four proposals. This not only increases your chances (by the numbers), but when selecting talks, if you have absolutely no other information on a speaker, this will at least give the reviewer a better idea of what you do, and a little more about what experience you may have.

Speaking Experience

The ability to communicate as a speaker is also something to worry about when selecting talks. Having a history of speaking, be it at other conferences, user groups, or even via webcasts/podcasts, is a big plus. Be sure to share all the media from your talks: slides, video and audio recordings. Similarly, podcasts are another way to give great insight into your ability to communicate verbally.

However, even writing can give insight into how you communicate.

Hard skills vs Soft skills Talks

There are two types of talks: so-called “hard talks” that teach technical skills, and “soft talks” which teach personal skills (e.g. team working, project management, how to get hired... how to write talk proposals).

When setting up a conference schedule it's very important to get the balance of hard skills vs soft skills talks right. Too few hard skills talks, and it's hard to justify the expense to your employer.

But quite often, the soft skills talks are the ones that get the most people talking, and when you are an experienced developer are often what you need to advance your career.

What this means is that you are far more likely to get a hard skills talk accepted than a soft skills talk — just because of the ratios, and because the few soft skills talks that are selected have to really stand out, typically well established speakers are chosen.

The "Distillation" Process: How We Selected Talks for Distill

For Distill, our review process was what I called "Iron Chef Style". We rated each talk as follows:

• Content (15 points)

• Fit (10 points)

• Speaker (5 points).

The content is the topic covered, the fit is how well the talk fits into the overarching theme of the conference, and the speaker is not who they were, but what made them the right person to talk on the subject.

Once they were all rated by each member of the committee, we tallied the numbers and sorted by the totals.

At this point, we asked if anybody had any specific talks they felt strongly about, and also used the standard deviation to see which talks have the biggest difference between the different reviewers to start discussion on those.

This gave us our top 32. We then looked at any speaker who had multiple talks in the top 32, and made a decision on which one of them we preferred and removed the duplicates (there were only 3).

Finally, as we further refined our theme, we narrowed our list down to the final 15 — who were selected as speakers for Distill.

I was surprised at just how much of an extremely lengthy and difficult task this was. To anyone who has ever done this with my talks… I promise that my bribes will be much bigger in the future, you deserve it!

The post Speaking at Conferences: How to write a talk and get it accepted appeared first on Engine Yard Developer Blog.