Skip to content



Article: Freedom Through Apps: Sexy Tech Startup

If you are like most developers, you dream of the idea of building the next big app that will cover the cost of your retirement. In the article, Freedom through Apps: The Road through Independence, I cover a few up-front considerations needed to begin the reality of building such an life plan. If you can’t be the lone wolf developer; because it’s too much work, or it’s too risky, or you like people too much and you want a road to financial freedom, how do you get there?

The other vision that people chase is the idea of creating a startup company, getting funding, and making it big. While certainly this has worked for some folks, it’s not the path that most successful folks take. As it turns out the hidden work of building a startup is more than most folks realize.

Fail First, then We’ll Talk

Imagine for a moment that you’re sitting down with an investor who has enough money to invest in your company. Imagine that you’re willing to give up any amount of ownership and you’re ready to deal. However, instead of the investor working on terms and negotiating for a percentage of ownership for an amount of money, you hear “Fail first and then we’ll talk.”

The reality of getting investment dollars is that investors invest in people and not ideas. They invest money where they believe that the person will make it work no matter what the cost. They invest when they believe the investment will pay off and not in a win-the-lottery type of way, but in the kind of way that they expect people will want to buy milk tomorrow. So investors are looking for two key things in a person. First, they want to know that you know what it’s like to fail. They want to know that you’ve learned what you’ve done wrong before so you know not to make the same mistakes.

Read More…


Article: Freedom Through Apps: Retiring a Rich Developer

In the first article of this series, “Freedom through Apps: The Road through Independence,” we started to look at the idea of gaining freedom from the daily grind through creating applications. We more specifically covered the idea of carving out time. In this article, we focus more deeply on how you can leverage your independence to create an app—and a company that will be your ticket to retiring rich. What does it take to set yourself up as a developer who can retire rich?

Our first view of the developer who has become independently wealthy and has retired is the lone wolf. The idea of the lone wolf is enticing because it means we don’t need anyone else to “make it big.” However, there don’t seem to be many successful lone wolves. Those who try to make it on their own often end up burned out and frustrated. One success story from many years ago is Phil Katz, who wrote an enhancement to the ZIP archive format—PKZip. The program was a success and a company formed around it and his software. However, PKZip is the exception not the rule.

To Know about Knowing

Most developers are hard wired for learning. Whether it’s a new language, tool, or environment, learning is a core part of what it means to be a developer. Most developers will initially resist a language or environment as a passing fad, but eventually dive in and learn the latest and greatest once they’re sure it’s going to stick around. We’ve all learned something that turned out to not be useful any longer. (I happen to know a great deal about sales and use tax because I needed to for a project once.)

However, when considering the lone wolf, not everything is rosy. Some of the skills that are required need a different way of viewing the word. Often, the required perspective is so foreign that it’s difficult to see how to get there from where you are. The skills I’m talking about aren’t the skills of a new language or environment; the skills I’m talking about are business, sales, and marketing.

Read more…

Joy, Inc.

Book Review-Joy, Inc.

Learning how to grow a company is a difficult challenge. There’s never enough time and always too many problems. There’s always the gap between what you want to do and what you actually do accomplish. However, despite this some leaders manage to create noteworthy organizations and some of those write books – Joy, Inc. is the story about Menlo Innovations, a software development consultancy located in Ann Arbor, MI. It’s an interesting contrast to Pixar which was covered in Creativity, Inc.


The Source of Success

When you’ve been successful – or moderately successful – it’s natural that you’ll want to determine what the factors are that made you successful. Admitting that it was dumb luck that allowed you to create an organization that others envy doesn’t do much for one’s ego so most successful business people build a mental model for how they became successful. Most successful business leaders will share with you how they believe they were successful – whether that is really what made them successful or if it was another hidden factor, well you’ll never know. They will, however, develop some sort of a theory.

Richard Sheridan is no exception. He believes firmly in seemingly every component of his environment and how it’s allowed to him (and his partner James) to create a company that is the envy of many. There is no doubt that they’ve done many things right. However, do I believe that everything that they’re doing is right? In a word, no. In fact, some of the practices that are called out are directly opposite of well-established research on how software can be developed best. However, many of the principles are sound. So from my perspective we’ve got a situation where 70-80% of what he says matters, 10-20% doesn’t matter, and perhaps 10% of what Joy, Inc. says is essential is probably ultimately probably harmful.

Accessing Agile

