Highly Supportable Garbage

During the course of developing Equals we have spent a lot of time thinking about what we are developing, developing test code, and then re-writing final code that ends up getting implemented in the project as appropriate. We also have a large backlog of previously written code to work from, although a lot of the prototypes are in Objective-C for iOS which we can’t use on the web. The good news is we have learned from all of our previous mistakes.

The benefit to all this throw-away code, something we have never really had before, is that the final code is a lot more solid. Rick and I are both noticing that we aren’t hacking in a lot of code to just make things work. That’s been a facet of almost every project we have done in the past ten years, which is partly a bi-product of having near-zero experience on the platform we are working on and always being in a ridiculous hurry.

With Equals that has been less of an issue. As we fix bugs now it is clear that the logic was correct. The changes are inserting a line here or correcting a mistake there, but not having to either rototill code or hack in fixes for stuff we have. It feels more stable.

This hasn’t just been because of the previous code we’d written, of course. Another big benefit is that we took far more time than ever before to plan and document what we were doing. An insane number of hours, for instance, went into figuring out how the server-client API should work. Even stuff like how do we determine what’s a variable and what’s an equation was hours of planning and thought. I had a college professor say that 70% of development should be planning. This is one of the first times in my career where I was near that number.

None of this is to say we won’t look back at this code in a year as garbage. But at least we know in a year that this code will be highly supportable garbage.

The Equals Story: What’s Taking So Damned Long?

I’m experiencing a writing drought right now of proportions never experienced before. I love to write and yet the last month or so has been like pulling teeth to get anything down on paper, if you will. I realized that at least part of that is because I have always been reticent to dive into the weeds on what we are working on, mostly because I, for whatever reason, think it will scare all of you away.

Well, too bad. If you leave you leave because we are deep diving now, my friends! I’ve decided to write a series of posts on the thoughts and decisions behind Equals. I’ll make sure it is noted clearly in the title so you can ignore these if you prefer.

The concepts behind Equals came from an app my partner-in-code Rick Huebner invented in 1998 called MathPad. The concept was simple: what if the calculator was a piece of paper that you can write text, equations and variables on, then hit a compute button and it would fill in the missing values? It was a positive little seller but it had very small revenues compared to powerOne and we shelved it soon after Rick came to work for me in 2001.

It sat in holding for 10 years until it was brought up in 2011 in a multi-month exploration of new ideas. By 2011 we had already been selling apps in the iOS App Store for 2+ years and it was clear that selling productivity apps at $5 per copy was never going to make us enough money to even be in business, let alone support the two of us full-time. So we started hashing around for new ideas, still based on spreadsheets and calculators and numbers, that we could develop. We came up with a dozen ideas, built a few prototypes and started testing. Equals, which we were calling MathPoint at the time, was the most interesting and compelling of these partly because of its connection to our existing powerOne customers.

We spent months using MathPoint ourselves and with a few close friends of the company. We began to refine it. We eliminated all of the syntax complexity of Rick’s MathPad, we expanded variables to include numbers and spaces, which made them feel much more natural. We went from purely text-based notes to include formatting and started playing around with how to do that on iOS and the web. We even moved from an iOS-only app to a sync-based system to a web-first application. Refining and simplifying took forever. We came very close to releasing apps a few times but backed off for one reason or another each time.

Our momentum on the project was slow. Throughout we had two core problems: 1) we were moving more and more toward a web-based product as a starting point; and 2) powerOne was/is making so little money that it wouldn’t support even one of us full-time. So we took the value we had — iOS development experience and a well-regarded product — and sold those. We received a number of custom development contracts over the last couple of years, all of which kept us in business. Our income went from 100% product to 70% custom development work but we also had profits for the first time in years all while paying ourselves a break even salary.

As mentioned, though, our philosophy about where to release the first versions of Equals changed as well. We went from an iOS-only app to an iOS app that leveraged the web for syncing only to a browser-based app. I hope to get into this decision later but for now understand that at the time we made this decision we had very little experience with browser-based, HTML5 apps. We had worked with it a little in the iOS app, but very little.

So we got a development contract that basically paid us to learn HTML5. While the project was a huge pain, we were able to learn rudimentary skills and it brought us enough money to give us a window of development in the summer and fall of 2013.

