Archive for the ‘Community News’ Category

Southern Fried Agile: A shift in perspective

Wednesday, November 5th, 2014

SFALogoIt was a day of firsts. It was the first time where the name and logo for the event indicated the lunch menu (Yes, we had fried chicken for lunch, of course.). It was the first time that I got to see Dave West, Tasktop’s Chief Product Officer, deliver one of his clever, information rich, and hilarious stand up comedy… err… umm… keynote speeches. And, it was the first time for me discussing agile metrics insights with a large agile audience since I left Rally Software and became Tasktop’s Data Scientist.

It represented a big shift in perspective for me — from the perspective of one of the leading agile application lifecycle management (ALM) tool vendors; to a more heterogenous perspective where there is both more than just one tool’s ALM data to analyze AND there is more than just ALM data from which to glean insight.

The perspective of others about me, I noticed, has also shifted. I was Rally’s quant. Now, I’m more of the agile community’s quant. One of the other speakers at the conference heard me speak for the first time and tweeted something to the effect that he would have normally skipped a talk by a vendor as not of much value, but that he was glad he came to my talk. Before, I was biased, now I am perceived as more neutral.

It’s amazing how a change of perspective can make all the difference.

Besides my personal perspective shifts, Southern Fried Agile was representative of a number of other perspective shifts ongoing in the agile community. The attendance was up by roughly 50% from prior years. They sold out in terms of attendance (over 600) AND sponsorship. I didn’t see a single room that wasn’t at least mostly full. Part of the credit for this goes to the excellent way in which it was run (shout out to Neville Poole and Kelley Horton, just two of the organizers that I had personal contact with). However, I think there is a shift in the industry going on here as well. We’ve been saying that, “agile is going mainstream” for a while now, but this is the first year where I think that’s totally true.

Beyond that though, I think there is a broadening of perspective occurring. It used to be that agile was the domain of developers with some input from QA. Now, DevOps, Architecture, Business Analysts, User Experience folks, and the rest of the business are getting into the act. We’re also using analytics more to make software engineering decisions. This broadening of the scope of agile is a definite change in perspective with significant repercussions.

There were many talks at the conference that representing this shift. The alternative title to Dave West’s keynote was, “Building a strategy that marries Scaled Agile, DevOps and Lean Analytics into a transformational approach that will kill any wicked witch”. Dave’s final advice was to focus on four things:

  1. Flow – How information moves around your organization
  2. Collaboration – How people cross teams communicate
  3. Reporting / Analytics – What information we need to see
  4. Traceability – How things are connected and governed

Roughly half of the talks at this conference represent this shift including:

  1. Eric King & Dr. Victoria Ann Kline: What Does Agile in the Non-IT Space Look Like
  2. Tim Wise: How to Successfully Scale Agile in Your Enterprise
  3. Roy Miller: NoOps: More Dev Less Ops
  4. Linda Butt & Todd Biedrzycki: Scaling Agile in the Real World
  5. Brad Murphy: Moving from Agile Software Dev to Scaled Business Agility & Radical Innovation

However, one talk more than any other represented this shift — Mark Wanish, David Poore, and Richard Thomas: “Optimizing the Whole” Development Business & Architecture Delivering in Harmony. I got the sense, both during their talk but perhaps more so when speaking to them outside of their talk that it currently takes a certain kind of leadership and a ton of determination to spread agile outside of the development teams at a larger organization like Bank of America, where they work. The first step was to get the infrastructure, DevOps if you will, to work in a more agile manner. Internal IT shops are competing with (or at least being compared to) hosted services like Amazon Web Services. If you can get a virtual machine in minutes and few clicks there, agile organizations shouldn’t put up with 3-6 month lead time for hardware. They seem to have gotten past that hurdle (or wave as they describe it). The next waves for them are architects, business analysts, and user experience folks.

Be sure to check out some of the presentations that have been posted. Keep coming back as they are still being added.

Note: I still owe this audience a description of why I left Rally and came to Tasktop. Now that we’ve released our Tasktop Data product, I think some folks can start to guess, but I’m now free to talk about that openly and will come back with a blog post on this topic before too long.

CAST 2014 Retrospective

Friday, August 29th, 2014

