Skip to content

Feed aggregator

Do You Have Questions About Estimation?

Johanna Rothman - Fri, 04/03/2015 - 21:01

I am doing a google hangout with Marcus Blankenship on April 10. We’ll be talking about estimation and my new book, Predicting the Unpredictable: Pragmatic Approaches to Estimating Cost or Schedule.

The book is about ways you can estimate and explain your estimates to the people who want to know. It also has a number of suggestions for when your estimates are inaccurate. (What a surprise!)

Marcus and I are doing a google hangout, April 10, 2015. There’s only room for 15 people on the hangout live.  If you want me to answer your question, go ahead and send your question in advance by email. Send your questions to marcus at marcusblankenship dot com. Yes, you can send your questions to me, and I will forward to Marcus.

The details you’ll need to attend:

Hangout link: https://plus.google.com/events/c3n6qpesrlq5b8192tkici26lcc

Youtube live streaming link: http://www.youtube.com/watch?v=82IXhj4oI0U

Time & Date: April 10th, 2015 @ 11:30am Pacific, 2:30 Eastern.

Hope you join us!

Categories: Blogs

Managing Conflicting Priorities

Operations teams cite constant context switching as one of their top frustrations. In this webinar, Dominica DeGrandis discusses how to manage conflicting priorities using a lean flow approach. About This Webinar Learn how bringing visibility to your work can help teams monitor priorities more effectively. Topics discussed during this webinar include: – Why conflicting priorities […]

The post Managing Conflicting Priorities appeared first on Blog | LeanKit.

Categories: Companies

What is the Product Owner Camp in Switzerland?

Scrum Breakfast - Thu, 04/02/2015 - 14:02
Dawna Jones, the management writer and initiator of the Stoos Sparks web series spoke with me about the Product Owner Camp in Switzerland. What is is about, who would want to go, and above all why? Check it out!
Product Owner Camp In Switzerland. Product Management meets Product Ownership. How do we create great products together? June 11-13, 2015. Registration and information at POcampCH.org.
Categories: Blogs

Guest blog: Retrospective Doughnut! A fun way to measure team’s response to Retrospectives.

Ben Linders - Thu, 04/02/2015 - 12:11
Retrospective Doughnuts can be used to make the adoption rate of retrospectives and the value that they deliver visible. This support organizations in using retrospectives to establish a routine feedback loop leading to continuous improvement. A guest blog post from Mukyul Vyas. Continue reading →
Categories: Blogs

Keep Austin Agile, Austin, USA, May 8 2015

Scrum Expert - Thu, 04/02/2015 - 10:08
Keep Austin Agile is a one-day conference that takes place in Austin, Texas. This event offers various tracks for education and networking in a relaxed environment. The target audience is project manager, Scrum Master, developer, tester and software development manager. In the agenda of the Keep Austin Agile conference you can find topics like “A Roadmap for (Agile) Engineering Best Practices – What Every Non-technical Person Needs to Know”, “Living Requirements with Behavior Driven Development”, “The 3 Pillars Approach to Agile Testing Strategy”, “Servant Leadership – The fine line between Motivation, ...
Categories: Communities

Mile High Agile, Denver, USA, April 3 2015

Scrum Expert - Thu, 04/02/2015 - 09:30
Mile High Agile is a one-day conference is produced by volunteers from Agile Denver that provides an opportunity to share knowledge and experiences in Agile software development for agile novices, intermediates and experts, technical professionals, team leaders, managers, executives, and organizational change leaders. In the agenda of the Mile High Agile conference, you can find topics like “Creating Program Alignment: The Product Wall Release Planning Workshop”, “The DNA of an Innovative Product Owner”, “Kanban at Scale – This Siemens Healthcare Case Study”, “Tales From the Trenches: Transforming Teams to Kanban and ...
Categories: Communities

Animate constraints with a simple UIView extension in Swift

Xebia Blog - Wed, 04/01/2015 - 23:01

iOS Developers that are getting started with Auto Layout for the first time often run in trouble once they try to animate their views. The solution is quite simple, but in this post I'll create a simple Swift extension that makes it even easier.

When you don't use Auto Layout, you need to make the changes to your UIView frames inside an animations block. Those changes will then be animated. So without knowing any better, you would do the same for your Auto Layout constraints, which means changing the constraint constants inside the animations block. This doesn't work however, and a quick google search on "how to animate constraints" shows that your need only need to call view.layoutIfNeeded within the animations block after you've made the changes to the constraints.

A simple example of this:

