eriksmartt.com/blog

Links from June 24th through August 14th

Links from June 24th through August 14th:

• Mass Editing - Tool for simultaneous editing of multiple rows of structured text.
• protochart - Google Code - JavaScript library for client-side charts using Prototype and Canvas.
• Polishing Up Our Django & BOSS Search Service - Part II of the Django and Yahoo BOSS tutorial
• Yahoo’s Build your Own Search Service in Django - A nice tutorial on integrating Yahoo BOSS into a Django application.
• Graphite: Graphite - Enterprise Scalable Realtime Graphing - Real-time web graphing engine based on Django.
• openFrameworks - c++ framework for creative/art programming projects.
• How to get Cross Browser Compatibility Every Time | Anthony Short | Web Design & Development -
• Pencil Project — Sketching and Prototyping in Firefox - Free, open source, GUI prototyping tool built on Firefox
• http://www.indiangeek.net/wp-content/uploads/Programmer%20competency%20matrix.htm - A matrix of programmer skills/experience vs. competence levels. Interesting in it's usefulness for interviewing.
• Nokia - Mobile leaders to unify the Symbian software platform and set the future of mobile free - Nokia opening the Symbian OS to companies that were previously paying for the source code. Doesn't sound like an Android strategy just yet.

“How to Win Friends and Influence People” in bullet-points

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):

Fundamental Techniques in Handling People

1. Don’t Criticize, condemn or complain
2. Give honest and sincere appreciation
3. Arouse in the other person an eager want

Six Ways to Make People Like You

1. Be genuinely interested in other people
2. Smile
3. Remember that a person’s name is to that person the sweetest and most important sound in any language
4. Be a good listener. Encourage others to talk about themselves
5. Talk in terms of the other person’s interests
6. Make the other person feel important — and do it sincerely

How to Win People to Your Way of Thinking

1. The only way to get the best of an argument is to avoid it
2. Show respect for the other person’s opinions. Never say, “You’re wrong.”
3. If you are wrong, admit it quickly and emphatically
4. Begin in a friendly way
5. Get the other person saying “yes, yes” immediately
6. Let the other person do a great deal of the talking
7. Let the other person feel that the idea if his or hers
8. Try honestly to see things from the other person’s point of view
9. Be sympathetic with the other person’s ideas and desires
10. Appeal to the nobler motives
11. Dramatize your ideas
12. Throw down a challenge

Be a Leader: How to Change People Without Giving Offense or Arousing Resentment

1. Begin with praise and honest appreciation
2. Call attention to people’s mistakes indirectly
3. Talk about your own mistakes before criticizing the other person
4. Ask questions instead of giving direct orders
5. Let the other person save face
6. Praise the slightest improvement and praise every improvements. Be “hearty in your approbation and lavish in your praise.”
7. Give the other person a fine reputation to live up to
8. Use encouragement. Make the fault seem easy to correct
9. Make the other person happy about doing the thing you suggest

Quick book review: “The Effective Executive”, by Peter F Drucker

“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:

1. Effectiveness Can be Learned — Effective leadership is a skill you learn by understanding what’s expected of you, and focusing on the right things. It’s a differentiating skill that has become increasingly valuable as we’ve moved from an industrial- to a knowledge-based economy.
2. Know Thy Time — Time is a finite resource, and you’re probably wasting more of it then you think. If you want to accomplish great things, you must manage your time wisely. Start by auditing your workday.
3. What Can I Contribute — Your energy will be wasted if you’re not focused on the right contributions. An executive’s salary comes with an expectation of addressing the right organizational opportunities.
4. Making Strength Productive — The key to being effective is to leverage your strengths. Position yourself so that your weaknesses are irrelevant.
5. First Things First — Focus on what’s important now, not in the past. Tackle issues one at a time (multitasking is rarely more productive then concentrated effort.)
6. The Elements of Decision-making — Focus on the important decisions; Identify boundary conditions; Determine what is right before making compromises; Understand what the decision needs to accomplish; Separate strategic implications from one-off situations; Build-in a plan for action and feedback.
7. Effective Decisions — Start with your gut; Don’t base future planning on today’s (or yesterday’s) way of doing things; Disagreement is a good thing (it means people are thinking about the problem. Find out why it’s happening or you won’t see the whole picture.)

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:

• Understanding what needs to be done
• Understanding what’s right for the organization
• Developing plans for getting things done
• Making good decisions
• Communicating
• Focusing on opportunities
• Runing productive meetings
• Focusing on the team/organization, rather than the individual (everyone is responsible, and accountable)

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.

Book Review: “Practical Django Projects”

Summary:

• Targeted at developers wanting to learn Django by building example applications rather then (or in addition to) reading the docs and man pages
• The reader builds three working applications by following along
• The examples are based on up-to-date Django features (ie., a 2008 build)
• Lesson’s focused on using Django (not on Django’s inner workings)
• Doesn’t waste time explaining Python and HTML (nor does it dive deep explaining the how/why of what you’re doing in the examples)
• Introduces the reader to powerful Django features — covering a wide range of capability
• Examples focus on designing for code reuse (and leading by example, by integrating with existing reusable apps and Python libraries)
• Offers an alternative approach to learning, focused on relevant, practical examples

