Customer Reviews

From Program to Product: Turning Your Code into a Saleable Product (Expert's Voice)

5 star:		(1)
4 star:		(3)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

Most programmers at some point think they have something they've built that, with a little luck and hard work, can be the next Visicalc of the computer world. In reality, there's a lot more that goes into it than that. Rocky Smolin talks about that process in the book From Program to Product: Turning Your Code into a Saleable Product. You'll know some of the stuff already, but it will keep you from making some other mistakes that could keep you from getting all you could from your brainchild.

Contents:
Who Wants To Be a Millionaire?; So What Do I Do First?; The Program - From The Outside Looking In; The Price of Success; Legal Matters; Some Financial Considerations; Sample Software Licence; Index

Smolin has a couple of different product offerings that he's taken from idea to saleable product. He uses that experience to talk about the perils, pitfalls, and payoffs of selling your work to others. Much of what he covers is how to take a step back and actually plan the product. This ideally should be done *before* you build it, but you may already have the program built and working for the original intended purpose. He shows how it's best to have that architecture and analysis done before you actually release it, as it will give you the foundation you need to create something that is solid and doesn't start breaking down under the strain of multiple customers. Probably the best information is on licensing and other legal issues (like escrow). We may be good at slinging code, but we're not all that hot at making sure the legal groundwork is done. Without it, you may find yourself giving up all your hard-earned profits to lawyers and disgruntled customers. Worth reading and considering before you make the mistakes.

There are a couple of nits I have with the book itself. Smolin is mainly an Access/SQL Server developer, so pretty much all the examples, interviews, and colleages mentioned in the book hail from that software niche. That doesn't make the core information any less valuable, but it does tend to get a bit old having all the examples showing the same type of software technology. Also, I'm not sure the interviews at the end of each chapter work as well as they could. They are nearly verbatim transcripts, so you have too many sequences of answers consisting of single word "yes" and "no"s. I realize that gives you the realism of the interview, but it also reads in an awkward fashion. I think I would have chosen clean up that area a bit more.

This book is worth reading if you plan to go down the independent software vendor route. It'll save you the hassles of repeating the common mistakes that nearly everyone ends up making.

Mr. Smolin's book isn't for the Sergei Brins or the Linus Torvalds of the world. If you think that the author is going to reveal the most sure-fire software development environment that will have the greatest chance of acceptance in the marketplace, you'd better look elsewhere. Actually, there IS no elsewhere because there is no such source that can deliver on such a claim.

Those that think that Mr. Smolin should have shown Java or C# examples in his book are entirely missing the point: this is a book that shows EVERY factor a developer should consider BEFORE releasing his much-beloved software to an unsuspecting public. The development environment particulars have no bearing on the business of selling software. Do you really believe that a jewelry shop looking for something to help keep track of all the parts needed for jewelry design really cares one way or another whether your program is written in C# or Cobol?

If you're looking at this book for guarantees, you won't find any. Software writing is a business, and anyone that indulges in wishful thinking is lost right from the start. You may think some feature you've written is just the coolest thing you've ever seen, but it may be the one thing that annoys a potential buyer so much that he'll pass your cool program right by without a second thought.

The 67 pages of interviews take up about a third of this book. I was charmed, informed, and bemused by them all at once. The interviews in this book read like direct transcripts from the tapes. There seems to be little editing; nothing, say, like "Ten Questions for Lotta Miles" in People Magazine. But the flow is very natural and Mr. Smolin makes an engaging interviewer. I think he felt it important to devote such a large portion of his book to the interviews because it serves up a huge dollop of authenticity.

None of his interview subjects have household names. Sure, an interview with the founders of Google or with Bill Gates would certainly have increased the general public's interest in this book and helped the sales considerably. But what do you really expect from an interview with a top flight software developer that hasn't been seen before? The people that are likely to buy this book will appreciate interviews with people that made a go of it by selling small, targeted software products to limited markets. That's going to make a heck of a lot more sense to developers looking to target small markets with their software products!

The "secret" to success in software development is the same as it is in every business: work hard, pay attention to what your customers say, get the details right, work hard, keep promoting your product, make sure to have enough capital at the start and keep your fiscal house in order, keep up with your taxes, work continuously on improvements to your product, work hard, watch your competitors like a hawk, don't let yourself become discouraged, keep on top of your billing, don't borrow too much money, and work hard.

Mr. Smolin's book covers them all. If you don't have a head for business, this book isn't really going to give you one. Well, NO book is going to give you that, all the thousands of business-oriented book titles to the contrary.

But what this book DOES give you is -- believe it or not -- a step-by-step guide to bringing your software to market. There isn't anything magical here. No, let me re-phrase that: there IS magic here, magic in the down-to-earth principles that Mr. Smolin writes about so clearly. Yes, you've heard them a hundred times, but have you drawn them to your bosom and made them a part of your everyday life?

If you want to know what this book is really all about, take these words from the section in Chapter 1 called "What This Book is Really About", contemplate them, absorb them, and realize that there really is no other way:

"This book is really about getting to your first day in business.

"It is about taking that raw idea you have for a program and creating a saleable product. And setting up the support system you need to make your business hum.

"If you're going to do this thing, you have to be ready for some tough days. But nothing worthwhile ever comes easy. Sometimes what it really takes is stupid, blind obstinacy -- the drive to keep going, stubbornly solving one problem at a time until you get the brass ring."

The magic comes from what Judith Martin calls "the alchemy of the spirit": the realization that you can, indeed, make a go of it if you just keep at it with "stupid, blind obstinacy", keeping your eye on the road ahead. Why should success involve anything more than what other successful people have done to become successful?

Here, in brief, are most of the steps that Mr. Smolin covers:

1) Define your product
2) Analyze it and create a system specification
3) Build in security
4) Design
5) Make program navigation consistent and smooth
6) Choose a platform
7) Decide whether to write it yourself or hire someone
8) Consider deeply the point-of-view of the user
9) Test
9a) Test some more
9b) Keep testing
10) Pricing and pricing options
11) Business considerations that lead to success
12) Financing options
13) Legal issues: copyright and ownership
14) The business type: sole propietor, corporation, etc.
15) Insurance
16) Software piracy
17) When to stop programming and sell the product
18) Writing a manual
19) Packaging
20) Going one step at a time