heightConstraint.constant = 100
UIView.animateWithDuration(0.5, animations: { [weak self] in
  self?.view.layoutIfNeeded() ?? ()
})

it's necessary to call it this wat since updating constants of constraints doesn't immediately change the frames of the views affected by those constraints. That's why we need to call layoutIfNeeded, to update all the frames of our views.

Since we just want to be always safe with memory management we'll use a weak reference of self within the closure, even though we know the closure is not retained after the animation runs and the view will not be deallocated before the animation finishes (it's good practice to use weak whenever you can to avoid memory related problems).

The above sample is not a lot of code, but each time you want to animate something with constraints you need to write the same thing. Wouldn't it be much easier to write the following instead?

heightConstraint.constant = 100
view.animateConstraintWithDuration()

We can achieve that by adding an extension to UIView:

extension UIView {
  func animateConstraintWithDuration(duration: NSTimeInterval = 0.5) {
    UIView.animateWithDuration(duration, animations: { [weak self] in
      self?.layoutIfNeeded() ?? ()
    })
  }
}

Default values for the method parameters makes this even nicer. Above we used 0.5 as default duration but of course you can fill in duration you want when calling the method. Also we can add parameters with default values for the other parameters that animateWithDuration has.

The final extension
extension UIView {
  func animateConstraintWithDuration(duration: NSTimeInterval = 0.5, delay: NSTimeInterval = 0.0, options: UIViewAnimationOptions = nil, completion: ((Bool) -> Void)? = nil) {
    UIView.animateWithDuration(duration, delay:delay, options:options, animations: { [weak self] in
      self?.layoutIfNeeded() ?? ()
    }, completion: completion)
  }
}

There we have it. An extremely simple extension method that not only saves us a little bit of code each time we need to animate constraints but is also makes the code a lot cleaner since the name of the method clearly indicates what it does, as apposed to the layoutIfNeeded method within an animations block.

Categories: Companies

Rally Customer Perspective: Q&A with Edgar van Zoelen of Philips

Rally Agile Blog - Wed, 04/01/2015 - 18:15

Edgar van Zoelen is leading a large-scale Agile transformation in Philips’ IT organization, which has already resulted in a 60% average improvement in project lead times and successful consolidation of projects that has led to millions of Euros in cost savings.

In just a few years the group has expanded from 7 Scrum teams to more than 120, with approximately 20 Agile release trains under the Scaled Agile Framework® (SAFe®.) Rally has supported Philips' efforts through transformation consulting, services, tool training, and the Rally platform.

Why start an Agile transformation at Philips?

At Philips, innovation is at the heart of what we do. And when you’re pushing forward at such a fast, relentless pace, it’s easy to see where there is drag in the organization. We needed to make improvements in IT delivery — that much was clear. As an organization, we were ready to change. We just didn’t know initially how to change and into what. From that point, it was simply a matter of connecting the dots from an unworkable situation — with more traditional development practices — to Agile, which gives us a more entrepreneurial and future-oriented stance.

How has Agile changed your environment?

Our hard work in the IT organization is paying off. We’re seeing all the textbook Agile improvements: employee engagement, better collaboration, a stronger link between business and IT, and more. When I look around, I see that people are having more fun, taking ownership, and gaining the confidence to challenge their managers. We also have more business stakeholders reaching out to us with positive feedback. For the first time, IT is adding direct value to the business. And we’ve done it at enormous scale, which is a huge achievement.

What’s the secret to a successful Agile transformation?

Consistency and persistence are critical in any Agile transformation. It’s not a one-off project with a defined end date. It requires ongoing, daily efforts to establish the right practices, make improvements, and show that it works. Because at the end of the day, it’s “show me the money.” That’s why I have a team of people who help me move the transformation forward, day in and day out. I call them fanatics because they have the passion and drive to push relentlessly toward business value. That attitude is the key to making a difference.

What was your biggest challenge?

In any transformation, there is always an element of resistance to change. Some people were wary of change in general. They viewed the Agile transformation as just another corporate initiative to endure. Others simply didn’t believe that Agile was the right methodology. We heard people say it was “too fluffy,” that it wasn’t concrete enough and didn’t provide enough security. Overcoming that resistance and building trust within the Philips community was a big challenge — and one of our top priorities as we rolled out Agile practices.

Looking back, is there anything you would have done differently?

True to the Agile philosophy, we’ve had many failures, and there were several things we could have done better. If I knew then what I know now, I would have spent more cycles on convincing people to buy into the transformation and optimizing our approach to coaching. However, every failure gave us an opportunity to learn, and that learning process brought us to where we are today. So in hindsight, I think we forged a very successful path and am proud of our approach.