I recently had the pleasure of attending CAST 2014, the annual conference of the Association for Software Testing, a conference that Tasktop sponsored. If you couldn’t attend the conference, you can watch some of the sessions and get some of the flavor of the conference in the comfort of your home or office via the Association for Software Testing’s YouTube channel.

I’m a proud Tasktopian and wore my Tasktop shirt every day. Since there were no areas reserved for sponsors, that was the only way folks could find me to ask about Tasktop and how we help testers … more on that later. This blog is really about the art and science of testing (which was the conference theme this year) and some of the other controversies that exist within the testing community.

In truth, the thing that’s interesting about CAST is the level to which there is active discourse on the controversies within the testing community. If you’re not immersed in that community, you may think it a very homogeneous discipline. It is far from that; it is LOADED with controversy and differing opinions.

There were many sessions on the central topic: “The Art and Science of Testing.” There are folks that believe that testing software is an extension of the liberal arts, heavy on the use of skills learned by studying psychology, sociology or philosophy… such as developing and using various heuristics. And there are practitioners who feel strongly that testing software is best left to those that have studied engineering or computer science… using the knowledge of how the application was constructed to approach the challenge of testing it. But that was the least of the controversy!

There was quite a bit of heated discussion around a software testing standard being proposed by ISO (the International Standards Organization) and IEEE (the Institute of Electrical and Electronics Engineers). ISO/IEC/IEEE 29119 proposes to define “an internationally-agreed to set of standards for software testing that can be used by any organization when performing any form of software testing.” But much of the conversation at CAST was firmly against this standard, as embodied by a petition to suspend the standard’s publication. It can be difficult to represent a consensus against a particular idea, but it seems that the fundamental concern is that the implementation of standards can easily create dogmatic adherence to a particular process. And the view of software testing as a definable process, flies in the face of the “context driven testing” school of thought. According to CDT, there are no particular best practices that fit every situation – what is required is the expertise of a professional software tester that can bring to bear the right techniques for each particular situation.

This controversy lead right into the discussion around automated testing: with some practitioners claiming that test automation signals a demise of the professional tester and some practitioners with more moderate views. The moderates propose that test automation has important applications, but agree that it is not a panacea. In particular, it’s no silver bullet for overcoming the challenges inherent in organizations seeking to increase the velocity of release cycles through Agile or DevOps initiatives.

One “controversy” that tends to be fairly universal no matter what practitioner-oriented conference I attend, is the schism between testers and developers.

To be honest I never understood the developer – tester antipathy. Everyone on the team has a common goal to deliver the right software, on-time, with the agreed-upon level of quality. As a developer, I never wanted to be viewed as the person who delivered “crap code.” I never checked in code late Friday night, enjoying my weekends, while others were left dealing with the fallout from a broken build. But more selfishly, I never wanted to be awakened in the middle of night to fix my broken code. I tested my code and helped my tester buddies, because to me they were an equal part of the team and, selfishly, the line of defense between me and a 3AM wake up call.

So, it actually gives me great joy that Tasktop helps bring developers and testers together by eliminating some of the tedium introduced because testers and developers use different tools to manage their work… making the little time they have to collaborate “face to face” even more productive and (gasp) enjoyable. The fact of the matter is, most testers DO use tools to manage their plans, test cases (when appropriate) and the defects they find. And these tools are often not the same tools that their dev colleagues use to triage, fix and report the status of defects. And the same is true for the development and management of requirements and user stories.

Tasktop Sync integrates these tools, allowing everyone to use their tool of choice, while collaborating on project artifacts. Moreover, Tasktop Sync can help testing teams turn their existing tools into the “single source of the truth” of project health. (To learn more, read the white paper).

There will never be a shortage of differing opinions among practitioners in software development and delivery. But presumably we’re all in agreement that working together to solve our mutual challenges HAS to be more effective than working at odds.

Tasktop Dev 3.5 and Mylyn 3.11 Released

Monday, April 14th, 2014

Tasktop Dev 3.5 and Mylyn 3.11 are now available. These releases include some cool new features that result from the combined efforts of many people in the Mylyn community and at Tasktop.

Speaking as a Tasktop Dev and Mylyn user, I am already loving the new support for finding text in the task editor. It was originally contributed to Mylyn Incubator a few years ago, but unfortunately the implementation suffered from serious performance problems. Recently I had the pleasure of supervising a Co-op student at Tasktop, Lily Guo, as she reimplemented it with dramatically better performance and improved the UI. Thanks to her efforts this very useful feature is now released and the task editor supports searching for text within the comments, description, summary, and private notes.