Some of these things are treated more-or-less in the form of to-do items on a checklist, such as insurance. You won't find a list of the best software product insurers in the land in this book...it's just another one of those things you must deal with if you're actually going to make a business out of your brilliant software.

Smolin's style has a light touch, particularly in the interviews. If you're somebody with little to no sense of humor, then this isn't the book for you. If you believe that business topics should be treated with seriousness and stodgy attention to every last stinking detail, then this isn't the book for you.

Not that it's a laugh riot, mind you. Smolin slips in the persiflage at the right moments, I think, to keep you mindful of the fact that business can be fun and that a bit of humor helps you overcome the self-doubt that can come with the inevitable business setbacks.

In "From Program to Product", Smolin treats the building of a software business, with all the attendant worries, obstacles, and triumphs, as if he's giving you advice as a very close friend who really wants you to do well. I truly wish that I'd had this book when I started my own software business. I'd still be in it ... and thriving.

This is a great book that I highly recommend for anyone considering creating and selling their own software. While you do not need to be programmer to read this book, it is assumed that you will be working with one--and programmers will get the most out of this book.

Rocky Smolin covers a lot of important, but easy to overlook, topics throughout the entire development process. Some of these topics are avoiding solving problems that don't exist, or not maintaining focus on what your program does, and does best. These are issues that need careful consideration at the beginning of the project and should not be taken lightly.

He also includes interviews with developers who have already gone through a lot of the growing pains associated with developing software for sale. These really bring to light issues that you may have never considered, but are valid nonetheless. For example, how the interviewee handles customer support and pricing models. Very useful stuff.

Some things you should not expect:
1) How to program - This book provides considerations for how your program should be designed, but not what and how to code it. That is not the purpose of the book.
2) Expert legal advice - Mr. Smolin is not an attorney and only addresses some legal considerations for writing and selling your software. Need legal advice? Hire a lawyer.

I like how Mr. Smolin doesn't try and give you a 900 page book filled with information you don't need. It's kept short, with good information, and to the point. I don't have time to read yet another super-thick book--I'm too busy programming!

I originally checked this book out from my local library, but have since purchased it from Amazon for my own collection. I really enjoy book and it continues to be a reference as I develop software for distribution.

I'd love to give this book more stars but unfortunately it falls short of the mark in a number of areas.

Pros:
1. It's well written.
2. It contains some useful information.

Cons:
1. It doesn't contain that much useful information (there are better books) which can be found on the Internet without any trouble.
2. Almost everything revolves around Access applications. I understand that the author is a great fan of Access (hard not to come to that conclusion) but a broader range of case studies would have been much better.
3. All the case studies were the author's own software. Again, I would have rather seen more general studies.
4. The design/UI principles etc are pretty dodgy - rather consult "real" books on this subject. The screen shots in the book are horrible.
5. The "interviews" are repetitive and boring - same questions, mostly Access. They follow the lines of; I wrote a program, went commercial, made some money, went bust (mostly), tried again (wash, rinse, repeat).

So, if you've got an hour or two to kill then read this book, but if you're going to choose one book rather go with "Eric Sink on the Business of Software".

I think this book is most valuable for non-techies. Smolin does a pretty good job at explaining to them in easy-to-understand terms the overall picture and details like how databases work, etc.

If you are a developer already, I'm not sure I can say this book would be as valuable to you as it would be to a non-developer. I definitely disagree with the above reviewer who rated it 5 and said "for the millions of programmers out there, this book speaks to you." It doesn't have any earth-shattering, mind-blowing AHA moments, which has kind of disappointed me (I was expecting something transformational).

Having said that, what I think it does for developers is offers them a reminder of what they probably already know. It's more for developers who are busy and don't want to sit down and think the process through for themselves or do the organizational thinking on their own.

For example, he says: "some of the folks you poll for feedback are going to express a bit of enthusiasm for the product... Ask if they would kindly agree to test your program once it's ready. And put them on your tester list." See, nothing earth-shattering!

What you should do is read as fast as you can and compile for yourself a list of maybe 5 pages (or less) that you can refer to over and over again of the stuff that you need to watch out for and not forget. That's probably the best way to use this book. But as I said, if you're a developer, don't expect a blueprint of how to be a master at this.

Good luck.