How has the partnership with Rally helped your group achieve its goals?

On a platform level, Rally helps us standardize the way we measure team performance and align our work to business value. In the past, we struggled with a lack of transparency. Everyone was creating their own reports using custom tools, Excel, Scrum boards, and other methods, so our visibility was very scattered. The Rally solution enabled us to synchronize and start looking at trend lines — how we’re performing, what value we’re delivering, and where we can improve. On a partnership level, Rally brings a lot of insights and expertise from their work with other organizations. This culture of knowledge sharing helps us avoid common pitfalls and get to value sooner. It also means that our experiences at Philips can help other organizations roll out successful Agile transformations. It’s a good ecosystem, and we’re happy to be a part of it.

What philosophy drives your Agile transformation?

“Fail fast” is our mantra. It’s very important for us to make mistakes and keep learning, especially because innovation is at the heart of what we do as a company. However, it can be a difficult philosophy to accept. Most people are conditioned to believe that they should avoid mistakes at all costs. After all, they cost the business time and money. Changing that mindset has been the key to our success at Philips. The faster we fail, the faster we learn — and those insights allow us to move the needle with innovation.

What are the next steps in your journey?

Our next step in IT is to use scaled Agile as a way to organize ourselves. We’ve read the books, we’ve seen the slides, we’ve watched the videos, and we have pockets of excellence throughout the organization, particularly at the team level. We are also starting to work well at the program level, though we still have work to do there. At the same time, we are looking to extend our Agile practices to the level of the portfolio. That’s where senior management sits, so we have the opportunity to really get them on board and show them the value our teams are delivering to their business lines.

Watch the video interview to learn more.

Rally
Categories: Companies

Should the Scrum Master validate the inputs from a retrospective

Scrum Breakfast - Wed, 04/01/2015 - 15:20
The retrospective can be the most challenging of the Scrum activities, because, well, people are involved. A former student, Vijay, asked me:
The scrum master is facilitating the retrospective meeting by hearing the positive and negative from the team members. Should the scrum master or team members validate each other's feedback during the retrospective? I hope the answer is....Dear Vijay, I think the purpose of the first phase of a retrospective is to seek understanding. Different people in the team will have different truths. The objective is to understand all the truths, rather than to find the truth. So I prefer to ask the question, "what happened?" Just the facts, no judgements or accusations. Oh, by the way the left side (top half) of the flipchart,  this is for things that made you happy. The other half is for things that made you sad. It is helpful to understand the mood, but don't ask the question too soon, lest people focus too much on the thumbs up or down aspect of the question.

As a Scrum Master, it's my job is to prevent debate and other downward spirals. That's right, there is no such thing as a constructive debate! It drives people into their corners and makes agreement and consensus much more difficult. So people can ask clarifying questions of each other, but not rebut or challenge what was said, justify their own behavior or criticize others. "We understand and truly believe, everyone is doing the best job they can...." So we look for that 80% that everyone can agree on. This is the better basis for achieving a consensus for action.

As for recording, At each step of the retrospective, I would get cards up on a flip chart or pin board, then take a picture. As Scrum Master, I would only record individually those points that the team wants to act on in this sprint.

For a more complete discussion, check out "How we do a retrospective."


Categories: Blogs

Neo4j: Cypher – Building the query for a movie’s profile page

Mark Needham - Wed, 04/01/2015 - 13:54
2015 04 01 12 11 51

Yesterday I spent the day in Berlin delivering a workshop as part of the Data Science Retreat and one of the exercises we did was write a query that would pull back all the information you’d need to create the IMDB page for a movie.

Scanning the page we can see that need to get some basic meta data including the title. Next we’ll need to pull in the actors, directors, producers and finally a recommendation for some other movies the viewer might like to see.

I’d struggle to be able to write this all in one go – it’s non trivial. However, if we break it down there are actually 5 simpler queries that we probably can write. Our final step is then to work out how to glue them all together.

Let’s get started.

If you want to follow along open up your Neo4j browser and type :play movies and import the built in data set.

We’re going to create the query for The Matrix home page so the first step is to find the node representing that movie in the database:

match (movie:Movie {title: "The Matrix"})
return movie.title
 
==> +--------------+
==> | movie.title  |
==> +--------------+
==> | "The Matrix" |
==> +--------------+
==> 1 row

Easy enough. Now let’s get back the producers:

match (movie:Movie {title: "The Matrix"})
optional match (producer)-[:PRODUCED]->(movie)
 
RETURN movie.title, COLLECT(producer.name) AS producers
 
==> +--------------------------------+
==> | movie.title  | producers       |
==> +--------------------------------+
==> | "The Matrix" | ["Joel Silver"] |
==> +--------------------------------+
==> 1 row

We’ve introduced the COLLECT function here as we want to ensure that our final result only has one row regardless of how many producers there are. COLLECT applies an implicit group by ‘movie.title’ and collects the producers for each movie (in this case just The Matrix) into an array.

We’ve used OPTIONAL MATCH *LINK* because we still want to return a row for the query even if it has no producers. In the case that there are no producers we’d hope to see an empty array.

Now let’s write the same query to pull back the directors of the movie:

match (movie:Movie {title: "The Matrix"})
optional match (director)-[:DIRECTED]->(movie)
 
RETURN movie.title, COLLECT(director.name) AS directors
 
==> +----------------------------------------------------+
==> | movie.title  | directors                           |
==> +----------------------------------------------------+
==> | "The Matrix" | ["Lana Wachowski","Andy Wachowski"] |
==> +----------------------------------------------------+
==> 1 row

We really want to do both of these in one query so we get back a single result with 3 columns. To do that we’re going to introduce the WITH clause which allows us combine the results of traversals together.

In this case we’ll first do a traversal to get the producers, collect those into an array and then traverse out again to get the directors and collect those. This is what the query looks like:

match (movie:Movie {title: "The Matrix"})
optional match (producer)-[:PRODUCED]->(movie)
 
with movie, COLLECT(producer.name) AS producers
optional match (director)-[:DIRECTED]->(movie)
 
RETURN movie.title, producers, COLLECT(director.name) AS directors
 
==> +----------------------------------------------------------------------+
==> | movie.title  | producers       | directors                           |
==> +----------------------------------------------------------------------+
==> | "The Matrix" | ["Joel Silver"] | ["Lana Wachowski","Andy Wachowski"] |
==> +----------------------------------------------------------------------+
==> 1 row

We can follow the same pattern to return the actors:

match (movie:Movie {title: "The Matrix"})
optional match (producer)-[:PRODUCED]->(movie)
 
with movie, COLLECT(producer.name) AS producers
optional match (director)-[:DIRECTED]->(movie)
 
with movie, producers, COLLECT(director.name) AS directors
optional match (actor)-[:ACTED_IN]->(movie)
 
RETURN movie.title, COLLECT(actor.name) AS actors, producers, directors
 
==> +--------------------------------------------------------------------------------------------------------------------------------------------------------------+
==> | movie.title  | actors                                                                                | producers       | directors                           |
==> +--------------------------------------------------------------------------------------------------------------------------------------------------------------+
==> | "The Matrix" | ["Hugo Weaving","Laurence Fishburne","Carrie-Anne Moss","Keanu Reeves","Emil Eifrem"] | ["Joel Silver"] | ["Lana Wachowski","Andy Wachowski"] |
==> +--------------------------------------------------------------------------------------------------------------------------------------------------------------+
==> 1 row

So far, so good. We’ve got everything except the other movies recommendation which is a bit trickier so we’ll write it on its own first:

match (movie:Movie {title: "The Matrix"})<-[:ACTED_IN]-(actor)-[:ACTED_IN]->(otherMovie)
RETURN otherMovie, COUNT(*) AS score
ORDER BY score DESC
 
==> +---------------------------------------------------------------------------------------------------------------------------+
==> | otherMovie                                                                                                        | score |
==> +---------------------------------------------------------------------------------------------------------------------------+
==> | Node[348]{title:"The Matrix Revolutions",released:2003,tagline:"Everything that has a beginning has an end"}      | 4     |
==> | Node[347]{title:"The Matrix Reloaded",released:2003,tagline:"Free your mind"}                                     | 4     |
==> | Node[490]{title:"Something's Gotta Give",released:2003}                                                           | 1     |
==> | Node[349]{title:"The Devil's Advocate",released:1997,tagline:"Evil has its winning ways"}                         | 1     |
==> | Node[438]{title:"Johnny Mnemonic",released:1995,tagline:"The hottest data on earth. In the coolest head in town"} | 1     |
==> | Node[443]{title:"Cloud Atlas",released:2012,tagline:"Everything is connected"}                                    | 1     |
==> | Node[452]{title:"V for Vendetta",released:2006,tagline:"Freedom! Forever!"}                                       | 1     |
==> | Node[425]{title:"The Replacements",released:2000,tagline:"Pain heals, Chicks dig scars... Glory lasts forever"}   | 1     |
==> +---------------------------------------------------------------------------------------------------------------------------+
==> 8 rows