I’ve been a fan of agile principles for many years. (Take a look at just a few of my book reviews on agile software development: Agile Software Development, Agile Software Development with Scrum, Agile & Iterative Development: A Managers’ Guide, and The Rational Unified Process Made Easy: A Practitioner’s Guide to the RUP). Unfortunately, I’ve run into more than a few customers who espouse that they’re doing agile when they’re really doing whatever they can to duck real responsibility under the guides of agile being all about no documentation and “sprints.” Too many clients I’ve walked into had done several sprints and hadn’t turned over the first thing for the customer to react to. Many of the clients I run into deliver no documentation instead of documentation without ceremony. They run “stand up” meetings where everyone sits so they can settle into a long winter’s nap as someone blathers on incessantly about some problem they want the group to solve – in the meeting.

The problem with this is that stand up meetings are supposed to be quick. They’re supposed to ask three things:

  • What did you do?
  • What will you do?
  • What’s in your way?

These simple questions are powerful. They create a commitment, follow up on the commitment that was made, and puts leaders into the position of being servant leaders (See Heroic Leadership) to help the developers resolve the problems that they have. While stand up meetings are three simple questions running them takes discipline.

So while I fundamentally agree with and support the concepts of agile, my feelings about test driven design and pair programming are more dubious.

Test Driven Design

One of the challenges I sometimes have with developers is that they don’t really know what they’re trying to do before they start. They just start coding not really understanding where they’re going. Covey said “Begin with the end in mind.” In other words, you have to know where you’re going before you can attempt to get there. As a result, the core tenants of test driven design are solid. By specifying the behavior of the tests you’re signing up for the contract that you’re going to follow. You know what you’re delivering because you’re already building tests for it. So conceptually, it’s a great idea. The problem is that practice gets in the way at times. So while I’m in favor of test driven design and the resulting unit tests – I’m not willing to make it an absolute requirement.

The first problem with writing unit tests for test driven design is the number of tests that you’re going to write. Technically to get full coverage of testing you’ve got to test for positive and negative conditions and two tests for every ‘if’ statement in the code. In short getting full test coverage requires a lot of tests and many of those tests aren’t going to be indicative of real world problems or conditions. So it’s too easy to get “test happy” and to start writing tests so that you can say your code passed more tests.

The second problem is that sometimes to test code you need to get a fair number of objects created to test the interactions. When the objects that you rely on are expensive to create (in terms of time or resources) or they are environmentally sensitive, you’re left with the challenge of how you can mock up the underlying objects that you need so that the tests can run quickly. The problem is that at this point we’re writing much more code and we’re writing mock objects that are supposed to emulate their heavyweight counterparts – but that rarely works exactly like it’s supposed to. So as soon as you plug in external objects you’re dramatically increasing the effort and simultaneously decreasing the probability that you’ll find a real problem.

The final problem with test driven development is that it doesn’t work for multi-threaded or event driven programming. Here the timing of events is critical and the testing harness will interfere with the timing.

Again, I’m for test driven design and unit testing – where it makes sense. The perspective described in Joy, Inc. is that this is an immutable part of their culture – which I believe is too much. However, that’s nothing like the concerns that I have with pair programming.

Pair Programing

Pair programming is an idea where two developers work on one computer on one section of code. There are variants to this approach including the use of multiple mice and keyboards but the fundamental is that there are two developers who are working on the same code. In general the research on pair programming says that it takes more man-hours to write code this way – though not as much as one might expect (roughly 15%). The advantage of pair programming is supposed to be early defect identification and removal. It turns out that this number too seems to settle in around (15%). However, the proponents offer that these 15% more defects are much more valuable from a cost perspective because finding defects early compared to later makes them much less expensive to fix. This is well established in the research.

However, even pair programming proponents are aware that there are many different situations that make pair programming difficult. The power dynamics between the pair can often cause one of the members (the observer) to disengage and effectively become a wasted resource. Finding teams that work well together and creating a culture where pair programming is only surpassed by the need to have projects that scale to having two or more developers assigned to it. It’s too my discouragement that many of the projects that I see require only a handful of hours and often are assigned only one full-time (and sometimes only part-time) resource. As a result there’s a minimum floor for where pair programing works. If you’re in an organization and you’re looking to hire one developer to do work – well, pair programming just doesn’t work.