Background:

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.

The Book:

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:

1. Welcome to Django — a wonderfully short introduction that wastes no space explaining prerequisites (it assumes the reader knows Python)
2. Your First Django Site: A Simple CMS — an introduction to the Django Admin and Flatpages
3. Customizing the Simple CMS — customizing the Admin interface (adding TinyMCE) and developing a simple, reusable search feature
4. A Django-Powered Weblog — defining the basic models, and using django-tagging and Generic Views
5. Expanding the Weblog — adding del.icio.us-synced links, and custom categories
6. Templates for the Weblog — more extensive use of Generic Views, template inheritance, and custom template tags
7. Finishing the Weblog — using django.contrib.comments and model signals to develop a moderation system with email notification and Akismet integration; Using django.contrib.syndication to add RSS/Atom feeds
8. A Social Code-Sharing Site — building the initial models, integrating with the pygments syntax highlighter, and writing custom model managers
9. Form Processing in the Code-Sharing Application — great examples of using newforms (much better then the The Definitive Guide to Django’s chapter on form processing)
10. Finishing the Code-Sharing Application — more custom template tags, this time used with bookmarking and rating features
11. Writing Reusable Django Applications — a summary of Bennett’s philosophy on decoupling application features into reusable components (with references to the UNIX saying, “do one thing, and do it well”)

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.)

The Core Message

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:

1. Add it to INSTALLED_APPS and run syncdb.
2. Add a new URL pattern to route to its default URLConf.
3. 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.

Conclusion:

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.

More reading: “Bargaining for Advantage” by G. Richard Shell

Summary:

• Dense, but full of valuable theory and examples.
• Explores multiple styles of bargaining (ex., personality, cultural, and ethical differences), offering insights on best-practices for each.
• Enjoyable examples put the theories in context.
• Good lessons in shaping negotiations into win-win outcomes.
• Definitely recommended if this is a topic you haven’t had training in.

Review:

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:

• Understanding your bargaining style (aiding by a “Bargaining Styles Assessment Tool” in the Appendix, in which I was rated as being more competitive then I would have guessed.)
• Setting your goals and expectations. (Two key lessons: (1) Don’t aim at your bottom line; (2) People who aim high tend to get more.)
• Understanding authoritative standards and norms.
• Building, ignoring, and/or leveraging relationships.
• Understanding the other party’s interests (a key to finding a win-win solution.)
• Understanding and using leverage.

The second half of the book takes a deeper dive into the negotiation process itself. The chapters cover:

• Preparing your strategy. (You’re not going to win if you haven’t assessed the situation and thought through your key issues.)
• Exchanging information. (Establishing rapport and asking lots of questions. A key point here is to uncover the other party’s key issues and values. Listen more then you talk.)
• Opening and making concessions. (This chapter explores the age-old question of when you should [or shouldn't] make the first offer, by breaking down negotiations into a matrix of situations and tactical decisions.)
• Closing and gaining commitment. (A key lesson here is how to ensure commitment to the agreed terms. Shell provides some interesting examples on including terms in a deal to prevent a questionable party from backing out.)

Finally, the book closes with two “wrap-up” chapters on:

• Ethics in negotiation.
• Summarizing and applying the techniques in the book.

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.”

More reading, “Little Green Book of Getting Your Way”

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:

• Be passionate about what you’re selling
• Add value — be interested in solving people’s problems, not selling them a solution
• Be funny
• Be entertaining
• Be confident
• Be persistent
• Write a lot

All good lessons, and good things to practice; But there wasn’t enough substance for me to recommend the book.

Finished reading “Cut to the Chase”

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:

• A quick read
• The short chapters make it easy to pick up when you have a few minutes
• The lessons are good, and tend to reflect the habits of effective senior management
• Feels like the kind of book you could pick up once a quarter to glance over the Table of Contents as a reminder to focus on what’s important
• If you’re new to the professional world, reading this will definitely give you an insight into the type of behavior you’re likely to encounter when interacting with senior management; And it should help you prepare for the type of communication styles expected of you

Cons:

• If you’ve been in business for while, you probably should know this stuff already
• If you’re new to the professional world, you may have fewer opportunities to practice this stuff (though better to get started now then not know how to manage your time when you are tasked with greater responsibilities)
• Depending on your work environment, the lessons may be a little too “harsh” — ie., these are techniques for efficient time management, not for making friends

Overall, my reaction is positive. There were certainly a few lessons in there that I look forward to applying to my working style.

Finished reading “10 Days to Faster Reading”

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)

My times definitely improved, though comprehension suffered as the pace increased. Interestingly though, two things came out of this:

1. If 70% comprehension is good enough (ie., if all I need is to get the gist of something), it’s possible to really crank the speed up.
2. Familiarity with the subject matter makes a huge difference. (Which is why previewing and skimming before reading can make a big difference.)

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:

• Speed Reading (on Wikipedia)
• Can a “Personal MBA” Match the Real McCoy? (on Business Week)