Our recommendation query finds all the actors in The Matrix and then traverses out to find other movies they’ve acted in and orders those movies based on how many of our actors appeared in them. Not surprisingly the other Matrix movies come out top.

In order to plug this into the rest of the query we need a single row to be returned i.e. our other movie suggestions need to be returned as an array rather than individual rows. Let’s do that:

match (movie:Movie {title: "The Matrix"})<-[:ACTED_IN]-(actor)-[:ACTED_IN]->(otherMovie)
 
WITH otherMovie, COUNT(*) AS score
ORDER BY score DESC
 
RETURN COLLECT({movie: otherMovie.title, score: score}) AS otherMovies
 
==> +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
==> | recommended                                                                                                                                                                                                                                                                                                                                                  |
==> +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
==> | [{movie -> "The Matrix Revolutions", score -> 4},{movie -> "The Matrix Reloaded", score -> 4},{movie -> "Something's Gotta Give", score -> 1},{movie -> "The Devil's Advocate", score -> 1},{movie -> "Johnny Mnemonic", score -> 1},{movie -> "Cloud Atlas", score -> 1},{movie -> "V for Vendetta", score -> 1},{movie -> "The Replacements", score -> 1}] |
==> +--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

We’ve introduced a WITH clause for two reasons:

  1. To ensure the order of the movies based on highest score
  2. Because we can’t do an aggregation within an aggregation i.e. COLLECT(COUNT(…)) would be an illegal operation in Cypher.

Now we’re ready to plug this recommendation query into our main one:

match (movie:Movie {title: "The Matrix"})
optional match (producer)-[:PRODUCED]->(movie)
 
with movie, COLLECT(producer.name) AS producers
optional match (director)-[:DIRECTED]->(movie)
 
with movie, producers, COLLECT(director.name) AS directors
optional match (actor)-[:ACTED_IN]->(movie)
 
WITH  movie, COLLECT(actor.name) AS actors, producers, directors
optional match (movie)<-[:ACTED_IN]-(actor)-[:ACTED_IN]->(otherMovie)
 
WITH movie, actors, producers, directors, otherMovie, COUNT(*) AS score
ORDER BY score DESC
 
RETURN movie, actors, producers, directors,  
       COLLECT({movie: otherMovie.title, score: score}) AS recommended
 
==> +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
==> | movie                                                                           | actors                                                                                | producers       | directors                           | recommended                                                                                                                                                                                                                                                                                                                                                  |
==> +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
==> | Node[338]{title:"The Matrix",released:1999,tagline:"Welcome to the Real World"} | ["Hugo Weaving","Laurence Fishburne","Carrie-Anne Moss","Keanu Reeves","Emil Eifrem"] | ["Joel Silver"] | ["Lana Wachowski","Andy Wachowski"] | [{movie -> "The Matrix Revolutions", score -> 4},{movie -> "The Matrix Reloaded", score -> 4},{movie -> "Johnny Mnemonic", score -> 1},{movie -> "The Replacements", score -> 1},{movie -> "Cloud Atlas", score -> 1},{movie -> "V for Vendetta", score -> 1},{movie -> "Something's Gotta Give", score -> 1},{movie -> "The Devil's Advocate", score -> 1}] |
==> +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
==> 1 row

Voila! 4 different types of data gathered and just one query to do it all.

For the eagle eyed cypher specialists (Hi Michael!), you’ll have noticed a bit of duplication in how we traverse out to the actors twice, once to retrieve them and once to make the movie recommendation.

We could optimise this by collecting the actors once and then using the UNWIND clause but that’s an optimisation which I think slightly obscures the intent of the query so I’ve left it like this for now.

Categories: Blogs

stop explaining it away

Derick Bailey - new ThoughtStream - Wed, 04/01/2015 - 12:00

This last weekend, I had a rather new experience. It wasn’t something I expected, and I wasn’t sure how to react to it. My initial reaction was a little bit of surprise, mixed with a desire to just explain things away. I wanted to deny the experience… of others, and of myself. Ironically, this was one of the very topics of the talk that I gave – denial – and here I was, mired in it.

stage-1-denial.png

A Powerful Set Of Reactions

