I finished a couple more books off the Personal MBA reading list this week — only this time I’m sharing them with you not so much in recommendation, but to suggest that you flip through them before making the purchase.
It took determination to make it through this one. The book just seemed to drag on. The lessons are good, but very touchy-feely. This is the polar opposite of “Cut to the Chase“, and even pretty far on the soft side of “How to Win Friends & Influence People
“. If your job routinely requires telling people bad news (ex. firing people, or hospice work) and you don’t think you’re very good it, perhaps this book is a place to start. The book walks through some good lessons on defusing hostile situations and handling rough relationship topics — all valuable to know. It just wasn’t very engaging.
Not much to this book. Even it’s aggressive line spacing can’t hide it’s lack of depth. Might be of value to someone just starting their career (meaning, first job, right out of school), but you’ll definitely want to flip through it before purchasing. Even though it’s on the Personal MBA reading list, I’d say skip it if you’ve been in business for more then five or ten years.
This week I finished How to Win Friends & Influence People by Dale Carnegie. It’s a classic, often referenced title, so I’m glad I read it. The book is organized in four main sections, with chapters that tell stories as examples for each of the books “principles.” While the lessons of the book are good, by the end, the stories start to feel a little repetitive, and at some point, I lost interest in whether they were real or made up. The overall take-away of the book is positive though, with a strong message of being friendly and considerate toward other people as a means to accomplish your own goals.
Below are the book’s sections and principles in bullet-points. I’ve spelled them out here for my own future reference (or for anyone who’s read the book and would like a quick reminder):
“Executives are not paid for doing things they like to do. They are paid for getting the right things done.” — Peter F. Drucker
That quote (from chapter 7) summarizes the philosophy of “The Effective Executive: The Definitive Guide to Getting the Right Things Done” quite well. It’s a book that explores what the job of an executive knowledge worker is — to make the right decisions for the organization being served.
The book is a fairly easy read, spread across seven chapters:
In addition to the original (1960’s) text, the edition I have starts with a reprint of Drucker’s “What Makes an Effective Executive”, first published in the June 2004 issue of Harvard Business Review. This introductory piece is actually quite good, and reflects some updating, more clarified thinking on the role of an executive. To paraphrase the introduction, it outlines the behaviors of successful executives as:
Overall, I enjoyed the book. It provides a very clear opinion on the role of the executive knowledge worker. Sometimes the material feels a little dated (though often it’s amazingly timeless), but the examples add interesting business and political history to the lessons. I don’t think I would have gotten as much out of this book back when I first started my career (where I was focused more on excellence in my craft), but now, the lessons provide a good framework for filtering through all the things I could be focusing on, so that I can select the ones that I should be focused on.
Practical Django Projects (Apress book description) was written by James Bennett, release manager and contributor to the Django Web Framework. It was published by Apress in 2008. This was Bennett’s first book.
Full disclosure: I was provided with a free, review-copy of the book by Apress.
Practical Django Projects introduces the reader to the Django Web Framework by example. It takes the reader step-by-step through three example projects: a basic CMS, a blog application (called Coltrane, which powers the author’s personal blog), and a code-sharing/snippets site (called Cab, which powers http://www.djangosnippets.org/.) The examples cover real-world problems (and integration tasks) that developers are likely to be interested in, and leaves the reader with three working Django applications.
The lessons are spread across eleven chapters:
The examples focus on building applications the “Django way” — meaning that they heavily leverage Django features such as Generic Views, custom template tags, and the django.contrib package. Each section starts by outlining the features to be developed, then walking the reader through model definitions, URLs, template design, and the request-handler (view) code.
While working through the three example applications, Bennett teaches the reader how to decouple applications from projects, how to think about (and look for) opportunities for code reuse, and how to integrate with other reusable Django applications. The lessons aren’t so much “how does Django work”, but rather “how do you, as a developer, structure your projects to get the most out of the framework.” Depending on your level of comfort using Django and Python, the lessons will either be a breeze, or ridiculously confusing. (ie., there’s a lot of magic going on in the examples, and the book assumes that either you get it, you’re comfortable not knowing, or that you’ll figure out the finer bits when you need them.)
Ultimately, the book isn’t so much about learning Django, as it is about learning how to use Django properly (where properly is defined as the way in which the Django developers use Django.) From this perspective, it’s quite successful. The reader is shown a number of patterns and concepts that can be applied to any Django project.
Bennett wraps up the book with a chapter on design philosophy, but I think the overall lesson of the book is best summarized on page 124, with the following quote:
…this is the hallmark of a well-built Django application. Installing it shouldn’t involve any more work than the following:
- Add it to
INSTALLED_APPSand runsyncdb.- Add a new URL pattern to route to its default URLConf.
- Set up any needed templates.
This is the zen of pluggable Django applications. It’s the path Bennett wants to help you start down. The value of going down this path will depend on how often you’ll use Django in the future.
Overall, I think the book will be more valuable for someone just getting started with Django, then someone who’s been hacking lower-level with the framework for awhile. It’s a developer-focused, quick-start, “get you on the right foot” kind of book that I certainly would have appreciated more a few years ago. The big question then, is whether this book is for you. The answer depends on a couple things, with the most important being how you like to learn. Do you prefer learning by example, or learning by reading the docs and building things on your own? If you prefer to have an expert guide you step-by-step, then this book is for you. You’ll still need to poke around in the Django documentation to really grok how it all works, but this book will get you up to speed quickly.
If you’ve read the docs, done the online tutorials, and are still interested in picking up some best-practices on decoupling your code from your specific application (ie., learning how Django supports code reuse), then this may still be a book for you. If you know you’ll be building a large application, the lessons in the book might help prevent you from writing a single, monolithic application, or at least give you some insight into how to organize and package your code. Down the road you’ll thank yourself.
For me personally, I was actually looking forward to this book before it came out. I think the Django docs online (as great as they are) can sometimes lack in providing best practices. However, I’ve also been using the framework professionally for a number of years (to deploy personal, start-up, and enterprise-class web applications), and I’ve previously built and deployed a pluggable, multi-site, Django-based blog engine (with del.icio.us and Akismet integration, flexible moderation rules, etc.), so the idea of using a blog engine as the core example in the book was a bit disappointing. That said, I did enjoy seeing another developer’s approach on solving the same problem, and I picked up a few nice tips around some of the more recent Django features.
If you’re looking to build a reusable code library (and you should be, if you’re going to build more then one Django project) and ensure that you’re using Django efficiently, this book will help point you down the right path and have you thinking about decoupling your architecture from the start.
Bargaining and negotiation are not skills I’d say I’m particularly strong in. Perhaps it’s because I tend to think of “haggling” when I think of bargaining, which is not something I normally do. That said, after reading “Bargaining for Advantage: Negotiation Strategies for Reasonable People 2nd Edition“, it’s more apparent to me now that what I needed was a broader view and understanding on negotiation tactics. The idea of “shaping negotiations into win-win situations by discovering hidden value” sounds much more appealing to me then “haggling” ever did.
“Bargaining for Advantage” is the second book I’ve read on negotiation. (The first was “Getting to Yes: Negotiating Agreement Without Giving In“, which was enjoyable, and great for learning about “positions vs. issues”, but not nearly as comprehensive.)
Shell’s book is organized in two parts: The first focuses on the “Six Foundations of Effective Negotiation”, while the second half discusses “The Negotiation Process” itself. The Foundations of Negotiation chapters cover:
The second half of the book takes a deeper dive into the negotiation process itself. The chapters cover:
Finally, the book closes with two “wrap-up” chapters on:
The book was more dense then the previous two business I’ve read (”Little Green Book of Getting Your Way” and “Cut to the Chase
“), which made it a longer read, but more enjoyable for someone like myself who wants real information with real facts and data behind it. Overall, I’m happy that I read it, and I’m now curious about Shell’s other book, “The Art of Woo: Using Strategic Persuasion to Sell Your Ideas
.”
Like “Cut to the Chase“, the “Little Green Book of Getting Your Way: How to Speak, Write, Present, Persuade, Influence, and Sell Your Point of View to Others (Jeffrey Gitomer’s Little Books)“ was a quick read; Unfortunately, it wasn’t as engaging for me.
I’ve seen some of Gitomer’s books before, so I knew they had a “sales” angle to them, but somehow I expected this one to be a bit more about negotiating then selling. My mistake.
The lessons:
All good lessons, and good things to practice; But there wasn’t enough substance for me to recommend the book.
I picked up “Cut to the Chase: and 99 Other Rules to Liberate Yourself and Gain Back the Gift of Time“ on the recommendation of Personal MBA reading list. It’s a quick read, containing 100 short (< 2 page) tips on professional behaviors that reduce wasted time.
In the spirit of cutting to the chase, I’ll summarize with a few bullet points:
Pros:
Cons:
Overall, my reaction is positive. There were certainly a few lessons in there that I look forward to applying to my working style.
When the Personal MBA manifesto came out back in 2005 (see The Personal MBA: Mastering Business Without Spending a Fortune for the original), I read through the list, jotted down a couple book ideas, but mostly just left it at that. Lately, however, I’ve been reading more business books, and I thought I’d give the list another look.
The idea of a Personal MBA has grown momentum, and the list of books has been kept fresh. This time around, I pulled out maybe half-a-dozen that sounded interesting; But before diving in, I took the recommendation to brush up on my reading techniques using “10 Days to Faster Reading.”
Before starting the book (and perhaps still now), I would have described my reading style as slow, steady, and thorough. I read to comprehend, debate, understand, and work the material into my world view. That’s also a fancy way of saying that I’m not the quickest reader, but that I pay attention. That said, I’m always interested in learning something new and boosting my productivity.
My mindset going into “10 Days to Faster Reading” was open, interested, willing to learn, but somewhat skeptical that it would work for me. My assumption about speed reading was that it focused more on skimming then on deep engagement. Fortunately, the book changed my view a bit.
One of the biggest takeaways for me, was the idea that when we’re young, and learning how to read, we’re taught to slowly go through each word at a time because we’re still building our vocabularies and teaching our eyes how to parse written text. Unfortunately, as we get older, our education systems tend not to re-visit reading skills in a manner more suited to our growing ability to process words. This is why adults can boost their reading speed — they have the ability to process text at a rate faster then we normally use, if you can teach your eyes how to do it.
Each chapter in the book contains lessons and timed reading exercises. With stopwatch in hand, I tracked my progress. Here’s my results: (Note that each chapter often had you applying a different technique, so progress wasn’t meant to be linear)
| Words per Minute | Comprehension | Notes |
|---|---|---|
| 265 | 100% | The first test, meant to be a baseline measurement before learning new reading techniques. |
| 345 | 90% | |
| 300 | 70% | |
| 459 | n/a | |
| 1096 | 70% | |
| 448 | 60% | |
| 400 | 90% | |
| 600 | 100% | Familiar subject matter |
| 400 | 70% | |
| 400 | 70% |
My times definitely improved, though comprehension suffered as the pace increased. Interestingly though, two things came out of this:
I still need more practice, but at least now I know what to work on, and I have a handful of techniques to experiment with. So far, I’ve found the best application to be with Newspaper and magazine articles, along with online news where I just need the general story.
Overall, I’d say that the potential boost in reading productivity was worth the $9 book price and the time it took to read it.
For more: