Code Complete
by Steve McConnell
Average Customer Review:
Paperback (14 May, 1993)
list price: $35.00 -- our price: $23.10
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Editorial Review

Believed by many of our customers to be the best practical guide to writing commercial software, and Highly Recommended. ... Read more

Reviews (145)

The Bible for the programmer
Steve McConnel has not simply written a book. He has collected, sorted and edited all relevant chapters of a tremendous number of sources (books, out of print magazines, research papers, etc.) to build the ultimate Bible for the Programmer. If you are writing code, that's your book! (Second Edition available)

Must read for professional programmers
If you've had to struggle through maintaining code written
by others who haven't a clue about how to name functions
or variables, this book is a great way to point them in
the right direction.I'm a Computer Science major who
has programmed professionally for 20 years, and this book
really polished my skills.If Steve's guidelines are followed,
readable code is the result that requires very few comments
to be understandable.This book was strongly recommended
reading at my previous job and rightly so.

Professional programmers style guide
If you want to write code for a living, read this book. The advice can be applied and is valid across languages. This book you will help you become a valuable member of the code team by teaching the way to write solid code, that will be easy to extend and maintain.

If you are a lead I would suggest Rapid Development by the same author. These books will pay for themselves many times over.

... Read more

Isbn: 1556154844
Subjects:  1. Computer Bks - Languages / Programming    2. Computer Books: Languages    3. Computer software    4. Computers    5. Development    6. Handbooks, manuals, etc    7. Microcomputer Networks    8. Programming - Software Development    9. Programming Languages - General    10. Computers / Programming / Software Development   

The Pragmatic Programmer: From Journeyman to Master
by Andrew Hunt David Thomas
Average Customer Review:
Paperback (20 October, 1999)
list price: $39.99 -- our price: $33.80
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Editorial Review

Programmers are craftspeople trained to use a certain set of tools (editors, object managers, version trackers) to generate a certain kind of product (programs) that will operate in some environment (operating systems on hardware assemblies). Like any other craft, computer programming has spawned a body of wisdom, most of which isn't taught at universities or in certification classes. Most programmers arrive at the so-called tricks of the trade over time, through independent experimentation. In The Pragmatic Programmer, Andrew Hunt and David Thomas codify many of the truths they've discovered during their respective careers as designers of software and writers of code.

Some of the authors' nuggets of pragmatism are concrete, and the path to their implementation is clear. They advise readers to learn one text editor, for example, and use it for everything. They also recommend the use of version-tracking software for even the smallest projects, and promote the merits of learning regular expression syntax and a text-manipulation language. Other (perhaps more valuable) advice is more light-hearted. In the debugging section, it is noted that, "if you see hoof prints think horses, not zebras." That is, suspect everything, but start looking for problems in the most obvious places. There are recommendations for making estimates of time and expense, and for integrating testing into the development process. You'll want a copy of The Pragmatic Programmer for two reasons: it displays your own accumulated wisdom more cleanly than you ever bothered to state it, and it introduces you to methods of work that you may not yet have considered. Working programmers will enjoy this book. --David Wall

Topics covered: A useful approach to software design and construction that allows for efficient, profitable development of high-quality products. Elements of the approach include specification development, customer relations, team management, design practices, development tools, and testing procedures. This approach is presented with the help of anecdotes and technical problems. ... Read more

Reviews (86)

Nice book but too shallow
The Pragmatic Programmer is a book that describes a no non-sense approach to programming. The book covers a lot of ground, from work philosophy, to coding practices to testing to project management. The book offers good advice. The style is engaging. However I am still very disappointed by the book. Why? I found that most topics are better dealt with in other books and chapters are often too short to really do justice to the topics. For example, work philosophy is better handled in 'Please Don't Just Do What I Tell You, Do What Needs to Be Done', coding and testing are much better handled in 'Code Complete', patterns by the gang of four.
The Pragmatic Programmer is a nice book for starting programmers or for a fun read. But the return on investment is very low for a professional programmer.

Fantastic book for anyone who codes for fun or work
This book will really make you take a step back at examine how you develop software.It will show you all the things you (and your team, if you're on one) could improve to really bring up your processes and skills.It goes through a series of best practices, going from topics like reducing duplication of all information (Don't Repeat Yourself - DRY), to the value of automation, to keeping separate systems distinct.It has many practical examples, both in code and diagrams, and a lot of resources to follow up on.Highly recommended.

