How do you know your user story is well written? use the INVEST acronym

A great bar-raiser for a user story as a product manager, is to leverage a well-known industry mnemonic, called INVEST. Any user story that fails to meet that criteria should definitely be a candidate for a re-write. So what is INVEST?

Screen Shot 2020-12-26 at 12.03.28 PM.png.png

“The INVEST acronym applies to having superior quality in the actual product backlog and serves as a way to check ourselves and not to produce defects or waste in the process flow.”

Excerpt From: J. Ashley Hunt. “PMI-ACP Project Management Institute Agile Certified Practitioner Exam Study Guide.” Apple Books.

(I)ndependent

Or rather, independent of all others. Software engineers will recognize this as decoupling as a self-entity, ensuring that the user story does not overlap with any other user story, and thus is independent enough that it can be implemented in any order.

(N)egotiable

This infers that each user story is nible enough that it is the outcome of collaboration between the product owner and scrum team. In other words, a well-written user story describes the what of the feature, but now the how, leaving the details for the engineering team to develop. This fits in well with the structure of user stories, which are in turn composed of tasks.

(V)aluable

Self evident but stories should result in an outcome that is valuable to the customer (and not the developer).

This is especially an issue when splitting stories. Think of a whole story as a multi-layer cake, e.g., a network layer, a persistence layer, a logic layer, and a presentation layer. When we split a story, we’re serving up only part of that cake. We want to give the customer the essence of the whole cake, and the best way is to slice vertically through the layers. Developers often have an inclination to work on only one layer at a time (and get it “right”); but a full database layer (for example) has little value to the customer if there’s no presentation layer. (XP-123)

(E)stimateable

A user story also needs to be clear and composed enough that during sprint planning, it can be estimated. This requires the right fidelity of information, user acceptance criteria for the scrum team to digest in a single sprint. Any bigger and its too complicated and may have to be split.

(S)mall

Following on from the previous point, good stories are small, and sprint-sized. Keep the description and user acceptance criteria succinct.

Alistair Cockburn described the cards as tokens promising a future conversation. Remember, the details can be elaborated through conversations with the customer.

(T)estable

Finally, the user story needs to be testable, and demonstrate-able. If it is not verifiable by both the scrum team first, and during sprint review, demonstrated to the product owner, then the defition of the story and its acceptance criteria will need to be re-thought. In fact, leveraging the test-driven development philospohy, write the tests first to ensure you can test the proposed solution, confirm with the product owner, and build for that.

The three pillars of scrum

Most practitioners associate the tenets of the agile manifesto as guiding principles in executing their scrum agendas. In this article, With the premise of Scrum optimized on empirical process control, I wanted to spend some time looking into the three pillars of Scrum theory: transparency, inspection and adaption and provide some annotation on what they really mean, and why these pillars should be the foundations of your practice.

Transparency

Scrum is a framework, and frameworks work when you create a mutual set of transparent standards that are understood and accepted. From cadence in communications to understanding user acceptance criteria and definition of done advocated for during planning, transparency is key to expectations within the Scrum team and associated stakeholders.

Inspection

As opposed to the waterfall sequential process of gathering requirements, building, testing, and publishing, Scrum prides itself on a circular iterative process. You build in iterations, inspect, adjust, and build again. Throughout the sprint, it is encouraged that scrum members validate the work they are doing with the product owner, facilitating incremental inspection towards ensuring trajectory to definition of done. Inspection allows for accounting for the unexpected conditions that may either prevent definition of done, or reduce the level of its overall success, however it is also important that the inspection mechanism isn’t overused at the expense of productivity and velocity, ultimately disrupting work. This of course sounds very familiar to engineers who employ test-driven programming, asserting a test suite of use cases accounting for known variances that map with the definition of done.

Adaptation

The fundamental superpower of Scrum is in its ability to encourage pivoting, shifting gears and direction based on feedback. Following on from inspection, adaptation allows you to learn and change what isn’t working, rather than commit to the project based on steadfast requirements gathered at a singular point in time. But not just the idea is open to change, but the process itself. As a framework, Scrum allows you to augment and adjust to your needs, and this pillar gives you the mandate to adjust communications, cadence, sprint length, inspection checkpoints accordingly.

Embracing the Agile manifesto

