I would buy Peter Ries’ book if given the opportunity or give it to new members of my team. I think there are a lot of things to learn about NetSuite and Peter is a great writer.
This year for Christmas I was really blessed to receive The Software Architect Elevator book from a family member. Gregor Hohpe has done such an incredible job putting incredibly technical details into a really easy to follow book.
It’s no secret to those that know me that I read a lot and spend a lot of time gathering knowledge and honing my craft. I believe I own and have read most of the books on apex and salesforce that are available right now. Advanced Apex Programming by Dan Appleman is definitely the most advanced book for programming on Salesforce and Force.com. Continue reading
A few weeks ago, I saw a post on Twitter about Kevin Poorman releasing a new book about programming in Salesforce Apex and really mastering the development environment. Kevin Poorman’s “Mastering Application Development with Force.com” covers a lot of different parts of Salesforce’s Force.com platform that aren’t well covered elsewhere.
Practical Salesforce.com Development Without Code written by Phil Weinmeister has been recently released. I think the book really targets those new to the Salesforce platform and does a wonderful job of providing examples and providing a reference that will be useful in the future.
Phil Weinmeister has done a phenomenal job putting together some different scenarios where it makes absolute sense to make use of the declarative functionality that Salesforce provides. As a developer I’ve struggled quite a bit when to use “clicks not code” and feel that Phil has great examples that would be useful to most Salesforce Admins and developers to learn from.
Some of the topics covered include workflows, approvals, process builder, validation rules, and more.
The chapter on object and field level permissions in Salesforce is really well written. I really wish this book had existed when I was first starting to use Salesforce.
Overall, I recommend using the book to learn the declarative features of Salesforce.
Magento Site Performance Optimization by Mathieu Nayrolles is a handy little primer on the basics of optimizing a server for magento. This little gem covers the basics, doesn’t spend a lot of time on fluff, and moves quickly into optimizing MySQL and covers the basics of using two mysql instances (through replication) one for writing and another for reading.
Chapter 1: Starting with the Right Hardware covers the basics of choosing what hardware is necessary, and how to decide who is a good host. I found the section of choosing a host to be very light because it basically suggests finding a magento recommended host and finding somebody located in the same country. It didn’t really cover much in the way of latency, dns, etc. The section on Content Delivery Networks left a lot to be desired, and really should have looked at some of the avaialble plugins.
Chapter 2: ￼Choosing the Best Web Server is about some of the different options available out there for serving websites on linux. Makes perfect sense to cover the normal Apache and lighttpd. The Apache section discusses the standard .htaccess modifications, compiling Apache with some of the modules, and disabling what you aren’t using. Overall, the Apache section was good for a basic primer. I’m interested in using lightttpd more after reading a bit about it.
Surprisingly, Mathieu also covers Nginx which turns out to be much better for hosting magento once it’s properly tuned. This chapter was one of the most interesting and useful to me. I haven’t ever really looked at the numbers in the way he presented them or decided to try and load test configuration settings as I made each one.
Chapter 3: Tuning, Scaling, and Replicating MySQL covered exactly like the title says. This chapter discussed a bit about some of the different scripts available, but the real gem was the discussion about replication and how to configure it in magento. I didn’t realize I could setup two mysql instances and have magento read and write to different ones.
￼Chapter 4: Caching Them All starts off with one of the first things I try to do with caching. Turn off most of it, and see how much it changes performance. On nearly every system, I’ve worked on the performance has actually improved because writing to files and reading the files for differences is usually more expensive than just pulling the data again from the database.
Mathieu presents a reall interesting approach, that again I hadn’t really thought of which is using the RAM hold /var/cache which seems like it could be a significant improvement for the caching since most sites are using SCSI drives and not SSD like his examples.
The different caching technologies covered aren’t covered in great detail, and don’t really have that same level of details as Chapter 2 which was pretty disappointing. I had hoped we would spend some more time and energy discussing full page caching, which I find to one of the greatest optimizations to be using full page caching.
The real beauty of Chapter 4 is the section on HipHop Virtual Machine (HHVM) which is something I’ve actually never heard of before. I can’t wait to try it in the next few months and test it on on my site. HHVM is open source and produced by Facebook.
Overall, I found the book to be detailed, easy to follow and full of useful information. Also fantastic is the fact there aren’t twenty pages devoted to installing magento; the book is free of fluff and really introductory details. I also felt that it really left a lot to be desired too. Hopefully, in the next version they can spend a bit more time discussing hosts,content delivery networks and some of the code enhancements that can be done to improve speed.
I first heard of “Uncle” Bob Martin on twitter, a few of the people I was following were discussing how amazing the book Clean Code was and how they would love if some of the other developers they worked with used some of the techniques.
“Uncle” Bob Martin wrote Clean Code: A Handbook of Agile Software Craftsmanship in 2008. The book consists of many different and related topics. Some of the topics Martin wrote about include: naming, using small functions, formatting, some threading, and of course some on testing.
Most of the book can be summarized as if you’re professional you will truly care about the quality of work you do and will not want to leave messy code for somebody else or another time to deal with.
Literally, Bob jumps into meaningful variable names, functions, and comments in the first few chapters and then talk about different techniques for reducing lines of code, reducing code rot, and what happens if tests are ignored and not properly maintained. Bob also says a lot more than simply saying using meaningful names, he says to use easily pronounceable, easily spelled, etc.
I don’t necessarily agree with all of Uncle Bob Martin’s writing: I really agree with Steve McConnell (Code Complete) that a function could be short and be 100 to 200 lines. The average function I write is probably about 20 to 30 lines of code including white space, brackets on a separate line, etc.
One of my favourite concepts is the clear writing about allowing a function or class to only do one task. For example, exceptions should be handled by either another function or a different class depending on the situation. Martin has clearly written one of the best chapters I have ever read on Error Handling even though it didn’t contain a huge amount of code.
One of the most interesting concepts is writing tests for 3rd party code so that you can understand the library’s functionality, and testing how an upgrade would affect the rest of the software. By far, I believe this book is one of the best books I have ever read and has really affected the way I write software.
Professional PHP Design Patterns written by Aaron Saray, coming in at around 250 pages is a very short and concise book. Unfortunately, the book doesn’t cover all of common design patterns but does do an adequate job of covering about 17 different patterns.
Each of the 17 patterns covered include fairly easy to understand examples, solutions, and a few pages of very easy to understand text regarding when to use the pattern and best practices for using the pattern. The pattern examples are clearly not just able to be dropped into your project, but each example could be easily adapted for most situations. Saray, has tried to be consistant and use a CD Store as an example and dsicusses how the code for its ecommerce solution would change as the company grows and offers different products.
I’m a little disappointed that there’s a few patterns that aren’t covered that I feel are so important: Chain Of Responsibility, and bridge pattern. Patterns are covered for 125 of the pages, and I really felt the book should be much larger to really cover more of the patterns.
The 20th chapter of the book is titled “Requirements Analysis” and covers an example situation that occurs before software development should happen. Saray throws out a few tips that I would consider best practices, and a generally good method of determing the requirements although I really felt that the example that takes over the next few chapters could have been much much better. Chapter 21 is an excellent addition to the book, because Saray takes the time and explains how he would do things by using UML diagrams and a lot of text before the programming happens. Saray really uses chapter 21 to mention all of the patterns he will use before he starts developing the application in chapter 22 and 23.
I wouldn’t pay full price for the book, and thankfully was able to find the book for a deep discount at a store in Buffalo. Over all, I like the book and felt I learned some pretty valuable things but I felt that in a few ways more time could have been spent on the patterns.
I found the book and its appendices to be extremely well written. I found the examples to be superbly written and extremely usable in my projects: there aren’t a lot of examples on basic things like selectors but there are a ton of great examples on much more advanced concepts. An additional feature that I found really helpful was the interactive lab exercises that begin around chapter two.
As a reference, which I don’t think was the primary intent, it would be difficult to use the book as some of the API is randomly spread throughout the book. The random spread does make the book a lot better though, because each chapter definitely builds well upon the previous chapter.
I completely recommend this book and can only imagine that the Second Edition improves upon the First Edition. I haven’t really found much negative about the book other than wishing the API wasn’t spread out so much, but the index is very good.
SQL Pocket Guide by Jonathan Gennick is a small pocket sized guide published by O’Reilly. The book isn’t really meant to be a learning guide and more of a quick memory refresher for something not commonly used. There’s very little fluff in the this small tome on the different SQL implementations in DB2, MS SQL, MySQL and Oracle and PostgreSQL.
The amount of information in the book is very good compared to many other books of similar style. The author stays completely on task and doesn’t waste any time on cheesy jokes. CRUD, and all of the joins are well covered in the book.
The book suffers from the flaw of not usually having details on previous implementations of the different DBMS. For example, there’s a lot of legacy MS SQL stuff that isn’t always immediately deprecated in the next version which could still be useful.
Overall, the book is fairly well organized. There are some things missing that are really quite frustrating: DDL, User Permissions, etc. I use the book regularly (maybe once a week) to quickly refresh my memory on something I’ve forgotten or haven’t used regularly. I sincerely believe the book has helped me save hours of my time and be a much more efficient programmer.
Operating System Concepts, 7th Edition is written by Abraham Silberschatz, Peter Baer Galvin, Greg Gagne isn’t a book about how to use a computer or how to use a particular operating system. Operating System Concepts is a book about the basic low level and some high level concepts of how the different operating systems actually work, some of the major problems faced, and some of the different solutions used by operating system programmers. The intended audience is senior undergraduate students. Readers of the edition I used are expected to understand C programming and have a very good understanding of techniques, hardware, and different technologies. Conveniently, I was required to read the book for COMP314 at Athabasca University.
The book isn’t always an easy read, often it felt dry and sometimes very slow moving, and I can admit there were many times I had to read and reread sections because I didn’t quite understand the concept being discussed. I’ve found a few errors in some of the diagrams, sample pseudo code, and a have of the example programs. Many of the practice problems are very good although I did find it very frustrating that the solutions are not in the back of the book and must be given by the professor/teacher edition of the book.
Overall, using just this book and some course notes from Athabasca I felt that I really learned a lot about the underlying operating systems that I use day to day and can appreciate even more why sometimes things aren’t always as smooth as I liked. I was a little disappointed that virtual machines and virtualization weren’t covered more in the book.
“Thinking in C++, Section Edition, Volume One” (ISBN:978-0139798092) was written by Bruce Eckel. The book is quite large coming in around 800 pages and focus on making the transition from C to C++, and focusing on practical programming. I believe the book could be much shorter if Bruce had a lot less repetitive, and long winded sort of writing. Bruce’s writing style does not really equate well with using the book for future reference later: thankfully, I don’t anticipate using C++ much as I focus almost entirely on creating and designing web sites.
The typography and presentation of the book need significant work: the font selection and size are annoying and incredibly difficult to read for long periods of time. The printer should have used a smaller size font and reduced the size of the headings slightly as well to decrease the number of pages, and to allow easier reading. The quality of the binding of my paperback edition of the book is absolutely terrible: the cover barely survived 1/2 a day of travel in my briefcase.
Each chapter ends with a lot of different exercises: unfortunately, the author does not include the exercises for free. “Thinking in C++, Volume 1 Solution Guide” must be purchased to see the answers to only some of the exercises. Exercises generally aren’t too bad, or too complex, but for the most part there’s always two or three that could almost be copied directly from the text.
Bruce covers a wide selection of C++, but doesn’t really cover the C++ Standard Template Library until another volume which of course must be purchased separately. I really believe that I learned more about object oriented programming from his introductory text than I have practicing OOP for the last three years: I really feel more confident about when to use composition vs inheritance. I was extremely disappointed to not see a mention of lint or any of the other automated testing and syntax sort of checkers; Bruce covered the compiler and how it generates assembler pretty well, so I would have liked to have seen a little bit about using lint or other software to check for memory leaks.
Bruce’s order of some of the topics should really be reconsidered as I often found myself flipping forward to read more about something especially in Chapter 15 there was a lot of flipping to read about something in Chapter 16. I find the forward references to be extremely frustrating and sometimes this can make studying more difficult.
Over all, I think Bruce has written perhaps one of the best textbooks I have ever used and has some issues with printing, his writing style, and making his text more reference friendly. I hate to say it, but I think that sometimes a box with important things that should be remembered or some tips is something that could be used to make referencing more friendly. (Dietel and Dietel produce many textbooks that make good use of boxes for emphasizing or summarizing something important.)
“Code Craft” (ISBN: 1-59327-119-0) was written by Pete Goodliffe. The book is relevant to all developers: code is very language agnostic. Code Craft doesn’t just cover the design of the program, but also includes quite a bit of content on the process the program goes through “in the trenches.”
The book does include some minor annoyances such as the “Good Programmers… Bad Programmers..” part which is often a large part of each chapter’s content summary. Code Craft also suffers from a visually boring layout. Unfortunately, there are also some parts where it feels like Pete has taken a lot of work from secondary sources and just sort of glued it together.
The first time, I read Code Craft I had just started my first professional programming job. Reading Code Craft really made me ensure that I started using source control management, and really started to pay attention to the process of software design which I didn’t really grasp while in school. Immediately, these first few things were noticed at that first job and got me some kudos from the more senior programmer who reviewed a lot of my initial work.
Code Craft is a larger technical book and spends a lot of time describing the process that software should go through and other softer skills than just the technical side of things. There are sections on growing code, different architectures, and even coding itself but over all there’s something for most programmers even if the main idea already appears in other books.
Although, I think the book is excellent there isn’t exactly new concepts that can’t be found in other books such as Code Complete, Refactoring, and even a bit in Design Patterns. I don’t regret spending the $30 or so on the book, because I really do feel that I learned new things, was even entertained a little bit because Pete’s humour is light and even a little funny at times. Pete’s work has definitely helped me to create more meaningful software and to act as a mentor even when I didn’t have one.
“The Passionate Programmer” is an excellent read and that I feel I have learned more about myself than I would have ever thought. I would never say that it is the next Code Complete or Code Craft, but it can definitely help you develop a meaningful career.