Screnshot of Find in the Task Editor

Another long-awaited feature in this release is task-based breakpoint management, which extends the concept of task context to include Java breakpoints. This was implemented as part of a Google Summer of Code project by Sebastian Schmidt, a graduate student at Technical University Munich. It provides several important benefits for Java developers. First, the debugger will not stop at breakpoints that aren’t related to the active task. Second, only breakpoints created while the task was active will appear in the IDE – when working on a task, the breakpoints view and Java editors are no longer cluttered with dozens of irrelevant breakpoints. Because the breakpoints related to a task are only present while that task is active, there is no need to delete or disable these breakpoints – which often contain valuable information such as which lines of code and which runtime conditions trigger a defect – when a task is complete. Finally, breakpoints can be shared with other developers as part of task context.

Screenshot of the context preview page showing breakpoints in the context

In a single view, the Hudson/Jenkins connector provides quick access to status information about selected builds across multiple build servers, even when you are offline. This includes information about build status, build stability, and test failures. But one thing I realized was missing was a quick summary of how many builds are passing, unstable, and failing. This information is now displayed at the top of the Builds view and, when the view is minimized, in a tooltip, making it really easy to tell when there’s a change in the number of failing or unstable builds.

Screenshot of builds view showing summary of build statuses

This release also includes a number of bug fixes and enhancements to the Gerrit connector. Among them are support for comparing images, buttons for navigating to the next/previous inline comment in the compare editor, and a code review dashboard that lets you see which of your changes have been reviewed and whether they have passing or failing builds. The connector also remembers your previous votes on a patch set, so that posting additional comments doesn’t reset your vote. Thanks to Jacques Bouthillier and Guy Perron from Ericsson for their work on comment navigation and the dashboard.

Screenshot of the Code Review Dashboard

To help you prioritize the tasks you are responsible for, a “Show only my tasks” filter has been added to the task list, and the tooltip uses the gold person icon to accentuate those tasks.

Screenshot of the task list showing the new filter button

Tasktop Dev 3.5 is built on Mylyn 3.11, including all of the above features. This release includes a number of bug fixes as well as support for VersionOne 2013. We have also upgraded Tasktop Dev for Visual Studio to support Visual Studio 2013, bringing the benefits of a unified task list to users of that IDE.

For more information, see Tasktop Dev New & Noteworthy and Mylyn New & Noteworthy, or try out Tasktop Dev and Mylyn for yourself.

Viva Eclipse Kepler!

Monday, July 15th, 2013

Say what? Another Eclipse DemoCamp at Tasktop? That’s right, and it was something to brag about! Tasktop Technologies, the Eclipse Foundation, and Pivotal hosted Eclipse Kepler DemoCamp at Tasktop HQ in downtown Vancouver for Eclipse enthusiasts, faculty and students who work with the Eclipse IDE.

The evening began with networking and snacks. We opted for delectable aliments doigt, with fine cheeses, le sandwiches, stuffed mushrooms and seafood, instead of pizza and pop that has become the staple food of many a developer (not you, of course, we know you have a more sophisticated palate).

David Green and Andrew Eisenberg then kicked off the evening with event intros and warm welcomes…

…followed by an icebreaker game…

This year, we played Big Data, where each participant was asked to gather data about other attendees. We thoroughly enjoyed it, maybe because we’re all geeks.

After the game, the data was collected and collated. It is now ready to be map-reduced by Hadoop. Here are the resulting statistics of the make-up of this year’s DemoCamp participants:

Yes No
Attended EclipseCon? 6 31
Commiter? 8 16
Student? 10 19
Created plugin? 21 9
Raised a bug? 8 7
Contributed? 10 13
Program daily? 40 5
Java? 21 8
IntelliJ? 0 29
Netbeans? 0.5 47
CS degree? 16 4

Note: these results reflect the skills of first time data-collectors (ie: numbers may not approximate reality).

…with all the attendees warmed up and well fed, the presentations followed…

David Green (Tasktop) Showed off the new super-secret tooling in Eclipse for working with GitHub.

Nieraj Singh and Kris De Volder (Pivotal) showed some of the new features of Spring Tool Suite 3.3.0, including the new Quick search feature and getting started guides.

