Skip to content

Feed aggregator

Quotable Quotes: Leverage Technology When Possible!

Learn more about transforming people, process and culture with the Real Agility Program

Jerry Doucett 201601 white background - head - 275 square“For increased chances of success, a Scrum team should leverage technology and engineering practices whenever possible.  Techniques, skills and tools that facilitate Agile approaches such as Continuous Integration, Automated Testing and Test Driven Development all make technical excellence, continuous improvement and truly being “Done” every Sprint a possible reality for a Scrum team.”

(By Senior Agile CoachJerry Doucett)

************************************************************************

Jerry is leading a series of SAFe trainings from September to December. More details are here.

 

 

Learn more about our Scrum and Agile training sessions on WorldMindware.comPlease share!
Facebooktwittergoogle_plusredditpinterestlinkedinmail

The post Quotable Quotes: Leverage Technology When Possible! appeared first on Agile Advice.

Categories: Blogs

Kurt Bittner Joins Scrum.org as Vice President of Enterprise Solutions

Scrum Expert - 7 hours 50 min ago
Scrum.org has announced that Kurt Bittner has joined the company as vice president of enterprise solutions. In this role, Kurt is responsible for enterprise-level professional software delivery initiatives. Kurt Bittner previously worked for Forrester Research, where he served as a Principal Analyst covering how enterprises are adopting Agile and DevOps practices. Prior to Forrester, Kurt served as CTO—Americas for the consulting firm Ivar Jacobson International. “Increasingly, organizations see software as the key for business success, but to do it well, development teams must be professional. Scrum.org, which focuses on professional Scrum through assessments and certification, training and licensed Professional Scrum Trainers, is developing enterprise initiatives to provide that organizational environment that enables multiple teams to work together more effectively,” explained Ken Schwaber, co-creator of Scrum and founder of Scrum.org. “Kurt brings a wealth of knowledge and experience to this new role, and will help us drive those initiatives for enterprises, which will enable organizations to adapt and thrive in this period of unprecedented challenge and opportunity.” Kurt will work alongside Ken Schwaber and others to evolve existing and create new ways for organizations to build environments that encourage and sustain scaling professional software delivery, and to drive a cohesive vision for Scrum.org on how enterprises can deliver greater value to themselves and their customers by delivering software in a professional way. Bittner joins Scrum.org from
Categories: Communities

My Favorite LeanKit Feature: Subscribe to a Card

Hana here, from Product Marketing at LeanKit. One of my main roles is as a liaison between our Product and...

The post My Favorite LeanKit Feature: Subscribe to a Card appeared first on Blog | LeanKit.

Categories: Companies

Continuous Integration & Delivery at Lego

TV Agile - 8 hours 6 min ago
Security is important – but in my experience managers, product owners and developers often find themselves lost in translation once they attempt to map the “Security is very important to us” abstraction to features and user stories. How do you as a developer protect secrets such as passwords and connection strings without loosing flexibility in […]
Categories: Blogs

Why I Joined LeadingAgile

Leading Agile - Mike Cottmeyer - 12 hours 13 min ago

People who know me well might be surprised to learn I’ve accepted full-time employment. I’m sort of an independent-minded person. So, here’s why. (It’s characteristically long-winded, so skip it if you wish.)

Backstory

In 2002, I was working as an enterprise architect at a mid-to-large-ish financial services holding company that operated banks, mortgage lenders, investment firms, and so forth. That was my 25th year in the information technology field.

I had reached such a point of frustration with the growing bureaucracy of IT organizations that my wife and I were looking into alternatives, like franchise businesses (Main Event, etc.).

Then a colleague at the company approached me. He said he knew I was on the way out the door, and asked me if I would be willing to work with him on one last thing before I changed careers. He wanted to assess the cost and value of the IT function of the enterprise, and then, based on lessons learned, see what could be done to improve it. I agreed.

Within a few months our small group had learned:
  • The main problem was the existence of functional silos with numerous cross-dependencies. These dependencies caused so much delay that the organization might be likened to a set of interlocking gears so arranged that they couldn’t turn.
  • Every January, the department launched 300 projects at the same time. Staff spent the next seven to eight months waiting to see which ones would crash and burn. Then they scrambled to complete the surviving projects before the December code freeze. January through August was “endless meetings season.” September and October was “death march season.” Then the annual code freeze. Time to recover before the next January.
  • The cost of going through the formal bureaucratic process to request services from the IT department was so high that line-of-business leaders didn’t even bother to request things they wanted. Besides, if they requested something they couldn’t be sure it would ever materialize.
  • Individual contributors had no idea of the context of their work. From their point of view, there was no coherent activity in the IT department; everything was just a series of disconnected requests for small tasks (add an index on this database table; open such-and-such a port on this internal router; add a field to this COBOL copybook; etc.).
  • No one ever received any feedback about the downstream impact of their work. Were the architectural designs sound, or did people have to revamp them? Was the code okay, or did operations have to mess with it to get it installed? Did customers like the user experience, or was it horrid?

In today’s terms, you’ll recognize some of those symptoms as high WIP, dependencies, context-switching, overloaded queues, big-bang delivery, and matrixed organizations.

It was during this effort that we discovered the Agile Manifesto. We recognized in it the same values we were seeking. We reasoned that if there were enough people out in the world who were thinking along the same lines to have published such a document, then someone out there must know how to do this stuff. We looked for help and found ThoughtWorks. We went from there.

I said at the time that if “this stuff” didn’t stick, and the industry reverted to the status quo ante, I would bail. There are other ways to make a living besides the slow death of bureaucracy. I began my Agile journey with one foot out the door. In some ways this has been a Good Thing; it has kept me actively focused on value every day.

Did I bail? No: 2016 is my 39th year in the information technology field.

Here we go again

