Customer Reviews

Joel on Software: And on Diverse and Occasionally Related Matters That Will Prove of Interest to Software Developers, Designers, and Managers, and to Those Who, Whether by Good Fortune or Ill Luck, Work with Them in Some Capacity

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

 

 

There is a fair bit of hard-won wisdom here. It covers every aspect of the programming world, from praise of hardware, through product management and economics, back to testing and coding style, and on and on. There are a few real gems among these 45 essays (plus intro and appendix), untrammeled by the need for consistency. He's certainly unabashed about bucking current fashions, including all the silliness seen under the revival tent of the eXtremists.

At several points, Joel rails against the false economies of making code smaller and sniggers at the people to whom it matters so much, then (ch 39) he rails against the size of a Microsoft runtime support package. He also points out that antialiased fonts, other than things like headlines, are a bad idea. That was already common knowledge around DEC by about 1980, since the visibly blurred margins of characters led to eyestrain as the focussing muscles fruitlessly tried to find the edge. Modern display technology with far smaller pixel sizes seems to have reversed that decision, however, except possibly at the smallest character sizes - a blow-up of a screen capture will often show antialiasing on body text that looks quite good. If he came on a bit less strong to start with, these annoyances would be a lot less annying.

Joel's incredibly high opinion of Joel wore on me after a while. Despite all the good in this book, I had to drag myself through the last half of his pontifications, repetition, and tendency towards the absolute. If you're already a fan of his other writing, that might not bother you. For me, Joel, in his role as high priest in the cult of Joel, became tiresome. I'm sure he's a skilled developer and savvy business man, but I really don't think I'd enjoy meeting him.

//wiredweird

I've enjoyed reading JoelonSoftware.com for several years now. Joel has a unique down to earth view on computers, programming and business that makes his blog worth reading. He believes in using the right tool for the job, and not just always using a hammer because you have one handy.

There are a lot of books and web sites on how business, software, computers and programming should be conducted. Most fail to understand the basics of what they are talking about because the writer has a theory that he thinks will solve everything. But the theory takes on a life of its own, and becomes more important than observed reality. Just the trap many political, religious and self-help demagogues fall into. They become pie-in-the-sky dreamers and less attached to normal life.

He seems to have a similar, if slightly younger perspective, on the field as Richard P. Gabriel who wrote his now famous "Worse is Better" essay about 10-15 years ago. Another writer/programmer he reminds me of is Paul Graham.

Others I would compare him too, though each if very different in their own ways, are the writings and blog of Wil Wheaton, The Cluetrain Manifesto, and the rants of Fred on Everything (Fred Reed), Jerry Pournelle's Chaos Manor, and much that appears on /.Slashdot.

Joel has not tried to generalize his very specific observations into a unified whole theory of all programming and computer management. But that doesn't prevent you, the home reader, from making those generalizations yourself. You may have to prevent yourself from thinking too much of it, least the Law of Leaky Abstractions take over. Joel gives one a good place to start.

I've used his "Law of Leaky Abstractions" in discussions I had many times.

Also, when I was thinking for a job I used his guide to interviewing when talking to perspective employers. Sure, he wrote it from employers to use, but I was able to easily enough reserve it's principals and applied them to finding out info about the company I was interviewing at. This allowed me find out what the bad interviewers really wanted to know when they didn't know what they wanted. It allowed me to show that I was smart and could get things done to the people who interviewed me. And since I'm employed again it must have worked.

Some of the best essays are:

The Law of Leaky Abstractions
Don't Let Architecture Astronauts Scare You
Interviewing (The Guerrilla Guide to Interviewing)
Three Wrong Ideas From Computer Science
How Microsoft Lost the API War
Getting Things Done When You're Only a Grunt
Top Five (Wrong) Reasons You Don't Have Testers

It is definitely worth the roughly 20 bucks you'll spend on it.

Joel is good a pissing people off! Weenie armchair quarterbacks and other fanatics that are easily infuriated probably won't like this book, or Joel's other writings.

A first glance at this book might give you the impression that Joel Spolsky is another bloging cynic with more opinion then experience. But don't be fooled. Joel is a very smart guy and this book is a great read. You probably won't agree with everything he says, I don't, but this book really makes you think.

An old coach of mine (Tony Blauer) told the "Good information doesn't displace OTHER good information."