First book on your bookshelf
If I ever had to start my book collection over, this would be the first programming book on my bookshelf. It's not one of those books that goes over the latest XYZ buzzword compliant technology of the day. This book talks about timeless principles to apply to a career in programming. ... Read more

Isbn: 020161622X
Subjects:  1. Computer Bks - Languages / Programming    2. Computer Books: General    3. Computer Programming    4. Computers    5. Programming - General    6. Computers / Programming / General   

The Mythical Man-Month: Essays on Software Engineering, 20thAnniversary Edition
by Frederick P. Brooks
Average Customer Review:
Paperback (02 August, 1995)
list price: $34.99 -- our price: $23.09
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Editorial Review

The classic book on the human elements of software engineering. Software tools and development environments may have changed in the 21 years since the first edition of this book, but the peculiarly nonlinear economies of scale in collaborative work and the nature of individuals and groups has not changed an epsilon.If you write code or depend upon those who do, get this book as soon as possible -- from Amazon.com Books, your library, or anyone else. You (and/or your colleagues) will be forever grateful. Very Highest Recommendation. ... Read more

Reviews (82)

Key concepts for project managers
This is an old book full of good concepts. Its value is not in the examples but on the concepts presented. The reader should focus on the concepts.

Some of the great qualities I found in this book:

- It is compact. Each chapter develops a major idea or concept in full.

- It is inspirational ( I think as you read it, your brain is activated in such a way that you will have ideas about your projects)

- It introduces a solid perspective on the value and impact of intelligence and skill in building or designing a product/system.

- It is applicable to many situations and not only to software projects. (if we could get the internal story of projects done by companies like GM, Ford, Toyota, Daimler Chrysler, Accenture, IBM we probably would find several examples for many of the ideas and concepts presented in the book)

The examples are old, but if you cannot deal with this, it is better to look for another book. One day you may come back and enjoy it.

Read it every 5 years...
I read this book about 1992, when I was just starting my career in software engineering.At the time, I didn't appreciate the book.I struggled through it, but frankly, didn't get much out of it because I was constantly saying to myself, "This book is ancient... what does IBM's OS/360 have to do with the world today?"

Fast forward to 2 years ago...I now had a lot more experience under my belt, and came across this book looking for material on the concept of "Conceptual Integrity" in architectural design.Now that I had the experience to 'relate' to this book, I got so much more out of it!This book isn't so much about the software part of software engineering as it is about the human element.If you are a programmer with several years of experience, or if you are a manager on a growing software project, you will get a lot out of this book.

I made a resolution to myself at that time to read this book once every 5 years...both to get new material out of it, and to provide some kind of 'reflection' on what I have seen in my career in those past 5 years.

So much better than "Code Complete" I can't believe it.
First if you are comparing "Code Complete" a book from MS which has yet to release a product that was complete, it is difficult to stop laughing.

Every new middle manager should read this book, and stop trying to ignore 50 years of experience. Oh yeah, we live in internet time, but we still can't make a project deadline, because human's haven't evolved much in the last 100 years. Yes extreme programming has its place. It's the mini team within the 7 person teams that Brooks outlines.

But its the communication issues within a project that kill bigger teams. Yes some programs and projects don't need this full scale project team. But try to write the flight control software for a modern jet, and you'd better be paying attention to the lessons in this book.

Yet managers still don't learn, go find "Programming Disasters" and see some examples of millions of dollars spent and no working project. People believe that there is some silver bullet instead of trying to work within the framework that they have. No one thinks that gravity doesn't apply to them for very long and neither will they think that communication issues don't apply once they see the disaster that unfolds. Usually though the money has been spent and the company folds/the project dies.

So pay attention! If you want "chief programmers" train them! It's not rocket science. The military trains generals and sargents with regularity, we can train our leaders if we care. To do it on the cheap well, we can see what happens when we try it. ... Read more

Isbn: 0201835959
Subjects:  1. Computer Bks - Languages / Programming    2. Computer Books: General    3. Computer Engineering    4. Computers    5. Microprocessors    6. Programming - Software Development    7. Software Engineering    8. Computers / Programming / Software Development   

Writing Solid Code: Microsoft's Techniques for Developing Bug-Free C Programs (Microsoft Programming Series)
by Steve Maguire
Average Customer Review:
Paperback (01 May, 1993)
list price: $24.95
US | Canada | United Kingdom | Germany | France

Editorial Review

