Hot Best Seller

The Art of UNIX Programming

Availability: Ready to download

The Art of UNIX Programming poses the belief that understanding the unwritten UNIX engineering tradition and mastering its design patterns will help programmers of all stripes to become better programmers. This book attempts to capture the engineering wisdom and design philosophy of the UNIX, Linux, and Open Source software development community as it has evolved over the The Art of UNIX Programming poses the belief that understanding the unwritten UNIX engineering tradition and mastering its design patterns will help programmers of all stripes to become better programmers. This book attempts to capture the engineering wisdom and design philosophy of the UNIX, Linux, and Open Source software development community as it has evolved over the past three decades, and as it is applied today by the most experienced programmers. Eric Raymond offers the next generation of hackers the unique opportunity to learn the connection between UNIX philosophy and practice through careful case studies of the very best UNIX/Linux programs.


Compare

The Art of UNIX Programming poses the belief that understanding the unwritten UNIX engineering tradition and mastering its design patterns will help programmers of all stripes to become better programmers. This book attempts to capture the engineering wisdom and design philosophy of the UNIX, Linux, and Open Source software development community as it has evolved over the The Art of UNIX Programming poses the belief that understanding the unwritten UNIX engineering tradition and mastering its design patterns will help programmers of all stripes to become better programmers. This book attempts to capture the engineering wisdom and design philosophy of the UNIX, Linux, and Open Source software development community as it has evolved over the past three decades, and as it is applied today by the most experienced programmers. Eric Raymond offers the next generation of hackers the unique opportunity to learn the connection between UNIX philosophy and practice through careful case studies of the very best UNIX/Linux programs.