Something as a practicing program manager I tend to always use as tenets when guiding teams, is relying on the spiritual bible of contemporary project management, and that’s the Agile Manifesto. Products of the Agile Alliance, the premise of the Manifesto is to simplify the practice of project management through a lightweight framework to build software expeditiously with bias for customer validation over processes and documentation and red tape.

The two drivers behind the manifesto are iterative and incremental development, over pre-medicated and over planning, and creating higher quality software in shorter time, or more concisely, build more with less.

The Agile Manifesto

I see the Manifesto as guiding principles, tenets as I mentioned earlier on, rather than rigid and enforced rules, advocation for the spirit rather than the letter of the law. So does the Agile Manifesto entail?

Individuals and Interactions over Processes and Tools

To me this infers bias towards the human element over procedures. Engaging customers, stakeholders, other team-members. It is not to say that processes and tools aren’t important, but the scales should favor people over process.

Working Software over Comprehensive Documentation

Following the spirit of being lightweight, don’t focus on heavy documentation, over-planning but build early, build fast, and iterate fast. It is therefore emphasized that working software that meets user acceptance criteria, even incrementally, over detailed documentation.

Customer Collaboration over Contract Negotiation

The Agile mindset is one that is flexible, and embracing requirements that can change. Pivoting is something that has to be accepted. This is not to say that contracts aren’t also important, but getting the right requirements from customers is favorable to rigid contracts.

Responding to Change over Following a Plan

Change is inevitable, the only constant is change, and that’s why heavy documentation is doomed to failure, because of the nature of change. Instead build components in a decoupled and nimble manner that fosters change, and work in an environment that allows you to react to changes based on new understandings.

The Agile Manifesto does not suggest that we do one over the other; rather, it advocates that while all of the mentioned items are important, some are valued more than the others.

PMI-ACP Project Management Institute Agile Certified Practitioner Exam Study Guide J. Ashley Hunt

The one thing agile teams miss when WFM: Osmotic Learning

Overwhelmingly, tech companies have transitioned their sprint iterations from co-location to having teams work remotely, from home. The Covid-19 pandemic has forced teams to change how they interact with each other, perform agile rituals and deliver products.

If you were to ask scrum masters and developers at large companies like Apple and Amazon, or early startups, most would concur that by-in-large, they are just as efficient working from home as they are coming into the office. Collaborative tools such as as Slack, Zoom, and Atlassian’s Jira, have made the transition smoother.

But for all the technology that aims to bring disparate teams virtually together, there is a specific element that cannot be resolved through technology, and that is osmotic communications.

What is Osmotic Communications?

Concocted by one of the founders of the Agile Manifesto, Alastair Cockburn, osmotic communications is the inadvertent overhearing of background information through co-location, that may later end up being important.

“Osmotic communication means that information flows into the background hearing of members of the team, so that they pick up relevant information as though by osmosis.” (Cockburn, 2005)

Source: https://www.simplilearn.com
Source: https://www.simplilearn.com

In other words, the ability for members of the team to audibly pickup information flows through background hearing of other team members, most commonly accomplished through co-location, by being in the same room. When someone is talking, another person can either tune-in or tune-out, “contributing to the discussion or continuing with their work”.

Webster’s dictionary defines the term as: “a process by which information is exchanged between individuals through a common system of symbols, signs, or behavior”.

The following video by Joshua Render provides a great mini-dive into the agile topic:https://www.youtube.com/embed/rCNlG_j_gSM?wmode=opaque&enablejsapi=1

As a real-life example, when I first moved to San Francisco, taking my MacBook with me to a coffee shop on Market street. Across the shared table there is another two guys working on an app and discussing some challenges to solve a backend problem.

They were talking about a cloud solution that at the time wasn’t as mainstream, but nowadays has become more common. Eavesdropping, I overheard their conversation, and injected myself in with my thoughts, and we ended up having a long philosophical and technical deep-dive into their problem.

Being physically present, beyond the inter-personal relationship building, you also loose the ability to exchange thoughts in an informal and accidental way.

Introduction to Combine for Swift

Mid-2019 Apple introduced in its annual developer conference, its newest framework, Combine, a declarative framework with the premise of becoming the business logic orchestrator empowering the apps of tomorrow. Inspired by popular contemporary third-party libraries such as RXSwift and ReactSwift, Combine consists of a Publisher on one side, such as a RESTful API, and a Subscriber that processes data values over time, via data streams.

The programming paradigm is known as reactive programming, modeled around data flows propagating change and your UI controls reacting and adapting to those changes. The benefits of this framework inherently lies in allowing you To centralize event processing, making for a measurably high-performance architecture that is easier to read and maintain.