Ah, but there’s trouble in River City. Today, Agile seems to be all about peddling frameworks. You can become certified to teach a framework certification class by passing a framework certification class. It isn’t necessary to have worked in the IT field at all, let alone to understand how Agile thinking can apply to enterprise IT. There are some 400,000 Certified Scrum Masters, only a few of whom have ever written a line of code, worked as a tester, in operations, or in production support.

Some frameworks are meant for scaling team-level Agile methods. They operate by re-introducing traditional governance methods, and killing agility in the process. (See “Every Agile Scaling Framework in the World“)

Other frameworks are meant for de-scaling the organization. They operate by insisting upon radical structural changes on Day One; changes that are impractical in most cases.

The alternative, Kanban, (as defined by Lean Kanban Inc.) is a business organized around selling training courses. It’s more realistic and practical than any of the Agile frameworks, and yet it stops short of providing concrete guidance to clients. The approach is to train leaders (and coaches) and then let them chart their own path forward. Change their thinking, and then get out of their way. Not a bad approach, actually, but it may not go quite far enough.

Agile conferences are 99% about playing board games, sticking notes on the walls, bending pipe-cleaners, and constructing things with little plastic building blocks; and 1% about addressing business needs through Agile thinking or advancing technical excellence through sound software engineering practices.

Agile consultancies that used to help clients solve problems and achieve goals have devolved into sales organizations for “frameworks.” It’s easy money. I know a number of people involved, and they know better than to do this. It really hurts my heart to see them selling their ethics this way. I guess that sounds maudlin, but at least it’s sincere.

Maudlin or not, I’m far from alone in this assessment of the state of Agile.

Four members of the ScrumAlliance board resigned within two months of the date I wrote this. They gave generic reasons, but two of them mentioned that the organization was going in a direction inconsistent with the values expressed in the Agile Manifesto. (I don’t know how long this link will remain valid, but here’s their letter of resignation.)

More than a few people are disappointed with the way things have been going. Here’s an excerpt from a piece by James Grenning on Quora.

Being one of the people that participated in the creation of the Agile Manifesto, I find myself very disappointed by the reaction of engineers to the question “Are you practicing Agile?” Their shoulders drop. They tell me agile is horrible. I ask why. Reasons that stand out are:

  • We’re being micromanaged
  • The pressure is constantly on for every two week deliveries so quality suffers
  • All they care about is the date

Unfortunately, none of those activities are part of Agile, though I can see how it comes to be. The usual starting point is one of mistrust (note they above). Then you get a Scrum Master with two-days of training and pressure for two week deliveries; engineers will get the idea they are the Scrum Slaves.

Another of the Manifesto’s authors, Ron Jeffries, has had occasion to question the direction in which the ideas have been taken. Here’s an excerpt from an article on his site entitled “What I wish we had done…“.

As a faithful reader, you’re probably aware that I believe that the word “Agile” should mean “consistent with the Agile Manifesto”. And, of course, it doesn’t mean that at all. Instead it means whatever the word’s user means at that moment. There’s great confusion as a result. Ah, well, life is tough, then you die. Quickly, I hope, but not soon. But I digress…

An important contributor to the confusion is the proliferation of branded or named methods and frameworks. At the time of the Manifesto, if I recall, there were Scrum, XP, Crystal, and DSDM. Anyway right around that time, Jim Highsmith came out with Adaptive Software Development, Mike Beedle began a series of names like XP@Scrum, and it went on and on. It continues to this day.

…Point is, there are a lot of them. I don’t think we really need a “method” at all. I feel quite sure we don’t need a dozen…

Dave Thomas wrote, in a 2014 piece entitled, “Time to Kill Agile”.

The word “agile” has been subverted to the point where it is effectively meaningless, and what passes for an agile community seems to be largely an arena for consultants and vendors to hawk services and products.

Another Manifesto author, Brian Marick, has recently reanimated his 2009 idea, “Artisanal Retro-Futurism Crossed With Team-Level Anarcho-Syndicalism.” The name is designed to be descriptive of the underlying concept while simultaneously hard for people to cargo-cult. It’s intentionally non-catchy. The catchiness of the word “agile” has backfired.

Those comments come from authors of the Agile Manifesto. They aren’t alone. There’s a lot of disillusionment going around these days. I sympathize. Sometimes it feels as if the entire Agile movement is going in a direction inconsistent with the values expressed in the Agile Manifesto.

The whole thing with “scaling frameworks” has gotten totally out of hand. On a recent subcontracting engagement, I was tasked with helping the prime contractor’s client adopt the Scaled Agile Framework, a.k.a. SAFe. It didn’t take long to observe that the framework was a poor fit for the organization’s transformation goals. They were wasting massive amounts of time, effort, and money on it. But I couldn’t say so, as the prime contractor was pushing SAFe to the exclusion of any other ideas or approaches; and they were only pushing the outward appearance of compliance with SAFe’s “rules.” They were doing nothing of substance. I didn’t last long on that engagement, and that’s okay with me. It made me feel soiled.

That’s not an isolated example, or an aberration. It’s the norm when it comes to companies trying to adopt one “scaling framework” or another. It’s all about the “rules.” There’s no attempt to learn to think in a “lean” or “agile” way. And middleman companies are all too eager to stand under the rain of cash, arms wide and mouths agape, soaking up the profits. People who know better are hawking frameworks like stereotypical used car salesmen. Ethics, anyone?

By January of 2016, I had one foot out the door…again. The reason for the long gap since my last contract is that I’ve been taking a real estate training course, to become a licensed real estate agent. “This stuff” didn’t stick. Time to leave.

Enter LeadingAgile

Then a colleague in the Agile community approached me. He said, hey, before you leave, take a look at this. He pointed me to his company’s website: leadingagile.com.

