Skip to content


An Introduction to Monoids

About SCRUM - Hamid Shojaee Axosoft - Thu, 03/23/2017 - 17:30

When you think of programming, you might not immediately think of mathematics. In the day-to-day practice of writing software it’s often hard to see much theory behind REST requests and database schema migrations.

There is, however, a rich world of theory that applies to the work we do, from basic data structures to architectural patterns. This is the field of category theory, sometimes described as “the mathematics of mathematics”. Category theory is concerned with structure and the ways of converting between structures.

NOTE: This article is based on an Axosoft Dev Talk I recently gave, also titled Practical Category Theory: Monoids. Watch that video or keep reading!

Hopefully this sounds like the kind of thing you’re familiar with as a programmer, and if it doesn’t, hopefully it just sounds like a good ol’ time. After all, category theory doesn’t care about specifics; it’s abstract, which helps it be applicable to a great many fields.

Software therefore needs to apply the concepts of category theory to match the realities of programs that execute on real computers. You may have heard of some of these, especially if you’ve looked into statically typed functional programming languages such as Haskell, OCaml, F#, or Scala.


In talking about Monoids, we actually need to talk about two structures: the Semigroup and the Monoid. A Monoid is a superset of a Semigroup, so let’s start there. The Semigroup is a simple structure that has to do with combining. In the following example, I’ve combined two strings with an operator such as +:

helloWorld = “Hello” + “world”

And in this example, I’ve created a concatenating list:

parts = concat([“Parsley”, “Sage”, “Rosemary”], [“Thyme”])

Both these examples have some similar properties. They take two values of a certain shape and combine them into a single value of the same shape. We don’t take two strings and combine them to get a number or an array; it’s quite reasonable to expect the result remain a string.

Let’s start with just this single property, that there is some “append” operation that takes in two values of some type and gives back a combined result of that same type. In various languages this might look like:

T Append(T first, T second)
Javascript with Flow
append(first : T, second : T) : T
Haskell, Elm, PureScript
append :: t -> t -> t

This may not seem like a particularly novel thing to do, after all, you probably do this sort of operation all the time on various kinds of data. Remember though, that we’re talking about a concept from category theory, so while the above type signatures are the end of the story in terms of what that compiler can enforce, we are obligated to obey a few more rules.

These rules are “things that must remain true,” and in math we call these laws. You’re already familiar with tons of these laws even if you haven’t heard them referred to as such. One example is with addition. When adding two numbers you can freely swap the order of the arguments, so 1 + 2 is the same as 2 + 1. This is the commutative property, and the law here is that swapping the order doesn’t affect the resulting value.

For Semigroups, we must obey the associative property, which has the law that the order in which you combine things does not matter. That is

(“hello” + “ “) + “world”

is the same as

“hello” + (“ “ + “world”)

As you can see this doesn’t mean we can swap the order, just that we can do our combine operation on any two adjacent elements, and when we’re all done we’ll end up with the same result.

The append operation is whatever you want it to be (as long as it obeys the rules)

Consider CSS classes. They’re kind of like a string, except when you combine them you don’t just shove them together; it’s more like we’re doing a join operation using a comma and space as the separator:

“app” + “button” + “selected”

should turn out to be

“app, button, selected”

CSS classes aren’t the only type where this is true; if you think in terms of Semigroups, there are lots of cases where fundamentally we’re combining two things of the same type, and that type has a unique rule around how to do the combination.

That’s actually all there is to Semigroup, an append operation that is associative. If you’re feeling underwhelmed, don’t feel bad! I was hardly excited when I first encountered the idea. Let’s dig a bit deeper to see how this unassuming structure punches quite a bit above its weight class.

For the purposes of grounding our discussion, let’s pick a few types that satisfy the rules of Semigroup. List is a straightforward data structure that every mainstream language supports (even if it’s named something else), so we’ll talk in terms of Lists moving forward.

Depending on the language you’re using, you might be able to express Semigroup as an interface or protocol, and you might be able to implement that interface/protocol on your language’s List type. If not, don’t fret! These ideas are still useful and applicable even if your language doesn’t give you a way to represent it in your type system (or if you’re using a dynamic language and don’t have a static type system). I’ll use square brackets to represent a list and the ++ operator for my List’s “append” operation.

bandMembers = [“Stevie”, “Lindsay”] ++ [“Christine”, “John”, “Mick”]

The second type we’ll consider is the String. For our discussion, we’ll use the same ++ operator to concatenate Strings.

greeting = “Hello” ++ “ “ ++ “World”
Interesting attribute #1: Semigroups are partition friendly

Consider the following SQL related code:

databaseQuery = selection ++ table ++ constraints

At the end of the day, we want to have a nice query we can use to get a result from the database. If our top level value is a String that makes up our query, then the associativity of Semigroups means that we have a lot of flexibility in building this up.

One example of this might be in building up the selection. We want to end up with something like:

select * from

or if we want specific columns:

select a, b from

It seems reasonable to build up this String from some fixed parts, the “select” and “from” mixed with some customizable parts, the “*” or “a, b”.

selection = “select “ ++ ”a, b” ++ “ from “

The resulting String will be combined with the other elements of the query, but it doesn’t matter when we decide to combine the elements, we could defer the column name conversion to a String by leaving it as a List.

selectionParts = [“select ”, [“a”, “b”], “ from”]

When we’re ready for a selection String, we could combine the column names first, then combine the resulting String with the other two parts. This same flexibility in when to go from a more structured form into a final string, is present in other parts of the query as well.

table = “myTableName”
constraintParts = [“where “, constraint1, “ AND “, constraint2]
constraint1 = [columnName, “ IS “, value]
constraint2 = [columnName2, “ NOT “, value2]

As developers, we can decide when it’s best to go from the representation of values in Lists to a final String form—either for a part or for the whole of our query. We can defer this decision through the layers of functions used to build up the query, and we know we can go from parts to whole for any section of the query—independent of any other part, and nothing will change.

We originally had:

databaseQuery = selection ++ table ++ constraints

Let’s see what the query might look like if we had all of the bits inlined:

databaseQuery = “select “ ++ “a, b” ++ “ from “ ++ “myTableName” ++ “ where “ ++ columnName ++ “ IS “ ++ value ++ “ AND “ ++ columnName2 ++ “ NOT “ ++ value2

If we were to recreate the order of operations in the original version, it would require us to group our values into 3 parts:

databaseQuery = (“select “ ++ “a, b” ++ “ from “) ++ (“myTableName”) ++ (“ where “ ++ columnName ++ “ IS “ ++ value ++ “ AND “ ++ columnName2 ++ “ NOT “ ++ value2)

But because of associativity, these are exactly the same. We can group the individual combinations however we want, which is effectively what we would be doing along the way by collapsing the various query parts into selection, table, and constraints.

This might seem obvious (after all we’re dealing with Strings), but the ability to arbitrarily partition your data and combine it, is useful for more exotic types as well. Imagine you have a type Log that represents a single logging event and is a Semigroup. You might have files filled with Logs spread across files that are rotated, grouped by date or time range, or some other bucketing criteria. Being a Semigroup means you can combine adjacent Logs into an aggregate Log in any order you want. You could split up the work of combining Logs across multiple threads and know that it is still 100% safe to combine the individual thread’s results into a final result.