Apple had also coupled their announcement of Combine with SwiftIU, Apple’s move towards a declarative UI framework that is exceptionally simple in enabling you to build cross-device user interfaces that lets you focus on defining how you want your UI to look and work, without the pitfalls of imperative programming that make tracking transient states cumbersome and error-prone.

Declarative programming takes care of transitioning to states for you, once you declare all the possible states. This means that together with Combine, you don’t have to get bogged down in dealing with delegate callbacks or completion closures when handling and processing data events, and subsequently displaying them in your UI controls.

Publishers, Subscribers, and the Lifecycle

The foundations of Swift Combine consists of Publishers, Subscribers, and Operators.

Publishers and Subscribers 2.png

The quickest way I like to illustrate the framework is through a simple REST API, which acts as a publisher, streaming user analytics.

The counterpart to a publisher, is the subscriber, and you have numerous subscribers associated with that publisher. So we have a Subscriber and Publisher. Say the publisher asynchronously calls a URL and returns data. This bond creates a subscription that is given back to the subscriber.

Subsequently, the subscriber requests values from the publisher, ingesting a stream of events, getting each element event object. In most cases, you filter, manipulate, and reformat, before displaying it in your app UI, accomplished through an operator. When a publisher has no subscribers, it stops publishing.

So as you can see, unlike RxSwift, Combine is very much a Subscriber-driven framework. That is, if there are no publishers without subscribers, but rather subscribers dictate how much information to ingest, if any. This is done through what Apple terms, back pressure. You will learn all about it later in the course.

Suffice to say, the subscriber sets a specific Demand, whether there is a max number, a minimum number, unlimited, and so forth.

Power Up Your App with Combine

I’ve barely scratched the surface in this article on what Combine can do for you. In my latest LinkedIn learning course, Power up your app with Combine, I take you through a deep dive into the framework, stuffed with Xcode playground samples to help transition you into this modern framework.

Review of the StayGo USB-C Hub by @TwelveSouth

In today’s Geek Journal, we take a look at TwelveSouth’s StayGo USB-C Hub.

My work setup consists of a 2018 MacBook Pro plugged into an LG Ultrafine monitor, via USB-C, fully embracing the world of USB-C’s as you can see. But even for the avid new technology-minded folks like me, I often do have to resort to plugging in a device that is beyond what Apple offers in its modern line of laptops.

I have a Canon camera that I often take with me on scenic escapades, as well as the “old-school” USB-A dongles I often interact with, such as the one I use to plug in to my Tesla as part of its security camera. Sometimes when I am out on-site at client locations, their security protocol dictates that I plug in to their network via Ethernet believe it or not.

Having avoided numerous third-party hubs because of their bulky forms, I was given a review hub by TwelveSouth, a company I have a deep affinity for, for many years. Famous for their amazing leather cases that have kept my IPhone from damage for so long, as well as their laptop stands and other accessories, I was excited to receive a USB-C hub that combines a premium aluminum case with the compactness you need as a road warrior.

Equpped with a convenient cable tucked within the case shell, you can take this hub with you as a one-for-all solution for all of your peripheral needs. The hub gives you:   3 USB-A 3.0 ports.    1 USB-C port, with pass-thru 85W USB-C PD charging.    SD and Micro-SD card slots, with the ability to access both simultaneously.    Ethernet port.    4k HDMI port.   I also have an iPad Pro that I take with me on the road, which is also equpped with a USB-C port, so i can leverage the power of multi-port connetivity on my iPad as well, which comes in very handy. I present on the big screen using my iPad and Keynote, and to be able to leverage HDMI, gives me the ability to travel light at times.
Equpped with a convenient cable tucked within the case shell, you can take this hub with you as a one-for-all solution for all of your peripheral needs. The hub gives you:3 USB-A 3.0 ports.1 USB-C port, with pass-thru 85W USB-C PD charging.SD and Micro-SD card slots, with the ability to access both simultaneously.Ethernet port.4k HDMI port.I also have an iPad Pro that I take with me on the road, which is also equpped with a USB-C port, so i can leverage the power of multi-port connetivity on my iPad as well, which comes in very handy. I present on the big screen using my iPad and Keynote, and to be able to leverage HDMI, gives me the ability to travel light at times.