Within a couple of months I learned:

  • There are still people in the Agile community who are genuinely interested in helping clients solve problems and achieve goals.
  • There are people in the Agile community who understand an established company can’t abruptly restructure itself and “go agile.”
  • There are people in the Agile community who recognize the value of a framework when it adds value, but who do not “push” a framework.
  • There are people in the Agile community who have a realistic model of organizational transformation, a way to craft a practical roadmap tailored to a client’s situation, and the willingness to guide the client along a path to improvement over the long term.

Many of those people work at LeadingAgile.

LeadingAgile has a very pragmatic and results-focused approach to organizational transformation. Some people think the word pragmatic implies backing off from Agile principles; actually, it means something like practical and realistic. Moving an organization toward business agility means defining a rational system of delivery built around teams. It means paying attention to flow, by which we mean the flow of value, not just “busyness.” Ideas from Lean Thinking are key to the approach, including high visibility and paying close attention to delivery rate and, by implication, anything that impedes value flow or delivery. This practical-mindedness has great appeal for me.

I discovered several people I knew were working at LeadingAgile. Some I had worked with in the past. Some I knew through Agile community events. Some I knew through their work. Mike Cottmeyer, Dennis Stevens, Chris Beale, Tom Churchwell, Rachel Howard, Derek Huether. A who’s who. An all-star team.

For me, then, joining LeadingAgile is like coming home. Home to people I know, whose views about Agile are aligned with my own, and whom I respect professionally and personally. Home to the core values of Agile, which have become so watered down and corrupt over the years.

That’s why.
Now, if “this stuff” doesn’t stick…

The post Why I Joined LeadingAgile appeared first on LeadingAgile.

Categories: Blogs

Alignment at Scale – slides from my Agile Africa keynote

Henrik Kniberg's blog - 15 hours 7 min ago

Here are the slides from my Agile Africa keynote Alignment at Scale (or How to Not become Totally Unagile when you have Lots of Teams). Thanks for a great conference!

And thanks everyone for the Emma greeting, that sure made an 8 year girl very happy :)

(Emma was supposed to join me on this trip, but couldn’t make it because I had missed some required paperwork for travelling with minors to South Africa).

Agile Alignment at Scale

Too busy to improve

Agile leadership

 

Categories: Blogs

AgileByExample, Warsaw, Poland, October 10-12 2016

Scrum Expert - 15 hours 42 min ago
AgileByExample is a Lean and Agile three-days conference taking place in Warsaw, Poland that helps you learn Agile on live examples. The first day is dedicated to a Lean Agile Dojo with workshops. Keynotes, talks and discussions are all in English. In the agenda of the AgileByExample conference you can find topics like “5 Whys Root Cause Analysis”, “Taking Back Agile: Returning to our Core Values and Practices”, “No time for Planning Poker? Try Silent Sort Estimating Instead”, “eXPert Leadership”, “Time to Clean up the Product!”, “Pair Programming Demystified”, “The Evolution of a Super Agile Software Development Capability”, “Scaling agile at LEGO”, “Choosing Change: How to Enable a Shift to Agile”. Web site: http://www.agilebyexample.com/ Location for the AgileByExample conference: Multikino Ursynów, Al. KEN 60, Imielin Metro Station, Warsaw, Poland
Categories: Communities

Neo4j/scikit-learn: Calculating the cosine-similarity of Game of Thrones episodes

Mark Needham - Mon, 08/22/2016 - 23:12

A couple of months ago Praveena and I created a Game of Thrones dataset to use in a workshop and I thought it’d be fun to run it through some machine learning algorithms and hopefully find some interesting insights.

The dataset is available as CSV files but for this analysis I’m assuming that it’s already been imported into neo4j. If you want to import the data you can run the tutorial by typing the following into the query bar of the neo4j browser:

:play http://guides.neo4j.com/got

Since we don’t have any training data we’ll be using unsupervised learning methods, and we’ll start simple by calculating the similarity of episodes based character appearances. We’ll be using scitkit-learn‘s cosine similarity function to determine episode similarity.

Christian Perone has an excellent blog post explaining how to use cosine similarity on text documents which is well worth a read. We’ll be using a similar approach here, but instead of building a TF/IDF vector for each document we’re going to create a vector indicating whether a character appeared in an episode or not.

e.g. imagine that we have 3 characters – A, B, and C – and 2 episodes. A and B appear in the first episode and B and C appear in the second episode. We would represent that with the following vectors:

Episode 1 = [1, 1, 0]
Episode 2 = [0, 1, 1]

We could then calculate the cosine similarity between these two episodes like this:

>>> from sklearn.metrics.pairwise import cosine_similarity
>>> one = [1,1,0]
>>> two = [0,1,1]
 
>>> cosine_similarity([one, two])
array([[ 1. ,  0.5],
       [ 0.5,  1. ]])

So this is telling us that Episode 1 is 100% similar to Episode 1, Episode 2 is 100% similar to itself as well, and Episodes 1 and 2 are 50% similar to each other based on the fact that they both have an appearance of Character B.

Note that the character names aren’t even mentioned at all, they are implicitly a position in the array. This means that when we use our real dataset we need to ensure that the characters are in the same order for each episode, otherwise the calculation will be meaningless!

In neo4j land we have an APPEARED_IN relationship between a character and each episode that they appeared in. We can therefore write the following code using the Python driver to get all pairs of episodes and characters:

from neo4j.v1 import GraphDatabase, basic_auth
driver = GraphDatabase.driver("bolt://localhost", auth=basic_auth("neo4j", "neo"))
session = driver.session()
 
rows = session.run("""
    MATCH (c:Character), (e:Episode)
    OPTIONAL MATCH (c)-[appearance:APPEARED_IN]->(e)
    RETURN e, c, appearance
    ORDER BY e.id, c.id""")

We can iterate through the rows to see what the output looks like:

>>> for row in rows:
        print row
 
<Record e=<Node id=6780 labels=set([u'Episode']) properties={u'season': 1, u'number': 1, u'id': 1, u'title': u'Winter Is Coming'}> c=<Node id=5415 labels=set([u'Character']) properties={u'name': u'Addam Marbrand', u'id': u'/wiki/Addam_Marbrand'}> appearance=None>
<Record e=<Node id=6780 labels=set([u'Episode']) properties={u'season': 1, u'number': 1, u'id': 1, u'title': u'Winter Is Coming'}> c=<Node id=5882 labels=set([u'Character']) properties={u'name': u'Adrack Humble', u'id': u'/wiki/Adrack_Humble'}> appearance=None>
<Record e=<Node id=6780 labels=set([u'Episode']) properties={u'season': 1, u'number': 1, u'id': 1, u'title': u'Winter Is Coming'}> c=<Node id=6747 labels=set([u'Character']) properties={u'name': u'Aegon V Targaryen', u'id': u'/wiki/Aegon_V_Targaryen'}> appearance=None>
<Record e=<Node id=6780 labels=set([u'Episode']) properties={u'season': 1, u'number': 1, u'id': 1, u'title': u'Winter Is Coming'}> c=<Node id=5750 labels=set([u'Character']) properties={u'name': u'Aemon', u'id': u'/wiki/Aemon'}> appearance=None>
<Record e=<Node id=6780 labels=set([u'Episode']) properties={u'season': 1, u'number': 1, u'id': 1, u'title': u'Winter Is Coming'}> c=<Node id=5928 labels=set([u'Character']) properties={u'name': u'Aeron Greyjoy', u'id': u'/wiki/Aeron_Greyjoy'}> appearance=None>
<Record e=<Node id=6780 labels=set([u'Episode']) properties={u'season': 1, u'number': 1, u'id': 1, u'title': u'Winter Is Coming'}> c=<Node id=5503 labels=set([u'Character']) properties={u'name': u'Aerys II Targaryen', u'id': u'/wiki/Aerys_II_Targaryen'}> appearance=None>
<Record e=<Node id=6780 labels=set([u'Episode']) properties={u'season': 1, u'number': 1, u'id': 1, u'title': u'Winter Is Coming'}> c=<Node id=6753 labels=set([u'Character']) properties={u'name': u'Alannys Greyjoy', u'id': u'/wiki/Alannys_Greyjoy'}> appearance=None>
<Record e=<Node id=6780 labels=set([u'Episode']) properties={u'season': 1, u'number': 1, u'id': 1, u'title': u'Winter Is Coming'}> c=<Node id=6750 labels=set([u'Character']) properties={u'name': u'Alerie Tyrell', u'id': u'/wiki/Alerie_Tyrell'}> appearance=None>
<Record e=<Node id=6780 labels=set([u'Episode']) properties={u'season': 1, u'number': 1, u'id': 1, u'title': u'Winter Is Coming'}> c=<Node id=5753 labels=set([u'Character']) properties={u'name': u'Alliser Thorne', u'id': u'/wiki/Alliser_Thorne'}> appearance=None>
<Record e=<Node id=6780 labels=set([u'Episode']) properties={u'season': 1, u'number': 1, u'id': 1, u'title': u'Winter Is Coming'}> c=<Node id=5858 labels=set([u'Character']) properties={u'name': u'Alton Lannister', u'id': u'/wiki/Alton_Lannister'}> appearance=None>

Next we’ll build a ‘matrix’ of episodes/characters. If a character appears in an episode then we’ll put a ‘1’ in the matrix, if not we’ll put a ‘0’:

episodes = {}
for row in rows:
    if episodes.get(row["e"]["id"]) is None:
        if row["appearance"] is None:
            episodes[row["e"]["id"]] = [0]
        else:
            episodes[row["e"]["id"]] = [1]
    else:
        if row["appearance"] is None:
            episodes[row["e"]["id"]].append(0)
        else:
            episodes[row["e"]["id"]].append(1)

Here’s an example of one entry in the matrix:

>>> len(episodes)
60
 
>>> len(episodes[1])
638
 
>>> episodes[1]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

From this output we learn that there are 60 episodes and 638 characters in Game of Thrones so far. We can also see which characters appeared in the first episode, although it’s a bit tricky to work out which index in the array corresponds to each character.

The next thing we’re going to do is calculate the cosine similarity between episodes. Let’s start by seeing how similar the first episode is to all the others:

>>> all = episodes.values()
 
>>> cosine_similarity(all[0:1], all)[0]
array([ 1.        ,  0.69637306,  0.48196269,  0.54671752,  0.48196269,
        0.44733753,  0.31707317,  0.42340087,  0.34989921,  0.43314808,
        0.36597766,  0.18421252,  0.30961158,  0.2328101 ,  0.30616181,
        0.41905818,  0.36842504,  0.35338088,  0.18376917,  0.3569686 ,
        0.2328101 ,  0.34539847,  0.25043516,  0.31707317,  0.25329221,
        0.33342786,  0.34921515,  0.2174909 ,  0.2533473 ,  0.28429311,
        0.23026565,  0.22310537,  0.22365301,  0.23816275,  0.28242289,
        0.16070148,  0.24847093,  0.21434648,  0.03582872,  0.21189672,
        0.15460414,  0.17161693,  0.15460414,  0.17494961,  0.1234662 ,
        0.21426863,  0.21434648,  0.18748505,  0.15308091,  0.20161946,
        0.19877675,  0.30920827,  0.21058466,  0.19127301,  0.24607943,
        0.18033393,  0.17734311,  0.16296707,  0.18740851,  0.23995201])

The first entry in the array indicates that episode 1 is 100% similar to episode 1 which is a good start. It’s 69% similar to episode 2 and 48% similar to episode 3. We can sort that array to work out which episodes it’s most similar to:

>>> for idx, score in sorted(enumerate(cosine_similarity(all[0:1], all)[0]), key = lambda x: x[1], reverse = True)[:5]:
        print idx, score
 
0 1.0
1 0.696373059207
3 0.546717521051
2 0.481962692712
4 0.481962692712

Or we can see how similar the last episode of season 6 is compared to the others:

>>> for idx, score in sorted(enumerate(cosine_similarity(all[59:60], all)[0]), key = lambda x: x[1], reverse = True)[:5]:
        print idx, score
 
59 1.0
52 0.500670191678
46 0.449085146211
43 0.448218732478
49 0.446296233312

I found it a bit painful exploring similarities like this so I decided to write them into neo4j instead and then write a query to find the most similar episodes. The following query creates a SIMILAR_TO relationship between episodes and sets a score property on that relationship:

>>> episode_mapping = {}
>>> for idx, episode_id in enumerate(episodes):
        episode_mapping[idx] = episode_id
 
>>> for idx, episode_id in enumerate(episodes):
        similarity_matrix = cosine_similarity(all[idx:idx+1], all)[0]
        for other_idx, similarity_score in enumerate(similarity_matrix):
            other_episode_id = episode_mapping[other_idx]
            print episode_id, other_episode_id, similarity_score
            if episode_id != other_episode_id:
                session.run("""
                    MATCH (episode1:Episode {id: {episode1}}), (episode2:Episode {id: {episode2}})
                    MERGE (episode1)-[similarity:SIMILAR_TO]-(episode2)
                    ON CREATE SET similarity.score = {similarityScore}
                    """, {'episode1': episode_id, 'episode2': other_episode_id, 'similarityScore': similarity_score})
 
    session.close()

The episode_mapping dictionary is needed to map from episode ids to indices e.g. episode 1 is at index 0.

If we want to find the most similar pair of episodes in Game of Thrones we can execute the following query:

MATCH (episode1:Episode)-[similarity:SIMILAR_TO]-(episode2:Episode)
WHERE ID(episode1) > ID(episode2)
RETURN "S" + episode1.season + "E" + episode1.number AS ep1, 
       "S" + episode2.season + "E" + episode2.number AS ep2, 
       similarity.score AS score
ORDER BY similarity.score DESC
LIMIT 10
 
╒═════╤════╤══════════════════╕
│ep1  │ep2 │score             │
╞═════╪════╪══════════════════╡
│S1E2 │S1E1│0.6963730592072543│
├─────┼────┼──────────────────┤
│S1E4 │S1E3│0.6914173051223086│
├─────┼────┼──────────────────┤
│S1E9 │S1E8│0.6869464497590777│
├─────┼────┼──────────────────┤
│S2E10│S2E8│0.6869037302955034│
├─────┼────┼──────────────────┤
│S3E7 │S3E6│0.6819943394704735│
├─────┼────┼──────────────────┤
│S2E7 │S2E6│0.6813598225089799│
├─────┼────┼──────────────────┤
│S1E10│S1E9│0.6796436827080401│
├─────┼────┼──────────────────┤
│S1E5 │S1E4│0.6698105143372364│
├─────┼────┼──────────────────┤
│S1E10│S1E8│0.6624062584864754│
├─────┼────┼──────────────────┤
│S4E5 │S4E4│0.6518358737330705│
└─────┴────┴──────────────────┘

And the least popular?

MATCH (episode1:Episode)-[similarity:SIMILAR_TO]-(episode2:Episode)
WHERE ID(episode1) > ID(episode2)
RETURN "S" + episode1.season + "E" + episode1.number AS ep1, 
       "S" + episode2.season + "E" + episode2.number AS ep2, 
       similarity.score AS score
ORDER BY similarity.score
LIMIT 10
 
╒════╤════╤═══════════════════╕
│ep1 │ep2 │score              │
╞════╪════╪═══════════════════╡
│S4E9│S1E5│0                  │
├────┼────┼───────────────────┤
│S4E9│S1E6│0                  │
├────┼────┼───────────────────┤
│S4E9│S4E2│0                  │
├────┼────┼───────────────────┤
│S4E9│S2E9│0                  │
├────┼────┼───────────────────┤
│S4E9│S2E4│0                  │
├────┼────┼───────────────────┤
│S5E6│S4E9│0                  │
├────┼────┼───────────────────┤
│S6E8│S4E9│0                  │
├────┼────┼───────────────────┤
│S4E9│S4E6│0                  │
├────┼────┼───────────────────┤
│S3E9│S2E9│0.03181423814878889│
├────┼────┼───────────────────┤
│S4E9│S1E1│0.03582871819500093│
└────┴────┴───────────────────┘

The output of this query suggests that there are no common characters between 8 pairs of episodes which at first glance sounds surprising. Let’s write a query to check that finding:

MATCH (episode1:Episode)<-[:APPEARED_IN]-(character)-[:APPEARED_IN]->(episode2:Episode)
WHERE episode1.season = 4 AND episode1.number = 9 AND episode2.season = 1 AND episode2.number = 5
return episode1, episode2
 
(no changes, no rows)

It’s possible I made a mistake with the scraping of the data but from a quick look over the Wiki page I don’t think I have. I found it interesting that Season 4 Episode 9 shows up on 9 of the top 10 least similar pairs of episodes.

Next I’m going to cluster the episodes based on character appearances, but this post is long enough already so that’ll have to wait for another post another day.

Categories: Blogs

Announcements, Links & Entertainment

Learn more about transforming people, process and culture with the Real Agility Program

For 10 years, Agile Advice has been providing useful information, Agile-related announcements & entertaining content for Agile ambassadors.

But Agile Advice is just one of the many portals to the BERTEIG online network.