Any programmer worth their silicon knows that it is wiser to invest time preventing bugs from hatching than to try to exterminate them afterwards. And this is one of the best books for developing a proactive attitude towards electronic entomology. Follow Maguire's advice, and your testers, supervisors and customers will love you. Recommended. ... Read more

Reviews (36)

Please ignore previous negative reviews
I was shocked to see this book get some negative reviews. Those that blasted Microsoft missed the point. This book provides invaluable advice in a quick read. For example, "If you have to look it up, the code is not obvious," or, "If you find yourself designing a function so that it returns an error, stop and ask yourself whether there's any way you can redfined the function to eliminate the error condition." This is the book that convinced me to single-step all my code. The heuristics on proactive bug prevention, which are summarized in the appendix by the way, will save your team time and let you move on to adding features rather than fighting fires.

Just look at the publishing date.
You are looking at a 10-year-old book with a bunch of green screens on the cover. What more can I say. I bought it in preparation for an interview with Microsoft. I did not find it helpful, except for a few pages that do help understand Microsoft culture (but you can learn much more about that on the net).

So many new things have appeared (and/or became popular) since the book has been published. OOAD, C++, Java, RUP, XP, design patterns, to name a few. It puzzles me that Microsoft still recommends this book.

Should be mandatory for every professional programmer
This is one of the best books on programming ever written.Maguire concentrates on how to eradicate bugs early in the cycle.At first what he says seems so simple.But these ideas are so powerful, and so well presented, that I'd give a copy to every programmer I know if I could afford to.

Don't worry that his examples are in C.The ideas transcend the source language.If half of the programmers followed half of his suggestions half of the time, the software industry would undergo a revolution in quality.There is no silver bullet, but these suggestions are so practical.It's just a matter of adopting a few good habbits.

This book will be a classic.Scratch that.It *is* a classic.

If you're a programmer, it belongs on your shelf beside _Programming Pearls_, _Code Complete_, and Knuth. ... Read more

Isbn: 1556155514
Subjects:  1. C (Computer program language)    2. C (Programming Language)    3. Computer Bks - Languages / Programming    4. Computer Books: Languages    5. Computer Programming    6. Computer software    7. Development    8. Programming - General    9. Programming - Software Development    10. Programming Languages - General   

Design Patterns
by Erich Gamma Richard Helm Ralph Johnson John Vlissides
Average Customer Review:
Hardcover (15 January, 1995)
list price: $54.99 -- our price: $47.04
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Editorial Review

Design Patterns is a modern classic in the literature of object-oriented development, offering timeless and elegant solutions to common problems in software design. It describes patterns for managing object creation, composing objects into larger structures, and coordinating control flow between objects. The book provides numerous examples where using composition rather than inheritance can improve the reusability and flexibility of code. Note, though, that it's not a tutorial but a catalog that you can use to find an object-oriented design pattern that's appropriate for the needs of your particular application--a selection for virtuoso programmers who appreciate (or require) consistent, well-engineered object-oriented designs. ... Read more

Reviews (187)

Design Patterns CD - Needs updating
The CD version is not 100% compatible with current browsers.Internet Explorer v6 reports errors on every page and it's new security features disable some CD functionality.

The Java search engine does not function in both IE and Firefox.

The content is, of course, exceptional; but the reasons for buying the CD are lost in the new browsers.Stick with the book.

An Excellent Intro and Reference for Design Patterns
You certainly can't get the information in this book from a more creditable source.The gang of four has produced an excellent book.The first two chapters get the reader in the patterns mindset and the document editor example introduces several patterns at a high level.

Though I wouldn't try to read the rest of the book cover to cover as it reads much like a textbook.It would be best to scan the handy patterns list on the inside cover and jump around to patterns that interest you or you've heard of.

These patterns certainly aren't the silver bullet to your design problems but becoming familiar with them will help you communicate more efficiently with your peers and avoid reinventing the design wheel.I often implement something and realize it is a pattern and then take a look at this book to see how to improve it.