Rafael Chaves (Abstratt) presented Cloudifier, a platform for rapid application development/deployment built on Eclipse Orion.

Deepak Azad (UBC) demoed new features in Eclipse JDT for the Kepler release, mostly new quick fixes and null type inferencing improvements.

Robin Salkeld (UBC) introduced holographic JVMs and a way to debug Java heap dumps. His technique allows you to attach a Java debugger to a heap dump and then execute queries against it using the Java debug interface.

Brendan Cleary (UVic Chisel) showed off Atlantis, which is a file viewer for massively huge files (60 Gb+). He described how Atlantis is used by the Canadian government for analyzing trace files to look for potential security breaches.

After the last presentation, everyone headed out for drinks to celebrate another successful Eclipse DemoCamp. Cheers!

AndrewA warm thank you must got out to Andrew Eisenberg for co-authoring this blog, as well as to all other organizers, sponsors and speakers who contributed their time and energy to making this event a success. If you’d like to be a speaker during a future Eclipse DemoCamp, please contact us. It’s a wonderful opportunity to show your stuff in a supportive circle of other Eclipse enthusiasts and have some fun while you’re at it. See you all next year!

Deep inside an Eclipse Hackathon, where the future Eclipse submitters are born

Friday, November 16th, 2012

Eclipse Hackathon 2012 A room full of developers and students, cans of beer loosely scattered around the room, along with bags of chips, pop and pizza. It’s a setup that would make more sense for a party, were it not for everyone clustering around power cords and loud finger tapping of engineers ripping up their laptops.

Sticking to traditional hackathon culture, there was a whole lot of coding, lots of beer, and happy chit chat mixed with serious faces betraying some heavy problem solving, in a word: hackathon-fun!

Eclipse Hackathon 2012

In attendence: several experienced Eclipse submitters, students from SFU and UBC, and other Eclipse enthusiasts. Projects hacked on: JDT UI, Scripted, Orion and Mylyn (for project details see the wiki page).

Eclipse Hackathon 2012It was great to have Ian Skerrett from the Eclipse Foundataion attend and hack away with all the others. Great many ideas were thrown around and many a bug got fixed. Newbies got to learn a lot about Gerrit & Mylyn and how to contribute to open source. Thanx to all who attended and made the night that much better!

See more photos from the event.

ALM analyst panel at EclipseCon 2012 with Dave West, Melinda Ballou, James Governor and Mik

Thursday, August 16th, 2012

At this year’s Agile ALM Connect sub-conference of EclipseCon 2012 Mik Kersten moderated a very lively analyst panel with a few of the leading analysts in ALM: Melinda Ballou of IDC, James Governor of RedMonk and Dave West (then at Forrester). Enjoy.

Tasktop’s Austin Office Now Open

Monday, August 13th, 2012

As someone who has lived in and around the Austin entrepreneurial scene for nearly the past decade, I am very excited about this announcement. In all the companies that I’ve managed while living in Austin from SolarMetric to SpringSource to Lexcycle, this is the first time a company I’ve been involved with had a real physical presence in Austin. I am thrilled about this. I feel like Austin has given me so much over the years but for whatever reason, I’ve generally been a solo flyer in Austin in all of my previous companies. At SolarMetric, we had one other person in Austin but with SpringSource and Lexcycle, I was the only one here. When I joined Vancouver-headquartered Tasktop on a day-to-day basis 2 years ago, most of my fellow ATXers rolled their eyes as I had yet again managed not to work for an Austin company.

As it turns out, Tasktop is different, and this announcement of our new office is evidence of that difference. I am excited to have launched the new office with a couple of fabulous women prominent in the local scene, Nicole Bryan and Melanie Wise. We plan to grow the office in coming months and years as we build out our business development, marketing, sales operations, solutions and the other areas of the company that I get to work with on a day-to-day basis.

Austin also has a little known Application Lifecycle Management (ALM) mafia with many of Tasktop’s partners who participate in the software value chain having a presence in Austin making Austin a perfect place for Tasktop’s US Headquarters.

Austin has been a big part of my growth as an entrepreneur, a businessman and a person. For those familiar with my time in Austin especially in the local tech start-up scene, I am grateful to:

greenbullet_icon Brett for his timely and very important advice
greenbullet_icon Josh letting me squat in his offices and including me in Capital Factory as mentor helping me re-engage in Austin
greenbullet_icon Jonathan and our never-ending search for the ultimate breakfast taco
greenbullet_icon Lisa being so supportive of Tasktop, helping us grow out our presence in Austin
greenbullet_icon Kyle’s big heart and soul
greenbullet_icon Mark and Greg and being able to reconnect

and so many more people that I apologize I am not mentioning.

One of the biggest influences on me during my nine years here in Austin has been Bijoy. I learned about Bootstrap Austin and met Bijoy right after we moved. Bijoy and I have debated and imbibed and debated. Those debates (is it really a debate when 1 person keeps being right?) have challenged me and caused me to assess and reassess. Although my crazy hair has come and gone, Bijoy and his hair have been one of the constants. I’m very proud of the fact that Tasktop is still bootstrapped since its founding in 2007, and I suspect that fact gives me a little cred with my friend who has gotten me to care far more about the journey than the destination.

My very first Bootstrap meeting was at the IC2 Institute in 2003 – I believe Dr. Darius spoke. If I am not mistaken, that is where I met Chad Jewell who 9 years later, helped us find our new office (even though I hadn’t spoken to the guy in at least 5 years). That’s Austin.

Also, I’d like to thank Lynn at Expero and look forward to spending time with her team in our shared location.

There is nothing like leaving a place to really appreciate it, and I had the fortune of doing so when we did our brief 1 year dalliance in Seattle. We made many good friends in Seattle but it probably wasn’t fair. Had I moved to Seattle from other places I’ve lived e.g., Boston or Morristown or Chicago, I may have fallen for Seattle. But unfortunately, my foil was the ATX and that is a tough act to follow.

And of course the family. Austin is home – its where Sharon and I decided to pitch our tent, its where my kids were born, and its where I plan on spending my twilight years wearing bad shirts and someday, even worse pants.

So, if you get a chance stop by and check us out.

Video interview with Dave West on joining Tasktop as Chief Product Officer

Wednesday, May 2nd, 2012

I recently sat down with Dave West and Mik Kersten in Austin, TX in order to discuss the significance of Dave joining Tasktop. I think it comes across in the video but for me personally, one of the best things about Dave joining is that we are going to have a lot of fun while we transform the world.

Read more in Dave’s post, Mik’s post and my post on the topic.

Incremental code coverage as a debugging tool

Monday, March 12th, 2012