If you read my post last week, I talked about how I was terrified of the presentation that I was preparing to do at a conference and how I need that terrified energy to drive me forward. I used that energy for my talk. I got up on stage, and I did my best.

It went well.

Very well.

Apparently, better than I had expected or believed it would go. The reactions that I received from the talk were far more numerous and emotional than I have ever experienced for a single talk – and this wasn’t the largest crowd to which I have spoken. There were multiple persons nearly in tears after, a few hugs, and more stories of a very personal nature than I can remember.

To say that I was stunned by this would be an understatement. I didn’t know how to react. So I started to do what I always do: deflect the attention away from me by trying to explain why I said the things I did. But I stopped myself just in time, and I remembered that I need to accept things graciously sometimes.

Learning To Accept A Compliment

For as long as I can remember, I have had a very hard time accepting compliments.  I don’t know if this stems from low self-esteem, other people consistently belittling me in school as I was growing up, or what the sources are. But it is what it is – me having a very hard time accepting compliments.

When I was younger, I would directly explain the circumstances under which I was able to do whatever it was that earned the compliment. I would explain it away, deflecting the attention away from me – and inadvertently deflecting the grace and favor of the person from whom the compliment came.

It turns out this isn’t a very nice thing to do.

Insulting A Compliment

I was unaware of the insulting nature of explaining away a compliment, for a very long time. One day someone told me to learn to accept a compliment and leave it at that. They were pretty upset at me at the moment, because I had just explained away yet another favorable mention.

It took a moment to think about this, and a few moments of discussion, for me to realize that my desire to let the other person know how I felt about my accomplishment was directly diminishing the other person, and not just myself.

“Your Opinion Is Invalid!”

Say you’re in an art gallery, admiring a painting. Another person comes along and looks at the same painting. When they ask your opinion, you freely express how wonderful it is and how it makes you feel. Now imagine the other person informs you that they are the artist. Then they begin telling you that you’re wrong; that you know nothing of art and your opinion is invalid. Clearly, you don’t know what you’re talking about and you should leave.

How would that make you feel?

I would be insulted.

Yet, this is exactly what I was doing every time I explained away a compliment from someone else. “What’s that? You liked my presentation? You felt inspired? Actually, let me tell you who you should really look to because I didn’t do anything of value, here. In fact, your opinion of me is wrong. There’s no way I could have inspired you. I was simply relaying what someone else said, and you should thank them and not me.”

I’m Working On It

I did my best to say “thank you” at every right moment – to the point of over-stating it and saying it at inappropriate times once or twice.

I still have a hard time accepting compliments at their face value. There is still a part of me that wants to believe it wasn’t me, but some circumstance that the other person should be appreciating. But I know that this is destructive, so I script my response, practice saying “thank you” and shut my mouth after that.

Honestly, I prefer the non-verbal compliments – hugs, hand-shakes, a simple nod and a smile. It’s easier for me to accept that, because there is no expectation of a verbal response from me. In other words, I get to keep my mouth shut. But I don’t want to deny someone else their desire to express themselves verbally.

That would be as arrogant and destructive as me explaining away a compliment.

Thank You

It is a tremendously humbling experience to see someone else fighting back tears of joy, understanding, and compassion – someone reliving the pain, happiness or other emotion – from a talk that I gave. I don’t want to undermine your emotion, your reaction, your compliment or opinion of me in that moment.

So I try to keep it simple. I try to say “thank you” and leave it there. I try… and I want to say thank you, myself.

Thank you to everyone that was there, that listened and allowed me to share. Thank you to everyone that spoke with me, hugged me, shared a moment of emotion or a personal story with me. I treasure all of those moments. Thank you to all of you, reading this now. Thank you to everyone that has put up with me, understood me in spite of me, and been there to help me become a better me.

Thank you.

– Derick

Categories: Blogs

New Version of HP Agile Manager Released

Scrum Expert - Tue, 03/31/2015 - 18:23
HP has released a new version of its Agile project management software to assist mobile teams in adopting Agile practices and delivering high-quality mobile applications faster. HP Agile Manager is a SaaS-based Agile project management solution to organize, plan, and execute Agile projects. It leverages native cloud architecture for instant-on access, boasts a clean, intuitive design, removes latencies, bolsters Agile practices, and fosters continuous improvement. The new version of HP Agile Manager supports real-time integration with HP Application Lifecycle Management software so that no matter how fast Agile teams deliver, they can ...
Categories: Communities

Trends for 2015

J.D. Meier's Blog - Tue, 03/31/2015 - 17:13

It’s time to blow your mind with the amazing things going on around the world.