For those of you who really hate the idea of carrying around multiple dongles, this is the peripheral for you. For me, I have survived more or less without the need for dongles, until I did start to need them more and more, and this is where this becomes the one conduit I can rely on.

Quality is second to none, and being someone that owns about 9 different TwelveSouth products, including the TimePorter which is my favorite bed-side accessory, you won’t be disappointed with the s StayGo USB-C Hub..

It currently retails for $99.99, but when it comes to such a central and pivotal device that you throw into your backpack, don’t get a knock-off hub, get something that will last, and provide you with power and mobility, all at the same time. A solid thumbs-up from me!

Twelve South StayGo | USB-C Hub for Type C MacBooks, Laptops and iPad Pro with included 1 meter desktop cable + stowable travel cable for Home, Office & TravelTwelve South

Better Product Decisions With Experiment-Driven Product Development

Product Managers are always asked upon to justify their product decisions, why invest company resources in a roadmap. In order to back your decisions, you need to be able to prove that it is indeed what the market is asking for, and you are addressing a need. As a product manager myself, I have continually started to rely on a framework that I have become to grow fonder of, and that is Experiment-Driven Product Development, or XDPD for short.

While it should be the de-facto mindset of product managers, XDPD frames your team’s development through the framework of experiments to uncover the premises which can be based on prior knowledge, assumptions, feature ideas, or claims being made about the product or its users. You start off by development questions that you want to answer, the foundation upon which you would then develop your hypotheses, a statement denoting what your answers might be.

You would then begin to design your experiments in a way that you can prove causality for your hypotheses by selecting a method in which you can run and measure your experiments. The outcome of such exercises would then help you make your decisions, whether it is worth pursuing or abandoning.

The underlying process in creating your hypotheses is that you need to justify why those hypotheses are important, why you need to know the answers to those, and this framework helps you shift the focus from assumptions to the step beforehand, and as the author recites, it seeks to reinforce the basic tenets of Lean while bringing rigors and a different perspective to the approach.

This quarter I found creating a horizontal table where I develop my questions, then hypotheses, followed by how I would measure them. The author of the book makes use of experiment cards, but I simply overlay on a whiteboard the columns for more contextual vision.

PNG image.png
PNG image 2.png

I would recommend you give this framework a try on your next product, and see how it works for you and your team. And don’t forget, take a look at the book that guided me this quarter on product development.

Why i moved from mint to @CoPilot

Last week I made the move from Intuit’s Mint to one of the new and exciting startup apps, @copilotmoney. Powered by machine learning, CoPilot lets you track your account spending and other behaviors to give you unique insights to help you effortlessly understand and manage how you spend, save, and invest your money.

Screen Shot 2020-02-01 at 8.24.26 PM.png

Transactions are organized automatically so they’re as easy to search, sort, and filter as your email inbox.

But being a mint user for so many years, why make the move to this app? Well mint hassles me with advertising everywhere, spam emails me, and trades my information to others, in a opaque manner. It’s intuit and it’s their nature. Granted I didn’t have to pay for it every month, but is my financial privacy worth the trade?

Screen Shot 2020-02-01 at 8.25.30 PM.png

Hesitant to shift my years of memory muscle to a new platform, getting all the connectivity errors with mint was my last straw and so I tested the water with CoPilot and was pleasantly surprised. Granted it is only an iPhone app, and I am paying a little bit every month, but at $2.99 it is certainly a fraction of what I would pay for coffee in San Francisco.

PRIVATE AND SAFE, LIKE IT SHOULD BE.

Copilot protects your information with bank-level security and has read-only access from your financial institutions. We treat your personal data like we’d want ours to be treated, which means never selling or sharing it with third parties. Ever.

It is simple to use and on-board, it is fun and cutesy, clean and dynamic dashboards without the bloatware you get with mint. More so, no pun intended, this is a good investment because I know the folks at CoPilot are working on an amazing product that will only get better with time, the more people back the smaller guys over the Gmail of the financial world, Mint.

I am looking forward to seeing what they deliver in 2020 and beyond, including hopefully iPad support, and perhaps web support. For me, the experience thus far was almost flawless, only one banking institution didn’t have connectivity for, but everything else it found, including even my Australian bank.

Why not give it a try for a month, and if you like it, as I am sure you will, you can finally ask Intuit to delete your account and get out of their cobwebs. Get a free month on me, by using the following link.

Moving to @Fastmail from Gmail and Office 365, Two Years on