Interesting attribute #2: Semigroups are “incremental combination” friendly

Carrying on with the idea of Logs, consider a remote logging service that accepts Logs from your various servers and aggregates them down into something you can do reporting on. If we still have a Log type that is a Semigroup, we have a lot of freedom in how we proceed. For example, when a Log is generated by one of your servers, it could send it immediately, or combine some number of Logs before sending them:

Remote Logging Server Worker Server Log <-worker sends Log immediately– Log Log ++ Log Log Remote Logging Server Worker Server Local Batching Log Log –> Log Log Log Log –> Log Log Log ++ Log …repeat until n logs or time limit reached… Log <-worker sends batched Log– Log

On the receiving end, you could accept the Logs and combine them with the main log as they arrive, or you could batch them:

Remote Logging Server Worker Servers Log <– Log Log ++ Log Remote Logging Server Local Batching Worker Servers Log <– Log Log Log Log Log <– Log Log Log ++ Log …repeat until n Logs or time limit reached… Log <– Log Log ++ Log Monoids

Ok, that’s a lot of things we can do with Semigroups, so where do Monoids fit in? Thankfully, Monoids are, by comparison, very simple. They are everything that a Semigroup is, plus an “empty” value of the type.

For Strings, this would be an empty string; for Lists it would be an empty List; for Logs… well, that’s slightly less clear. If you can define a concept of an empty value for your type though, then congratulations, your type is a Monoid. The types signatures for this sort of thing look like this:

T Empty
Javascript with Flow
empty : T
Haskell, PureScript, Elm
empty :: t

You guessed it! There are laws that go along with Monoids, and this time there are two: the left and right identity. These state that combining the empty element with any value shouldn’t change the meaning of the value. That is, the empty element is an identity value for that type. Looking at the String we see that

“” ++ “some string”

is the same as

“some string”

This works on either the left or right side (hence the left/right identity):

“some string” ++ “”

is the same as

“some string”

This comes in handy when you want to append values but you don’t want to distinguish between having zero and having one already. Consider the case of the remote logging service:

Remote Logging Server Worker Server Log <-worker sends Log immediately– Log Log ++ Log

Where did that Log that the Remote Logging Service starts with come from? If Log is a Semigroup then we’d need to generate it somehow. However, if Log is a Monoid, we have our answer: the initial Log value on the Remote Logging Server is the “empty” value of Log. Since combining the empty value with a Log doesn’t change the Log, this is safe to assume, and now we can deal exclusively in terms of Log ++ Log operations. Less special cases means happier developers™.

There are lots more fun use cases for Monoids. One example is taking a Monoidal type in a list and running it through a fold/reduce/Aggregate operation, where the fold function is appended and the initial value is empty. You could write a specialized fold that only works for Lists of Monoids but can aggregate them with no other information needed.

Go forth and aggregate!

For something so simple as having an append operation, an empty value, and the associative property, I hope you’ll agree there’s a lot of depth to Semigroups and Monoids. This is just the tip of the categorical iceberg though. Due to its abstract nature, category theory can describe a variety of structures, and best yet, be supported by lots of formal reasoning (aka proofs).

This formal reasoning can give us a lot of confidence that what we’re doing really will work as long as we’re implementing our types in accordance with the laws of the structure. If you’re looking for next steps, Functor is a mild step up in complexity, but it’s equally as rich in terms of applications and reach.

Categories: Companies

April Fools Ideas for Techies

About SCRUM - Hamid Shojaee Axosoft - Wed, 03/22/2017 - 17:28

I am not much of an April Fool’s Day fan. Not everyone can achieve the giddy heights of, say, the BBC’s oldie but goodie prank on its viewers 60 years ago, and attempts to do so can be sadly ineffective. Nonetheless, April 1st is almost upon us, and as we welcome Spring back into our lives, we must also endure the one day that our workplace prankster (we’ll call him Tad) comes into his or her own.

It doesn’t have to be this way. You can strike at Tad first, as long as you have a few ideas up your sleeve. Here are some classic and alternative ways to make sure that Tad—and his silly unmatching socks and zany ties—don’t mess with you in the future.

WARNING: The following pranks can result in being:

  1. Tame to the point of failure: Prank is so tame it may genuinely go unnoticed, forever, with no consequences.
  2. Pretty underwhelming: Tad can easily shake it off.
  3. Mildly-to-actually annoying: This is the level you’re shooting for. These pranks hopefully disrupt Tad’s flow for long enough to give him a taste of his own medicine.
  4. Instant dismissal: Tad’s a real bore, but that doesn’t make it a good idea to pants him in the cafeteria or toss his laptop over the side of the balcony.
  5. Arrest: This includes but is not limited to: murder (murder is not a prank), violence, aggressive nudity, arson.

Ok, let’s get this out of the way so we can carry on enjoying our lives!

NOTE: A couple of these pranks are aimed at MacOS users, although they’re likely achievable on other platforms. They also require access to Tad’s work machine. To gain the element of surprise, consider a diversion tactic of your choice, or implement one or more of these pranks early (or even better, in August). 1. The low hanging fruit: Chrome Extensions

A good prank needn’t take the week to plan, and for the half-hearted pranksters out there, most of the heavy lifting has been done for you through the gift of Chrome extensions. It turns out there are a lot of good ones out there, but here are a few to get your creative juices flowing:

  • April First Prank Toolkit: You’ll be shocked to hear that April First Prank Toolkit is a toolkit specifically aimed at pranking people on April first. It has a bunch of options for easy-yet-effective prankage; some pranks are more subtle than others (and therefore, IMO, more effective as slow-burner pranks). These include hiding the cursor and randomly reloading tabs–actions that make it less immediately obvious that your victim has fallen fowl to a dastardly prank!
  • Prank ‘Em: Another toolkit; this one allows for subtle irritations such as a flash on the screen. Every setting has a frequency slider too, so you can make things happen intermittently for better covert prankular tactics.
  • Cenafy: This does one thing and one thing only (1/100 of the time): Gives you John Cena. It’s infrequent enough to be another winning slow-burner.
2. Keyboard typing replacements MacOS only

This one is short and sweet. Go to System Preferences > Keyboard and click the Text tab. Click the + symbol. From there you can replace ‘the’ with ‘teh’, for example.

NOTE: This replacement doesn’t work on every application, so you may have to be patient to see the fruits of your labors.

3. Application Overload MacOS only

