Category: Book Review

97 Things Every Programmer Should Know is a collection of short essays on many programming topics – coding, testing, pair programming, and more.

You can get a full list of the essays, as well as the full content. It was a bit surprising how much shorter and less readable they seem in this format, compared to the MOBI file.

The essays are somewhat useful, but most of them cover subjects that any good programmer should already have seen elsewhere, and thus were not very useful to me.

That said, while the amount of notes that I took in this book is way below average, it still contains plenty of interesting content.

Some of the essays I found useful or interesting:

38. How to use a Bug Tracker

39. Improve Code by Removing it

41. Interprocess Communication Affects Application Response Time

52. Let Your Project Speak for Itself

56. Make the Invisible more Visible

57. Message passing Leads to Better Scalability in Parallel Systems

64. Pair Program and Feel the Flow

66. Prevent errors (using Undo logging to review error prone section)

73. Resist the Temptation of the Singleton Pattern

76. The Single Responsibility Principle (separating classes for how they change)

90. Verbose Logging will disturb your sleep

Overall I'd say that the book is worth the money and time – but just barely.

I read Quick & Easy Keyword Optimization, Setting up a Profitable Flow of Traffic – by Karon Thackston – on record time (maybe 15 minutes) , mostly because I recently read her SEO Copywriting Flow recently. And it is on most part the same material.

So, is it any good? Yes, there are a few insights that makes SEO Copywriting Flow worth it, but for the current US$25 (US$15 with the launch discount) difference I can't recommend you get this one instead.

There are a few extra insights here, though:

• use keyphrases, individual words and synonyms in your copy. This is not mentioned on the book, but there are LSI (Latent Semantic Indexing) tools all around that search for relevant synonyms for keywords.
• remember to add your keywords on bullet lists.
• position as opposite to avoid calling your product something that users are looking for (i.e.: cheap).

So overall, I recommend that you get SEO Copywriting Flow from Amazon instead.

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.

Think outside the cubicle – by Scott Young – is a short e-book dealing on ways to be more productive while working from home.

Here are a few suggestions covered:

• Work for your peak everyday length instead of wasting hours of low productivity. You can also let low creativity tasks that require less of you for later, after your peak.
• A system of Day/Weekly to-do lists. The goal being having an achievable to-do list every day (instead of mine which currently have several hundred items!). You don't add items if you are done before the end of the day – that would only punish your productivity.
• Take breaks when you need them. But real breaks – not just checking your e-mail or Facebook, or anything related to work.
• Exercise and eat well.
• Write your goals and leave them where you can see them for motivation.
• Increment your output level slowly
• To stop wasting time with the internet, only check e-mail/sites/facebook once per day (this is a tough one to follow!)
• Always empty your e-mail inbox every day (also a bit though).

Overall, it was an interesting little (I think it took me less than an hour to read it) e-book. You can get it Scott's site. I wouldn't have bought it at his price, however – I got it on an Appsumo bundle.

The Dark Art of Writing Long-Form Sales Pages is a book on writing long-form sales pages – you know, the usually really annoying ones, full of bullet points, bonus products and testimonials that just keep scrolling down forever.

The thing is – while they seem annoying, for certain markets, they convert very well. So you might want to learn how to write them, and test them on YOUR market.

The book covers a lot of material:

• The genres of the long-form pages.
• How to research your product and customers
• The right way to do headlines, crossheads and hooks
• Writing the body
• Using testimonials
• How to show incentives, discounts and bonuses
• Suggestions o nhow to design and format your page

There are also a few bonus videos and extra PDFs. These are somewhat useful. The videos had really low audio in the screencast parts, but not too bad.

The main e-book also had some weird formatting, such as beige backgrounds with white text. Fortunately this was only on a few text boxes in the beginning. Other than that, it was very readable on my iPad using Kindle and the MOBI version.

Overall, the book was very good, and I have a ridiculous amount of pages bookmarked and sections highlighted. Joanna says on the book and on the videos that you should read the book twice (not an uncommon claim), and I agree that this is probably a good idea in this case. It really is a lot of material to absorb, specially if (like me) you are not a full-time copywriter and just want to learn how to promote your own products.