versorge

Think Python is well written book that is easy to read with exercises that range from remedial to challenging (if done mentally). However, if one approaches the book as a cohesive unit: reading the chapters and actually doing the exercises; the author's intent becomes evident. The reader discovers the power of programming: viewing problems as a collection of related (and solvable) sub-problems. Code re-use is implied and the problems in later chapters can be easily solved by utilizing solutions of previous chapters. In other words, this book is best experienced sequentially. Answers are provided to almost all of the exercises and I found it quite illuminating to compare my working solutions to those of the author. In summary: this is a great book, refined by editing (unencumbered by typos), that I would highly recommend to anyone interested in practicing or learning the basics of programming.

Distinguishing itself among other Hacker books that have ventured across my desk, Hacking: the Art of Exploitation has a very easy introduction that could get any interested reader (regardless of their background) to understand the concepts presented. This is not a book about how to hack into systems; it is a presentation of the ideas behind the exploits. I could not get the cd to work on my 64 bit laptop which happened to have a processor that can not emulate 32 bit vms. But I would still recommend this book to someone who is really interested in learning about computer architecture and it's limitations.

TJ O’Connor does a great job of conveying his enthusiasm for subject. The experience of reading this book, reminds me of visiting the office of an expert in his field who is excitedly sharing his knowledge. There are a few grammatical typos, that can be easily overlooked.Violent Python After reading the first few chapters I tried an example to find that, writing a useful password cracker is not as easy as presented: brute force does not work if your passwords have been made with modern rigor (mixed case, 9+ characters, not a dictionary word). The examples were sometimes oversimplified. However, the fact remains that that this book is full of really useful projects that I had never thought to use Python for. The chapter on forensic investigation was quite revealing (what a wealth of information is stored in those sqlite databases)! This is a well written book that is a pleasure to read and is likely to explore practical projects that most readers would not have thought of on their own.

Carl Albing does a great job of walking you through this bash video tutorial at a conversational pace that is easy to follow. I have been coding in bash for some time now so I was mainly interested in observing the style of others. This video was a good fit, I felt like I was listening to a more experienced co-worker share his approach to bash. There are some really neat tricks here and there, that I had either forgotten or had never properly learned: such as the beauty (and simplicity) of variable substitution and different ways to pass input streams. I started this series while beginning to write a system in Perl. Inspired by the way that Carl Albing so easily wrangled piped streams, I rethought the project and wrote a portion of it in bash (to compare the complexity). As it turns out, bash was a much better tool for the job! The video editing was smooth and the volume was fine but the section titles were not correct. On several of the videos the section titles were for "Great JavaScript with Carl Albing". Also, the tool tips on the bottom of the screen went by far rather quickly. The most important part is, of course, the content: and that was excellent. Summary: I highly recommend this video series as an introduction (or refresher).

Who wants to read a book about programming philosophies? The answer depends on whose philosophies are to be read, and in this case the ideas are those of Max Kanat-Alexander. As an experienced programmer with an impressive track-record, he has the real world experience to back up his insights. Being a computer programmer who has worked on many projects, in many languages, with teams of varying sizes and management of varying dispositions (and skillsets): this was a fascinating book that I devoured in a couple of afternoons. Kanat-Alexander's analogies are priceless and memorable. I may not agree with every statement in the book, but that was not a hindrance from enjoying it thoroughly. Many past projects came to mind and the cause of their success (or failure) was (largely) trace-able to Kanat-Alexander's conclusions. Projects change and grow over time, it is important to design for such change, but not to make any attempt to predict the future (since that is not possible). This book stresses design and provides tips and analogies for good design (as well as pitfalls to avoid). Max Kanat-Alexander hit the nail on the head with this book, it was exactly what I needed to read over the weekend before returning to work on a critical code project that will change over time.

In many cases, knowing how to use a tool well enough to get the job done is acceptable. However, to be a master of your craft, you will need to know your tools so well that they become an extension of your consciousness. Vim is one of those tools that I was using well enough to get by: Learning the vi and Vim Editors has helped me to bypass years of ‘stumbling upon’ features of vim, by presenting all kinds of useful commands. I have been using Vim (to varying degrees) for about 8 years. I really enjoy the fact that one does not need the mouse and that I can program commands (with regular expressions). However, I knew that there was more to this powerful tool than I had been making use of. After a few paragraphs of elementary introductions to the philosophy of using vim (command mode and insert mode), the text got right into some very useful vim commands and presenting use cases for each (text editing or computer programming). Strengths content. Most anything there is to know about vim is in this book Weaknesses organization. Reading the text, I had trouble maintaining a view of where I was in the larger process of learning. For example: the commands to delete, change, replace, and insert were sprinkled throughout the early chapters, without clear commentary on how they differ or where how they fit into larger operations (such as with numeric operators). There was mention of combining simple operations with each other, but it just felt like the paragraphs had been hacked apart and glued together. Perhaps this is a by-product of being the 7th revision. Not a huge deal, but it made the text less engaging. The first time through this book I have made heavy use of the highlighter and bookmarks. I read it quickly because I was excited to learn more about the tool that I spend so much time with. I have already found myself keeping it near my desk since it has immediately become one of my favorite reference books.

Upon reading the title of this book (Realm of Racket: Learn to Program, One Game at a Time!; O'Reilly Media), one might expect to find an elementary level intro to functional programming. However, while the book does take a very gentle course of introduction to the subject matter, (somewhere around the first couple chapters) there appears to be a quick departure away from the 'hand-holding' and into Lambda Calculus terminology. This was not what I was expecting and I actually set the book aside for a while because of it. However I would encourage readers to press on, continue reading and expand your horizons. Since the authors (Matthias Felleisen, Conrad Barski, M.D. and David Van Horn) are experts in the fields of functional programming and education, they deserve a certain degree of trust. The reader should continue reading even when they are not completely following the explanations. That was the case with me: around mid way through chapter 8, the 'light came on' and their previous explanations began to make sense. It is my opinion that the explanations of code are a little too detailed and don't give the reader a broader sense of what is being accomplished. As such, the explanations can be a bit long-winded and difficult to keep in your mind. Consequently, I would suggest that the reader who wishes to get the most out of this book, read it while taking notes and actively programming through each chapter. This book helped me to gain experience in functional programming while tinkering with the downloadable source code (that makes video games)! I would recommend this book as a brain exercise for any programmer who wants to learn functional programming or for an ambitious person who wants to learn to program!