Considering opinions that are the same as our own is far less valuable than opinions that differ from our own. Joel's book is full of opinions that have "growth opportunity.

Really good writers make you think. According to the chief blogger on my team at Microsoft (Rory Blyth) a great blogger is at least a but controversial, they not only make you think, they make you want to respond. Joel is on my short list of bloggers in aggregator.

The book is basically a collection of Joel's writing originally published on his blog at www.JoelOnSoftware.com, though this is not his first book. As near as I can tell the writings span a time frame from 2000 to 2004.

Joel is an interesting guy, the kind of guy you'd love to debate. He was an Israeli paratrooper went to Yale, worked at Microsoft for a few years then Juno, and now owns Fog Creek Software in New York.

To begin with, the book is a FUN. Joel's casual writing style is almost conversational and makes for a read that's more like listening to a story than reading a manual. I read it cover to cover in two days.

One of the things that I, as a Microsoft employee, love about the book is that Joel published his thoughts at "points in time" and his opinions evolve over time. It's important to remember this as you read the book. His opinions as a former Microsoft employee are also interesting. Some of them I see as dead on. Others tainted by the years between now and when Joel worked at Microsoft and distance between Microsoft's strategy then and now, and, of course, Joel's morphed perspective as the owner of a growing Software Vender. None the less, this is the kind of guy you'd wanna have dinner with. (Joel, can I buy you dinner next time I'm in New York ?)

Above all Joel's perspective on software development is, pragmatic and honest and his style of communication is direct, even blunt (which I love.)

The book is divided into five parts.

1. The practice of programming.
2. Managing Developers
3. Random thoughts on Not-So-Random Topics
4. Microsoft's .NET
5. The Best of Ask Joel

Part one on the practice of programming is full of hard nosed, pragmatic guides for developing great software including Joel's somewhat famous "12 Step Test", the importance of writing specs (and HOW to), scheduling software projects, why you MUST daily build, "Hard-Assed bug fixin', the Five Worlds of Software Development, Paper Prototyping, "Architecture Astronauts" (WICH I LOVED) , Fire & Motion, Wrong Ideal from Computer Science, Biculturalism, and Crash Reports (brilliant!).

Part two can basically be viewed as a forensic guide to (organizationally) why software development projects often fail and how to manage software development so that it doesn't fail. He bucks conventional management theory in explaining that most "incentive programs" in software development are counter-productive, that the industry fails to appropriately hire and keep software testers, developers NEED workspaces with walls and doors, and "Things you should never do" including some really interesting theory on "leaky abstractions".

Part three is all "Joelisms" !

I'm not going to describe this section too much - you really need to read it for yourself, but here are some of the chapter subjects.

" Rick Chapman's In search of Stupidity.
" What is the work of Dogs in the country?
" Getting things done when you're only a grunt. (MANDATORY READING !)
" Big Macs vs. The Naked Chef.
" Nothing is as simple as it seems.
" Defending "Not Invented Here" Syndrome.
" Ben & Jerry's versus Amazon.com
" Chicken and Egg Problems
" Bloatware & the 80/20 myth.
" The Economics of Open Source
" Murphy's Law gone wild.
" How Microsoft lost the API War.

Part four is Joel's reactions, over time, to .NET Tools and Technologies.

Part five is the Best of Ask Joel, selections from his forums.

In summary. GREAT BOOK, whether you agree with Joel's opinions or not. As easy as this book is to read, everyone that works in some part of Software Development or IT should read it.

I hope Joel writes another opinion based book. There are lots of folks writing books that help you learn, far fewer folks are writing books that make you THINK.

Lastly, the thing I liked the very most about this book is that it's reminded me how much I want to write MY OWN book.

Thanks Joel.

This book is a collection of the best 45 articles from Joel Spolsky's blogs (www.joelonsoftware.com). He has a HUGE fan following amongst software developers and ilk.

Why one loves reading Joel:
1. He presents a very human face; any article he writes is as if he is trying to talk directly to his reader.
2. Writes about very useful stuff that you dont get to read in textbooks (and other expensive, impressive books :-)
3. He condenses what he has to say into Lists (GMTA)

Some of my favorite articles (and included in the book):

1. Law of leaky abstractions: A very insightful essay on the tradeoff between the piles of abstraction layers we have in todays development world and the inefficiencies they cause.

2. Getting Things Done When You're Only a Grunt: A practical, funny and very useful article on how be a good developer when you are a bit low on the company's totem pole.

3. Two Stories: A thought provoking article about Joel's contrasting experience working in Microsoft and Juno. (he was the project manager for an earlier version of MS Excel)

All in all, whether you subsequently agree to his opinions or not, Joel is a must-read.

Apress was kind enough to send me a review copy of Joel On Software by Joel Spolsky. Spolsky is the creator of the website http://www.joelonsoftware.com, where he waxes eloquent on issues related to software and software development. As the head of his own company, Fog Creek Software, he brings both a technical and a business perspective to many of his essays.

This is the latest in a trend of books based on a compilation of a person's blog writing. In Joel On Software, a selection of important and insightful entries over the last four years are gathered and presented in a single volume. In some ways, it's a selective "best of..." book that distills down the writings that the author feels are still worth examining. This could be due to truths that haven't changed or to show how much things *have* changed since the original entry. You could say why read the book, as you can get it all on the web site. True, but you don't get the opportunity to have the writer add any clarification based on hindsight.

Joel will make you think about issues you've likely ignored, and he'll also teach you a few things in the process. For instance, you may think you know everything about Unicode, but count on some new stuff in the essay "The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)". And if you want to understand the two methods of growing your business, read "Ben & Jerry's vs. Amazon". Really good stuff to ponder...

This book will challenge, encourage, upset, and entertain you. Spolsky knows his stuff, and he's got the war wounds to prove it. This book is worth the price of admission...

Joel on Software is a collection of 45 articles from Joel Spolsky's Web Column. Yes, that means you could read these articles online for free, but if you're like me you'll appreciate having the best of the collection gathered and arranged in one easy-to-read-anywhere source.

So what are all these articles about? Opinions. Joel is one of those guys that has an opinion on everything and sometimes he's even right. (Sorry Joel, couldn't resist.) Just how right and how wrong will vary for each reader I'm sure, but in truth it doesn't matter. Joel's observations, rants, strategies, and opinions are always intelligently presented. That means he'll make you think, especially when you disagree.

