Starglider Systems Blog

SideProject is a series (39) of interviews with developers of iPhone (mostly), Saas (Software As A Service),Mac and PC software.

Most of the interviews detail:

• the product
• how the developer got started
• what they were doing before or during development
• what tools they used (development and analytics)
• sales (first sale, first few weeks, now, etc)
• advice for developers who want to build their side project

There are a few common trends, specially for the advice. Unfortunately, it is not as helpful as you might think, because developers both say:

1) Just stop thinking about it and do it, and do something you want. It doesn't matter if people think it is useful (cue in reports of naysayers before the app became a hit). Learn from the experience, even if it fails.

2) Research to find out if people actually want your product before you start building it.

Personally, I think you should stick with 1 unless your idea is is very expensive/time consuming to develop, at which point you might want to switch to 2.

Some other pieces of advice

• (repeated many times, and I agree) Find your minimum viable product (MVP), release it and then improve it gradually with customer feedback. Don't try to put everything in on the first release. You will just never be ready to ship it.
• Being involved in related forums to your product or target market is great for getting sales.
• Ruby on Rails (which I personally like too) is the primary SaaS tool.
• Doing your idea as a side project is great because you have a safety net if it fails.
• Tracking tools: Google Analytics (mostly), KISSMetrics, Flurry (popular), Apsalar, AppViz, TestFlight, Clicky, AppFigures, Piwik, Verify, MixPanel,  AppAnnie, GoSquared, Visual Website Optimizer (author was interviewed in the book,BTW)
• Increasing prices can be good for extra revenue and sometimes sales (a well known fact).
• Hire someone to do the graphics if you are not good at it (specially for iOS apps)
• Try talking to bloggers in a related area and asking for reviews, or offering coupons for their readers.
• Development tools mentioned: XCode, AppEngine, Eclipse,
• Start with a small project, then larger ones later.
• Pay attention to user feedback, and make it easy for users to send it.
• Outsource. But use money you can afford to lose, because while your app might do great, it might fail too.
• Keep trying even if it doesn't succeed at first.
• Don't spread yourself thin – focus on one project at a time.
• Test, specially with app stores that take time for a new release.

Conclusion

SideProject is not only full of useful information, but it is also fun to read. Recommended if you are planning on starting your own side project, or even if you already full time on your apps.

You can get it at their site for US$34.

Outlining – by Sean D'Souza – covers how to use outlines to speed up – and improve – your article writing.
Like many Psychotactics books, it is very short (about 35 minutes for me, including taking a few notes).

That is good because if you are anything like me, you don't have a lot of time to waste and would rather get to the point as fast as possible. However, that still means there isn't all that much stuff for the price.

Why use Outlines?

Mostly, because it easy to get stuck or start wondering around outside the topic with them.

They also help focus your ideas without the extra baggage of the whole text, as well as making it easier to see bloat.

What to cover in your outline

Sean suggests the classic journalistic questions, plus a few more items – drama (a story to add interest), how, what, why, when, where, which, objections and benefits.

Keep an eye on bullet points – they can cause bloat because you expand the details for each of them. In some cases, each bullet point could be an article.

Instead they should only have a few lines each. and when you notice they could be an article, write that down for when you need article ideas.

To see if your article is any good, scan the article to see if it works – headline, first 50 words, sub-headlines and ending. You should see that it flows properly.

Sudden Switch (to general article writing book)

At a certain point in the book, it switches from outlines to general article writing. I imagine that either Sean ran out of articles about outlining (he does mention that articles can be repurposed on e-books…), or want to add a discreet plug for his article writing courses.

Either way, it is somewhat useful material.

Conclusion

The book is pretty good, and while I have been doing some minor outlining before writing my articles (as well as documentation and software) for years, I still felt a big difference on the flow after reading the book while writing this review. And I just read a sales page and the structure was very clear to me.

Clearly the time investment on reading is worth it. I'd say it is a little expensive for the amount of material, though. Otherwise it'd get 4 stars.

The ThoughWorks Anthology 2 consists of a few essays on topics of interest for software developers.

The essays

– The Most interesting languages – covers a few languages with why they are used, basics on what is different about them and some examples.