However, my real concern with pair programming comes from the awareness of flow (See Finding Flow, Flow, The Rise of Superman, and The Art of Learning). Getting into flow can take a while (See Peopleware for instance on how long it takes for a developer to recover after an interruption.) As an aside the environment for Menlo Innovations is open-air where everyone is expected to be constantly monitoring for a call from someone else in the room or the CEO asking for an impromptu communication. I know this is not advantageous to creating flow.

It’s my perspective that it would be better to have frequent code reviews in pairs than it would to work together. I believe that done correctly the reviews will take less time than pair programming and the process of explaining the code to someone will activate different parts of the brain of the coder thereby creating additional opportunities for discovery and learning.

Ultimately, pair programming is great at creating learning in developers. As developers work with each other they learn the best tricks of the other developer and they’re allowed to diffuse in the developer pool. (See Diffusion of Innovations for more about the spread of innovations.) As a learning tool, pair programming is incredibly valuable – but I don’t know that it’s warranted in every situation.

Legacy of Learning

So while I’ve got some criticisms of individual components of the organization there are some really important concepts – like the learning created by pair programming that I love. Richard explains that developers need to continually learn. They must be lifelong learners. I heartily support this. I’m also discouraged by Steve McConnell’s comments that most developers have never read a book on development. The creation of opportunities to learn both through pair programming and through creating channels of honest feedback are – I believe –one of the keys to the organization’s success. Arie de Guis – the former head of strategy at Shell – said that the differentiating factor for longevity in an organization is its ability to learn. Institutionalizing the desire to learn is a critical factor for success.

Relentless Honesty

If you’re hiding things or you’re refusing to share what’s real and true, you’re denying reality and you’re depriving yourself of the ability to learn from it. Unfortunately our natural tendency is to protect ourselves, to withhold any information that doesn’t support the idea that we’re amazing or flawless. There are such powerful forces at play to prevent us from being ruthlessly honest that it’s no wonder that it’s difficult to create a culture where honesty is not just valued by practiced.

Accountability is a special tool for creating honesty. Accountability makes it clear that the lies – even if they’re through omission or seen as harmless – will eventually come into the light. The only way that secrets retain their power is through the belief that they won’t be found out. Twelve step programs often say that you’re only as sick as your secrets and by making it difficult to hide secrets you remove their power to hold you back. In an organization creating clear rules for what is and isn’t acceptable is important. Following those rules up with accountability is essential.

Accountability has to apply to everyone – all the way up to the CEO. When the CEO doesn’t believe that he or she is above the rules then it’s easier for everyone to believe that the rules apply to them. If they don’t apply to the CEO does that mean they don’t apply to the entire C suite? What about directors? Making it clear that the rules apply to everyone sends a powerful statement.

In Change or Die the stories of Delaney Street and how even the leaders would be held accountable to the rules sends a powerful message that resonates with all of the people.

Systems That Support

There are so many things that the traditional organization espouses but doesn’t live up to that it’s hard to tell what organizations really believe. If your organization does employee satisfaction surveys, what actually happens with the results? Do they get communicated out in an all-company meeting and then grand plans for how to improve the scores are summarily forgotten until next year when the survey comes out again identifying the same things that need resolved? In many organizations, if not in your organization, this is the case. The organization says that they care about how employees feel about the organization but their commitment to take action on the results says something else – something very different.

One of the revealing things about Joy, Inc. was exposure to the systems that keep things on track. Whether it’s the system for adding work to a project or sprint or it’s the estimating process which uses simple folded sets of paper, the transparency of the internal processes and the recognition that these systems are specifically designed to ensure that the values of the organization are adhered to are another pillar, I believe, to Menlo’s success.

Enthusiastic Estimates

Another simple but effective technique being employed is that estimates are done by the people who are going to have to do the work. This is critical because it eliminates the distortion that happens as project managers and clients distort reality in the direction that they want. If the feature requires 40 hours to do but they only have 32 hours left in the sprint planning, it’s tempting to reduce the effort to 32 hours to make everything balance out – however, doing this perpetuates a lie. We know that our best information about the time it will take is 40 hours but we’re willing to practice “wishful thinking” and say it may only take 32 hours. That sends the wrong message to everyone in the value chain. The developer feels undervalued. The project manager and the client feels like they can squeeze one more thing in.

What you can be enthusiastic about when estimating is that your estimates won’t be tampered with. You won’t be lambasted because the answers aren’t what someone else wanted to hear. Instead you can be rewarded for communicating honestly what you believe.

Requirements Gathering Through Anthropologists