For your easy reference here is a list of other 5 links which may bring you to the information you are looking for.
  1. Register for Training & Learning Events 
  2. Sign Up for BERTEIG’s Loyalty Program
  3. Find out More About BERTEIG’s Corporate Experience
  4. Join the 1000+ others in the LinkedIn Worldmindware Group
  5. Visit the BERTEIG-hosted Facebook Scrum Group with 2600+ members
Learn more about our Scrum and Agile training sessions on WorldMindware.comPlease share!
Facebooktwittergoogle_plusredditpinterestlinkedinmail

The post Announcements, Links & Entertainment appeared first on Agile Advice.

Categories: Blogs

Announcement: REAL agility newsletter released today!

Learn more about transforming people, process and culture with the Real Agility Program

rachelheadshot“Each week there are more and more exciting items to share with our ever-increasing newsletter subscriber list of leaders who, like you, are creating positive change in organizations across Canada.”

Rachel Perry, Content & Community Coordinator

Today we sent out a newsletter with some really great announcements! Here is a snippet from the weekly REALagility newsletter.

“Not only do BERTEIG coaches have fantastic insights to contribute to the advancement of the Agile industry, but also our Learning Events – for CSM, CSPO, CSD, SAFe, or Leadership – in both Toronto and Vancouver – continue to expand. In addition, multiple avenues for offering encouragement and support in a variety of ways are opening up all the time.

If our weekly newsletter were to include all the news, it would be 100 pages!

Sure, that might be a bit of an exaggeration but, truth-be-told, instead of putting EVERYTHING in the newsletter we share just key highlights, along with a warm invitation to hop on over to the Agile Advice blog where more knowledge, announcements and entertaining posts can give you plenty more details than what can be expressed in a weekly communication to your inbox.

We are excited to share that last month Agile Advice was viewed 18,000 times. Not only will you find more articles posted than ever before, but you will also discover a new development on the World Mindware page on Agile Advice; detailed accounts of hundreds of positive statements about BERTEIG’s coaches who are some of the leading Agile coaches in the world.

This week we featured Agile Leadership coach, Michael Sahota, onMichael Sahota - Profile Picture (2016) Agile Advice. In September, he will be presenting training for the Certified Agile Leadership (CAL1) training in Toronto. He was the second person to receive the designation to teach this class and the first to offer the training world-wide. Michael recently posted an article on Agile Advice sharing highlights of his personal and professional journey. He will also be offering a webinar this Wednesday, 24th Aug – register here.”

If you haven’t signed up for our weekly newsletter yet, I encourage you to consider giving it a try.

Learn more about our Scrum and Agile training sessions on WorldMindware.comPlease share!
Facebooktwittergoogle_plusredditpinterestlinkedinmail

The post Announcement: REAL agility newsletter released today! appeared first on Agile Advice.

Categories: Blogs

Product Backlog Refinement Checklist

Scrum Expert - Mon, 08/22/2016 - 16:22
Product backlog refinement (or grooming) is an important activity in Scrum projects where user stories are prioritizes, right-sized and estimated. In his book “Agile Reflections”, Robert Galen provides some hints about how to verify that that product backlog grooming has been done successfully and that the right requirements information is available for the next sprint. 1. Sprint planning is incredibly crisp, short and easy; usually taking 2 hours or less for a 2-week sprint. There are NO architectural or design discussions within the meeting—the relevant parts of these discussions having occurred earlier. 2. As a daily occurrence, team members are talking about epics and stories targeted for 2-3-4 sprints in the future. As a result, everyone is naturally aligning with the Product Owners’ vision. 3. The team easily contributes new stories to the backlog which represents non-feature based work; for example: testing artifacts, non-functional testing work, refactoring, automation development, performance tuning, research spikes, etc. Everyone views it as a shared responsibility. 4. The team has a feel for where the product is going long term and maps efforts, designs, theme suggestions, and trade-offs towards that vision. 5. Each sprint’s goal is easily derived from the backlog; i.e., there is a sense of thoughtful and meaningful story collections or themes that easily surface from within the backlog. From time to time, think of these as “packages” for customer delivery. 6. The Product Owner includes team feedback (bugs, refactoring, improvement, testing, etc.) in EVERY sprint – in some percentage of focus. They [...]
Categories: Communities

undefined is not a function

Derick Bailey - new ThoughtStream - Mon, 08/22/2016 - 15:48

Every developer that has worked with JavaScript knows the frustration of “undefined is not a function”.

Undefined is not a function

Most of the time the cause is something simple, though.

A quick survey of StackOverflow questions around this error message shows some basic examples, such as:

  • Mis-spelled function name
  • Capitalization of words in function name
  • jQuery is in “no-conflict” mode and “$” doesn’t exist
  • Calling methods that don’t exist
  • And more

The questions around this often come down to simple mistakes made during the development process.

It’s easy to misspell a word or get capitalization wrong, for example. And sometimes we get the <script> tags in the wrong order, or forget to include a script tag entirely.

Fortunately, most of these simple problems have simple solutions.

In the case of spelling mistakes and capitalization problems, you correct the mistake and move on.

When you run into jQuery in “no conflict” mode, you just replace your $() function calls with jQuery() and life is good.

This error does become significantly more frustrating, though.

When you start getting into more obscure problems – the ones that are not necessarily your fault – it’s easy to go from annoyed by a simple mistake to angry at a problem that is plaguing you.

Like a 3rd party library removing a function.

Tiago Garcia relates a story, via Twitter, as an illustration of this error, and a potential downside of relying on other people’s code.

@derickbailey we had a 3rd party lib being injected on the page which had this function, its name got changed, so we were getting that error

— Tiago Garcia (@tiagooo_romero) August 11, 2016

That’s not to say all 3rd party code is bad or dangerous. But, there are times when we can see common errors caused by uncommon problems.