(See also this article’s translation to Serbo-Croatian language by Vera Djuraskovic at

I joined Tasktop in part because I share the goal of increasing programmer productivity, especially by filtering out unimportant information.  I also liked how Tasktop is committed to being involved with and connected to the broader Eclipse community.

In this spirit, I suggested a feature to the EclEmma project: letting developers create and view incremental code coverage results.  This would let developers see a much smaller, but more relevant, set of classes and methods which they could then investigate.

It had bothered me how difficult it was to find where things happen in code, especially in large, unfamiliar code bases.  Yes, you can step through the code, but sometimes you have to step for a long time.  This is boring and tedious, and frequently you step one step too far and overshoot the place you wanted to see — losing the information about the values of the variables at the point you cared about.  If an asynchronous process gets spawned as the result of a Listener attached to a GUI element, it is nearly impossible to step through.

You can search for text on or around the GUI element to help you find where the actions related to that element are processed, but sometimes this isn’t practical.  Sometimes the GUI element has text that is so common that it is impractical to search for it, like “Finish” or “Next”.  Sometimes the GUI element doesn’t have text associated with it, like a button with a picture on it (and no tooltip).

In practice, I have observed that people usually guess at what words might be included in the class or method names, and then when they think they are close, simulate stepping through code by reading through it and making informed guesses about where the execution flow will go.  Unfortunately, frequently they guess wrong, usually in the choice of a starting point or the value of an if-condition.

Another particularly pernicious mistake is not realizing that you are tracing through a superclass of the class that is actually executed.  If you Command/control-click on a method name, Eclipse will preferentially take you to the implementation of that method in the same class; this means that if you ever trace into a superclass, Eclipse will tend to keep you in the superclass; realizing that you need to go back to the subclass is not always obvious.

I thus suggested to the EclEmma code coverage team that they add a feature to the code coverage tool to let users start and stop coverage so that they can see which code was executed for specific short periods of the execution.

With the 2.1 release of EclEmma, the EclEmma team has implemented incremental code coverage — a very useful feature!

How to use it

First, install EclEmma.

Next, go to Preferences > Java-Code Coverage, and check the “Reset execution data on dump”.

Open a Coverage view.  In the Coverage toolbar, there is a “Dump Execution Data” button.

Pressing the “Dump” button will now display coverage and reset the code coverage results.  Thus, if you press the dump button right *before* you do the action you are interested in (e.g. pressing a certain button), and then again right after you do the action, then the code coverage results will show only the exact classes and methods that were executed in response to that action.  Among other things, this means you won’t get misled to look in the superclass instead of the appropriate class.

If you need finer-grained information about which code executed, EclEmma colours your lines of code based on whether they were executed in that interval: green if they were fully executed, red if they were not executed at all, and yellow if they were partially executed (if, for example, the line uses a “?” ternary operator, as in the “drightSide” assignment below).

By default, EclEmma only shows coverage information for your code, not for all the libraries you bring in.  To change this, uncheck “Source folders only” in Preferences > Java > Code Coverage.

Note: while for code coverage, you probably want to see the coverage results for all classes and methods, when using incremental code coverage to locate places in code, you should select “Hide unused elements” from the Coverage toolbar’s drop-down menu.

Incremental code coverage is a very powerful technique: instead of wandering through thousands of classes and methods to find the handful of classes and methods that are interesting, you can spend a few minutes to get their names directly.

I do need to give a slight caveat: exceptions interfere with the code coverage instrumentation, interrupting the marking of that branch of code as executed.  That is a known limitation with the way that code coverage is done.  Thus if your code uses exceptions a lot, EclEmma might incorrectly say that a branch of code was not executed when it was in fact executed.   However, if EclEmma tells you that code was executed, it really was executed.

Using EclEmma in conjunction with Tasktop Dev or Mylyn is an exciting prospect.  Mylyn and Tasktop Dev tell you what you (or someone else, if you are looking at their context) had looked at; EclEmma gives you hints on what you should look at. We have only just started thinking about how those two could be combined, but are excited by the possibilities.

For further information, see EclEmma, Tasktop Dev, or Mylyn.

Note: the screenshots used from the open-source Java GIS tool GpsPrune, isolating the action of showing the scale legend.

Independent Technology Audit for Tasktop Sync from Ovum’s Azoff

Tuesday, March 6th, 2012

Ovum Technology Audit
of Tasktop Sync, Version 2.0
Author: Michael Azoff, Principal Analyst, Software – IT Solutions
Date: February 2012 ( NO LONGER AVAILBLE for download )

For a limited time, we’re excited to make available to our customers and users the Ovum Technology Audit for Tasktop Sync (registration required). Technology Audits are independent product reviews done by Ovum analysts.

Recently named as a Power100, Michael Azoff handled this Technology Audit. Azoff focuses on Agile practices, DevOps, and software development lifecycle management (SDLM) especially when related to the cloud. I feel like I’ve been briefing Michael for half a decade through a couple of different companies. Michael definitely gets our partners’ businesses, and I am glad that he evaluated Tasktop Sync.

You might be wondering “why should I read another piece of marketing from Tasktop?” The main reason is that this is not pure Tasktop marketing but rather a proper analyst report.

A lot of folks don’t know how analyst Technology Assessments (TA) work so I thought I would share the process by which we were able to make this TA available. We went through a stringent process with Ovum… extensive written questionnaires followed by verbal interviews. At the end of the effort, we were given a chance to review a draft of the TA to ensure that the facts were correct, and then Ovum published the TA making it available to its research customers. We felt that the TA gave a fair and accurate representation of Tasktop Sync as well as some great insight on what types of companies would be most successful using Tasktop Sync so we decided to go ahead and distribute the TA for a few months.

We are hopeful that you will find this content compelling. In particular, the TA highlights some deployment scenarios and how Sync customers are using Tasktop Sync to connect their software development lifecycle. Additionally, the TA also goes on to talk about some areas of strategic growth for Tasktop Sync… we’ve been getting increasing requests from customers for integrations and synchronization with Product Portfolio Management (PPM) tools and Helpdesk / ITSM tools.