I published my first course on Pluralsight in September of 2014. The course was Good Requirements Gathering for Developers. I created the course because one of the challenges I found was that more frequently than not getting good requirements – whether you’re running a more traditional non-iterative waterfall project or an agile project is difficult work. Most of the people that I see generating requirements don’t have the skills to create requirements. Often times the project manager is assigned to capture the requirements so they can be put into the project planning documents. At Menlo, however, there’s an awareness that it takes a different skill set than that of a typical project manager or a developer. The ability to quickly sketch ideas, to listen, and to observe are not natural skills for most project managers or developers. While they’re teachable skills, they’re not automatic. As a result of the general lack of skills in this area too many projects proceed with an unclear understanding of what needs to happen.

Hidden in the Menlo description of High Tech Anthropologists is a recognition that the objective isn’t really to capture requirements, the true objective is understanding the users to a level that allows you to delight them with the solutions that you’re able to co-create with them. Anthropology is the study of humanity. When we’re trying to solve problems for customers (internal or external) we’re trying to connect with their human needs and deliver solutions that address the wants and needs that they may not be able to fully articulate.

Make Mistakes

They’re inevitable. The sooner that you realize that mistakes cannot be avoided the sooner that you can move the perspective of creating learning from them and building the ability to recover from them. (See Creativity for more on making mistakes.) We want to avoid the embarrassment of a mistake but since none of us have holes in our hand from being nailed on a cross I’m relatively certain that none of us are perfect. That being said no matter how hard we try to avoid mistakes, they’re going to happen.

The beauty of making mistakes – if you’re willing to put on the optimist hat for a moment – is that in mistakes is the potential to learn something new. We can learn what we did wrong or how the circumstances didn’t align with our response. Mistakes are – or at least can be – a good thing.

Systems for People

In the end I may disagree with some of the assertions about the specifics that lead to an organization that’s a joy to work for – particularly as it pertains to the specifics of how to do software development. However, I do believe that the fundamental systems approach to people problems leads to better outcomes. From my perspective the true genius of Menlo has nothing to do with how they develop software. To me the key value is in how they design systems that reinforce their core values and support employees.

The idea that it’s possible to bring children to work absolutely demonstrates the message that families are important. Pair programming, while not necessarily practical or efficient in all ways, reinforces the core message that everyone should be learning all the time. There are dozens of examples from the book where the leadership at Menlo have developed an awareness of how people based systems interact and how to change those systems to get the desired outcomes. (See Thinking in Systems for more on systems thinking.)

Whether you agree with the specific claims that are made about software development, Joy, Inc. can help you think about how you can create an organization that you want to work for – and others do too.

Developing photos

Article: A Developer’s Path to Freedom Through Apps

Rarely is there a developer I come across in my travels who isn’t interested in starting their own company and creating the next big app. Actually, it’s more accurate to say that most developers have a view of creating an app as a way to win the lottery. It’s the shared dream of retiring early, driving sports cars, and leaving the cubicle police far behind.

The good news is that the dream has become a reality for some. They’re already where we want to go—so they can help us get there too. The bad news is that the road isn’t straight and it’s not without work. Sometimes, more work than people expected. Along the way, I’ve met folks who’ve tried and failed, who’ve soared and crashed, but there is wisdom in their stories, too. In this series of articles, we’re going to look at building apps and how they can lead you to freedom or just another prison. The first stop is the road through independence.

The vision we have is that those who’ve created their apps and are living the good live starts in one of two ways. They start as a lone wolf coding through the night living on Mountain Dew and Cheetos, or they start as part of a posh startup located in a city we don’t live in who received their funding from an angel investor—who you have no hope of meeting.

Read more…

die face

Article: Six Things Every Developer Should Know to Stay Current

Our technology world is spinning faster, and sometimes trying to figure out what you need to do to stay relevant to employers and to continue to enjoy being a developer is difficult. It seems like every day there’s a new release of a language, library, or technology that you need to know to be at the top of your game. With that in mind, here are six things that you can do to stay current.

1. Protect Your Passion

You became a developer for a reason. You’re good because you love it—or at least you did at one time. If you want to be a great developer, you have to maintain or regain your passion for the craft. This can mean developing a game in Unity “just because.” It can mean developing an Internet controlled toaster with a Raspberry Pi II.

The point isn’t what you do to have fun with your development again—the point is to have fun. The best developers are those who’ve got a passion for their craft. If you’ve got it, keep it. If you’ve lost it, find it.

Read More…

Recent Posts

Public Speaking