We thought we were close. We reached out to some of our existing powerOne customers, getting them all excited, when we thought we were within a month of shipping. Unfortunately the window collapsed. One reason was because we had some health issues that our now dealt with. Another is because getting a releasable version turned out to be far more complex than we ever anticipated.

The window closed. By the fall of 2013, we were again running out of money. We closed more contract deals and focused exclusively on those. By early 2014, though, we had stockpiled enough money again to focus full-time on Equals. In fact, we have now stockpiled enough contracts and deals to likely need no contract work until the end of 2014, our longest window to focus exclusively on Equals (and get paid) in a very long time!

As we’ve been head’s down now for more than two months on developing a web-based version of Equals, we are finally getting very close. It has been interesting, though. Sometimes we think we are closer than we are and sometimes we are battling the technology for weeks on end trying to make it do what we want and sometimes we head down a path only to realize, after getting 95% of the way there, that it was absolutely the wrong technology or process.

It turns out the devil really is in the details. The amount of spec writing I’ve done in the past few months far exceeds the design work I’ve done in the history of the company, and of course every time we make a change it has ripple effects through the code. Add to that our relative inexperience with HTML5 and our time estimates have been way off.

Anyway, that’s enough for now. All I can say for certain is we are (finally!) very close. Yesterday I pushed to the live server our first partially working version and hopefully the remaining handful of missing pieces will lay in quickly over the next few weeks. The learning hurdles should be behind us now as we have the basics of the technology working. We need to finish up the last missing pieces and test and test and test.

Our goal is to roll this out slowly. We have never had to worry about server load before and we have never had to worry about client-server interactions and all the unknown unknowns that go with new technology on a new platform in a new environment. I’m also worried about the rudimentary nature of Equals. It is so early and there is so much to do. I hope Equals isn’t too far down on the minimum viable product curve.

I can’t wait to share it with you, though. It has been a slow train coming.

Would you like to know when Equals is ready? Tell us. Your email address stays between you and me.


Paul Graham: Start Small To Grow Big

One of the most influential thinkers in the world of startups has got to be Paul Graham. The founder of Y Combinator also writes some of the most influential essays, always excellent and thought-provoking. Recently Paul announced he was stepping down as the head of Y Combinator and then was interviewed at The Launch Festival about the things he has learned.

One of the most interesting and important comments, from this TechCrunch article, was the following:

In relating the ingredients or factors that are the secrets to — or most often point the way to — achieving that illusive hockey-stick-style growth curve, Graham said:

“Start with a small, intense fire.”

In other words, find a small number of people that want what you have or are making badly. In the beginning, Graham said, that number is going to be small, and that’s okay. Don’t be embarrassed. Graham related the example of Apple, which only produced a couple hundred units of Apple I, its first computer. However, Apple sold 175 of those 200 units within the first 10 months by finding and appealing to early computer hobbyists.

More so than identifying who you want your users to be, your ideal customer, you have to understand who your users actually are, and who is really clamoring for your product. “You’ve got to know who those first users are,” Graham explained, “and sit with them, spend time with them, focus on them — have a party with them.”

Your first goal is focusing on those first 50, 100, or 500 users, and make them really, really happy. If you can do that, you’re on your way, and you can go from there, he said.

I’ve been asked how we get started a lot lately as we applied to a startup incubator for Equals and did some practice pitches last year. What’s the marketing plan, they ask? I know what I’m doing in my head but I’m certain I’ve done a really lousy job of relating what I’m thinking to others.

Paul Graham put the right words in my mouth. Our goal is to get 50-100 extraordinarily committed customers using and excited about Equals. I want to understand these people as well as I can and then use that knowledge to tailor the product even further. I believe the marketing plan will flow out of this work.

The problem, though, is that getting “50, 100 or 500 users” is really hard and that’s one of the reasons we chose to work on Equals out of all the prototypes we wrote a couple of years ago. We have 1.5 million iOS and Android powerOne downloads, 230,000 of which use our software calculators — which solves a similar job to be done — on a monthly basis. Of those 230,000 active customers, 50,000 are using one of our paid products with the rest using our free ones. We have already queried a small subset about Equals (about 2,000 of the 230,000), showed them the site, a video and other materials and had some small conversations with a few. The email list stands at around 700 right now.