Each year, I try to create a bird’s-eye view of key trends.   It’s a mash up of all the changes in technology, consumerism, and ideas that seem to be taking off.

Here are my trends for 2015:

Trends for 2015:  The Year of Digital Transformation

I call it the year of Digital Transformation because of the encroachment of technology into all things business, work, and life.

Technology is everywhere (and it’s on more wrists than I’ve ever seen before.)

What’s different now is how the combination of Cloud + Mobile + Social + Big Data + Internet-of-Things are really changing how business gets done.  Businesses around the world are using Cloud, Mobile, Social, Big Data, and Internet-of-Things to leap frog ahead of their competitors and to differentiate in new and exciting ways.

Businesses around the world are using technology to gains insights and to shape their customer experience, transform their workforce, and streamline their back-office operations.

It’s a new race for leadership positions in the Digital Economy.   With infinite compute and capacity, along with new ways to connect around the world, business leaders and IT leaders are re-imagining the art of the possible for their businesses.

While Cloud, Mobile, Social, Big Data, and Internet-of-Things might be the backbone of the changes all around us, it’s business model innovation that is bringing these changes to the market and helping them take hold.

Here is a preview of 10 key trends from Trends for 2015:  The Year of Digital Transformation:

  1. The Age of Instant Gratification.
  2. It’s a Mobile Everything World.
  3. Businesses Look to the Cloud.
  4. Internet of Things (IoT)
  5. Design is everywhere.
  6. Economy Re-Imagined (“The Circular Economy”)
  7. Culture of Health.
  8. Money is Reimagined (“The Future of Payments and Currency”)
  9. Digital Personal Assistants are Everywhere.
  10. Renegades and Rebels Rule the World

As a tip, when you read the post, try to scan it first, all the way down, so you can see the full collection of ideas.  Then circle back and slow down to really absorb the full insight.   You’ll find that you’ll start to see more patterns across the trends, and you’ll start to connect more dots.

I designed the post to make it easy to scan, as well as to read it end-to-end in depth.  I think it’s more valuable to be able to quickly take the balcony view, before diving in.   This way, you get more of a full picture view of what’s happening around the world.  Even if you don’t master all the trends, a little bit of awareness can actually go a long way. 

In fact, you might surprise yourself as some of the trends pop into your mind, while you’re working on something completely different.   By having the trends at my fingertips, I’m finding myself seeing new patterns in business, along with new ways that technology can enhance our work and life.

Trends actually become a vocabulary for generating and shaping new ideas.   There are so many ways to arrange and re-arrange the constellation of ideas.  You’ll find that I paid a lot of attention to the naming of each trend.  I tried to share what was already pervasive and sticky, or if it was complicated, I tried to turn it into something more memorable.

Use the trends as fodder and insight as you pave your way through your own Digital Transformation.

Categories: Blogs

Agile Reflections

Scrum Expert - Tue, 03/31/2015 - 16:33
In his book Agile Reflections, Robert Galen has aggregated multiple articles that he wrote about transitioning to Agile for the online publication PM Times. The book is based on his experience as in Agile coach helping companies in different phases of their transition to Agile software development. The book deals with five main aspects of Agile adoption: beginnings, execution, customer, mindset and leadership. It articles that discusses many different topics like Agile metrics, team appreciation or focusing on value. Each chapter is easy to read as it mixes in a pleasant ...
Categories: Communities

Why I Dig Bootstrap

Bobtuse Bobservations - Bob MacNeal - Tue, 03/31/2015 - 16:01
Bootstrap is one of the most significant web development improvements in recent years because it standardizes on class names for common css (cascading style sheets) for html layout and html page...

Bobtuse can be wildly informative
Categories: Blogs

Do You Know How to Say No?

Johanna Rothman - Tue, 03/31/2015 - 15:48

Some of my coaching clients have way more to do than they can manage. Some of my project portfolio clients are struggling with how to say no.

My most recent Pragmatic Manager newsletter is all about what to do when you have too much to do. Read it at Do You Have Too Much to Do?

Categories: Blogs

Are You Really Done, Done?

Leading Agile - Mike Cottmeyer - Tue, 03/31/2015 - 15:08

One of the principles of agile is to Deliver Working Software: Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale. What that principle doesn’t tell us is: who are we delivering the software to exactly? Of course the answer is (and should be) it depends!