Joel's articles are organized into three major sections and two minor ones. The first big section "Bits and Bytes: The Practice of Programming" is a collection of Joel's thoughts on the art and science of programming. This section largely branches out from one of the early articles, "The Joel Test: 12 Steps to Better Code". As it sounds, this is Joel's 12 Step Program refined from years of programming in the trenches. I agreed with him on many points, and only strongly disagreed on one point. He convinced me to at least try a few practices that I hadn't given enough consideration to in the past and that's never an easy sell with me.

The next section, "Managing Developers", centers largely around, well, managing developers. Joel has plenty of experience here. He held manager positions on the Microsoft Excel team as version 5.0 was developed, he was in charge of developers at Juno for years, and he now runs Fog Creek Software. I'm not a manager and never have been, so I honestly didn't expect to get much out of this section. In truth, it was probably my favorite. I learned scary facts about interviewing and the interviewing process, the effectiveness of multitasking (for humans, not processors), and just how the people calling the shots think. He makes a sensational case in here about why you should NEVER rewrite a code base from scratch. I just knew he was wrong about that before I read this book. I'm still struggling to find the faults in his logic, but he certainly put a few cracks in my armor here...

The last major section, "Being Joel: Random Thoughts on Not-So-Random Topics" is really an insightful section on business strategy, as it applies to software operations. There is a classic contrasting of Ben & Jerry's verses Amazon style growth, a definition of what exactly bloatware is, a great look at the economics of open source software, and detailed look at some changes Microsoft is going through.

Finally, there is a small section on .NET, which surprised me by being interesting to my non-Microsoft self, and a short Q and A with Joel appendix.

In all this, Joel basically develops his version of Sun Tzu's The Art of War for programmers. There are great tactics and strategies to be learned here for any level of programmer. You might have to suffer through a little praise for Microsoft and listen to some painful truths about Unix, but Joel is a fair-minded author who will also tell you what Unix does right and where Microsoft makes mistakes. Ride the waves when he stirs things up and learn what you can. Just don't tell Slashdotters what you're reading.

This book by the well-known software developer, entrepreneur and blogger Joel Spolsky is a comprehensive collection of the most interesting articles that have appeared on the Joel on Software website in the course of the last five years.