I’m betting that Paul Graham is right, that it takes less than a few hundred to start an inferno. I’m also betting that we will find those 50-500 amongst our existing powerOne customers. We will know more in the next few months.

Sunk Cost

Sometimes it just isn’t working. We have this window of opportunity to get a first beta version of Equals shipped and, for goodness sake, it just isn’t getting done. Here’s the problem: we realized last year that delivering the iOS version first was a mistake. Instead we needed to do a web version first.

Equals is partly written in C, partly in Apple’s Objective-C, and partly in Javascript, but the Javascript code was done before either of us had any experience writing HTML5. (Read: hack job.) If we were going to do a true web version then we needed money (time) and we needed to learn Javascript so we lined up a contract job that paid us to learn it. It was painful (unstable, new platform without much documentation) and it didn’t buy us as much extra time as we would have liked, but it worked. By the time we were done we could re-write the code for Equals.

But too much of Equals code was still in Objective-C, which won’t work for the web version, so we needed to move it into C. Rick started to make the changes. He made it part way and then was interrupted by a health issue (now stabilized) and then contract work. He started again in late December. He thought three weeks.

Four weeks later and it isn’t done. In fact, Rick looks exhausted. He isn’t sleeping well and even days off don’t feel like days off because it isn’t done. Worse, every time he makes a change it breaks other code, so it is really fragile. Edge cases are killing him. He told me Monday he just stares at the code, not knowing what to do anymore.

I’ve been worried about the fragile code for a while. I’ve also been concerned about storing the notes in HTML as every browser changes it and will make it very hard to track changes some day. We needed a different approach.

The fundamental problem is that the code was written to handle text. When we added HTML, it was added as a side layer as to not disturb the functioning engine. Originally Rick was trying to strip the HTML, note the cursor position (which HTML doesn’t want to handle correctly to begin with), make adjustments as the code was changed, then add everything back in. As mentioned this wasn’t working.

So I suggested we change the approach. A la Markdown, which gave me the idea, I suggested we just replace the HTML with our own “markdown”, text that Rick could safely ignore and that we could store as a neutral format in the database. In fact, Rick realized we could use a feature from an early version of the app that we are no longer using, one that already was being ignored. The first thing Rick gets to do is rip out months of code.

Sunk cost. It doesn’t matter anymore.

Now we are back on track, I hope. Let’s hope we don’t hit any major snags. It is time for people to start using Equals.

Learning From Our Customers: Soliciting Feedback For powerOne v4.1

A week ago we released a major update to powerOne that brought the look of the application in line with iOS 7. It was a major overhaul. Every aspect of the application was touched and, in the process, plenty of bugs were found and squashed.

The release created a minor uproar among some of our customers though. While some people absolutely loved the re-design, others hated it. From most of those customers we received very constructive feedback, including many things we didn’t, and in some cases couldn’t, have foreseen before releasing.

We learned things like the new look was hard to see in sunlight (we live in Oregon so don’t see sun this time of year :-), it was particularly hard on color blind people (should have thought about that one especially since my wife’s brother is color blind), the contrast wasn’t strong enough for poorer eyesight, and the buttons felt smaller (only because there were no borders as in reality all buttons are larger).

We are human over here, folks, and we work very hard to make the best choices we can. We do what we think is right then we get feedback and make adjustments, which is what we are doing now.

Here is what we are going to do: instead of one calculator design option, we are going to give you three. The themes will be available in the calculator settings. Since we made the mistake last time of not soliciting feedback, I thought this time we would. I’ve added the three screens here. Please leave a comment to this post or email help@infinitysw.com to tell us what you think.

theme #2
Theme 1: This is the original v4.0 theme. We still really like this and think it is the closest we can get to the iOS 7 design aesthetic. While it will be available, however, it will no longer be the default. It might just be a little too radical for some.


theme #3
Theme 2: This theme is designed to be as close as we can get to the version 3 design but remain true to iOS 7. This theme should be good for those that need high contrast or just prefer the old look.


theme #1
Theme 3: Personally, I’m tired of all the white and black in iOS 7 and wish people knew how to use another color. This theme still provides those striking colors prevalent in v4.0 but also provides more contrast a la v3. This will be the new default.

Again, I’m looking for your input, especially from those of you who don’t like the version 4.0 re-design. Please leave a comment here or email help@infinitysw.com.