A small team would deliver software directly to the consumers. In larger organizations, and specifically ones going through an agile transformation, the delivery of working software has different meanings. For example: your team builds the front end of a complex system. Can it simply upload your software to a production server when it’s development ready? It is likely that someone deploys it for you. Training and documentation may also be necessary, and scheduling and executing it also requires additional time. Integration and regression testing at scale is yet another factor, and the list goes on.

As we work with agile at scale the definition of done for a team is only sufficient for the team. The definition of ready for a user story is sufficient for those developing the stories. So how do we know when we’re truly ready to release?

The Definition of Release Ready.

Our Teams work with a supportive cast of characters that help us get our work to its destination. Much like a business analyst will consider what the developers need, it is logical that developers consider the downstream activities that affect their ability to release. Developing the software doesn’t end our responsibility to deliver working software.

I use the Definition of Release Ready as a way to give the Team an opportunity to explicitly understand and track what needs to happen after the development is done. To define Release Ready I include various stakeholders that are responsible for getting the work to the finish line. Some groups that should be involved in the definition are:

  • Security
  • Integration Testing
  • User Acceptance Testing
  • End User Documentation
  • Training
  • Tech Ops

All the work mentioned above should take place as close to development as possible. Some of the work by its nature will tend to leak beyond the sprints. Defining Release Ready together with the Team will not only validate your work, but also build on the agile principles of building relationships, respect, face-to-face communication, and delivering working software.

When are you really done, done…done?

The post Are You Really Done, Done? appeared first on LeadingAgile.

Categories: Blogs

Python: Creating a skewed random discrete distribution

Mark Needham - Tue, 03/31/2015 - 00:28

I’m planning to write a variant of the TF/IDF algorithm over the HIMYM corpus which weights in favour of term that appear in a medium number of documents and as a prerequisite needed a function that when given a number of documents would return a weighting.

It should return a higher value when a term appears in a medium number of documents i.e. if I pass in 10 I should get back a higher value than 200 as a term that appears in 10 episodes is likely to be more interesting than one which appears in almost every episode.

I went through a few different scipy distributions but none of them did exactly what I want so I ended up writing a sampling function which chooses random numbers in a range with different probabilities:

import math
import numpy as np
 
values = range(1, 209)
probs = [1.0 / 208] * 208
 
for idx, prob in enumerate(probs):
    if idx > 3 and idx < 20:
        probs[idx] = probs[idx] * (1 + math.log(idx + 1))
    if idx > 20 and idx < 40:
        probs[idx] = probs[idx] * (1 + math.log((40 - idx) + 1))
 
probs = [p / sum(probs) for p in probs]
sample =  np.random.choice(values, 1000, p=probs)
 
>>> print sample[:10]
[ 33   9  22 126  54   4  20  17  45  56]

Now let’s visualise the distribution of this sample by plotting a histogram:

import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
 
binwidth = 2
plt.hist(sample, bins=np.arange(min(sample), max(sample) + binwidth, binwidth))
plt.xlim([0, max(sample)])
plt.show()

2015 03 30 23 25 05

It’s a bit hacky but it does seem to work in terms of weighting the values correctly. It would be nice if it I could smooth it off a bit better but I’m not sure how at the moment.

One final thing we can do is get the count of any one of the values by using the bincount function:

>>> print np.bincount(sample)[1]
4
 
>>> print np.bincount(sample)[10]
16
 
>>> print np.bincount(sample)[206]
3

Now I need to plug this into the rest of my code and see if it actually works!

Categories: Blogs

Let’s Do Some Upfront Design

TV Agile - Mon, 03/30/2015 - 17:46
Sometimes a little time spent upfront on design is worth it. Just because we’re agile doesn’t mean no design upfront. Unfortunately some people have taken “working software over comprehensive documentation” to mean no documentation and no design. In this talk, Mark will present a method for evolving an object oriented design through tests, with a […]
Categories: Blogs

Agile Games, Cambridge, USA May 16-17 2015

Scrum Expert - Mon, 03/30/2015 - 15:56
The Agile Games Conference is two-day annual event organized by Agile New England that focuses teaching, demonstrating, and improving Agile and organizational effectiveness using game theory. The conference program consisting of workshops and games will be selected from an open submission process. All members of the Agile games community are encouraged to submit their ideas for consideration to be included in the planned conference program. In the agenda of Agile Games you can find keynotes and workshops like “Puppet Mastery: The Ultimate Agility Game”, “The Game Within the Game”, “Sudokuban and ...
Categories: Communities

Knowledge Sharing


SpiraTeam is a agile application lifecycle management (ALM) system designed specifically for methodologies such as scrum, XP and Kanban.