Moving from Gmail and Office365 to Fastmail and why you should do it. I made the move two years ago, and fastmail is hands down the best mail service for iPhone, macOS and ipadOS.

I wrote an article almost two years ago, outlining my reasoning for moving to Fastmail, and I wanted to update the internet world two years on, how it has fared. Well, truth be told, it has been surprisingly smooth riding for me.

Using Google Apps, syncing with Apple Mail and iOS had been a pain in the ass. The way Google interprets IMAP meant I couldn’t truly get push emails. And yes there are ‘exchange’ settings to enable it to give you push emails, but it has a lot of downfalls, such as one calendar only. Secondly, as a product of Google, your privacy is certainly compromised.

image-asset.png

So I moved to Office365, and while it had initial promises, I wasn’t able to sync my contacts and their photos properly. Using their Outlook app, it was well very clunky and had its own contact universe, rather than the native one. So that didn’t work either.

On the advice of a work colleague, I switched to Fastmail thinking why not, what do I have to lose. And you know what, it ticked all of my boxes, being a fickle Mail user:

  1. IMAP works perfectly as it should. My iPhone, iPad and macOS mail get email via push.
  2. Calendar and Contacts sync via push as well, flawlessly.
  3. No advertising on my web-mail client. In fact, they maintain your privacy and don’t sell your data.

It’s simple, nothing Microsoft or Google couldn’t have achieved if they didn’t try a little, but hey, they dropped the ball and two years later, nothing has changed. So my recommendation is to give fastmail a shot. It;’s affordable, fast, integrates with your existing ecosystem, and you are supporting the smaller companies.

And if you are going to try it out, use my referral code to get 10% off your first year with them!. Click here to get 10% off

A Quick 5-Minute Introduction to Apple’s Swift Combine Framework

Aside from SwiftUI blowing the developer community audience at WWDC this year, the other prominent announcement was Apple’s declarative framework for Swift, Combine. In Apple’s very own words, 

The Combine framework provides a declarative Swift API for processing values over time. These values can represent many kinds of asynchronous events.

In this article, you will get the skinny on what this framework is, why you would may consider using it, and where to learn more.

Introduction

Swift’s Combine framework is Apple’s move towards a more asynchronous programming model, a significant improvement over the inherent approach thus far that is more tightly coupled, forcing assumptions on order and process. 

Trying to work in asynchronous code into UIKit is somewhat cumbersome, with greatest casualty being resource sharing. Maintaining the correct state is difficult to achieve in many instances, which is what brought about numerous contemporary third-party frameworks, the likes of RXSwift. But with Apple introducing its own native solution, Combine, developers are able to interact and integrate with many of Apple’s own foundational libraries, such as Core Foundation, CoreData, and most obviously, fully empower SwiftUI and its controls and views declaratively. 

What is Combine

I’ve been dropping the term declarative quite a lot so far, but what does it mean? It’s essentially functional programming, applied to streams of elements rather than list of visual elements. Combine is composed of publishers on the one end, that emit data streams before completing. On the other end, subscribers listen to the events being published, and ingest. You also have operators, that takes the upstream publisher events, and manipulates them, before going downstream. 

Use cases for Combine include updating UI views based on stream values, react to user control actions, such as typing in a text field, asynchronously.

Publishers and Subscribers

publisher is tasked with emitting data, but the control of flow ultimately lies with Subscribers, in what is termed back-pressure. Back-pressure is the control knob subscribers use to filter how much data it wants to ingest from publishers, the demand. Subscribers also have the ability to cancel a stream of data, via the inherent Cancellable protocol.

Screen Shot 2019-12-23 at 9.06.09 PM.png

Operators

Publishers make use of operators, a set of pre-built functions, to further decompose and restructure the data streams. Operators can be used to filter, map, and replace various elements in the stream, or even combine multiple publisher streams into one, in addition to handling errors, buffering, and other functions. 

Subjects

Subjects are also considered publishers, although the are tasked with the purpose of injecting values into streams, as well as publish element values to multiple subscribers. 

Conclusion

This is only a brief theory into what Combine is, and once you apply the theory into practice with some code, you will truly appreciate the power and robustness of declarative programming. Follow this blog, as I will go through the various concepts in greater detail, and work towards building APIs powered by Combine. 

In April 2020, my complete Combine video course will be available on LinkedIn Learning. Be sure to subscribe to my blog, to be one of the first to find out when it comes out.