In Tiago’s case, he had to put in a check to ensure the function was available when the script loaded.

That took a little more code, but was still a fairly simple solution.

There are tools that can help. Sometimes.

Linting tools like JSHint and ESLint can show you variable and function names that are not defined, for example.

These tools won’t catch every problem, though.

Linting tools typically don’t know what methods exist on objects, for example. You would need runtime analysis of the code for that to be accurate, as objects are often composed at runtime.

Worse than objects and methods, though, are the errors that only occur at runtime because of the way JavaScript’s “this” keyword can change.

Seeing a message like “this.doSomething is not a function” can be infuriating when you look at the code in question and see the method right there, on the object.

You know the method is there. You can see it with your own eyes!

But the JavaScript runtime says it’s not there, at runtime.

NewImage

This is a case where the simple rules and reasons that are typically associated “undefined is not a problem” break down and fail.

It isn’t a simple misspelling or capitalization problem. It’s not a function that disappeared without warning, either.

It’s a case of runtime definitions changing – differing from what was intended at the time of writing code the code.

JavaScript’s “this” strikes again.

And “this” is perhaps the most notorious keyword in any language.

Not because of strange or unique behavior, but because of the deceptively familiar behavior in many situation.

It’s easy to see code like “this.doAmazingThings()” and assume “this” references the object on which the method was defined. This is how other languages, like C#, work. So why would JavaScript be any different?

The truth, however, is that JavaScript manages “this” at runtime, and can change the value of “this” for any of several different reasons.

In the above example, for instance, jQuery may be calling this method from an event, setting “this” to the element that produced the event.

You could use the classic “var that = this” technique to fix “this”.

Most developers – myself included – have written code like this hundreds, if not thousands of times.

By taking advantage of a JavaScript closure around “that”, the callback function can work as expected.

While this technique does solve the immediate problem – and I do have a long history of writing code like this – I rarely use this trick anymore.

Instead of ignoring the underlying rules for managing “this” in JavaScript, as this technique would have you do, take the time to learn the rules.

They aren’t too numerous, or difficult.

The core of JavaScript’s “this” comes down to a single principle, in fact.

And I’ll share that principle with you in my Mastering JavaScript’s “this” email course.

Sign up for the free 7 day email course, below.

I’ll send you the secrets to one of JavaScript’s most misunderstood fundamentals.

Categories: Blogs

Link: How To Manage the “I’m the bestest” persons in Agile

Learn more about transforming people, process and culture with the Real Agility Program

therules

Can you believe there is an actual disorder which prevents people from seeing their own limits? It makes them over-cofindent to do things and yet under-skilled to achieve them. If you have a person with a disorder like this on your team, it can lead to disaster.

But you likely are not aware of what exactly is going on. Not until it’s too late.

You can read for yourself the nature of this condition and how a Scrum Master can help a person who perpetually under-estimates or over-estimates their capacities.

It’s called The Dunning-Kruger effect and here is the article entitled, “How to manage the “I’m the bestest” persons in Agile – The Dunning-Kruger effect.

What I like so much about this article is that despite the challenges of working with someone who is largely unaware of what they don’t know, is that the author offers encouragement to Scrum Masters.

Basically, a scrum team turns no one away. We are all capable of some degree of contributing. This article shows that the more a Scrum Master knows the individual team members and the collective capacity of the whole team, the better everyone can be!

Learn more about our Scrum and Agile training sessions on WorldMindware.comPlease share!
Facebooktwittergoogle_plusredditpinterestlinkedinmail

The post Link: How To Manage the “I’m the bestest” persons in Agile appeared first on Agile Advice.

Categories: Blogs

Announcing: New Course Offerings!

Learn more about transforming people, process and culture with the Real Agility ProgramBERTEIG Provides World Class Training For Agile Teams & Organizations

Join the BERTEIG team for Training in the GTA and throughout Canada.  Register for an upcoming class near you!

Imagine that you could learn the secrets to high performance teams, management and organizations! Double your productivity! Dramatically improve quality! Create great working environments! Delight your customers! Our Learning Events give you the tools and practices to transform your team and your organization. Whether you are a team member in a small startup or an executive in a Fortune 500 organization, we have something for you. Learn about the performance-enhancing methods of Scrum, LeSS, Kanban, SAFe and others!

Types of Training Scrum Alliance Registered Education ProviderCertified ScrumMaster (CSM)Certified Scrum Product Owner (CSPO)Certified Scrum Developer (CSD)Certified Scrum Professional (CSP)
Large Scale ScrumScaled Agile FrameworkReal AgilityProject Management Institute (PMI) Registered Education Provider

See our complete schedule of Learning Events!

Earn PDUs! Earn SEUs!

BERTEIG is a Registered Education Provider with Scrum Alliance and Project Management Institute. Our training courses qualify as professional development units for IIBA, OpenAgile Institute, and others.

Learn more about our Scrum and Agile training sessions on WorldMindware.comPlease share!
Facebooktwittergoogle_plusredditpinterestlinkedinmail

The post Announcing: New Course Offerings! appeared first on Agile Advice.

Categories: Blogs

A Safe Approach To Developing High Performance Teams

Learn more about transforming people, process and culture with the Real Agility ProgramJerry Doucett 201601 white background - head - 275 square Improving Teams Means Changing Culture

By Jerry Doucet

Under the right conditions Scrum can be a tremendous success story, but it often requires hard work to get there.  For new Scrum teams it means learning to fundamentally work very differently than they are used to, such as relying on a lot more collaboration, making and delivering on shared commitments and building a high degree of trust.  For existing Scrum teams it means constantly renewing the team commitment to each other, the cause, and to the Scrum framework.  This includes the rather painful practice of revisiting the fundamentals and ensuring any deviations from accepted processes or practices were for the right reasons and had the right results.