30 review for The Art of UNIX Programming

  1. 4 out of 5

    Christoffer Ventus

    This book is about programming. Still, there is almost not a single snippet of code in this 500 page book. Instead it focuses on the philosophy that has developed within the UNIX community over the years. There is a lot of knowledge to be found here, even if you don't develop for, or even like UNIX systems. It has got comments from early UNIX hackers, even some of the original creators, which enrich the text and gives a broader perspective on things in some cases. The fact that many sections incl This book is about programming. Still, there is almost not a single snippet of code in this 500 page book. Instead it focuses on the philosophy that has developed within the UNIX community over the years. There is a lot of knowledge to be found here, even if you don't develop for, or even like UNIX systems. It has got comments from early UNIX hackers, even some of the original creators, which enrich the text and gives a broader perspective on things in some cases. The fact that many sections includes historical perspective alone makes this an interesting read. This field is very young after all, and makes you think of how far (or not) we've come since the 70's. It also contrasts UNIX to other operating systems, and the way programs are built on these, since a huge point is that the environment you work in greatly influences how you think of things. For instance, UNIX programs tend to be small, specialized and made to work collaboratively, while Windows programs tend to grow quite big, have many features and do everything by itself. The comments and evaluation, in respect of the UNIX philosophy, of wide ranging things, such as IPC, configuration and domain specific languages are very interesting. But if you're not an Emacs user (like me), prepare yourself to hear a lot of evangelism.

  2. 5 out of 5

    Will Semin

    I wanted to love this book, but INSTEAD I just sort of liked it. The book definitely was not a bad read, but it did not fit my needs.

  3. 5 out of 5

    David

    Available at http://catb.org/~esr/writings/taoup/h... Available at http://catb.org/~esr/writings/taoup/h...

  4. 4 out of 5

    Vlad Ardelean

    WIP, will review later

  5. 4 out of 5

    Erika RS

    Good book. There were a lot of things in here that I've felt for a long time but was not sure how to explain. For example, the discussion of why config files should be human readable made me realize why I was so opposed to an advisor's suggestion that our config file be a giant ugly s-expression on a project I did last year; it also made me realize why I felt that the backend for that project should use sockets to communicate with the GUI (because it encourages modularity, keeps GUI code out of Good book. There were a lot of things in here that I've felt for a long time but was not sure how to explain. For example, the discussion of why config files should be human readable made me realize why I was so opposed to an advisor's suggestion that our config file be a giant ugly s-expression on a project I did last year; it also made me realize why I felt that the backend for that project should use sockets to communicate with the GUI (because it encourages modularity, keeps GUI code out of real program logic, allows new interfaces to be easily added, allows GUI to run on a separate machine than the back end; we'd only though of the last). Not all was justification though; I also learned lessons about good ways to format and output errors and how much our testing process sucked.

  6. 5 out of 5

    Jonathan

    Victory!!! I have finally completed this book. The book weighs in at just under 500 pages, but it reads much longer than that (at least for me) I don't want to imply that that is negative though, the book is wonderful, and is an absolute must read for any software developer. It just took me 3 months to read, which is significantly longer than I would have thought, or originally wanted. This book does a very good job of explaining the culture and history of unix, but all of those cultural and hist Victory!!! I have finally completed this book. The book weighs in at just under 500 pages, but it reads much longer than that (at least for me) I don't want to imply that that is negative though, the book is wonderful, and is an absolute must read for any software developer. It just took me 3 months to read, which is significantly longer than I would have thought, or originally wanted. This book does a very good job of explaining the culture and history of unix, but all of those cultural and historical lessons are written in the context of how they drove or were the result of technical decisions. Chapter 1 lays out 13 rules of the Unix philosophy, and constantly comes back to them when discussing the design of a particular unix program. If the program breaks one of the rules, Raymond points it out, explaining why it was a poor decision to do so. The 13 rules themselves would be worth the price of admission. If you can only read one chapter, make it chapter 1.

  7. 5 out of 5

    Dave Paola

    The history section alone is worth it. Nathan Marz's mantra of "first make it possible, then make it beautiful, then make it fast" clearly were taken from this philosophy. A nearly identical mantra is stated in the first pages of this book. History is doomed to repeat itself. I first read the chapter on Textuality, and have since gone back and started from the beginning. So far this book is excellent. The history section alone is worth it. Nathan Marz's mantra of "first make it possible, then make it beautiful, then make it fast" clearly were taken from this philosophy. A nearly identical mantra is stated in the first pages of this book. History is doomed to repeat itself. I first read the chapter on Textuality, and have since gone back and started from the beginning. So far this book is excellent.

  8. 4 out of 5

    Ajitabh Pandey

    This book is more about the learnings/lessons from Unix world. Mostly historical descriptions and why certain choices were made by Unix and how they were revolutionary as compared to other operating systems. Lots of practice case studies are included wherein how and why certain choices were made by certain popular programs were made. A very quick read for me - more of like a refresher -as I was already well versed with the historical developments.

  9. 4 out of 5

    Justin Cormack

    Curiously Raymond managed not to read Gancarz's classic The Unix Philiosophy while writing this. It doesnt cover quite the same ground, and is much less concise. Its bigger on scripting languages and other more recent developments. Curiously Raymond managed not to read Gancarz's classic The Unix Philiosophy while writing this. It doesnt cover quite the same ground, and is much less concise. Its bigger on scripting languages and other more recent developments.

  10. 5 out of 5

    Jay Bhattacharya

    An extended argument for the genius of UNIX.

  11. 5 out of 5

    Teodor Moroz

    The book includes an overview of core Unix principles and philosophies, such as: Rule of modularity - write simple parts connected by clean interfaces Rule of clarity - clarity is better than cleverness Rule of composition - design programs to be connected with other programs Rule of separation - separate policy from mechanism; separate interfaces from engines Rule of simplicity - design for simplicity; add complexity only where you must Rule of parsimony - write a big program only when it is clear by The book includes an overview of core Unix principles and philosophies, such as: Rule of modularity - write simple parts connected by clean interfaces Rule of clarity - clarity is better than cleverness Rule of composition - design programs to be connected with other programs Rule of separation - separate policy from mechanism; separate interfaces from engines Rule of simplicity - design for simplicity; add complexity only where you must Rule of parsimony - write a big program only when it is clear by demonstration that nothing else will do Rule of transparency -design for visibility to make an inspection and debugging easier Rule of robustness - robustness is the child of transparency and simplicity Rule of representation -fold knowledge into data, so program logic can be stupid and robust Rule of least surprise - in interface design, always do the least surprising thing Rule of silence - when a program has nothing surprising to say, it should say nothing. Rule of repair -repair what you can—but when you must fail, fail noisily and as soon as possible Rule of economy - programmer time is expensive; conserve it in preference to machine time Rule of generation - avoid hand- hacking; write programs to write programs when you can Rule of optimization - prototype before polishing. Get it working before you optimize it. Rule of diversity - distrust all claims for “one true way" Rule of extensibility - design for the future, because it will be here sooner than you think With which I completely agree. Other than that book consist of a lot of history and case studies of tools, which are nowadays mostly obsolete.

  12. 4 out of 5

    Harald Groven

    This book is a CS classic. Now, as more than a billion computers (ie /servers/smartphones/notebooks) run a Linux operating system, software running Unix derivates is ubiquitous. That was not the case when this classic book was written in 2003. The original creators of the Unix operating system reflect on the design decisions they made in the 1970s, 80s and 90s as well as the underlying philosophy that guides the suite of software tools running on Unix (now eclipsed by Linux). These deliberate, a This book is a CS classic. Now, as more than a billion computers (ie /servers/smartphones/notebooks) run a Linux operating system, software running Unix derivates is ubiquitous. That was not the case when this classic book was written in 2003. The original creators of the Unix operating system reflect on the design decisions they made in the 1970s, 80s and 90s as well as the underlying philosophy that guides the suite of software tools running on Unix (now eclipsed by Linux). These deliberate, as well as evolved design choices are the the reason that made this suite of software tools so great that this software later conquered the server and smartphone market. Half of the pages and software mentioned in this book is now obsolete, as twenty years have passed since the publication. But the remaining content contains distilled wisdom from 30 years of development.

  13. 5 out of 5

    FleshyShowoff

    An excellent book, although I think the title is badly chosen because it's a bit of a misnomer and could put people off: the title implied to me that it would be about how to code for UNIX, what it *actually* is is the philosophies and design decisions that have influenced UNIX and why they were made. I think you could read this book without being a programmer and still get something out of it, however I also think that some familiarity of common UNIX tools would help as a number of them are use An excellent book, although I think the title is badly chosen because it's a bit of a misnomer and could put people off: the title implied to me that it would be about how to code for UNIX, what it *actually* is is the philosophies and design decisions that have influenced UNIX and why they were made. I think you could read this book without being a programmer and still get something out of it, however I also think that some familiarity of common UNIX tools would help as a number of them are used as case studies. Being written in 2003 it is a little dated but the vast majority of the advice in it stands up and of course the history it covers hasn't changed.

  14. 4 out of 5

    Abdulfattah Popoola

    Great book albeit quite biased against Microsoft and looks down on all other software/OSes. The last chapter offers some critical reflection on this pride. I really enjoyed the software-related discussions on design and implementation methodologies. The talk of transparency and discoverability being critical to ease of software maturity and usage. The book's age however shows in the dead links and outdated sections (e.g. on JavaScript, web browsers etc.). Great read though and full of wisdom. Great book albeit quite biased against Microsoft and looks down on all other software/OSes. The last chapter offers some critical reflection on this pride. I really enjoyed the software-related discussions on design and implementation methodologies. The talk of transparency and discoverability being critical to ease of software maturity and usage. The book's age however shows in the dead links and outdated sections (e.g. on JavaScript, web browsers etc.). Great read though and full of wisdom.

  15. 4 out of 5

    Aaron Dutton

    While dated (published in 2003), this book covers a large amount of relevant history that help explain *why* Unix is the way it is. I lived through about half the history that was covered and experienced about a decade and a half. Despite being a professional programmer for twenty years, I felt like I learned a lot from this book. While I have heard most of the Unix programming maxims before, this book really filled in the history and reasoning behind the sayings. I think this would be a valuabl While dated (published in 2003), this book covers a large amount of relevant history that help explain *why* Unix is the way it is. I lived through about half the history that was covered and experienced about a decade and a half. Despite being a professional programmer for twenty years, I felt like I learned a lot from this book. While I have heard most of the Unix programming maxims before, this book really filled in the history and reasoning behind the sayings. I think this would be a valuable read for developers who aren’t well versed in Unix history.

  16. 5 out of 5

    Ummat

    There are lots of wisdom in the book, The information in the book is relevant today. The discussions about tools, such as sed, cat, awk are interesting since he says they have survived the trial of time, 17 years later and still in use. Vi and Emacs are two editors that survived the trial aswell. In the end, the aspect of developing tools for non-developers is still a struggle today. For example, Jenkins is a high performance and the GUI leaves lots of things to wish for. Not that it was an examp There are lots of wisdom in the book, The information in the book is relevant today. The discussions about tools, such as sed, cat, awk are interesting since he says they have survived the trial of time, 17 years later and still in use. Vi and Emacs are two editors that survived the trial aswell. In the end, the aspect of developing tools for non-developers is still a struggle today. For example, Jenkins is a high performance and the GUI leaves lots of things to wish for. Not that it was an example of the book, but still it proves his point.

  17. 5 out of 5

    Marcus Davanço

    It's a dense book with a brief tour trough the pre historical unix and many aspects regarding the good practices involved in developing software the unix way. I'm sure I didn't absorbed everything that was shown, but I'm sure I got really good insights that would help me to become a better developer. I'll have to read it again somehow in the future, and certainly I'll be able to take more from it. It's a dense book with a brief tour trough the pre historical unix and many aspects regarding the good practices involved in developing software the unix way. I'm sure I didn't absorbed everything that was shown, but I'm sure I got really good insights that would help me to become a better developer. I'll have to read it again somehow in the future, and certainly I'll be able to take more from it.

  18. 4 out of 5

    Claudio Noguera

    Wonderful book in my opinion. It really tells you why Unix (and Linux) are the way they are and the efforts that made it become what it is. To me, Linux is a great humanity achievement. This book is technical without being technical, it really is about philosophy and principles rather than algorithms, syntax or other programming techniques. Could be seen as an encyclopedia.

  19. 4 out of 5

    Noah

    Enjoyable insight into some history of the UNIX world.

  20. 4 out of 5

    Tomas Janousek

    Even though it's dated and ESR isn't very popular these days, the book is really good. Explains a lot of concepts that many of us intuitively understand but have difficulty arguing for. Even though it's dated and ESR isn't very popular these days, the book is really good. Explains a lot of concepts that many of us intuitively understand but have difficulty arguing for.

  21. 5 out of 5

    Jose Seco Sanz

    Amazing book. Here are the whys and hows. I don't know of any other book like this. Amazing book. Here are the whys and hows. I don't know of any other book like this.

  22. 5 out of 5

    V

    Not exactly what I thought I was getting into, with much more discussion of the culture and history of UNIX than I expected, but nonetheless a pleasant read.

  23. 4 out of 5

    Brandur

    This review has been hidden because it contains spoilers. To view it, click here. Great insights into some of the historical roots of Unix and its successors, as well as some deep dives into the design of many classic Unix programs. My only complaints were that there was a lot of attribution of elegance to interfaces which, in my opinion, are not very elegant (take the make system or fetchmail configuration for example), and that large sections of the book are dedicated to technologies which are a bit outdated these days. Otherwise, this is a very interesting read.

  24. 5 out of 5

    Artem Gapchenko

    The combination of threads, remote-procedure-call interfaces, and heavyweight object-oriented design is especially dangerous. Used sparingly and tastefully, any of these techniques can be valuable—but if you are ever invited onto a project that is supposed to feature all three, fleeing in terror might well be an appropriate reaction. With the exception of rpc interfaces, that sounds an awful lot like modern-day mobile development to me, at least on Android :smile:

  25. 5 out of 5

    Rembo666

    This is an awesome book and it will make you question your approach to coding. I'm not saying that it changed my mind about OOP or writing integrated applications, but it did influence me. This is a well-written book seemingly written by a "grumpy old man", but I feel that it gave me a lot of perspective I wouldn't have had otherwise. This is an awesome book and it will make you question your approach to coding. I'm not saying that it changed my mind about OOP or writing integrated applications, but it did influence me. This is a well-written book seemingly written by a "grumpy old man", but I feel that it gave me a lot of perspective I wouldn't have had otherwise.

  26. 4 out of 5

    Gwern

    (Read online version.) Not bad, but more than enough dated at this point (finished in 2004 and most of it is more relevant to before then) that I'm not sure how much is worth reading. The CLI material is as worthwhile as ever, but the GUI parts are totally obsolete. The case studies are also rather too brief. (Read online version.) Not bad, but more than enough dated at this point (finished in 2004 and most of it is more relevant to before then) that I'm not sure how much is worth reading. The CLI material is as worthwhile as ever, but the GUI parts are totally obsolete. The case studies are also rather too brief.

  27. 5 out of 5

    Peter Haglund

    While suffering from having no residential Internet access for eight days, I did a lot of things in order to kill time. One such thing was reading this book which has been sitting on my shelf for eons.

  28. 4 out of 5

    Ramesh

    Knowing merely the programming tools, languages and utilities in Unix is not sufficient. Unix is a culture and to really exploit it, requires a Unix mind-set. Embrace the culture! Live the culture! This is a MUST-READ book for anyone who is serious in a career based on Unix!

  29. 5 out of 5

    John Lancaster

    Took me a while to finish, but very worth it. Great explanation of unix culture, practices, and history. Lots of information to digest but will serve as a good reference for my projects moving forward in the open source world.

  30. 4 out of 5

    Ondrej Sykora

    You might or might not like Eric Raymond, but that does not make this book any worse. This is a nice summary of the basic principles of the design of Unix and Unix applications, but most of the advice presented there is not limited to a single operating system or a single type of applications.

Add a review

Your email address will not be published. Required fields are marked *

Loading...