Caveat emptor
This is, of course, one of the cornerstones of OOP. This book definitely influenced programmers at all levels and richly deserves the acclaim that it enjoys.
However, this book is not for everyone, especially beginners. To be able to get the best out of this book, you need some solid experience in object oriented programming. This book is ideal for people who have been developers and are moving up to designers/architects. The foundation of real world experience makes a very good base for absorbing the experience captured in this book.
This book is not theoretical by any means. In fact, it captures the experience gained by many people in the course of their careers and offers practical solutions to typical problems encountered in software engineering, specifically object orientedprogramming.
The material in the book is authoritative and terse and would be daunting to a newbie. Most of the explantions and examples are offered without much ado, and expect a certain level of not just knowledge from the reader but also awareness about practical applications and typical scenarios encountered in practice.
I would say that this book is suitable for full time object oriented programmers (whatever the language) with at least a couple of years of experience looking to further strengthen their knowledge of OOP systems and looking to gain an insight into the practical aspects of how to solve typical situations in real world projects. ... Read more

Isbn: 0201633612
Subjects:  1. Computer Bks - Languages / Programming    2. Computer Books And Software    3. Computer software    4. Computers    5. Object-Oriented Programming    6. Object-oriented programming (C    7. Object-oriented programming (Computer science)    8. Programming - Object Oriented Programming    9. Reusability    10. Software patterns    11. Computers / Computer Vision   

Refactoring: Improving the Design of Existing Code
by Martin Fowler Kent Beck John Brant William Opdyke Don Roberts
Average Customer Review:
Hardcover (28 June, 1999)
list price: $54.99 -- our price: $47.14
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Editorial Review

Your class library works, but could it be better?Refactoring: Improving the Design of Existing Code shows how refactoring can make object-oriented code simpler and easier to maintain. Today refactoring requires considerable design know-how, but once tools become available, all programmers should be able to improve their code using refactoring techniques.

Besides an introduction to refactoring, this handbook provides a catalog of dozens of tips for improving code. The best thing about Refactoring is its remarkably clear presentation, along with excellent nuts-and-bolts advice, from object expert Martin Fowler. The author is also an authority on software patterns and UML, and this experience helps make this a better book, one that should be immediately accessible to any intermediate or advanced object-oriented developer. (Just like patterns, each refactoring tip is presented with a simple name, a "motivation," and examples using Java and UML.)

Early chapters stress the importance of testing in successful refactoring. (When you improve code, you have to test to verify that it still works.) After the discussion on how to detect the "smell" of bad code, readers get to the heart of the book, its catalog of over 70 "refactorings"--tips for better and simpler class design. Each tip is illustrated with "before" and "after" code, along with an explanation. Later chapters provide a quick look at refactoring research.

Like software patterns, refactoring may be an idea whose time has come. This groundbreaking title will surely help bring refactoring to the programming mainstream. With its clear advice on a hot new topic, Refactoring is sure to be essential reading for anyone who writes or maintains object-oriented software. --Richard Dragan

Topics Covered: Refactoring, improving software code, redesign, design tips, patterns, unit testing, refactoring research, and tools. ... Read more

Reviews (102)

valuable reference book
While it is no groundsbreaking stuff, it is very useful for people who want to bring better design into existing code; or those who are just unhappy with the existing code. It clearly identified common problems with existing code and provides techniques to help you make it better. While experienced programmers have most likely used some of these techniques on their own, reading this book helps you remember/organize these techniques in your mind. One of the most useful things is that Martin outlines the steps to take to get to the desired code - each step is very small so as to minimize your chance of screwing it up.

Teaches concept not coding
Some of the reviews here have focused on this book as a way of learning coding techniques for refactoring. Other reviews have focused on refactoring being another term for what they have already being doing. While learning some new coding techniques might be a side effect of reading this book, the real value of this book is descibing a process and terminology for facilitating refactoring - something that many developers have done on an ad-hoc basis for years. It has been invaluable in broadening the acceptability of refactoring, an activity that was often dismissed as not being a good use of development resources time. It also gives a vocabulary for discussing refactoring rather than relying on engineers own adhoc practices. And there's probably a few refactoring techniques that won't seem obvious.

For C# users,you may wish to look at NUnit.org for a .Net version of the JUnit software mentioned in the book.

Finally, the technique has a name!
Although this book has been around for a few years now, the technique that Fowler names "Refactoring" is as old as programming.I've been doing refactoring for the twelve years I've been a professional programmer, often to the chagrin of my supervisors; they often seemed to subscribe to the "if it ain't broke, don't fix it" mentality.Yet I could always tell that the code *was* broken, even if it didn't appear that way when the product was used.I was beginning to suspect that I was the only one who saw this, and then I read this book - written by an eminent researcher in the field and one of the brightest people to ever put pen to paper.

By giving a name to the technique, it can be talked about in planning/design meetings, discussed as a best practice, measured, and demonstrated.But Fowler takes it much further - he gives names to common refactoring techniques as well as what he calls "bad smells", or signs that you need to refactor.("Speculative generality", for example - a perfect name for an annoying tendency of the 10,000-foot architects).

This book is well-researched and well thought out, and is a must-read for anybody who's serious about software development.It's principal value is in providing common terminology for common actions, in addition to good justifications for each refactoring. ... Read more

Isbn: 0201485672
Subjects:  1. Computer Bks - Languages / Programming    2. Computer Books: General    3. Computers    4. Object-Oriented Programming    5. Object-oriented programming (C    6. Object-oriented programming (Computer science)    7. Programming - General    8. Programming - Object Oriented Programming    9. Software refactoring    10. Computers / Programming / Object Oriented   

Extreme Programming Explained: Embrace Change
by Kent Beck
Average Customer Review:
Paperback (05 October, 1999)
list price: $28.95 -- our price: $19.11
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Editorial Review

Kent Beck's eXtreme Programming eXplained provides an intriguing high-level overview of the author's Extreme Programming (XP) software development methodology. Written for IS managers, project leaders, or programmers, this guide provides a glimpse at the principles behind XP and its potential advantages for small- to mid-size software development teams.

The book intends to describe what XP is, its guiding principles, and how it works. Simply written, the book avoids case studies and concrete details in demonstrating the efficacy of XP. Instead, it demonstrates how XP relies on simplicity, unit testing, programming in pairs, communal ownership of code, and customer input on software to motivate code improvement during the development process. As the author notes, these principles are not new, but when they're combined their synergy fosters a new and arguably better way to build and maintain software. Throughout the book, the author presents and explains these principles, such as "rapid feedback" and "play to win," which form the basis of XP.

Generally speaking, XP changes the way programmers work. The book is good at delineating new roles for programmers and managers who Beck calls "coaches." The most striking characteristic of XP is that programmers work in pairs, and that testing is an intrinsic part of the coding process. In a later section, the author even shows where XP works and where it doesn't and offers suggestions for migrating teams and organizations over to the XP process.

In the afterword, the author recounts the experiences that led him to develop and refine XP, an insightful section that should inspire any organization to adopt XP. This book serves as a useful introduction to the philosophy and practice of XP for the manager or programmer who wants a potentially better way to build software. --Richard Dragan

Topics covered: Extreme Programming (XP) software methodology, principles, XP team roles, facilities design, testing, refactoring, the XP software lifecycle, and adopting XP. ... Read more

Reviews (119)

not found - the silver bullet
Maybe I'm too cynical because I never got to work for the successful, whiz-kid companies; Maybe this book wasn't written for me!

This book reminds me of Jacobsen's "Use Cases" book of the 1990s. 'Use Cases' was all the rage but after several years, we slowly learned the truth: Uses Cases does not deal with the architecture - a necessary and good foundation for any piece of software.
Similarly, this book seems to be spotlighting Testing and taking it to extremes.

'the test plan is the design doc'
Not True. The design doc encapsulates wisdom and insight
a picture that accurately describes the interactions of the lower level software components is worth a thousand lines of code-reading.

Also present is an evangelistic fervor that reminds me of the rah-rah eighties' bestseller, "In Search Of Excellence" by Peters and Waterman. (Many people have since noted that most of the spotlighted companies of that book are bankrupt twenty five years later).

- in a room full of people with a bully supervisor (as I experienced in my last job at a major telco) innovation or good work is largely absent.

- deploy daily - are you kidding?
to run through the hundreds of test cases in a large application takes several hours if not days. Not all testing can be automated.

- I have found the principle of "baby steps", one of the principles in the book, most useful in my career - it is the basis for prototyping iteratively. However I heard it described in 1997 at a pep talk at MCI that the VP of our department gave to us. So I dont know who stole it from whom!

Lastly, I noted that the term 'XP' was used throughout the book, and the back cover has a blurb from an M$ architect. Was it simply coincidence that Windows shares the same name for its XP release? I wondered if M$ had sponsored part of the book as good advertising for Windows XP! :)

Embrace Change Again
In Kent Beck's first edition he articulated a manifesto for lightweight methodologies. These methods today are referred to as Agile Methodologies; which Extreme Programming is only one.

The Second Edition builds on the first edition but has a distinctly different tone. In the first book XP was a described as 12 practices that may or may not have been new but the aggregation of the 12 brought together something that as whole changed the way many people wrote software. In this book more emphasis is placed on the whys behind the practices which include values and principals. For example, here is a quote from the book, "Values bring purpose to practices". Kent goes on to say that if he told you to follow practices blindly some people would but most people want to know why you might do a practice. Here is where the values and principals come in to give you the reasoning why a practice is useful. Overall given the renewed emphasis on values, principals, and practices I thought the book itself was much more approachable than the first edition which hopefully will encourage the people who had been on the fence to try out the practices on their next project.

Quick and Solid Intro to XP
Even if you don't plan on adopting XP, this is worth a read.It's concise, reads quickly and has a nice table of contents.

The chapter on the four variables in projects was one of my favorites.It will give you a clue what to say next time everything needs to be done yesterday.The chapter on test first development was also useful and I've had great success with its techniques.

This book is worth a read even if you're initially turned off by XP.Even though it's on a specific development strategy, much of the information is useful everywhere.
... Read more

Isbn: 0201616416
Subjects:  1. Computer Bks - Languages / Programming    2. Computer Books: Languages    3. Computer software    4. Computers    5. Development    6. Programming - General    7. Programming - Software Development    8. Programming Languages - General    9. Software Development    10. eXtreme programming    11. Computers / Programming / General   

The Practice of Programming
by Brian W. Kernighan Rob Pike
Average Customer Review:
Paperback (04 February, 1999)
list price: $34.99 -- our price: $23.09
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Editorial Review

Coauthored by Brian Kernighan, one of the pioneers of the C programming language, The Practice of Programming is a manual of good programming style that will help any C/C++ or Java developer create faster, more maintainable code.

Early sections look at some of the pitfalls of C/C++, with numerous real-world excerpts of confusing or incorrect code. The authors offer many tips and solutions, including a guide for variable names and commenting styles. Next, they cover algorithms, such as binary and quick sorting. Here, the authors show how to take advantage of the built-in functions in standard C/C++. When it comes to data structures, such as arrays, linked lists, and trees, the authors compare the options available to C, C++, Java, and even Perl developers with a random-text-generation program (using a sophisticated Markov chain algorithm) written for each language.

Subsequent sections cover debugging tips (including how to isolate errors with debugging statements) and testing strategies (both white-box and black-box testing) for verifying the correctness of code. Final sections offer tips on creating more portable C/C++ code, with the last chapter suggesting that programmers can take advantage of interpreters (and regular expressions) to gain better control over their code. A handy appendix summarizes the dozens of tips offered throughout the book.

With its commonsense expertise and range of examples drawn from C, C++, and Java, The Practice of Programming is an excellent resource for improving the style and performance of your code base. --Richard Dragan ... Read more

Reviews (42)

OK, but there are way better books out there
Unfortunately, this book didn't give me much. It more or less is a extract of scattered wisdoms found in Steve McConnells "Code Complete" and Jon Bentleys "Programming Pearls." A lot of the examples and ideas brought forward in "The Practice of Programming" seem to be taken more or less directly from those books. I highly recommend getting the original works instead, as they are more complete, in-depth and also present a more consistent and enjoyable read.

One of those books that will make you a better programmer
Simplicity, Clarity and Generality are indeeds the qualities of fine code. This is one of the few books that strives to make you a better programmer. Most books are about how-to, this is a book that goes beyond that and gives you information that can make you better. The other two books that do this for me are "Programming Pearls" by Jon Bentley and "Refactoring: Improving the Design of Existing Code" by Martin Fowler.

The pedigree of the authors is something that you should not dismiss lightly, after all, Brian Kernighan is the "K" in the K&R book, and also with Rob Pike the author of "The Unix Programming Environment".

Lots of good stuff.

Experience distilled into a book
This book is perfect, it's not really for beginners, but more for someone crossing over to an intermediate level of programming, and wishes to learn some golden rules to keep in mind while programming.

The book is written in an incredibly simple and straight-forward way, which makes everything incredibly simple to grasp, and memorable. I know more than a handful of UNIX programmers that all either keep this book on their desktop for reference, or read it at least once a year.

This is the book I'd recommend to anyone who wants to "program better", this book probably won't teach you any new techniques, but it will teach you how to make your code more solid, more readable, and more enjoyable to maintain/debug. ... Read more

Isbn: 020161586X
Subjects:  1. Computer Bks - Languages / Programming    2. Computer Books: General    3. Computer Programming    4. Computers    5. Programming - General    6. Programming Languages - General    7. Computers / Programming Languages / General   

The UNIX Programming Environment
by Brian W. Kernighan Rob Pike
Average Customer Review:
Paperback (01 March, 1984)
list price: $49.99 -- our price: $32.99
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Reviews (28)

Fantastic!
This was my first book on UNIX in general, and I was extremely pleased with it. Kernighan and Pike provide a great introduction to UNIX. Topics covered include pipes, input/output redirection, sed & awk, UNIX system calls, lex and yacc, and much more. I reiterate: "Fantastic!"

The much-vaunted Unix "philosophy" in practice
This book is one of the cornerstones of the Unix philosophy."There's a philosophy?" I hear you ask. Ohhh yessss.Unix gives you the tools to build whatever you want and asks only that you behave nicely, reading standard input and writing to stdout.Problem is, the tools sometimes seem too small to get anything useful done.What can you do with tiddlers like ls, cp and diff after all?

This book answers those concerns by a series of examples.My favorite is the version control system implemented in diff.Yes, it's dated, but the quality still shows.I prefer to think of it as "old-school"; it shows just how much can be accomplished with talent and an understanding of the Unix Way.

Yes its great
This is the book I wish I had as an undergrad. I only purchased the book out of curiosity but was delighted with its content. If you are new to *nix programming then this book is a must! If this book demonstrates anything it reveals the true strength of Unix -- timeless. After all, the book was published in 1984. I always judge a technical book by its cover and this book is no exception (the less flashy the cover, the better the content). Eventually you'll need this book so you might as well buy it now. ... Read more

Isbn: 013937681X
Sales Rank: 92289
Subjects:  1. Computer Bks - Operating Systems    2. Computer Books: General    3. Computer programming    4. Operating Systems - UNIX    5. Programming - General    6. UNIX (Computer file)   

Software Tools
by Brian W. Kernighan
Average Customer Review:
Paperback (01 January, 1976)
list price: $29.95 -- our price: $19.77
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Reviews (4)

It's what's under the hood
The tools you will find in this book are ancient. They're written in a cockeyed hybrid of C and Fortran, and they're almost hilariously user-hostile by modern definitions. If this intimidates you, look at it this way -- you're looking under the hood of modern applications. Much modern word processing, page layout, and language implementation can be built by putting a nice, shiny coating on what you find in this book.

Kernighan and Plauger set out in this book to document what they used in their labs at the time it was written, and show how to build them. Ratfor was chosen because C was not as widespread then as it is now, and for those who didn't have it, a translator to standard Fortran '77 was one of the major parts of the book. A simplified version of the nroff text formatter and a version of ed are also included for text file processing (then as now one of the major uses for computers), the result being both a toolkit and a practical education in the ins and outs of applications development.

The environment given is not Unix-based inherently, but this book is a natural companion to Kernighan and Rob Pike's The Unix Programming Environment and John Lions' Commentary on Unix 6th Edition. It should be required reading for anyone who wants to do software development.

Classic on software design
Elsewhere on Amazon I reviewed Kernighan's "Elements of Programming Style." To quote one paragraph from that review -

Brian Kernighan has co-authored three books almost essential to learning our craft, this volume, "Software Tools" and "The Unix Programming Environment". "Elements of Programming Style" spells out the fundamental rules, "Software Tools" shows you how to apply them to a number of simple projects and extends the rules to software design and finally "The Unix Programming Environment" shows you how to use them in an operating system designed to reward you for your effort.

It could be said that "Elements" teaches programming and "Software Tools" teaches software design. Rules such as "do just one thing, do it well" seem to seep in through the pores as you read and work through this book.

It presents a number of projects starting with a word count program and progressing through some filters to some fairly complex tasks culminating in a RatFor pre-processor for Fortran. All the examples are written in RatFor, a version of Fortran that adds some more structured elements to that early language.

Don't be put off by the use of RatFor, the language is easily understood and the style of programming so clear that the algorithms are easily understood. I've personally translated a fair number of them to both BASIC and C and the RatFor pre-processor design became the basis for an AppleSoft BASIC pre-processor written by a close friend.

I've relied on this book so much for the last ten years, after writing "Hello World" I drag it out and translate a couple of the tools into every new language I've learnt. I then spend a day or two thinking about and implementing a design optimised for the new language. After that I find I have a good handle on a language and how to design for it.

This volume is not for those who want a book that gives them pre-written tools, a fair number of the tools are standard issue on any Unix derivative and the code is only tersely commented, relying on the exaplanatory text. However I recommend this book to all software designers and programmers because as you work through these examples you will learn a great deal about honing your craft.

Disappointed
My hopes were high because of the good reviews this book had received... I was disappointed. The idea of many simple programs, each with some clear functionality, that can be combined to produce powerful commands isillustrated clearly enough in the book. But the readability of the codeleaves something to be desired. There are lots of if-the-else, while, andrepeat constructs, and it's not possible to understand the code without theverbose explanations from the text. Often checking program behaviour forspecial cases, such as an empty file on input, are not part of the normaltext, but left as excercises to the reader.

I would have liked concisecomments that state invariants, pre-conditions, and post-conditions toillustrate the correctness of the program. These comments should be part ofthe program code, not some separate prose that is disconnected from thecode. All too often have I had to support code without these comments, andwithout the accompanying prose to describe the code. This book seems toencourage writing such code.

And also the book is somewhat dated: some ofthe programs have functionality that made sense in the early days ofFORTRAN programming, and are of little use to currentday C/C++ programmers. ... Read more

Isbn: 020103669X
Sales Rank: 58977
Subjects:  1. Computer Bks - Languages / Programming    2. Computer programming    3. Computer software    4. Programming - Software Development    5. Programming Languages - General    6. Questions & Answers   

Dr. Dobb's Journal
Average Customer Review:
Magazine
list price: $59.40 -- our price: $20.00
(price subject to change: see help)
US | Canada | United Kingdom | Germany | France

Features

• Magazine Subscription

Reviews (4)

Not for those trying to stay ahead of the curve
Solid practices fill this journal, but don't go looking for the cutting edge here. This magazine follows a theme every month, August 2004 is Testing and Debugging, not just a hodgepodge of articles slapped together with relevant advertising. In a given issue, the articles range in expertise from simple concepts of HTTP interactions to advanced techniques in runtime monitoring. It does seem to focus on two languages nowadays; C++ and Java.

It is a good supplement to you subscriptions. Every month I tend to find only two or three articles out of the dozen or so they print to be interesting.

The journal falls short in staying timely, a couple articles every month on emerging technology or practices would really improve this journal.

No longer the Dr. Dobbs you knew in '92
Any review placing this shell of a former mag in a five-star category doesn't remember how good it used to be, doesn't have anything to compare it against, or hasn't read it lately.

I'll be blunt: this isn't Dr. Dobbs.This is an imitation of Dr. Dobbs, now with less content than ever before.

I started a subscription recently after letting mine lapse a few years ago, and my first thought was how thin this magazine had gotten.Ads galore, the venerable PC-Lint product is still throwing code at readers with aspirations of deification, but a decided *lack* of relevant content.

Then I thought about it, and here's the problem: Dr. Dobbs wants to cover practical computer science each month, but it's gotten too big (too specialized, too complex, too broad) to cover well in a single magazine weighing less than ten pounds per month.

Add to this the absolute panoply, the metaphoric world of resources now available today just with some decent Google skills, and Dr. Dobbs is suddenly less relevant, less *necessary* than it once was.

You can still get algorithmic optimization lessons in an issue or two.Once in awhile, you'll get something worth that issue's cover price.More often than not, you'll read about things you don't use, or don't understand, because in reality, nobody can keep up with every trend in CS.The ACM and IEEE have about 150 specialized magazines just to make the attempt, so how can Dr. Dobbs even pretend to be a full spectrum resource?

No, Dr. Dobbs had a primary mission once that could make it great again: talk about the code.Code, code, and more code, and the less esoteric, the better.There are 50 million COBOL programmers in the world, and five XSLT-SOAP-webMethods package writers.What's more relevant, even today?

How to stay current with trends in software development
Dr. Dobb's Journal is one of those must-have periodicals on your software development bookshelf.Sure, there are other magazines and journals that are better at covering specific areas, but Dr. Dobbs will keep you updated on the entire world of software development.

Each issue has a general theme, such as graphics, programming languages or algorithms.Articles span a wide variety of development languages and are generally easy to read, even if you aren't familiar with the subject. ... Read more

Asin: B000060MI5
Sales Rank: 698
Subjects:  1. Computers & Technology    2. Computers    3. Mathematics, Computer Science    4. Computers & Internet