Let’s get a bit more serious. In this prank, we’re going to create an AppleScript application that launches applications in a way that Tad isn’t expecting. When he launches Word, he expects Word to launch just once! Classic Tad. Let’s say you want to launch 20 instances of Word instead. Here goes:

  1. Open Script Editor (found in Applications Utilities)
  2. Select New Document
  3. Add the following script:
    on run
        set wordPath to "/Applications/Microsoft Office 2011/Microsoft"
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
    end run
  4. What does that do? Well, it assigns the path of Word to a variable. We can then run a shell script to open that path and activate the app. Now, lines 3 and 4 are crucial, because we’re going to call them again—19 more times (or however many you want to do:
    on run
        set wordPath to "/Applications/Microsoft Office 2011/Microsoft"
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
        do shell script "open -n " & quoted form of wordPath
        tell application "Microsoft Word" to activate
    end run
  5. Go to File Save
  6. Choose File Format: Application and call it “Microsoft Word”. Save it in a discrete location

  1. Hit Save
  2. You now have an app that will run Word 20 times when opened. But it still looks like a script!

  1. Find the REAL MS Word, right-click and select Get Info
  2. Click the application icon in the top-right and hit command + c
  3. Find your script, get info and click the script’s icon
  4. Hit command + v
  5. You now have an app that looks just like Word. Replace the actual Word icon in the dock and you’re set! This can be adapted to suit your needs. Maybe only have it launch Word twice—that’s enough to be a mild yet persistent annoyance. Or, have it open a nice selection of other applications.

4. Grunt Task Tomfoolery

This one’s a tad (ha!) obscure, but might be fun. WARNING: It could also be a fireable offense if your prank somehow makes it to production. You have been warned!

Let’s say Tad is working on a bunch of projects (typical Tad), and he uses Grunt to automate his tasks and build his websites. Open up one of his projects in the terminal and type:

npm install grunt-string-replace

Now open up Tad’s Gruntfile and add the task:


In his build tasks, add 'string-replace' to the array of tasks.

Next, define that task! In the following example we’re focusing on the build folder, and it’s last in our list of tasks (this ensures that our hard work isn’t overwritten by subsequent tasks). We’re searching for all html files and replacing ‘the’ with ‘teh’ using a regular expression (defining a string as a pattern will only change the first instance).

'string-replace': {
    dist: {
        files: [{
            expand: true,
            cwd: 'build/',
            src: '**/*.html',
            dest: 'build/'
        options: {
            replacements: [{
                pattern: /the /g,
                replacement: 'teh '

That’s it. Sit back and wait for Tad to run a build task. Of course, you could get more inventive with the replacements and perhaps only target one or two files. However, most importantly, remember that I never, ever, recommended you do this to anyone. Ever. Don’t do it.

Categories: Companies

Deprecating private impediments

TargetProcess - Edge of Chaos Blog - Tue, 03/21/2017 - 17:01

Good day everyone!

In our efforts to continuously improve the Targetprocess experience for you, we're analyzing the performance of some core features, such as visualizing your data on dozens of different views or accessing that data through our API. It's a well-known fact in the software engineering industry that every feature comes with a cost. Unfortunately, sometimes the features we build become obsolete or just don't fire off at all. In a perfect world, such features would be free or extremely cheap to maintain and we could simply ignore them. However, the real world is much more cruel, and quite often there is a cost associated with the ongoing support of these features.

Our "private impediments" feature is a good example of this. According to our analysis, its usage is close to none, but it adds a significant performance overhead to our data querying operations, most notably for inbound/outbound relations lookup. Therefore, we'd like to remove private impediments from Targetprocess in our upcoming release.

So, what does this mean for you?

If you don't use impediments at all, then nothing changes for you. If you use impediments but don't use the "Private" flag on them, then once again nothing changes for you. If you have private impediments, they will be deleted from your Targetprocess account, unless you make them public before the new release.

Wait, what? Are you really going to delete my private impediments?!

Well, yeah, but we've thought this through. There are basically 2 options: either delete them, or make them public. We assumed that it would be terrible to make someone's private data publicly visible. Also, given the fact that the private impediment usage is quite low, and we also continuously make backups for our on-demand instances, we'd be able to restore the data for individual customers if you ask us to.

Hopefully, this all makes sense for you. Don't hesitate to get in touch and contact our support if you have any questions!

Categories: Companies

Axosoft Dev Talk: React and Redux

About SCRUM - Hamid Shojaee Axosoft - Tue, 03/21/2017 - 16:32

In this talk, GitKraken developer Tyler Wanek discusses React and Redux, and their uses for one-way dataflow. Tyler will be using the following repo as an example:

Fork and play along!

Part 1

Part 2

Part 3

Categories: Companies

How to open views with the currently selected Projects and Teams

TargetProcess - Edge of Chaos Blog - Thu, 03/16/2017 - 10:22

Some time ago, we redesigned the Projects-Teams selector. It became a part of views, and the global selector was removed. This helped to standardize and simplify views, but made it impossible to set Projects and Teams just once and navigate through several views with that selection.

To make this scenario work, in v.3.11.0 we’ve implemented a keyboard shortcut that lets you navigate to a new view with the currently selected Projects and Teams.

As usual, you can select the needed Projects and Teams in the selector on the top of the view (this selection won't override the predefined Projects and Teams for this view).


Explore the data. If you need to navigate to another view with the same selected Projects and Teams, simply hold Alt and click on the view you wish to explore.


As a result, the view will be opened using the Projects and Teams that were selected on the previous view.


You can use Alt+Click to navigate through any number of views with the currently selected Projects and Teams.

For more details on how the Projects and Teams selector works, see the guide post.

Categories: Companies

Targetprocess v.3.11.0: multiple final states, team mentions, Project selector in Reports, and plenty of fixed bugs.

TargetProcess - Edge of Chaos Blog - Wed, 03/15/2017 - 20:09
Redesigned Settings

We've done some housekeeping over the last few months. As a result, the Targetprocess Settings page has a new look and feel. We hope we've made it more pleasant to work with.

As before, you can reach Settings by clicking the gear icon at the top right corner. 


We've regrouped all settings into logical sections to make it easier to quickly find the options you need. You may need some time to get used to new grouping, but it makes much more sense arranged this way.

We have completely reworked the Tags section. You can read more about this here. We've also removed the Team section from Settings, as it's more easier to assign multiple users to Projects and Teams right from the Project or Team view. You can read more about this here.

Regular users have access to Import and the Diagnostic and Logs section. Admin users will see the following groups:



Multiple final project states

There used to be no easy way to find out if a closed bug was rejected or fixed.

You can now use multiple final project states for this. For example, let's say I want to set a new kind of resolution for a Bug or Request. I would go to Process Setup > Bug Workflow, set up Rejected and Duplicate bug states, mark them as final, and set the Completed state as the default final state. All 3 states have the semantic of a “final” state — cards in this state will be grayed out, end dates will be set automatically when the entity moves to these states, and filters with 'IsFinal' will be applied. 

Multiple final states are not supported if you use Team Workflows.

Mention Teams in comments

When you start typing several symbols after an '@' symbol, you will now not only see a list of users, but also a list of teams above the users. If you mention a team, then all its members receive an email notification. In the comment, the mentioned Team (or User) becomes a link to the Team's (or User's) view.

Shortcut 'alt+click' opens next View with the current Team/Project context applied

This is a solution that will be helpful for anyone who uses the same set of boards for different Teams or Projects. You can now set your Projects and Teams selection just once and navigate through several views with that selection.

To make such scenarios work, you can do the following: Select the Projects and Teams you wish to see using the selector at the top of the view. To open another view using the selection you just applied, you can hold the ‘Alt’ key and click on the new view in the left menu. For more details visit the post.

Project/Team selector added to Process Control, Cycle Time Distribution, Relations Network charts

You will no longer have to set the proper Project or Team before you go into Reports, or have to close a Report to reach the context menu. Now you have a Team/Project selector right in Report Settings.


Cumulative Flow and Burn Down charts:

You can now easily change the selected Project using a dropdown list.


Project board now shows active and inactive projects in different shades

Inactive project cards are now slightly greyed out, as disabled elements usually look like. Hover your mouse over the card to see its details pop-up; all of these units will be greyed out as well.


CSV import Features

We've improved CSV import a bit. Now when you import a batch of Features, you can map them to a parent Epic so that they get to the right place in your work hierarchy.

Cards and Axes sorting order unified

We groomed sorting inconsistency a bit. Earlier, Release lanes were sorted by Creation Date while Release cards were sorted by Project. That was a bit weird, so now cards or lanes of the same entity type have a unified sorting order - Releases are sorted by Start Date.

Service Desk Widget in Targetprocess

We migrated from UserVoice to our very own Service Desk and updated the 'Contact Us' widget. Now you can post your issues and ideas right from the widget and navigate easily to our Service Desk portal.

screen-shot-2017-03-07-at-5-06-18-pm Fixed Bugs
  • You can now send images and attachments in comments with email notifications
  • Fixed DSL filters to find items with attachments. The following filters will now work: '?attachments.count>0'  and '?Attachments.Where(Name is 'log.txt')'
  • Timesheet: time improperly associated a NULL role if added by a user whose role was not responsible for that entity
  • Fixed possible effort inconsistency when applying metric results
  • Fixed comment losses which occurred if the 'Source' button was clicked twice.
  • Timesheet: Fixed transfers to states which require a comment
  • Fixed Team state transfer for non-admin users, which failed if Team states were mapped to the last Project state.
  • Fixed cache for List views to support complex filters by custom fields
  • Fixed effort recalculation for a User Stories if their Tasks are removed or moved to/from another User Story
  • Fixed Dashboard TODO widget: filter by entity type apply on first load only
  • Fixed Epic > Feature > User Story List views which showed only 25 items and no 'show more' link
  • Fixed Requests and Test Plan Run effort units in a List view to be consistent with the entity views
  • Fixed improper Initial estimate field population with an Effort value when User Story copies to a new Project
  • Fixed export to CSV so that it takes the axes filter into account
  • Added the ability to filter entities by a 'None' option in a Multiple selection field ('?MultipleSelectionCustomField is None)
  • Fixed Quick Add failures if there are no teams in the system yet
  • Fixed mixed Test Plans/Test Cases lists sorting by Business Value column
  • Non-required dropdown custom fields which do not have a default value could be saved with an empty value now
  • 'Last Run date' unit gets back
  • Fixed 'Add & Open' button in quick add in the new inner lists and Relations
  • Improved performance of hierarchical test plan run creation
  • Fixed a calculated custom field creation error in case its formula uses another custom field but with the same name
  • Corrected the error message for an unsuccessful attempt to attach a file that's too large
  • Fixed reply comments that could not be deleted if their parent comment was deleted first
  • SMTP password length limit expanded
  • Fixed Time add from a list in the 'Work Hierarchy' tab
  • Fixed Tabular Report 'Assigned Effort' to show names properly (when there are multiple users assigned under the same role)
  • Fixed CSV export: checkbox custom field 'false' value used to export as 'null'
  • Fixed occasional failure to save Description changes which would sometimes occur even when only one user edited it
  • Fixed issue with renaming tags
Categories: Companies

Axosoft Tips III

About SCRUM - Hamid Shojaee Axosoft - Wed, 03/15/2017 - 20:06

Are you looking for ways to use Axosoft more efficiently? Well, you’ve come to the right place! Here are our 10 latest Axosoft tips.

Axosoft Tips
  1. You can quickly add a work log by right-clicking on any item OR by using the keyboard shortcut W .

  2. In Axosoft v17, quickly access sub-menus with our NEW Command Palette. Use the keyboard shortcut shift + p and start searching!

  3. Quickly refresh your workspace by clicking on the refresh button in the upper left corner of the main menu bar.

  4. Use the Show Charts button to quickly review the burndown chart and projected ship date for the selected release.

  5. In the Release Planner, click the remove all users with no work assigned to them icon to remove them from view.

  6. Collapse your workflow swimlanes in the kanban Card View by clicking the arrow icon in the corner.
  7.  Click the stamp icon in the Details panel to auto-stamp your description.
  8. Click the List View dropdown and select Sort by rank to see your items organized by stack rank.
  9. Want to change the order of items in your view? Click a column header to sort numerically or alphabetically.
  10. Once you’ve enabled Global Dashboard Settings for your dashboard widgets, you can update widgets all at once in Dashboard Settings.

Categories: Companies

5 Electron Apps You Need to Try

About SCRUM - Hamid Shojaee Axosoft - Tue, 03/14/2017 - 15:46

As you may already be aware, GitKraken owes the consistency of its cross-platform experience to the fact that it is built on Electron.

Electron is a powerful framework that allows developers to create OS-native applications through web-based technologies; essentially packaging web apps into native desktop apps that look and behave consistently across operating systems. The framework has gained significant traction in a relatively short period of time, with the official list of apps built on Electron continuing to grow.

There are some Electron apps that I would select as obvious favorites, including:

  • GitKraken (of course!)
  • Atom
  • Slack’s desktop app

I discussed the apps above in an earlier post, 10 Apps You Can’t Work Without, so I won’t repeat them here. Instead, I want to offer up a handful of lesser-known apps built on Electron that you might not have heard of and might want to try out. All these apps are listed on Electron’s extensive page of Electron apps.

5 Electron apps you should try 1. GIF Maker

GIF Maker is a utility to create GIFs from a variety of video services. For example, you can insert a YouTube URL in the URL field, hit the ‘create’ button and GIF Maker will generate a working GIF file for you. From there, you can make some edits to trim the file, apply balance adjustments, and resize the video.

The website touts that you can source from over 200 websites (although I’ve not had luck when testing it with Netflix), and you can also select a local video file for conversion.

GIF Maker comes in free and pro versions. Pro has more options; such as, video filters and more advanced editing capabilities. But the most obvious difference is that the pro version doesn’t watermark your outputted GIF.

2. ndm

ndm offers a GUI for managing your node packages. It has a logical tree view for differentiating globally installed and per-project modules. At a glance, you can see:

  • The modules you have installed for the current project/globally.
  • The current version of an installed module.
  • Whether or not there is an update available for each module.

You can also install new packages, and even update npm itself through the app.

Though not as fully featured as an app like CodeKit (which, in addition to offering a GUI for package management, can run compiling tasks through the client instead of via the command line), the experience in terms of package management is similar. It’s potentially a real time-saver for housekeeping node modules, seeing clear lists of which versions of packages you have, and seeing where package updates exist.

3. Kap (MacOS only)

I’ve been using screen capture software for years. In my freelance days, I would make short screencasts as educational resources; mini-tutorials to show how to make certain changes. However, there was never that sweet spot for functionality that covered all my use cases. Initiating a capture would often involve having to set numerous options, such as: compression settings, framerates, etc.–frankly the kinds of options I’d rather see after recording in a compression app. GIF creation for shorter captures wasn’t even an option, and although we now have functional apps like LICEcap, Kap  covers all the bases, offering a simple MP4/WebM format, or a GIF capture option from the same app. Define your capture area, click record and you’re on your way.

The real power in this app is its simplicity, which I would argue helps get work done better than more feature-rich or option-heavy screen recording apps. It’s solid, stable, and, like the best restaurants, doesn’t give you too much on the menu as an obstruction to getting started.

4. Hyper

Hyper  is a terminal app that is based on HTML, CSS and JavaScript. It is inspectable, meaning that from within the app you can look at and manipulate the UI. Like this, for example:

You can modify the app’s config file to apply changes to the UI according to your needs and tastes. In this regard, Hyper has a similar to Atom in its ease of hackability, and like Atom, it has a plugin system (Hyper’s plugin management uses npm).

Hyper is also open source.

5. Google Play Music Desktop Player

If, like me, you’re using Google Play as your music service of choice, you’ll know that your only real official desktop solution is opening the web app in your browser. Google Play Music Desktop Player  (how did they think of that name?) is a third-party app offering a material-like interface for your Google Play music playback, as a discrete application.

It doesn’t offer offline playback, but it does allow you to keep your listening separate from your browsing. It also allows for deeper levels of customization than would otherwise be easy to achieve from the browser, such as notifications, hotkeys, and minimized playback. It also allows you to customize the look of the app.

Additionally, Google Play Music Desktop Player is open source!

Categories: Companies

GitKraken v2.2

About SCRUM - Hamid Shojaee Axosoft - Thu, 03/09/2017 - 17:35

Did you enjoy the Oscars the other week? Well, we’ve got a few announcements of our own to share, all of which we’re certain are correct, all focusing on version 2.2 of the “Best Git GUI in a Leading Role,” GitKraken.

So, take a seat out front between Jack Nicholson and George Clooney, and let’s open some envelopes!

GitLab Integration

GitKraken has had GitHub integration and Bitbucket integration for some time. And now, we’re excited to add GitLab to our list of nominees for “Best Remote Service in a Supporting Role,” as we add it to our family of integrated services!

But couldn’t I already connect to GitLab repos, John?You

You could indeed; GitKraken has always allowed you to connect to most remotes on most services, but we’re talking integration. Consider the GitLab tanuki. Before, it was a tanuki, and that was cool. Now, it’s like a tanuki with a rolodex, a filofax, a cellular phone and a sharp suit with shoulder pads. It’s an on-task tanuki, pumped and ready to go, and it remembers who you are.

Rough impression of what a turbocharged tanuki might look like

So, now you’ll see that darling raccoon in the tabs for integration services, just like you see GitHub and Bitbucket. Here’s what you can do to make using GitKraken with GitLab that much more simple:

  • Add and remove SSH keys: From Preferences Authentication, you can now quickly generate and manage your keys. It’s easier than announcing the correct winner of an Academy Award for Best Picture!
  • Initialize a repo
  • Clone a repo from a GitLab account by browsing for it and selecting it
  • View GitLab remote avatars in the graph and (**spoiler alert**) left panel

We’ve been really excited about getting this integration into the app. We will continue to work closely with GitLab to leverage the capabilities of their API.

New Repository Management View

Take a peruse of your repos in GitKraken for a second, and you’ll notice some big changes that may just wow you on the red carpet. Plenty of users have requested that the repo management interface be tidier and more intuitive, so the new Repository Management View has been created as an entirely different way to organize and open repos. In this view, users can now:

  • Browse the file system for a repo to open
  • Open a repo from a list of recently opened repos
  • Create custom project folders that contain groups of repos.

That last one is a big deal for the convenience of GitKraken users. Folders that contain groups of repos can now be added to GitKraken as Project Folders, and these folders can be discretely named in the app. Your folder outside of GitKraken will keep its name, of course.

Needless to say, you can still clone and init repos as usual, just in a spiffier UI that makes working with connected services more clear.

Avatars in the Left Panel

In a controversial leak earlier in this article, we shockingly exposed the inclusion of left panel avatars in v2.2. Version 2.1 introduced avatars in the graph, and the addition of the left panel means that the owners of remotes are now clearly visible and more instantly identifiable at a glance.

HTTP and Proxy Credential Storage

Such is the drama, intrigue, excitement and sheer sexiness of this topic that it can be hard to relate the details over all the commotion. I’ll give it a go.

When entering a username/password for a host, GitKraken will now ask if you’d like to remember those credentials. Changed your mind? We all get cold feet once in awhile so stored credentials can be purged in Preferences Authentication.

That just about covers the major new features in this release. OMG OMG there are just too many people to thank! Please be sure to check out the release notes for a full run-down of what’s new, including features, improvements and bug fi–<cut out by orchestra>

Categories: Companies

Targetprocess Mobile for Android, Releases 2.4 and 2.5

TargetProcess - Edge of Chaos Blog - Thu, 03/09/2017 - 17:07
View and edit Custom Fields from entity details view

Custom fields are widely used by our customers, so we've finally added them into the entity details view on our Android app. You can view and edit Custom Fields of all types (except for the Multiple Targetprocess type, because it’s hardly ever used).

You can find the Custom Fields section in the same place as our main desktop app: scroll down the entity view and you will see Custom Fields panel under the Info panel.


Planned Dates

Since release 2.4, you may notice that Planned Start and Planned End dates have appeared at the bottom of  the ‘Info’ panel. You can now plan work items directly inside the app:


Some other useful improvements include:
  • Added the Initial Estimate field to Epic views and the Run Estimate field into Test Plan views
  • Estimation fields will now display Effort units

If you have anything you want to share with us, just use the Feedback form in the ‘Me’ tab, or send us a message at

Click here to download the Android app.

Categories: Companies

U, I and Everything In-between…

About SCRUM - Hamid Shojaee Axosoft - Wed, 03/08/2017 - 19:25

Until recently, some of our customers have been, shall we say, forthcoming in their feedback on our UI and their frustrations with it. Some were eloquent in their summaries. Here’s a good example:

Every time a developer opens up axosoft, a UI designer dies.

— Douglas Isaksson (@DouglasIsaksson) November 18, 2015

OUCH. But fair.

We appreciate all criticism, and we take it seriously (especially because we don’t want to be responsible for thousands of designer deaths per day). We knew that the time was right for UI improvements, but the opportunity really presented itself recently, when Axosoft’s marketing team finished a rebrand with a new look and visual aesthetic. This was the perfect starting point for our designer to create a visual exploration of how a reimagined Axosoft UI might look.

And so the journey begins

With a laptop and a dream, the Axosoft team embarked on what would end up being a 4-month journey through a forest of UI and UX micro-improvements. There were arguments. There were certainly tears. There were moments when discussions about hex values produced faces in pure #ff0000. But we came through it, and the process helped us set the stage for the next version of Axosoft. Here is a rundown of what went into just a few of the many changes we made, and why we made them.

Colors… more colors!

The most noticeable change in Axosoft is the color palette that was applied across the system. The design and marketing team had developed the brand and provided general direction, using our internal style guide to help us apply things to Axosoft. One of the ways we applied color to enhance the experience was through making more visual distinctions between larger segments of the application to allow people to see groups of content more clearly and to make sense of a system with less thinking.

Principles like this are nothing new, and in fact, they correlate to a well-known theory in cognitive physiology: Gestalt. The mind wants to group things together that make sense, and in this case, the Organize panel’s behavior and functionally made it a candidate to visually separate it from the list of items in the main view of Axosoft.

Comparison of the color and tone of the UI before and after V17.
On the left (before), all 3 regions are of similar color and tone, suggesting equal relation. On the right (V17), the Header and Organize Panel are recolored to provide a visual connection between those panels. This reinforces the fact that these two panels contain UI elements that control the display of the Main Panel.

Additionally, many people often found themselves confused about why certain work items were not in view. It turned out that for most of these cases, certain selections and filters were applied without the user being able to clearly see that this was the case.

Utilizing color to help identify some of these states has made it easier to see that there is a change in the system and that your view has been altered. One area where this revision can be seen is in searching your work item list. Along with in-context search messaging, we added in some of the key alert-focused colors from the design system to make it easier to identify when a search is active in the UI.

Signal to noise, I can’t hear you. Is this thing on?

What are we looking at? This may seem like an obvious question, but it can be hard to answer if you work with any large-scale application. In an ideal world, the tasks and behaviors that are used most routinely are the ones most visible. We felt it was time to move some of the less used UI elements of Axosoft out of the main area so they would compete less with the more important elements. These lower-order elements are still easily accessible but aren’t clogging up the main area. The visible toolbars are the biggest areas where we applied these types of changes–reducing the number of visual options helps make it easier to choose the existing ones. We also increased the size of the components within the main toolbar, while reducing the size of surrounding elements to reflect the priority they should have when you’re using Axosoft.

By reducing the number of options in the main toolbar and removing the toolbars from individual panels in the UI, it is far easier to focus on relevant content instead of deciphering where things are and what they do.

I suggested the tagline “Axosoft, now with 72% fewer toolbars!” to the marketing team, and the enthusiasm in the room was palpable:

It’s the little things…

Some UI changes are more subtle than others, yet can have a huge impact on the day-to-day usage of an application. We made quite a few of these changes in version 17.

Counts for your item details

While we removed things that were less relevant, we also added some that were more so. Simply by adding a number next to each item in the right panel, it is now easier to see not only whether information exists or not, but also how much information is there. Knowing the difference between 2 work logs vs 14 can be important in understanding how much attention a particular work item is receiving compared to another.

Sorting, sizing and ordering your stuff

One of the most powerful aspects of Axosoft is its customized views, which can be set up and defined by each user. There were particular areas in the application that made it difficult to perform some expected adjustments (or did not allow it at all), such as moving content around within the Organize panel, or resizing the lower details when viewing an item in a new window. As these issues were identified, we tried to make it easier for users to manipulate the Axosoft UI for their needs.

The Organize panel sections now have menu options that can easily be repositioned within the group, and you can immediately sort your comments or history from within each detail section, instead of having to manage this elsewhere.

These changes may seem like subtle solutions to trivial issues, but such issues can add up to be considerable annoyances. Our aim is to continue making these improvements to annoy you less!

Categories: Companies

Join Our Product Update Webinar on March 15, 2017!

TargetProcess - Edge of Chaos Blog - Wed, 03/08/2017 - 18:08
Q1 Product Update Webinar graphic

We invite you to join us for our Product Update Webinar on Wednesday, March 15 at 12:00 PM - 1:00 PM EDT.

It's already been a busy year here, and we want to make sure that everyone is up to speed with all the recent changes.  We'll also be going over some of our immediate plans for the future, and there will be a team of Product Specialists available to answer your questions.

At the webinar, you can expect to see a demonstration of all the latest features and improvements, including:

  • lane suggestions and the new "My Recent" tab in the left menu
  • new connectors for integrating Targetprocess with ALM tools such as Jira, TFS, CA Agile Central, and DevOps tools such as Git, GitHub, Jenkins, and many others
  • how to setup the Service Desk and use Custom Request Types to expand its possible use cases
  • improved Project and Team assignments for Person, Team, and Release views
  • the latest releases for our mobile iOS and Android apps, and more

You can register for the webinar here. We hope to see you there!

Categories: Companies

Blog Series: TDD and Process Part I

NetObjectives - Tue, 03/07/2017 - 15:58
Part 1: The False Dichotomy Traditions in software testing suggest that the balance among the various types of test types (Acceptance, API, Integration, Unit) should be weighted toward the lower-level, more granular tests and less toward the larger-scale, or end-to-end tests.  The visualization is typically something along these lines, in terms of the effort that should be devoted to each: It...

[[ This is a content summary only. Visit my website for full links, other content, and more! ]]
Categories: Companies

Agile Pixie Dust

NetObjectives - Tue, 03/07/2017 - 13:26
You know the history well. At an executive level, the organization has decided to "go Agile". Everyone in the organization attended a 1/2 day Scrum Training course. The project managers were re-titled as "Scrum Masters" and the business analysts were re-labeled "Product Owners". Finally, the developers and testers were reorganized into a set of Scrum Teams and "Sprint Zero" was started. Since...

[[ This is a content summary only. Visit my website for full links, other content, and more! ]]
Categories: Companies

Why Agile Should Be More Predictable Than Waterfall

NetObjectives - Sun, 03/05/2017 - 17:17
Executive Summary Many executives have been led to believe that Agile is inherently less predictable than a waterfall approach.  However, Agile, when wrapped in Lean-Thinking, can be more predictable because it enables working directly on the true causes of unpredictability in software development.  Waterfall’s large projects and stage gate approach cause delays in feedback, workflow, testing...

[[ This is a content summary only. Visit my website for full links, other content, and more! ]]
Categories: Companies

GitKraken vs the CLI

About SCRUM - Hamid Shojaee Axosoft - Fri, 03/03/2017 - 00:28

There are quite a few things that I do every day in GitKraken that make my work easier. When I just worked with my repos using the command line, these tasks were always a hassle. Maybe, sometimes, the hassle is worth it. Imagine you’re Tom Hanks and you bring an old, manual typewriter to a baseball game to keep score. Now, admittedly, that is really cool, but it’s not something I’d want to do all the time, and the idea of typewriter-like permanence in Git operations makes me shudder a shiver of pure fear. So, in honor of Hanx, I thought I’d share 6 reasons why I prefer GitKraken over the hassle of just banging away on the keyboard.

Click image to download this infographic as PDF 1. User Friendly

The CLI has a steep learning curve because you have to memorize commands and understand what those commands actually do. GitKraken, on the other hand, is a great tool for learning and teaching Git. GitKraken allows you to simply make a few clicks to perform commands and then provides a visual representation of the commands so you can see their effects.

See that big Undo button up top? That means that if you make a mistake, there’s also a good chance you can undo that mistake.

2. Speed

With GitKraken, you can drag and drop to quickly merge, rebase, reset, push, and more. If you need to undo a commit, simply give the Undo button one quick click.

I also love being able to easily see all of my work in progress; I can stage, discard, or stash any changes as I wish, so I don’t accidentally commit small mistakes. It makes me feel fabulous and powerful like I’m on the Bachelorette, and I can see which hunks I want to keep and which can be discarded.

3. Performance

Ok, look, it’s a GUI, and with a GUI there’s always some trade-off between the convenience of the UI and the demands on your CPU. I’ll admit that the CLI will be less taxing on your machine than any GUI out there, but you’re still getting bang for your buck when using a client.

The background processes that often run on a GUI, though they affect your CPU usage, are often also a great convenience to the end user, keeping up-to-date with file changes, for example.

4. Remote Control

If you’re tracking multiple remotes from your team, it can often be difficult to differentiate your local work from changes on other forks. With GitKraken, you can always see the avatar of the user on GitHub or Bitbucket, to know whose branch you’re viewing, or you’ll see a computer icon for your local changes.

Creating and viewing pull requests is something I do all the time, and I really couldn’t do them in the command line. With GitKraken, I can create new PRs, view my existing PRs in the repo, and even add the remotes attached to the PR if I don’t already have it pulled down.

5. Preference

I hate Git Spaghetti.

An actual Git commit graph from 1918

We’ve all witnessed a commit graph that is a mess of merges and branches that people forgot about. In many cases, this mess can accumulate because people have pushed without being able to visualize what’s going on. My history has been much friendlier and cleaner since switching to GitKraken. Now it’s more of a nice tidy riGitoni instead of a messy Git spaghetti.

Bonus: GitKraken Frees up my terminal

Just because I’m using GitKraken, doesn’t mean I am ending my relationship with the terminal. In fact, GitKraken allows me to use terminal for other essential tasks like updating npm packages, starting/stopping processes, using vim to edit a file, or even to play a game of Zork without having 8 different terminals open.

What’s more, GitKraken can augment the way you work with your repos and, if you still want to launch the command line to scour the reflogs or to play some nostalgia 80’s text based games, just use the keyboard shortcut alt + T (Windows/Linux) or option + T (MacOS).

Categories: Companies

Targetprocess Mobile for iOS Release 3.3: Notifications tab, view setup, follow entities

TargetProcess - Edge of Chaos Blog - Thu, 03/02/2017 - 20:10
List of notifications inside the application

Previously, you could get push notifications sent to your device, but you couldn't view a list of them inside the application. We've now put all notifications into one place, so they are much easier to find.

You can find notifications for:

  • State changes for entities assigned to you
  • New comments where you are mentioned
  • When you are assigned or unassigned to an item


View setup

For those who aren't sure what's going on with their board, such as why certain cards or lanes are not displayed, we’ve added the possibility to see the view configuration. This includes:

  • Cards selected on the board and filters applied to them
  • Horizontal and vertical lanes and filters applied to them
  • Projects and Teams and selection that is applied to the displayed cards and lanes

You can see it all in read-only mode plus and also choose to reset your personal filter applied to cards:


Some other useful improvements include
  • Copy the link to an entity
  • Follow an entity
  • Save Attachments


If you have anything you want to share with us, use the Feedback form in the app's 'Me' tab, or shoot us a message at

Click here to download the iOS app.

Categories: Companies

6 Popular Atom Packages

About SCRUM - Hamid Shojaee Axosoft - Wed, 03/01/2017 - 21:40

Here at Axosoft, one of the most-used tools, unsurprisingly, is the humble text editor. No matter what kind of developer you are, you likely have your own setup for the editor you use: theme, keyboard shortcuts, add-ons; everything configured just the way you like it.

At Axosoft, the most popular editor of choice—by far—is Atom: GitHub’s functional, flexible, open-source, cross-platform editor. Out of the box, Atom is a very capable app that doesn’t take long to feel familiar. But its real strength lies in its extensibility and hackability. This is a real boon to developers with their own unique requirements, languages, preferences and habits. Should you need to, you can tweak config files, or create entire plugins to extend Atom’s base functionality.

These days, there are lots of packages available for Atom, and they’re easy to browse and install from within the app. Here’s a roundup of some of the most-used packages around the Axosoft office.

Our 6 Most-Used Atom Packages 1. linter/linter-eslint

The most popular plugin with our devs, is a combination of two plugins for linting code. A linter is a program that assesses code for probable errors and for enforcing a consistent coding style. The base linter, combined with a JavaScript linter installed on top of the base, is the combo of choice with developers at Axosoft. Syntax typos begone!

2. highlight-selected

As you may have guessed, the “Highlight Selected” package highlights your selection; in fact, it highlights all instances of that selection in the document. Simple, but effective if you need a quick reference to all visible instances of a string.

3. pigments

Pigments is an indispensable package if you’re working with colors and variables. Pigments highlights all color values (hex, rgb, rgba) with the color that value represents. Among other settings, you can choose the “marker type,” opting for, say, a color dot next to the color value rather than highlighting it in that color.

Pigments supports precompilers, too, so you can use Stylus, Less, Sass, or Scss and it’ll highlight functions and variables that represent colors. Need examples? Well, we all know that Chuck Norris’s hex value is #bada55, but here are a few Stylus suggestions for you:

rocky                  = #ba1b0a
ringo-starr            = alpha(#bea71e, 0.5)
whats-that-smell       = #badc0d
whats-that-other-smell = #faece5
4. minimap

Minimap offers an at-a-glance graphical preview of the current document’s entire source code. The package’s home page shows the copious configuration options, but even without setting those, Minimap offers a really easy way to work out where you are in your code, and quickly get to where you need to be.

Combine this package with the minimap-highlight-selected package to see all your selections in the map!

5. regex-railroad-diagram

Do regular expressions fill you with the kind of dread otherwise reserved for dental surgery, high school reunions, going to the DMV, or, actually having dental surgery at your local DMV performed by one of your old high school friends? If so, Regex Railroad Diagrams might be the answer to your prayers. This package offers a visual view of your regular expressions so it’s easier to debug their behavior.

6. rulerz

Where did my cursor go? Where am I in this row? I’m frightened! If only there was a little vertical bar that followed my cursor on the screen, subtly giving me a visual reference for where I am!

Ah, there’s a package for that. Rulerz gives you a simple vertical rule to help you know where you are. What’s more, it’s customizable, thanks to Atom’s stylesheet. Here’s a modest example: {
    ruler-view.rulerz {
        border: 10px solid #5234d4;
        width: 500px;
        box-shadow: 0px 0px 10px 10px #ff0, 0px 0px 100px 10px #f00;
        background-image: url('');
        background-size: contain;

Gives you:

Ah, that’s better. And you are most welcome.

Categories: Companies

How to introduce Agile to non-IT teams

TargetProcess - Edge of Chaos Blog - Wed, 03/01/2017 - 00:00

It’s clear that the Agile Methodology is not restricted to software development teams. Countless organizations have improved their flexibility and delivery speed with an Agile mindset, and many have successfully scaled Agile through every department. Agile is already widely used in marketing, education, and even auto manufacturing.

If you’re a non-IT team that wants to adopt the Agile mindset, you will likely encounter some resistance to change. This is good. Criticism of Agile can help your application of its values to improve.  To encourage non-IT teams to embrace Agile, you should first demonstrate the value that an Agile mindset can deliver. 

Don’t prescribe; encourage

The Agile methodology has (unfortunately) been fairly well-saturated with buzzwords and prescriptive practices. As Dipanjan Munshi puts it, “The process whose manifesto declared ‘People over Processes’ has now became a standardized prescriptive process in itself.”

To avoid putting anyone off unduly, don’t introduce Agile as a set of prescriptive processes. Instead, frame it as a cultural practice and a mindset for approaching work. Note that a successful Agile culture will help to increase employee independence, trust, and personal responsibility. In a traditional environment, management ends up being responsible for both failures and successes. In an Agile environment, responsible individuals shoulder this responsibility.  

It’s important for Agile transformations to happen more-or-less organically. Nobody wants to put up with another vague strategy change that’s been mandated by management. This is the the sort of thing that an Agile mindset is supposed to eliminate.

Don't transform; iterate

There are a lot of practices that have formed around Agile; introduce them iteratively, and you’ll be able to the avoid the culture-shock that has stagnated many transformationsTo get started, research Scrum and Kanban. Try to understand which practices might work for you, and why:

Kanban - Kanban uses a board with cards that represent work items. As a work item progresses from idea to completion, it is moved forward through the board's swimlanes. It's great for helping teams adjust to frequently changing priorities. Setting WIP (work in progress) limits helps teams to reduce context switching and avoid getting bogged down by an ever-expanding scope of work.

Scrum - Scrum is great for organizing teams and for making continuous improvements to your work process using Retrospectives. It's fairly heavy on planning (compared to Kanban), and uses fixed iterations to help teams understand and improve their velocity. Most teams utilize a Scrum Master - an individual whose job it is to facilitate meetings, remove impediments, and generally help the team get their work done.

If you're aiming for a large scale shift to Agile, take extra care when planning change. Peter Merel, a long-time Agile consultant and founder of the XSCALE Alliance, advocates the use of steel-thread squads: A small number of progressive people adopt Agile practices and measure their metrics to prove the productivity benefits. The team then divides like a cell and spreads to other teams. This allows for a natural change that doesn’t disrupt the established organization. The transformation is iterative rather than sudden; Agile is adopted using Agile.  

Bridge the gaps between software development and the domain of your teams

Some Agile coaches have noted that it is difficult to link the idea of “delivering working software” to other fields of work. Opposition tends to come in the form of rebuttals such as “We’re too quality-focused to adopt this practice.”  This line of thinking comes from a lack of understanding about the core principles of Agile.  Keep in mind that Agile does not mean sacrificing quality for speed. Rather, it means you should deliver the highest quality you can, without getting bogged down by process or bureaucracy.

The concept of developing “Working software” can easily translate to any field. It simply means the first point where you can deliver real value to your customers. Define the variables of what "working software" and "end user" means to your team. Figure out what what could be considered as one of the basic building blocks of your final deliverable so that you can get feedback at an early stage. 

You also shouldn't feel obligated to use the vernacular of Agile. It was created in an IT world, and might be irrelevant or confusing for your teams. Consider changing the terminology of your tool or process to reflect the vernacular your team already feels comfortable with. For example, a marketing team might rename Features as Campaigns, a sales team might rename User Stories as Leads, etc.  

Synchronize, but don’t get bogged down by ceremony

When you have multiple teams practicing Agile, you run the risk of creating what has come to be called "Agile silos." These are teams which are practicing Agile internally, but lack cross-team or cross-departmental coordination. This is not a good recipe. There needs to be some sort of unifying vision to help turn these different teams into a collaborative ecosystem. There are multiple frameworks to help you plan this out, including SAFe, DaDLeSS, and LeadingAgile

So, it's important to synchronize your teams, but you also have to be careful to not get bogged by ceremony and bureaucracy. A central pillar of Agile is replacing processes with interactions. Adopting the ceremonies of Agile without understanding their purpose is a huge red flag. Don't constrain your teams by trying to over-synchronize them with processes that they don't need. 

“Humans are of very low value as cogs in a machine doing identical things in interchangeable ways. That's for robots. Humans are most valuable when they have high autonomy, and able to play to their unique strengths and histories, particular sensitivities, op-tempos, and patterns of privileged information. The idea of "wisdom of the crowds" in fact rests on humans having diverse, unique private knowledge bases. The madness of crowds kicks in with synchronization and imitation.”  -Premature Synchronization is the Root of All Evil

Final thoughts

One of the biggest pitfalls you can fall into is looking at Agile as a cure-all panacea that will help you do more work in less time. This is not what Agile is about. It's about breaking out of the rigid structures that constrain individuals from completing their work in the best possible way. 

Dilbert on Agile

Learn the various techniques and strategies that Agilists have accumulated over the years, and pick the mixture that works best for you. Above all, don't lose sight of the values in the original Agile Manifesto.

Categories: Companies

We’ve moved from UserVoice to Service Desk for Idea Management

TargetProcess - Edge of Chaos Blog - Mon, 02/27/2017 - 18:13

Our new Service Desk application can be used to manage almost any kind of Request. One of its most common use cases is Idea Management, which allows you to gather feedback and prioritize features in your product based on your customers’ needs.

For the past several years, we’ve been using UserVoice for Idea Management. Now that our own Service Desk provides the same functionality and more, it’s time to move on. Last week we carefully moved about 10,000 users and 2,800 ideas to to make sure your feedback is not lost.

This means that the forum at is now deprecated. You are welcome to share your ideas at

The other thing we want to highlight is that you can also use the Service Desk + Targetprocess combo to collect and manage ideas for your own projects. Service Desk has all the usual features such as voting and comments, it allows you to easily link ideas to particular work items in Targetprocess, and it’s free. Also, as our own Product Owner observed, it's much more convenient to manage incoming ideas when you have all the power of Targetprocess to back you up.

Service Desk can be enabled from the Settings page in Targetprocess. Take a look at our guide if you need help getting started, or send us a message at

Tip: You can create Custom Request Types to expand your use of the Service Desk for almost any kind of application. If you’re not using Service Desk for customer support, just remove the Issue and Question request types and rename them to something that corresponds to your needs.


In addition to all that, we have just released a widget that can be handy if you have your own system and don’t need the full Service Desk application, or if you just want users to submit requests without leaving your website.


We understand that you might need some flexibility from the default settings, so we made the widget customizable. You can hide elements like top requests, description, and attachments, define default request types and privacy, and change the form's subject text. It is already available for you and you can embed it anywhere – all you need to do is to provide a link to your Service Desk with the correspondent parameters. See our guide for more information.

Categories: Companies