Book Reviews

Hacking Vim 7.2 by Kim Schulz is a great resource for the already experienced Vim user. It assumes you are already familiar with the basic operation of the Vim editor and takes you through a myriad of different configuration operations and niche features of the program. Schulz covers a wide variety of areas such as personalizing the editor to your preference, improving your navigation skills within a file or project, using features like folding, autocomplete, and taglists for improved productivity, and configuring Vim to automatically format your code for you. In my opinion however, the real value of this book comes in chapters 6 and 7. In these chapters, Schulz gives a very detailed guide to working with the immensely powerful Vim scripting language. The first half focuses on the very basics of the language and how to write your own basic scripts and use existing scripts. In chapter 7 there is a much higher emphasis on more complex language features along with how to debug and distribute your scripts. Finally, a cute appendix closes out the book by detailing several ridiculous things that Vim can do including a number of games and how to use Vim as a Twitter client. This is definitely not a book for beginners of Vim. The only words of advice to the Vim neophyte are in the preface and they are simply instructions to go use the built-in vimtutor program to learn the basics of the editor.

All of that being said, if you already own a copy of the previous edition of this book "Hacking Vim" I would not rush to buy this new edition. The previous version was written for Vim 7.0 and I honestly could not find that much of a difference looking through the two versions side-by-side. All in all, Schulz did an excellent job with the book in terms of compiling examples of a wide range of configuration options together into one easy to read compendium. This is only strengthened by the chapters that instruct the reader on how to fully maximize the power of their editor using Vim script.

If you ever wanted an introduction to reverse engineering or cared to learn about the basics of how debuggers work and implementing your own, look no further than Gray Hat Python by Justin Seitz. This book dives right into the mess of things assuming that you already know a fair amount about low level development, Python, and how to use a debugger. By the end of chapter three you have already built your own basic user-mode debugger for Windows in Python. The next two chapters of the book focus on how to use two already existing Python debuggers: PyDBG and Immunity Debugger. After you have developed your skills with both of these tools, Seitz leads you through several chapters on developing exploits, DLL and code injection, and fuzzing techniques. The last third of the book or so focuses primarily on fuzzing techniques, disassembling, and using the PyEmu IA32 emulator.

I would have to estimate that over half of the text in the book is actually part of an example that is being used to illustrate one of the concepts the Seitz is trying to teach. The chapters are littered with code examples, a few screen shots, and great command line examples of exactly what you should be learning. I would definitely recommend this book to people who want to learn more about the practical side of secure coding and how to take advantage of poorly developed software. It definitely teaches you a lot that you would not learn without having this sort of knowledge and experience.

The Art of Debugging with GDB, DDD, and Eclipse by Norman Matloff and Peter Jay Salzmann is a great introductory book to a number of topics. The authors spend just under half the book reviewing the basics of the tools that they cover and various principles of debugging. This section primarily focuses on basics such as working with breakpoints and inspecting data in your program. This is then followed by a great chapter that goes into the details of why programs crash and looks at how programs are laid out in memory, some basics of process signaling, and how to work with core files. The next few chapters look at debugging in more complicated scenarios. The authors go into great detail on debugging threaded programs, client/server model, parallel applications, and working with GUI programs in a debugger. Finally, they wrap up the book with some great chapters that detail additional tools such as strace, ltrace, and lint; ways of using the tools they have taught you for languages like Perl, Python, Java, and assembly; and finally, a set of good practices to use for working with the compiler, writing code that is easier to debug, and making the best use of your text editor.

Throughout the book the authors make great use of screenshots and example code snippets and shell commands to illustrate exactly what is happening. The examples they use are great for illustrating a wide range of possible failures and how to successfully identify and debug the failures that occur in your code. My biggest qualm with the book is that through the text they enter a topic area and jump back and forth between the three debuggers that they are focusing on. While this might work for some people, I feel that I would have been better benefited if the introductory sections of the text had been divided into a specific chapter on each debugger. It would have allowed me to easier maintain my focus and train of thought while learning.

Debugging is a fundamental concept that is oftentimes overlooked in Computer Science and Software Engineering education today. I would recommend this book to anyone who is looking to begin learning more about debugging as well as people who are already familiar with the basics and want to improve their skills. The authors cover a wide range of tools and techniques for debugging in a number of basic and complex situations. I felt that I was able to learn a lot about more complex development situations by reading this book and how to apply my already existing knowledge of gdb to help solve those problems much more rapidly than I was previously able to.

The C Pocket Reference by Peter Prinz and Ulla Kirch-Prinz is probably the most dense book on the C Programming Language that I have ever seen. I won't be so bold as to say that they successfully cover every single aspect of the language in 134 pages, but they manage to pack a lot in there. Having had experience doing OS development before, I could and still do find this book highly useful. It is a very condensed reference material on the language, covering topics from the very basics of the C language all the way to a number of specific language features such as process control, mathematical functions, and working the compilation process. The authors also have used a number of tables and brief examples to illustrate the majority of the concepts being discussed in the book.

All in all, I think this book is excellent for someone who has already gotten their feet wet in the world of low-level programming and is looking for a reference material on a number of features of the C language. I think it also would serve well for someone who prefers to learn from reference materials that cover each topic in a very brief fashion.

If you know little to nothing about hardware and are interested in learning hardware in a simple way, this is a good book for you. The first chapter goes over some circuit basics such as some fundamental equations (i.e. Ohm's Law, power, etc) and how to read schematics. I did feel a little more could have been added to this first chapter since it doesn't go too in depth about circuitry, but that's what the "Further Reading" section is for.

Wait, why didn't the first chapter discuss things such as transistors and relays? Not to worry, these topics and other topics are discussed in a later chapter. I am disappointed that there wasn't as much detail about transistors (specifically MOSFETs as these are very simple to use) as there should have been.

The projects in this book are very interesting and not too overwhelming for a hardware newbie. Even as someone with hardware experience, I picked up a couple of interesting ideas from some of the projects in this book. As you step through a project, all the information about the hardware and software is carefully explained. I especially liked that at the end of each project is a section that mentions variations of each project. This gives readers ideas to explore and mess around with independently. I would encourage readers to also look into the resources listed at the end of each chapter as these provide some decent information about certain aspects of each project.

Overall, I was impressed by this book, but with some reservations. While this is a good book for hardware newbies, it won't teach you everything. The focus of this book is, of course, on developing projects using the Arduino platform. I would recommend picking up something that covers electronics specifically so that you have a more solid reference to go to while working through these projects. This will also come in handy when you start designing your own projects. The reference section on the Arduino website is probably one of the better resources for using the Arduino platform. As boring as it may seem, read through the data sheets for the ATMega328/168 chip. There is a lot of useful information in the data sheets and the sooner you learn how to read them, the better off you'll be in the hardware world.