To have a chance at achieving high performance a new-to-Scrum team will not only need to just change their processes, but fundamentally change the culture and behaviour of the team and all of the supporting roles (that includes their leadership).  Meanwhile, a mature or well-established team should never assume they are high performance; they should always be checking (and rechecking) that they are still living the Agile values.

********************************************************************

Jerry is offering a number of SAFe training opportunities in Toronto, Ontario from September through December 2016. More details here. 

Learn more about our Scrum and Agile training sessions on WorldMindware.comPlease share!
Facebooktwittergoogle_plusredditpinterestlinkedinmail

The post A Safe Approach To Developing High Performance Teams appeared first on Agile Advice.

Categories: Blogs

LINK: Virtual Retrospectives

Learn more about transforming people, process and culture with the Real Agility Program

191

The Agile Manifesto says face-to-face interaction trumps all other forms of communication and colocated teams are the ideal.

But what to do when a team is distributed across a province, or a country, or internationally?

Mario Lucero shares his solution in “Virtual Retrospectives”.

He suggests using a virtual board and if anyone has had experience with this please leave a comment below. It would be great to read how this has been used with success.

With or without this virtual board, I really think he is on to something. With tact and wisdom, virtual meetings through online forums such as Google Hangouts or Skype can really give the impression of being face-to-face with people.

It provides more visual body-language cues which are missing in phone calls and this is bound to help keep communication among a distributed team much stronger.

Learn more about our Scrum and Agile training sessions on WorldMindware.comPlease share!
Facebooktwittergoogle_plusredditpinterestlinkedinmail

The post LINK: Virtual Retrospectives appeared first on Agile Advice.

Categories: Blogs

Video: Explaining Scrum in less than 120 seconds

Learn more about transforming people, process and culture with the Real Agility Program

 

Learn more about our Scrum and Agile training sessions on WorldMindware.comPlease share!
Facebooktwittergoogle_plusredditpinterestlinkedinmail

The post Video: Explaining Scrum in less than 120 seconds appeared first on Agile Advice.

Categories: Blogs

Agile Coach Profile: Michael Sahota

Learn more about transforming people, process and culture with the Real Agility ProgramMichael Sahota - Profile Picture (2016)Michael Sahota: Sage Advice For Organizational Growth 

By Rachel Perry

 

BERTEIG is proud to announce that in September Michael Sahota is offering a brand new Certified Leadership Training in Toronto, Ontario.

  • this is the first training of its kind in Canada!
  • Michael was the second trainer to be approved, based training he  developed & delivered over the last few years.
  • Michael was the first to deliver this training worldwide!
A Bit of Michael’s Background

In 2010, Michael was approved as a Certified Scrum Coach, a prestigious certification for someone capable of coaching enterprises. He says he was and continues to be very proud of this since certification which demonstrates extensive experience and qualifications.

He openly shares that several years ago, he experienced his own personal inner transformation which has enlightened him and opened many new doors of opportunity.

When reflecting on this process of growth, he describes it like this.

 “I looked at myself in the mirror and [saw] I was in no position to invite leaders on a transformational journey. I needed to work on myself. So I set about reinventing myself.”

The journey of reinventing himself is a whole other story which he shares in his blog Agilitrix.com.

He writes,

“I had a hypothesis that if I changed how I showed up, I would be able to invite leaders on their own transformational journeys. This hypothesis has been proven several times over. I have become the change that I want to see in the world. And at the same time I continue to be a work-in-progress with edges around ego, seeking attention, too attached to ideas, etc.”

He says he is excited to delighted to help managers, executives and coaches become more effective in fostering Agile environments through Scrum Alliance’s new Certified Agile Leadership training program.

 

 

Learn more about our Scrum and Agile training sessions on WorldMindware.comPlease share!
Facebooktwittergoogle_plusredditpinterestlinkedinmail

The post Agile Coach Profile: Michael Sahota appeared first on Agile Advice.

Categories: Blogs

New book! SAFe® 4.0 Reference Guide captures Framework body of knowledge in print and eBook

Agile Product Owner - Fri, 08/19/2016 - 00:37

reference_guide_400Well, we finally got here. After years of people asking for a book on SAFe, I’m happy to say that the SAFe® 4.0 Reference Guide, Scaled Agile Framework® for Lean Software and Systems Engineering is now shipping.

This guide provides the content from scaledagileframework.com, but in book form for easy reference. It’s available in paperback and eBook formats (including Kindle) at major book retailers. Like the SAFe website, it provides comprehensive guidance for work at the enterprise Portfolio, Value Stream, Program, and Team levels. It also includes the various roles, activities, and artifacts that constitute the Framework, along with the foundational elements of values, mindset, principles, and practices.

Why a book, when you can get SAFe online?

We think of the Reference Guide as the ideal companion to the website. You can mark it up, scribble in the margins, read it on the plane, add sticky notes, and highlight relevant sections to make it your own. For example, the first night it was available, a student from our Denmark SPC4 class downloaded the eBook to help him study for the certification exam. He came back the next morning raving about it (I bet he passed his exam). Raves aside, we’re in the training business, and we know from experience that everyone learns and connects to information in different ways, so having SAFe captured in as many forms as possible just makes good sense.

To learn more about the SAFe Reference Guide (and to get some promotional savings!), visit scaledagile.com/reference-guide.

I’d like to thank my co-authors, Alex Yakyma, Richard Knaster, Drew Jemilo, and Inbar Oren, as well as the larger SAFe contributor community. Without this fusion of dedicated people, ideas, challenges, and honest feedback, SAFe wouldn’t be what it is today. It’s an exciting space in which to work as we continue to evolve the Framework, and help enterprises fulfull their mission of building better software and systems.

Stay SAFe!
–Dean

 

Categories: Blogs

Knowledge Sharing


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