Rating: 
Summary: A great book about Unix
Review: I read the book first in its HTML form, from Raymond's site, and I felt need to buy the real book.
Its format is very appropriate and shows the best we have in Unix.
Even though I have a degree in chemical engineering, I found it to be a valuable resource for my own projects for open source development.
Rating:
Summary: Finally, an excellent book for programmer
Review: I was able to spend a couple of months finishing this book. As soon as I finished the first chapter, I know the book would be an excellent one, and it does not disappoint me from the beginning to the end.I have been using Unix (and its variants) for a decade amd have quite some knowledge about "how-to", but probably like most other Unix programmers, have never systematically thought about the underlying "why". This book is going to tell you both in details. The book contains topics in software engineering / design / implementation / interface / documentation areas. They are all supported by solid examples, both success and failure stories. This makes it stand out among numerous books on similar topics. The author's concise and clear writting style is among the best I have seen in computer books (similar to Richard Stevens's famous series, if you have to make a comparison). The author apparently does not fail on me to make me a better Unix programmer. The book is an good complementary to your library if you are a Unix programmer (it is also refreshing even if you do not program under Unix). And I'd recommend this book to everyone who starts to program under Unix or have programmed under Unix even for a long time.
Rating:
Summary: Finally, Unix culture laid bare.
Review: I'm glad someone finally wrote _The Art of Unix Programming_, and particularly pleased that it was one of the Unix community's greybeards who did it. I earned my computer science degree a decade ago and have spent the time since wondering why no one has ever written anything like Eric Raymond just did. Excellent.
Rating:
Summary: To Learn the Philosophy of OS(UNIX) Software Architecture
Review: Others have found that the INTP Myers-Briggs Type Indicator is the preferred personality type for (software) architecting team membership. After I wondered how to be more "philosophical", this book helped by teaching about the Unix Zen-like philosophy. If you think this way, you should be able to improve a design. Chapter 3 "Contracts: Comparing the Unix Philosophy with Others" starts with this quote from a Dilbert newsletter, "If you have any trouble sounding condescending, find a Unix user to show you how it's done." Nevertheless, I am more likely to be less critical and more philosophical about designs after learning about the OS designs of VMS, MacOS, OS/2, Windows NT, BeOS, MVS, VM/CMS, and Linux. The last chapter titled "Futures: Dangers and Opportunities" summarizes the philosophical differences between operating system design in the past and in the present with Linux. By the time I got to this last chapter, I see that this book is a real eye opener and you will think "philosophically" about software designs. Understanding history does help. The next generation is thinking about usability along with the open design patterns of the OS. This is paradigm shift for Unix and Windows gurus. Besides learning about how to think philosophically, this book is a gold mine to a software engineer. For example, chapter 2 "Basics of the Unix Philosophy" covers 17 rules on design that every software engineer needs. Additionally, chapter 16 "Reuse: On Not Reinventing the Wheel" is a hoot. Today, some professors do grade on code readability, style, and program documentation. Chapter 14 "Languages: To C or Not To C?" is another learning experience on language choice. I cannot help but wonder if the authors are not Zen-like enough because of their love of their offspring C, when today there is a growing community using Java for embedded Linux software, because of its portability, improved memory management, and eliminated pointer security problems. Platform neutral language and OS. Chapter 19 "Open Source: Programming in the New Unix Community", should be required reading for a software engineer. We need to learn about the open source software development process. If there were only time, this book would make an excellent addition to a computer science OS or software engineering course. Software architects need this book. The Masters have a done a great job by contributing to this.
Rating:
Summary: Timeless Technology
Review: OVERVIEW
--
OK- so I'm a relatively young developer, and my 'professional' programming experience doesn't start until the mid-late 90s. So I guess that means I've grown up in what's manifest as Open Source. Open Source and UNIX is all around me, and has become the richest and most open creative community I've ever been a part of. I can hardly fathom, any sustainable software world outside of Open Source, open standards, and open process. I love Open Source, every aspect of it. The Art of UNIX Programming has given me an understanding of where this all came from, the rich traditions and working process that _is_ UNIX, as well as the people that _are_ UNIX. ESR (as he's known in the Open Source communities) maintains an extremely forceful and open vibe throughout.
It is noteworthy that ESR is giving a fairly one-sided view of the history of computing, as he's completely focused on UNIX, and Open Source- and isn't afraid to poke at other processes and systems as he moves along, but it's clear that he's really passionate about UNIX. He's not preaching in this text, he's clearly addressing the Open Source UNIX hackers out there, and his directness seems to have made some enemies.
I tend to like it when one has enough guts to put their neck on the line to communicate what they care about- and ironically, ESR's tone, however one-sided, is biased towards Open Source in a sort of evolutionary selection process, in opposition to a human-forced set of rules that guide technologies; so his one-sided fervor is quite an easy pill for me to swallow. Noteworthy, this book will really tick off anyone who's not comfortable nodding to a periodic MS and Proprietary IT-establishment slam here and there. It's also got some stiff words for Object Oriented programming- but speaking as a programmer who uses Object Oriented languages and systems, I actually feel he addresses some of the design weaknesses that I have experienced (mostly in things that re-invent the computing wheel in confusing ways). If one can get beyond that, there's TONS of wisdom in here that EAR shares, from one of the oldest and evolved systems in computing, UNIX. ABOUT THIS BOOK
--
Right off the bat, I was hooked, as Eric S. Raymond is one of the first people I've heard in Computing to refer to one of my favorite authors, Christopher Alexander <http://www.patternlanguage.com/>. To me, this either says that like many professional communities, IT/CS doesn't pay much attention outside of itself, or I gotta go around the block a few more times before I state such things- (or perhaps a mix of both <g>). From here, I'll divide the book into 2 parts, People/History, and Process/History. ESR glides through a great history of the People and Systems that have influenced contemporary UNIX systems, and then proceeds to dive into the vast accumulated systems and process that an operating system with 30+ years of history has generated. Re. People:
UNIX roots are way more punk-rock than I could have ever imagined. Reading the history and personal accounts in The Art of UNIX Programming was to me, like going over my family history with a grandparent. To be honest, I had NO idea how much I had in common socially, IT-politically, and in spirit, with the original creators of UNIX. I hate to get all spooky n' stuff here, but it was all like some weird conformation of things I knew through osmosis- by using UNIXes. That's about the best way I can explain it. Not that it created some hierarchy of rock-stars, but it brought me closer to what I consider to be like family. ESR brings in some of the original creators of UNIX to speak on given topics throughout the book, and discusses some of the cultural divisions in UNIX culture. Re. Process:
Osmosis. Good design breeds more good design, and the rest of the book delves into the myriad of lessons in good design which have come out of UNIX.
The process sections of this book didn't really preach the legalism of a manifesto, but instead showed the roots of what's influenced UNIX today, and how that manifests in what I make daily. The principles discussed come from the vast discourse of software engineering on, and for, UNIX systems- and one of the best principles I took from this book are that the systems that have lived the longest lives, have done so because of a reason.
The process part of book have given me a whole new level of respect for a lot of developers and projects which I simply didn't understand before, or took for granted. CONCLUSION
--
This book was great fun for me; it's big-picture view made me realize I'm totally a kid with UNIX, and documented guiding principles that I interact with every day.
The book would be very accessible for non-technical readers, as advertised. This book would be a good read for an Architect, or Urban planner, as well as most anyone in a given Design-oriented field- though it does require some basic understanding of computing to get into. I believe the crossovers in UNIX practice and other fields are astounding (and I'd LOVE to read an 'outsider' review!).
Anyone in or around computing in any way would get SOMETHING good out of this book, and 'The Art of UNIX Programming' is a must-have for anyone who works with, and loves, UNIX. .ike
Rating: 
Summary: Highly informative and readable, though very biased
Review: Raymond does a good job of explaining the philosophy driving the Unix-style of programming. Coming from a background programming Windows, I always thought of the Unix approach (lots of abbreviated command-line utilities, mini-languages, pipes, semi-unstructured text-based process integration) as down-right primitive. However, after reading this book, I've started to understand the philosophy (and the practical reasons) for adopting this approach. I'd definitely recommend this book especially to newbie programmers from the Windows or Mac (pre-OS X) worlds. That said, I do have some criticisms: One of the problems with this book is the overly partisan tone it takes - one gets the impression that absolutely nothing Microsoft has ever done is of value, but the other major desktop PC OSes (Apple, Linux) represent different forms of perfection. (At home, I run Mac OSX, RedHat Linux and Windows, and have a reasonable sense of their relative strengths and weaknesses.) So, be warned: Art of Unix Programming paints a one sided picture. The author is a well-known figure in the open source community, one of its fiercest advocates, and one of Microsoft's most vocal critics, so it might seem to strange to wish for less anti-Microsoft spin from this source. After all, the Raymond brand certainly carries with it an obligatory expectation of Windows-bashing, doesn't it? One of the only Windows design decision which Raymond doesn't condemn is the (now discontinued) .ini file format. Even the thorough-going support for object-orientation in Windows is given short-shrift: after explaining the many horrors of object-oriented programming (according to Raymond), Unix-programmers are praised as "tend[ing] to share an instinctive sense of these problems." This section (http://www.faqs.org/docs/artu/unix_and_oo.html) is particularly illustrative of the one-sided approach that Raymond takes. Art of Unix Programming is really an excellent and informative book which could have been substantially better with a little balanced discussion. I found myself constantly second-guessing the author: Is he arguing such-and-such a point on the merits or because he simply loves UNIX & hates Microsoft so much? While the book does a great job of articulating and illustrating the UNIX idiom, it's a shame that the reading experience is marred by mistrust. If he hadn't been so blindly anti-Microsoft, we'd be able to more confidently rely on his conclusions, and the text would be not merely highly informative (as it is), but definitive (as it is not). Four stars, therefore, instead of five. PS: You can find this book on-line with Google - no charge.
Rating: 
Summary: Nothing About Everything or Everything About Nothing?
Review: Take a look at the online version available at http://catb.org/~esr/writings/taoup/html/ and think twice before buying this book. Unless you are a complete newcomer to Unix programming, TAOUP will be useless. The first part, "Design" covers the culture of Unix, and may be useful, but the rest of the text lacks the necessary depth. Real Unix programming books, like Stevens' one are much better.
Rating:
Summary: The philosophy behind the code
Review: The Art of UNIX Programming by Eric S. Raymond, contains over 30 years software engineering wisdom. In addition to Raymond?s own experience, the book also incorporates knowledge from thirteen UNIX pioneers including Ken Thompson (the creator of UNIX) and David Korn (creator of the korn shell). Raymond?s book tells about the philosophy, design, tools, culture, and traditions that make up UNIX. Raymond shows how these are being carried forward today in both the open-source movement and Linux. Personally, I rather enjoyed reading this book because it's not just another book that teaches you how to use a particular programming language. This book teaches you how to design software, teaching you the philosophy behind UNIX and contains some of the history hacker lore that made UNIX what it is today. Unlike most programming books I have read this book uses case studies to prove a point rather then tailored examples. The case studies use real, pre-existing pieces of open-source software that are in use every day (including Kmail, The Gimp, Audacity and many others). Through these case studies Eric demonstrates how to apply the book's wisdom in building software that not only adheres to the UNIX philosophy but software that is more portable, more reusable, and longer lived.
Rating:
Summary: Autohagiography with some programming tips
Review: The writing style of this book tends to hurt the reading experience, as Raymond trumpets his own minor achievments in the free software community. The work feels like it needed one more rewrite before being released to the public: some related sources Raymond hadn't yet read at the time of writing, and some of his advice gets repetitive. The exposition itself is not up to par with The Elements of Programming Style. Raymond tries to give a list of programming rules or principles to follow, but it reads more like a list of slogans that should be taken as axioms. While The Elements of Programming Style itself had a list of rules, the rules were well woven with each other, well defended, and they were used as a means of conveying a larger story. In Raymond's case, he relies upon the slogans in absence of such a story. Thus, the book ends up more like a list of random unrelated tips. Some very profound, like his writings on threads (which he acknowleges Mark M. Miller for his help). Others are very shallow and pointless in a book that supposes to call itself about "Art." Some of the pieces appear only to function to attack Windows, and sometimes the information about Windows is embarassingly inaccurate. One final criticism is that Raymond does not understand object-oriented programming very well and misses the point in several cases. You just need to see the popularity of Python, Java, C# (Mono), OO Perl and C++ in the Linux world to see that Raymond is off base calling OO a failed experiment. In fact, with almost any matter of opinion in the book you can feel Raymond's bias and be hit in the face with misinformation or dull false dilemmas. However, given this book's many flaws, I rate this 3 stars instead of 2 stars because it also has valuable information from the many contributors, some of them Gods in the Unix world. These contributors often even disagree with Raymond, or point out other interesting tidbits. For these tips alone, it is worth checking out this book, though I would not recommend you buy it. To get the true Unix programming philosophy, I recommend Software Tools, by Kernighan and Plauger. It's somewhat dated, and I recommend the Ratfor version of it, but that single book has became very influencial as I grow as a Unix programmer.
Rating:
Summary: Good introdution but limited.
Review: This book is about programing for the UNIX culture. And has many good sections.
In section 1.6 there is a list of design rules for writing UNIX programs. But I feel that these design rules are mainly for writing small programs or tools. I don't think that the rules are good enought to scale to large system. A problem with the book in general.
There is a setion comparing UNIX to other operating system. I not sure the need for this comparisons. The OS is not always the choice of the programer. I find this section just marketing.
The sections on data formats and languages comparisons are very good. And are back up with good case studies.
Also the section on writing doc. for UNIX programs is very good.
In all this would be a good introduction new to UNIX and programing.
| 