• Clojure – which has a nice transactional memory system and runs in the JVM.
• CoffeeScript  – A layer on top of JavaScript that compiles to Javascript, which is inspired by Python and Ruby.
• Erlang – Great fault-tolerance and resources for creating scalable servers.
• Factor – stack oriented.
• Fantom – runs on JVM and CLR – interesting system for inferences of types, nullable types.
• Haskell – pure functional language, great concurrency support.
• Io – pure OO, without classes, coroutines.

– Object-Oriented Programming: Objects over Classes

Interesting essay on how using an object focus vs a class focus, and thinking about object roles and avoid inheritance when possible. This helps reuses at runtime and makes it easier to change dependencies while running. Reminds me a lot of Ruby and ignoring types vs what the object can effectively do. It also makes mocking much easier. It also lists  languages with object-focused features, such as Ruby, Javascript , Groovy and Scala.

– Functional Programming Techniques in Object-Oriented Languages

Talks about functional programming techniques, such as using the transformational mind-set on collections and the patterns on which it usually appear, higher-order functions and others.

– Extreme Performance Testing

How to apply a more XP stance to performance testing. Recommendations on making performance testing part of the regular work on an agile way, including applying user stories, automated deployment, keeping a result repository and continuous performance testing in continuous integration.

– Take your Javascript for a Test Drive

Ideas and tools for testing  JS code.

– Building Better Acceptance Tests

Various useful ideas and suggestions for acceptance tests.

– Modern Java Web Application

Some useful suggestions on building web application. Mostly about Java, although some of it applies to all languages, such as server and client-side aggregation of contents, CDNs and the post redirect GET pattern (which is a common pattern on Rails, BTW).

– Taming the Integration Problem

Nice techniques on making integration easier.

– Feature Toggles in Practice

Easier ways to work on multiple new features at the same time, while keeping deploying new versions. Conditionals, using inheritance or compositions, annotations, run-time and build time toggles (the last is the one I've used the most)

– Driving Innovation into Delivery

Valuable ideas for making it easier for companies to innovate.

– A Thousand Words

Essay on Data Visualization. I am interested in the topic, and found the article somewhat useful.

Conclusion

Overall, I really liked the book and learned a lot. I have dozens and dozens of highlighted passages on my iPad Kindle app (Mobi version). The code listings are a bit hard to read, but they have an online link for a very readable version (you do have to be online, though).

Several of the essays were interesting or useful, but I feel that Object-Oriented Programming: Objects over Classes is the one that I can learn the most from in getting simpler designs for my projects.

 

Mind Performance Hacks, by Ron Hale-Evans is a book containing many techniques to improve your mind.

The book is divided into several sections:

– Memory – includes many different ways to memorize things like lists, numbers, overcoming tip-of-the-tongue effect.

– Information Processing: learning to catch your ideas, writing faster, optimizing your learning, mind maps.

– Creativity: forcing connections, finding ideas, anologies,

– Math: several little hacks for calculations, and also for calculating weekdays.

– Decision Making

– Communication

– Clarity: avoiding cognitive distortions, breathing, meditating.

– Mental fitness: warm-ups, games, sleep, overclocking.

Overall, I really like it, but it is interesting to note that many of the hacks require practice. And also, this book really deserves making notes and re-reading chapters that you found interesting.

Recommended.

 

Delphi XE Development Essentials – by Bob Swart is a very good e-book covering new features in Delphi XE – as well as some new features in Delphi 2009 and even Delphi 2007.

Since most of my programming is done in Delphi 2007 and I plan to switch to XE2, I found the book quite useful.

I have been a little remiss on upgrading Delphi, mostly because since 2007 there was a complex process on the local reseller which even included sending them signed contracts in the mail. That was surprisingly worse than the very simple process from Delphi 4 to Delphi 2007 – simply accessing a site and either entering your credit card number or printing out and paying a boleto online. Thus I skipped 2 or 3 versions of Delphi.

Obviously the forced Unicode support in Delphi 2009 didn't help, as it will take a while to change applications to support it. XE2 is a bit exciting as it added 64-bit support. In most software 64-bit has no practical use at all, but I have several users that had memory problems with STG FolderPrint Plus after scanning several million files at once. This was much improved with supporting 3GB memory in 64-bit OSs a few versions back, though.

The book was quite useful, and cover a lot of ground, including Unicode support, new compiler options, new features such as attributes, generics, unit testing, code site, subversion and more.

Recommended to anyone switching from an older Delphi version, or even starting with XE. It is interesting to note that you can get it for free when you get the XE2 Development Essentials edition.