|
Your search returned 11 matching documents
Code Generation in Action
by
Jack Herrington
|
Manning Publications
1 edition
July 2003
368 pages
|
Reviewed by Matthew Phillips, August 2003
       (7 of 10)
This book is packed full of information on code generators. This is both its positive and negative point.
It gives you a lot of information about when code generators are useful and when they are not. It also has sample code generators for just about any coding need you could imagine. The chapter on writing database access generators is almost worth the price of the book in its own right.
My biggest complaint about the book is that it is listed for software engineers or architects of any level of experience. This book is definitely not for beginners. It is a book that I will probably need to read several chapters again before I write my first code generator and keep it close by while I'm doing it. In some ways it seems to complicate some of the issues instead of simplifying them. Overall though it's a pretty good read although it could have been better.
Discuss book in the Saloon —
More info at Amazon.com
|
Working Effectively with Legacy Code
by
Michael Feathers
|
Prentice Hall PTR
1 edition
October 2004
456 pages
|
Reviewed by Jeanne Boyarsky, November 2004
   (10 of 10)
"Working Effectively with Legacy Code" is a very valuable resource. The author defines "legacy code" as "code without tests." It doesn't matter whether the code was written last week or ten years ago. There is more emphasis on old code that nobody understands, mainly because it is messier and harder to work with.
The examples in the book are mainly in C, C++ and Java, but there are a couple in C# and Ruby. While it is essential to know one of these languages, the author provides enough information to understand the others. When a technique only applies to a certain language, it is clearly indicated.
The author shows how different diagrams can help you learn how to understand code. In addition to UML, there are dependency and effect sketches. The author uses these to show how to think about understanding and refactoring. Other tools, such as refactoring browsers and mocks are explained.
Speaking of refactoring, there are "dependency breaking techniques" (aka refactorings) with step-by-step instructions (Martin Fowler style) throughout the book. There are also explanations of why patterns and design rules exist. Most importantly, there are lots and lots of cross-references and an excellent index.
Working with legacy code isn't fun, but this book helps make it as painless as possible. With the split emphasis between psychological/understanding/techniques and refactoring, this book is both a great read and an excellent reference.
Discuss book in the Saloon —
More info at Amazon.com
|
Refactoring: Improving the Design of Existing Code
by
Martin Fowler, et al
|
Addison-Wesley Professional
1 edition
July 1999
464 pages
|
Reviewed by Paul Wheaton, January 2000
(10 of 10)
This is currently my favorite book. It has changed the way I do development because it gave words to the way the I was doing things and took me even a few steps further! The book discusses the importance of rewriting code NOT to add functionality, but to add clarity and improved design. There is general discussion as well as a list of specific refactorings. It gives tips on how to stress the importance of this to managers, or sneak it by them if they might not be so understanding. :) I think we are going to hear a lot more about refactoring in the next decade. I found the refactorings to be as useful (if not more so) as design patterns.
Discuss book in the Saloon —
More info at Amazon.com
|
Code Reading: The Open Source Perspective
by
Diomidis Spinellis
|
Addison-Wesley Professional
unknown edition
June 2003
528 pages
|
Reviewed by Thomas Paul, June 2003
(5 of 10)
Programmers need to be able to look at code and analyze what it does in order to change it or fix it. The concept behind this book is to use many of the open source code samples to discuss how to read code and how to spot potential trouble areas in code. Unfortunately the book doesn't stay focused on this single goal and that detracts from its overall value. The book spends too much time explaining the basics of programming instead of concentrating on reading code. It also bounces around from one language to another, from C to C++ to Perl to Java, which is very confusing. For example, if you are a Java programmer do you really care how the C compiler optimizes strcmp calls? And what does that have to do with reading code?
Some of the advice is fairly basic such as try to realign indentations properly and replace complex code structures with simple placeholders when doing analysis. Although there are parts of the book that are excellent, too many of these good parts are wrapped under what should be basic concepts to anyone reading code. How can you debug a Java program, for example, if you are unfamiliar with abstract classes, libraries, or polymorphism? Do you really need a book on code reading to explain basic object oriented programming?
Overall, the book seems very unfocused and I really can't recommend it.
Discuss book in the Saloon —
More info at Amazon.com
|
Exploiting Software: How to Break Code
by
Greg Hoglund and Gary McGraw
|
Addison-Wesley Professional
1 edition
February 2004
512 pages
|
Reviewed by Ernest Friedman-Hill, April 2004
(6 of 10)
"Exploiting Software" purports to be a book aimed at helping software professionals understand the security risks they face; it uses the pedagogical device of teaching how software can be attacked to achieve the goal of explaining how secure software should be built. Unfortunately, I think it fails both as a guide to building secure software and as a guide to being a black hat hacker.
Most of "Exploiting Software" reads more like a book proposal than a completed work: too detailed in places (do we really need a dozen pages on writing plugins for the IDA Pro Disassembler?), not detailed enough in others, and generally not well organized. Far too often, the reader is simply told that an exploit exists, and is then directed to the original source for details. Worse, the original sources are often white papers, personal web sites, and conference proceedings -- things that are either hard to obtain, unlikely to be available for long, or both. As a result, the reader learns nothing.
The preface to "Exploiting Software" explains that this is a companion volume to "Building Secure Software," written by the same Gary McGraw with another co-author, and this helps to explain the main failings of this book. While the last two chapters, "Buffer overflow" and "Rootkits", are better than the rest -- they provide plenty of concrete details -- two chapters aren't enough to vindicate this fairly shallow work. For $49.99, I expect a book that can stand on its own.
Discuss book in the Saloon —
More info at Amazon.com
|
Beginning Java Objects: From Concepts to Code
by
Jacquie Barker
|
Wrox
1 edition
November 2000
665 pages
|
Reviewed by Jane Griscti, May 2001
(5 of 10)
My first reading of this book left me dazed and confused; then I read the reviews on Amazon, which were good, and decided to give it another try; with the same result! The book takes you through the design and development process for a Student Registration System while describing various Java language and OOP concepts along the way. It is well written and Ms. Barker knows what she's doing and where she's going but herein lies the problem. As the reader, I felt like a daytripper on a bus tour with Ms. Barker acting as the sight-seeing guide. If you're looking for an example case study and are curious as to how someone else builds an application; this book is for you. If you want to learn Java or you want to learn OOP, start somewhere else.
Discuss book in the Saloon —
More info at Amazon.com
|
Beautiful Code: Leading Programmers Explain How They Think
by
Andy Oram & Greg Wilson (editors)
|
O'Reilly
1 edition
June 2007
618 pages
|
Reviewed by Frank Carver, May 2008
(10 of 10)
This is a delightful book. A collection of 33 chapters, each by a different author, all of them worthy of study and thought. Each author was given the same brief - write about your most beautiful code - and the results range widely across the software landscape. Trendy topics such as concurrency and "Map Reduce" nestle cozily with their old friends quicksort and regular expressions. Languages used include the obvious Java and C#, but also JavaScript, perl, Fortran, scheme and others. Don't be frightened, though. No specialist skills are needed other than an inquisitive mind and some experience of software development.
Although there are code samples aplenty in this book, it's not really for direct use. If you want copy-and-paste solutions, look elsewhere. What this book offers is deep insight into what good code is, and how it is created.
It felt somehow wrong to chew and swallow this book for a review. This is a book like a box of fine chocolates; even choosing what to consume next is pleasant anticipation, and each morsel is best savoured, slowly, to get the most enjoyment. Beautiful Code will take a well-deserved place on my bookshelf alongside "The Pragmatic Programmer" and next to the gap where Bentley's "Programming Pearls" once stood. I won't be lending this one out in a hurry, though.
If you care about the craft of code, you should buy this book.
Discuss book in the Saloon —
More info at Amazon.com
|
Clean Code - A Handbook of Agile Software Craftmanship
by
Robert C. Martin
|
Prentice Hall
edition
2009
430 pages
|
Reviewed by Janeice DelVecchio, April 2010
(8 of 10)
Robert Martin's Clean Code was an awesome read. This book illustrated the major points of writing readable and maintainable code. There were lots of code samples, and examples of how to make the code tell its own "story" and become readable to any programmer who comes along. It would be an appropriate read for someone at at least an intermediate level of understanding of programming. All the code examples are written in Java.
The entire last chapter was a summary of all the "code smells" that he had discussed throughout the book. This could make the book useful on a longer term basis as a reference book.
Although the book did light the desire in me to go and find programs to refactor, I felt the book as a whole dropped the ball a little when it came to depth. Each relatively short chapter (there are 16 plus the section with the rehash of code smells) could have been fleshed out with more substance -- especially the chapters about unit testing, data structures, and error handling, and the sections that discussed the costs of maintaining dirty code. There is an appendix adding to the concurrency chapter. I thought this might have sat better in the chapter itself and the other chapters extended.
Overall a great read, and a good foundation to build on when the goal is readable code.
Disclaimer: I received this book from the publisher in exchange for writing this review.
Discuss book in the Saloon —
More info at Amazon.com
|
Sunshine On Java: Secure Web Applications With Code Examples
by
Natalie "Sunny" Wear
|
edition
July 2012
29 pages
|
Reviewed by Jeanne Boyarsky, August 2012
(7 of 10)
This e-chapter (e-book) covers 3 of the OWASP top 10 (XSS, CSRF and SQL injection.) With a bonus mention of session fixation. While Amazon counts it as 29 pages, once you get past the intro we are down to 24 pages. The author covers the attacks and how to prevent them in a succinct manner.
When I first read the chapter, I was surprised to see Clickjacking wasn't included. But then I looked and it is not currently in the OWASP top 10 which was the inspiration for the book. (It is still important though; make sure to read about it on owasp.org.)
I would have liked more detail. For example show an example of CSRF along with the different ways to prevent it. It's not enough to say use a filter/token. This introduces issues of its own which need to be addressed.
As far as whether to buy the e-chapter, it is a question of whether you would pay $5 for one chapter of a book. A good chapter, but still only one chapter. I think the answer is yes in this case. But I can't bring myself to call it a book so I'm going to recommend this e-chapter to those who are unfamiliar with two or three of these attacks. If you are already familiar with them, just go on OWASP directly.
---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.
Discuss book in the Saloon —
More info at Amazon.com
|
The Clean Coder: A Code of Conduct for Professional Programmers (Robert C. Martin Series)
by
Robert C. Martin
|
Prentice Hall
1 edition
May 2011
256 pages
|
Reviewed by Jeanne Boyarsky, June 2011
(9 of 10)
Yes, "The Clean Coder" is a sequel to Uncle Bob's "Clean Code." This is a great book and drills what being a professional developer really means as delivered by a well respected source.
The book is very readable and contains advice mixed with stories from the author's past and dialog. I like the use of dialog to show communication issues like saying "done" or over committing. Even the foreword was a story.
I think there was too much repetition of the stories across chapters. Almost like the chapters were written in standalone form. I felt like I read about the same employer (introduced from scratch) a few times. It was interesting hearing about the punchcard world with lessons and how things have changed. Same for FitNesse. I get that it has unit tests.
The advice is excellent. My favorite three (that were fairly unique for computer literature):
1) difference between performance and practice
2) TDD on offense vs defense
3) focus manna on time management
The only advice I felt strongly against is being in the "flow" being a bad thing. As long as you define the problem out of the flow, I don't see the problem with isolating yourself from the big picture temporarily.
---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.
Discuss book in the Saloon —
More info at Amazon.com
|
Prentice Hall
1 edition
May 2011
256 pages
|
Reviewed by Mohamed Sanaulla, December 2011
(10 of 10)
I would say that this is a must read book for all the programmers. Its packed with much needed advice in the current scenario. If you aren't much exposed to the industry (may be you are freshmen), I dont think the book might make much sense. Because lot of ideas discussed in the book would directly apply to your daily activities. We always think that programmers are professionals, but author in the book clearly mentions what it takes to be a professional programmer.
Author takes us along each chapter using either anecdotes related to his life and work or by using conversations between key people relevant to the topic. This way you dont get bored while reading through the topics and can understand the possible type of implementation of the idea.
Author has covered testing and its related strategies over 3 chapters, this shows how important testing is for a product. I got to know in detail about TDD, and other testing strategies and now I can connect these ideas to my work.
Not only technical aspects but also personality development related topics are covered in the book giving the reader a possible all round development.
I found the anecdotes were a lot repeated, but its makes sense because few of them had lot of lessons to be learnt. Few specifications of computers were hard to understand, but it helped me to imagine the skill of the programmers in those 70s and 80s when the technology was still at a nascent stage.
I learnt a lot of new tool names, new testing techniques and few tips for improving my productivity at work and also to learnt the importance of continuous learning and practicing. Overall it was a really good read, managed to complete most of the chapters in one sitting
---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.
Discuss book in the Saloon —
More info at Amazon.com
|
Test-Driven Infrastructure with Chef: Bring Behavior-Driven Development to Infrastructure as Code
by
Stephen Nelson-Smith
|
O'Reilly Media
second edition edition
October 2013
308 pages
|
Reviewed by Jeanne Boyarsky, November 2013
(6 of 10)
Regarding "Test-Driven Infrastructure with Chef":
Step 1 - Disregard reviews about version 1 of the book. It is completely different.
Step 2 - Make sure you are near a computer with internet
Step 3 - Start reading
Part of the book is higher level. The principles of good coding. Why infrastructure developers are developers and why best practices for developers still apply. Along with the benefits of test driven. This shouldn't be new to developers, but it was still a good take on the topic and worth reading. And of course, it could easily be new to the system administrator part of the audience. Chapter 2 is the Ruby you need to know to understand the rest of the book. It was a good and fast moving overview.
Then we get to the meat of the book. A series of exercises including directions, a walkthrough of the author's attempt (with lots of output and dead ends), and then a discussion on the topic.
I liked the comments about workarounds for various "annoyances." And the incremental TDD demo. I liked the quadrant approach to the different types of tests on page 166 (how's that for a teaser.)
There were two things I didn't like. One was the pages of output. That's not my learning style. The other was the insistence that you look up things in the manual before reading. I like to read on the train where there is no internet. I also found a couple of typos, but not significant.
I'm rating this as a 6 because I couldn't try the exercises or the manual with the book. If you plan to read this book at a computer, add another star.
---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.
Discuss book in the Saloon —
More info at Amazon.com
|
|