If you're a devote follower of Joel, like me, there's almost nothing here that you haven't probably already read online. Still, it can be useful to have all this content nicely reorganized and reprinted. As Joel puts it, the book is a heck of a lot more cohesive than the website, where by cohesive I mean «can be read in the bathtub without fear of electrocution.» At the very least, it can be a nice present from a developer to his/her manager, who might get a couple of clues they're still missing.

Inside here, there's plenty of clues indeed and Joel will be very happy to share them with his readers, drawing from his experience as developer, program manager at Microsoft, software entrepreneur and Israeli paratrooper.

Not everything here has to do with technical matters, but you'll also find something about the economy, managing people, business strategy and insulating pipes. This makes for a pleasant and varied reading, particularly if your ambitions go beyond being a good developer. In any case, you can count on the first third of the book to give you plenty of advice in this respect, while the second third deals with managing developers. The third part is a semi-random collection of topics, the majority of which deal with strategy. At the end of the book, you can find three articles on .NET and an appendix with questions and answers taken from the website.

Joel's basic approach can be described as very down-to-earth, beware-of-hype, no-silver-bullet philosophy. This is not to say that what he writes is bland and clichéd. Quite the contrary. He does not refrain from being original and even controversial at times, at the risk of being unpopular in denouncing the excess hype that sometimes surrounds topics like eXtreme Programming or Open Source, or attacking entrenched myths like network transparency or software reuse.

In any case, he his always witty, sometimes downright humorous and never haughty.

Joel Spolsky does very well in presenting the "best of" his weblob - Joel On Software - in book form. There are very few rough edges due to the transition of one form to another.

As for content, Joel has unique insights on the software industry, albeit from the shink-wrap Windows-centric world. When Joel stays the course and talk about these things he excels and draws non-obvious, but intuitively right conclusions. I quite enjoy his writing style and have found his thoughts on paper very useful. This book is an easy read, and hard to put down.

The only downfall of the book is the same problem that Joel himself criticises Eric Raymond for in "The Art of Unix Programming" - that is, his statements on a culture that is foreign to him often miss the mark. While ESR paints the Windows-culture incorrectly in his otherwise excellent work, Joel misses the boat in his characterisation of the Open-Source community. Too often does Joel dismiss the Open-Source community as teenage bedroom hacker zealots, rather than a broad community inclusive of professionals and large multinationals.

While distracting from the remainder of the book, we can forgive Joel - his business is Windows shrink-wrap, but his insights go further in describing a broader subsection of the ICT industry. This book is good stuff, and is a great follow on from his excellent previous work on user interfaces. A good read for software engineers, developers, programmers and those people that manage these activities.

This book is fun and easy to read, but there is actually a lot of stuff in here that is really right on the mark. A lot of it is common sense, which means of course that the majority of software teams do the opposite. Anyone with software development or management experience will probably wince with recognition at some of the points, such as the mistake of rewriting software from scratch, or creating over-complex architectures. This is a book I would actually buy for my engineers or managers, which is pretty rare. It's nice to have something to offer besides the Mythical Man-Month, which is really old.

Joel Spolsky is one of those people who has made a name for himself through his insightful, witty, and honest mini-essays online. Having learned the ropes at Microsoft, Juno, and his own Fog Creek Software, Spolsky has a knack for using his real-world experiences as perfect illustrations of those difficult abstract concepts everyone hears about but can never really define. Want to know about writing specs - why they are important, what they should address, etc. - but don't know where to start? Spolsky has four short, useful chapters to provide some answers. However, this isn't a traditional "how-to" that you ingest like a pill and systematically apply to your workflow. Instead, this is a book to enjoy, consider, and (all too often) then slap yourself on the forehead with an *AHA* moment.

One word of warning for the Unix crowd: I am a Unix guy with a sever Mac penchant. Joel's Microsoft background pops up at times and makes his argument seem a bit "foreign". He even goes so far as to defend MS and criticize the quick condemnation of the Linux and *BSD crowd. Spolsky is a good enough writer that he almost lured me in - before I knew it, I was starting to think that MS had written good software :) Be warned.

Despite any reservations or disagreements that may occasionally pop up, I have no qualms about recommending this book for any software developer or software development manager. There is a lot of value in this book - far more than the selling price - and the self-conscious developer will find him- or herself writing better code and making better development decisions for reading it.