Skip to main content

Ted Talks (Book Review)

TED talks often get me intrigued and inspired about topics that I sometimes hadn’t thought about before. As someone who speaks to various audiences at work and at professional events, I’m always looking for ideas about how to be a better speaker, and TED Talks, The official TED Guide to Public Speaking sounded like a promising resource, and I wasn’t disappointed. The book provides some good guidance about everything from developing an idea to actually speaking on stage. Even if you never expect to speak on the TED Stage or any other, the book still has value. Anderson points out early and repeatedly that “presentation literacy” is an important skill for everyone. Even if you never present to a formal audience, learning how to organize and distill what you want to say is a valuable skill, and many of the concepts are relevant to writing as well. Keeping “presentation presence” in mind can be useful even if you are sharing an idea with a colleague. If you want to be a better presenter (in any context) this is a worthwhile book to read.

A key premise of the advice here is that an effective talk isn’t meant to convince or lobby, but to share your passion for an idea, and perhaps spread it to others. While this may sound like this book is not useful to those who are interested in selling ideas or convincing others, it may actually be. My first post-college job involved doing a bit of pre-sales technical support and the sales manager I worked with told me that “people told like to be sold to, they like to buy.” This resonates with my experience. If you can share well an idea that you are passionate about, you’ll find the people who are interested, and you avoid the discomfort that people often feel when they are receiving a sales pitch.

While reading I was both excited and saddened as Anderson explained why some conventions that you may have learned about presenting are a best not valuable, and at worst a distraction. I was excited because books such as Presentation Zen and Back of the Napkin helped me to understand that slides and other visuals are there to support your ideas, not be the medium for presenting them. But even with the popularity of TED and other approaches that get us away from the text heavy, read your bullet point slides approach Powerpoint presentations with dense bullet points seem to be an organizational standard that is hard to change. Even in elementary school, where powerpoint is a presentation option I cringe when I see the patterns that my son follows when doing a presentation for an elementary school class.

Anderson includes examples from a variety of good (and not so good) TED talks, which makes some of the abstract ideas more concrete. In some cases, he over does it, which makes the book longer than it could have been, but that is not a fatal flaw. When combined with the pointers to TED talks in the back, the examples make this book a bit of a “best of TED,” and a great way to learn more about the scope of TED topics if you have only seen a few.

Overall, this is a useful book that can inspire and guide you being a better presenter of ideas. Even if you don’t intend to present the first section will help you organize your ideas better. And the need to present may happen when you don’t expect it. The book ends with a survey of techniques to try and venues to practice. Even if you don’t expect to be a future TED presenter, this book can help you be a better presenter in any venue.

Comments

Popular posts from this blog

Continuous Integration of Python Code with Unit Tests and Maven

My main development language is Java, but I also some work in Python for deployment and related tools. Being a big fan of unit testing I write unit tests in Python using PyUnit. Being a big fan of Maven and Continuous Integration, I really want the  Python unit tests to run as part of the build. I wanted to have a solution that met the following criteria:
Used commonly available pluginsKeep the maven structure of test and src files in the appropriate directories.Have the tests run in the test phase and fail the build when the tests fail.
The simplest approach I came up with to do this was to use the Exec Maven Plugin by adding the following configuration to your (python) project's POM.

<plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>exec-maven-plugin</artifactId> <executions> <execution> <configuration> <executable>python</executable> <workingDirectory>src/test/python</workingDirect…

Displaying Build Numbers in Grails Apps

Being a fan of Continuous Delivery, identifiable builds, and Continuous Integration: I like to deploy web apps with a visible build number, or some other way of identifying the version. For example, having the build number on the login screen for example. In the Maven/Java world, this is straightforward. Or at least I know the idioms. I struggled with this a bit while working on a Grails app,  and wanted to share my solution. There may be other, better, solutions, but the ones I found approaches that didn't quite work they way that I'd hoped.

My requirements were:
To display a build number from my CI tool, where the number was passed in on the command line. In Bamboo, for example you might configure a grails build as
-Dbuild.number=${bamboo.buildNumber} warTo only change build artifacts and not any source files.To not misuse the app version, or change the names of any artifacts.To be simple and idiomatic.I realized that that Grails itself changes the application metadata (appl…

Motivation Visibility, and Unit Testing

I've always been interested in organizational patterns (such as those in Organizational Patterns of Agile Software Development). I've recently found myself thinking a lot about motivation. I'm now reading Drive: The Surprising Truth About What Motivates Us and just finished Rob Austin's book on performance measurement. Being the parent of a three year old, I'm finding more and more that "because I said so, and I'm right" isn't too effective at home. My interests in motivation are closely related to my interest in writing software effectively. Writing software is partially a technical problem about frameworks, coding, and the like, but the harder (and perhaps more interesting) problem is how to get a group of people working together towards a common goal. Agile practices, both technical and organizational, build a framework which makes having the right amount of collaboration and feedback possible. But there's a bootstrapping process: How do yo…