We’ve been replacing C as our serious language since the 70s. C++ mostly succeeded, and became the official language of Microsoft Windows. Objective-C got a solid niche when Apple chose it for OSX, and later iOS. Java, became the serious language of web apps, and is now the language of Android. The two recent exciting developments here are Go and Rust.

In scripting-language world, Perl was largely replaced by Python and Ruby, and for web-app work by PHP.

So by now my serious language was Java, and my scripting language Python. But then three interesting things happened.

One, everyone had to learn Javascript. Clearly this wasn’t going to be my serious language, because it was client-side only, but it wasn’t really a scripting language either. So now I have to know three languages at once.

Two, Rails and Django came along and blew my precious artificial distinction all to hell.

Serious work was being done in scripting languages. In retrospect, serious work was being done in PHP on the web for a while before that (Yahoo, Flickr, etc), but the web-only nature of PHP made it easier to avoid noticing. Later, Node.js allowed us to do server-side programming (previously a serious language only space) in Javascript!

The two recent serious-language choices I mentioned earlier, Go and Rust, both make good scripting languages too. The distinction is completely gone.

Three, mobile. Java for Android, or Objective-C for iOS. Soon Javascript for Firefox OS.

Today, in a single day I will get paid to write code in Python, Javascript, and Go. In the evening I will write Java (Android) and recently Rust. And talking to friends and colleagues, that is by no means unusual. Today, we are all polyglots.

There’s always more to learn than I have time for. It makes my brain hurt sometimes. But in the words of Ward Cunningham, I am excited to go down the stairs because there is a lot more to it than I even knew and I learned it last night and I am going to go apply it and in another week I will be an expert. And you can do it too.

I’ve been learning bits of it the past few days, and whilst Rust is still rough around the edges there’s a lot to enjoy. Rust is only at v0.7pre and changing daily, so you may have to adjust some of the code here.

Rust is a big language, and unless you come from C++ it will probably make your head hurt. In a good way :-)

The two most helpful introductions I have found so far are:

• Official Rust tutorial
• Rust for Rubyists book.

I’d encourage you to run through both of those, starting with Rust for Rubyists. When you get stuck reading one of them (and you will), switch back here.

Contents:

• Install
• Hello world: Creating functions. Compiling.
• Ask your name: Declaring variables. Using a macro.
• Memory management: Best of three
• Looping: Loops, closures, traits, functional style.
• Read a file: I/O, error handling, generics, pattern matching.
• Connect to a socket: Networking, non-blocking I/O, using libraries.
• Objects: struct + impl
• sqlite3: Building and using a third-party module.
• Mutable pointers: Changing a variable is different from changing the data it points at.
• Multiple files: Splitting a project over multiple .rs files.

Install

At time of writing Rust is v0.7pre:

git clone git://github.com/mozilla/rust.git
cd rust
git checkout incoming
./configure
make
sudo make install

The make step will take a while and heat up your machine nicely.

Hello world

So far so normal. We have curly braces, semi-colons at end-of-line, fn to declare a function, and main as the entry point of executables. Let’s run it.

Compile: rustc hello_world.rs. This makes a regular binary, hello_world

Run: ./hello_world.

Instead of the compile / run cycle you can: rust run hello_world.rs.

You can even make your rust file a shell script by adding as the first line:

#!/usr/local/bin/rust run

(don’t forget to chmod +x hello_world.rs).

Ask your name

You declare a variable with let, and optionally give a type. The compiler will try and infer the type, and complain if it can’t. Here’s some variables:

let x;
x = 10;   // Compiler will infer  x: int
let pi: float;
let name: ~str;

The built-in types are what you would expect, plus some: List of Rust built-in types

The ~ is (briefly) explained in the next section. For now ~str is just how you declare a string on the heap. You use it for string literals too, as in let name = ~"Bob".

All variables are immutable by default, you can’t change their value once set.

let x;
x = 10;
x = 42;  // Compile error

You allow yourself to change a variable by prefixing it’s name with mut:

let mut x;
x = 10;
x = 32;  // All good

Each .rs file is a module. The line io::stdin().read_line() is using an io.rs file from the core library. Modules are grouped into crates (libraries) and on unix compile to a standard .so file. The core library, which contains the io module, is imported by default, which is why you don’t see an import statement here.

Modules are explained in the tutorial under Modules and crates.

The final new part in this section is fmt!. The ! means it’s a macro, i.e. it’s expanded by the compiler. fmt is a very useful macro, because it does the printf style formatting with all the %s, %d, etc that you would expect.

The most useful part is %? which formats anything. You will probably use println(fmt!("%?", thing)) quite a lot. Unlike C’s printf, fmt is type checked at compile time.

Memory management

The hardest part of Rust for me to understand is the memory management, and the three pointer types which declare it. Rust wants you to tell it how the memory for each pointer should be managed and checked.

~ and @ both mean you have a pointer, you are using heap memory. Without one of those you have a normal local variable (stack memory).

@ means several places can point at that memory, and you want Rust to track who points there and garbage collect the memory. It’s like pointers in Go, and what happens internally in Java and Python.

~ means one place owns that memory. For garbage collection Rust only needs to track who the current owner is, and whether that owner is still in scope. Other pointers can refer to this memory, by “borrowing” it (using the third type of pointer, &), but only as long as the owner is in scope.

The last line in that example println(name) won’t compile because by then you have given away the unique access to that piece of memory, to other. Change all the ~ to @ and it works.

This is the most exciting part of Rust for me, because I hope that once I get it, it will improve my programming in other languages too.

Because @ is the type of pointer you’re probably familiar with, right now I bet you’re thinking “I’ll just use @” everywhere”. But you can’t, because the standard library will return unique pointers (~), and you can’t just put those into managed pointers @.

You can however put either owned or managed pointers into the third type, the borrowed pointer, written &. Don’t worry, the compiler will tell you when to use one of those :-) In general the compiler is very good at telling you when you have to wrong type of pointer, so I just do what the compiler tells me and move on.

There’s lots of other good stuff in Rust, so don’t get too caught up in the memory management, at least at first. Onwards!

Looping

The loop syntax will look familiar to Ruby programmers. The two important features here are traits and closures.

Firstly, integers don’t have a method called times and vectors ([1,2,3] is a vector in Rust, meaning an array) don’t have a method called each. Those are added to the type by a trait, which I think is somewhere between an interface and a mixin. That can make it tricky to find which methods you can call on a given type.

Second, loops 1 and 2, and loops 3 and 4 are the same. for is just a nicer way of writing the loop beneath it.

Look at the documentation for times to see what I mean. See how it’s a method which takes a function? The first parameter will be familiar to Python programmers, it’s the object the method is called on. Ignore that, and look at the second parameter, which is a function with no arguments, returning a boolean.

Closures are well explained near the end of the Rust for Rubyists, Fizzbuzz chapter. They are essentially an anonymous function, declared by listing their parameters within ||, and their code in a block afterwards.

You give a closure to your iterator, and it calls it once each time through the loop. This will be familiar if you know Javascript.

The bool that the closure returns tells the iterator whether to keep running or not. With the for sugar, true is assumed unless you call break. With the un-sugared version you have to explicitly say true.

Finally (yes there’s a lot going on in Rust) notice that it just says true, not return true;. A block in Rust is an expression (as opposed to a statement), so it can evaluate to something. If you end your block with a semi-colon, it doesn’t have a value. If you don’t end with a semi-colon, it has the last thing you wrote. So you can set a variable like this:

let has_sanity = 
    if 1 == 1 { true }
    else { false }

By just saying true at the end of the closure you give to the iterator, the whole block evaluates to true, and the loop keeps going.

This is clearly explained in the tutorial’s Syntax basics section, in Expressions and semicolons.

Read a file

The loading itself is straightforward: Turn the string filename into a Path object (with path::Path), build a Reader object (with io:file_reader) and return all the lines (with file.read_lines()).

The interesting thing here is the Result object which wraps multiple returns, and is how error handling in Rust is often done.

Result is a disjoint enumeration, containing either the success result (a Reader here), or an error (here a string). Many Rust methods return a Result, and Rust’s pattern matching is often used to check for errors.

A more “Rustic” way of writing this uses Pattern matching:

match is similar to switch. The Result enum contains two variants: Ok and Err.

Oh, and the angle brackets in Result<@Reader, ~str>? Yes, Rust has generics. Hopefully you know them from Java or C#. They’re a way of making static typing more flexible, so that you can for example define a Map which works on any type, but is still type checked by the compiler. The types in the map are specified when you create an instance of it.

Connect to a socket

First we declare that we’re using the std external crate (meaning library). Until now we were only using core, which is imported by default.

Then we declare which parts of std we use. We don’t have to do this, but it allows us to avoid prefixing everything with std::.

We turn the IP address we’re connecting to (US weather service) into an internal representation, connect to port 80, wrap the socket in a Reader (at the socket_buf call) and finally in the last line read everything and return it (sock.read_lines()).

Of particular interest is this line:

let iotask = uv::global_loop::get();

All IO in Rust is non-blocking, so that Rust can be highly concurrent using tasks, lightweight threads similar to Go’s go-routines, Python’s gevent greenlets, or node.js. It uses libuv for this.

Here we say to run the blocking I/O task on libuv’s global loop. Yeah, I don’t know what that means either. Let’s move on.

Objects

Objects in Rust are a struct to hold the data, plus some functions grouped in an impl block.

The first function new is static. That’s the preferred way to define constructors. It doesn’t have to be called new, and constructors are optional (we’re just making a struct).

The second and third functions are the methods. They take the object itself as their first argument &self, just like in Python.

In new and when we’re using a functional style, without explicit return statements. The other item of note is that you cast with as. We’re casting an i32 (32-bit int) coming from time::now().tm_year to a regular int (size machine dependant).

Use an external module – sqlite3

Let’s build and use an external module – a sqlite wrapper. Rust has a package manager called rustpkg which will install modules for you, but for now we’ll do it manually. Make sure you have SQLite 3 development files, package libsqlite3-dev in Ubuntu / Debian.

git clone git://github.com/linuxfood/rustsqlite.git
cd rustsqlite
rustc sqlite.rc

Compiling it will give you libsqlite-<something>.so. The .rc is just a convention for .rs files which contain libraries, and that convention may change soon. Anyway, let’s use that library:

First we declare usage of the sqlite library, just like we did for std previously.

In the let database = part we’re using pattern matching, and the functional style evaluation. In the Ok case, we just wrote db, so db gets returned. This behaves like database = db.

At line 12 we set result (a Result) to be mutable, because we re-use it at line 16.

There are more example of using sqlite in the test suite at the bottom of rustsqlite’s sqlite.rc.

To compile it you need to tell rustc where to find the library you are using. Assuming you copied libsqlite-<something>.so into the current directory, you just:

rustc -L . use_sqlite.rs

Mutable pointers

There’s one more bit related to memory management that might trip you up. Everything in Rust is immutable by default (constant). To make a variable mutable, you simply say mut in front of it.

let mut x: int;

Easy enough, right? The trick is that in the case of a managed (@) pointer, there are two things which can change – the data the pointer points to, or the pointer itself. This is also the case for unique pointers, but unique pointer contents inherit the mutability of the variable pointing to them. Managed pointers do not.

Multiple files

Each file is a module, and several files can make up a binary or library. This is module m2:

m2.rs

Names (functions, structs, etc) are private by default. Adding pub makes them public, accessible from other modules.

m1.rs

You reference other modules with mod <name>. By default module x is stored in file x.rs. Directories create a hierarchy of modules.

To compile: rustc m1.rs The compiler will include m2.rs automatically.

That’s everything I’ve learnt so far! More soon.

• EduPsych Theory for Python Hackers: A Whirlwind Overview: How learning works, in 30 minutes. The speaker can be difficult to understand, but stick with it. I learnt so much, and took about 18 pages of notes. Here’s her blog post about the talk. To me, this was the best talk of PyCon 2013.

• Crypto 101: After this you’ll finally understand Crypto. He builds from a basic block cipher, to a stream cipher, then covers hashes (and why they aren’t secure), key exchange, message authentication codes, etc. Really interesting and easy to follow.

A few other interesting or noteworthy talks I attended:

• Guido’s keynote. Python 3.4 will have non-blocking co-routines, very similar to Go’s go-routines, and inspired by C#’s async / await operators. The syntax is a little awkward for three reasons: because it’s being added later (versus Go it’s there from the start), because Guido doesn’t want to add any more keywords (so it’s yield from my_coroutine()), and because it’s partly based on Twisted. Still cool though.

• Making DISQUS Realtime: Interesting to see the path DISQUS took to get real-time comments in their widget. The key component is nginx’s nginx_push_stream.

• Beyond Passwords: Secure Authentication with Mozilla Persona: Nice demo of Persona / BrowserID by a Mozilla evangelist.

• Porting Django apps to Python 3 by Jacob Kaplan-Moss. Nicely summarizes the state of Django on Python 3, and gives advice on upgrading apps to work on both 2 and 3.

Here are all the PyCon 2013 talks. Are there any great talks that I missed? Please let me know in the comments.

I’ve collected a list of the ones we tried, in order, with notes if appropriate. I’m linking all the books to Amazon to be clear which book it was, but we got most from our local library.

Jason’s Quest – A lovely book to start with. A wonderful adventure, which never gets too frightening, or too hard to follow, and the good folks win in a good way.

Fantastic Mr. Fox – Might have been a little too frightening at the beginning, with the mean farmers trying to kill the fox. In retrospect I would have saved it till he was a few months older.

Mr. Popper’s Penguins

– He turned four around here

We tried Harry Potter, but aborted it after a few chapters. Some parts were too scary, but mainly it was too socially advanced. The story relies on understand relationships between people that were beyond a four year old.

Charlotte’s Web

Charlie and the Chocolate Factory – this was definitely a favorite. We watched the movie (the original, with Gene Wilder) the weekend after we finished the book.

Stuart Little – I found this one a bit boring, although we finished it and it seemed to keep his interest.

George’s Marvelous Medicine – Short and really fun. Some laugh out loud moments.

James and the Giant Peach – Strangely I don’t remember liking this one when I was a kid, but my son loved it. He particularly liked the evil aunts getting squished, and the insect characters are a lot of fun.

How to Train Your Dragon – Clearly written for older kids (Harry Potter age), but he had no trouble following it, and it never got too scary. It has dragons and vikings and little kids saving their tribe.

Pippi Longstocking – Who doesn’t love Pippi! I wished this one would have kept on going.

We tried How to be a Pirate, the sequel to How To Train Your Dragon, but aborted rapidly, it was too violent.

A Nest for Celeste: A Story About Art, Inspiration, and the Meaning of Home – I thought this would be too boring, but it turned out to be quite exciting. Fantastic pencil drawings too.

– From here on he was reading parts of these books himself during the day

The Big Big Big Book of Tashi – also a definite favorite. We bought this one, and he has re-read it several times. Some parts are a little scary, but they always resolve nicely. Tashi defeats pretty much every fear a child could have – quite cathartic.

How to Save Your Tail – on the importance of cookies and story telling.

The 2nd Big Big Book of Tashi – More of the same, Tashi is a clever fellow!

Toys Go Out – sweet and entertaining. We would have read this when he was younger if I’d known about it.

A Mouse Called Wolf – A mouse with a brilliant singing voice, and an old lady piano player. Lovely.

The Unicorn’s Tale (Nathaniel Fludd: Beastologist, Book 4) – I’ve no idea why we started with book 4, we should have started at 1. Oh well, it was engaging and exciting anyway.

My Father’s Dragon – Would also have read this when he was younger if I’d know. Still enjoyable at this age.

Flight of the Phoenix (Nathaniel Fludd, Beastologist, Book I) – We went back to book one to continue his adventures.

Treasure Island – Disappointing. I had fond memories from my Dad reading it to me in my youth, but I think it had grown in my mind. There’s not a whole lot of pirate type adventures here, and it hasn’t aged particularly well.

The Lion, the Witch and the Wardrobe – we both loved this. Talking animals, a bad witch, swords and shields, and Father Christmas.

Prince Caspian I’ll update this page as we read more.

In the Google Calendar invite, I click the Google Hangouts link and video conference. I’m lucky to live in Kansas City, with it’s super-fast Google Fiber internet connection. We update a Google Doc, stored on Google Drive, with notes during the meeting.

I tell the team that the next version of our web app, written in Go (Google’s server language) was just uploaded onto Google App Engine (their app hosting platform). The client side is in Javascript, but we might update it to use Dart (Google’s client-side language), when that’s ready.

We’ve already got Google Checkout payment integrated, which makes measuring our Google Ads conversions with Google Analytics easy. We’re hoping to rank highly in Google Search, or no-one will find us. We’ve just started promoting it on our G+ page (we migrated from Blogger), and our Youtube demo video seemed popular.

Who knows, if the product goes really well, Google might acquire us.

It’s just a silly story. Move along. :-)

my_func(.username="Bob", .is_admin=true);

I found it in 21st Century C. It requires a macro and a structure, and relies on three features introduced in C99.

#include <stdio.h>      // printf
#include <stdbool.h>    // bool - there's a bool type now

// Macro that turns the kwargs into an struct
#define my_func(...) my_func_base(\
    (struct user){.is_admin=false, __VA_ARGS__});

struct user {
    char *username;
    bool is_admin;
};

// The actual function - and yes there's single line comments too
void my_func_base(struct user u) {
    printf("Hello %s\n", u.username);
}

int main(int argc, char *argv[]) {
    my_func(.username="Bob", .is_admin=true);
}

The three new features introduced in C99 that make this possible are:

• Compound literals which allow my_user = (user) {"Bob", true}.
• Designated initializers which give us struct user my_user = {.username="Test", .is_admin=true}
• Variadic macros which allow #define‘s to take ... as a parameter and have it substituted wherever __VA_ARGS__ appears in that macro.

All the keyword arguments are optional, because compound literal rules state that any unspecified arguments are set to zero / null of the appropriate type.

We even have default arguments, like the .is_admin=false in the macro above, because designated initializer rules state that if the argument is repeated, the last argument wins.

High-achieving individuals (he’s a Harvard business-school professor) often over-invest themselves in their career and under-invest themselves in their family, and regret this later in life. This book is his attempt to correct that.

I didn’t agree with all his advice, and some of it reflects his strong Mormon faith. However, this book made me pause to reflect on my life, and re-examine various parts of it. It felt like a valuable exercise.

2. What makes us tick

Two-factor theory, or how to achieve job satisfaction and avoid job dissatisfaction.

• Hygiene factors (money, status, job security, work conditions, company policies, supervisory practices, etc). Typically external. Absence of these causes job dissatisfaction.
• Motivators (challenging work, recognition, responsiblity, personal growth). Typically internal. Ask: Is this work meaningful to me? Am I going to develop and learn new things? Presence of these creates job satisfaction.

3. The balance of calculation and serendipity

Emergent and Deliberate strategy. Life won’t follow your five year plan. Stay on lookout for unexpected opportunities. Experiment. Pivot. Adjust.

Test assumptions before jumping. Do a “spike”. What has to prove true for your expectations to pan out?

4. Your strategy is not what you say it is

You have a set of resources: Time, money, energy. Your strategy is how you spend those, on a daily basis. To make sure your real strategy is what you want it to be, watch where you are spending your time, money, and energy – where you allocate your resources.

You intended strategy may be to put your family first, but if you are spending all your time and energy on work, your actual strategy is to put your work first.

5. The ticking clock

Invest in your personal relationships (spouse and children) whilst everything still seems fine, when it doesn’t seem necessary. By the time problems arise it is often too late.

Work has a more immediate and more obvious payoff than family, and family rarely shouts the loudest for your attention, so it is tempting to focus our resources / life-investments on work. That is a big mistake.

You cannot sequence life investments. You cannot “focus on your career” for a few years, and then “take a step back” to focus on your family later. By then you will be too entrenched in your career, and too distant from your family. Run both in parallel.

Plant trees before you need the shade.

6. What job did you hire that milkshake for?

Too often we think about what we get out of a relationship. Instead, think of what is important for the other person.

What job did your spouse (or friends) hire you for? What job do your kids need a parent for?

7. Sailing your kids on Theseus’s ship

Capabilities: What Resources, Processes, and Priorities will your children need in the future?

• Resources are financial and material, time and energy, knowledge, relationships.
• Processes are what your child does with the resources he has, to accomplish and create new things for themselves. They are relatively intangible. How they think, how they ask questions, how they solve problems, how they work with others.
• Priorities determine how a child makes decisions in life – which things go to the top of the list, which are procastinated, and which are ignored.

Many parents flood their children with resources, when what they really need are processes. Allow them to shoulder responsiblity and solve complicated problems for themselves and others. Sometimes the biggest gift is what you don’t do for your child. Children learn when they are ready to learn, not when you are ready to teach (c.f. teachable moment).

Don’t outsource too much of your children’s education. Otherwise they learn priorities from others, not from your family.

8. The schools of experience

Plan your (and your children’s) classes in the school of experience (coping with a difficult teacher, failing at a sport, navigating the social structure of school cliques). Find small opportunities for them to take important “courses” early on. Encourage them to fail forward.

Think about what your want your child to learn and look for experiences that will help them acquire that learning (by doing (processes), rather than being taught (resources)). Work backwards from the learning to craft the experience.

9. The invisible hand inside your family.

Culture. Decide explicitly what you want your familiy’s culture to be, and live it. Culture is the informal but powerful set of guidelines about how your family behaves. The family norms and values.

Culture will become your children’s auto-pilot, enabling them to do the right thing when on their own. Culture is created in all the small everyday interactions within a family.

10. Staying out of jail

Marginal thinking. The road to hell is not marked with signposts – the first step to a big mistake rarely seems like an imporant decision. To avoid taking that small first step, don’t ever give in “just this once”. Decide what you stand for. And then stand for it all the time.

Epilogue. Find your purpose

A useful Purpose statement needs three parts:

• Likeness: What you want to become, what you sincerely hope to be.
• Commitment: A deep commitment, almost a conversion, to the likeness you are trying to create.
• Metrics: How you measure your approach to that likeness.

Purpose must be deliberately conceived and chosen, and then pursued. The purpose is deliberate, but the path to the likeness is typically emergent, as opportunities and challenges arise. It can take time to find your purpose.

Purpose is your rudder in the rough seas of life. Finding it is the most important thing you can learn. How will you measure your life?

• Android is multi-user. Just swipe down, select a different account. iOS seems designed for individuals living alone.
• Widgets on the home screen. Just by glancing at my Nexus 7′s screen I can check my email, my calendar, and the weather. iOS’s home screen is just a list of all your apps.
• AdBlock Plus. Android has an AdBlock app, which tries to block in-app adverts.
• Internal access – Terminal, Disk usage, RAM usage, etc. I feel more comfortable with a device that gives me that level of knowledge. Android holds it’s users in higher regard than iOS.

In May 1995, Canadian academic, broadcaster and environmental activist David Suzuki invited marketers, scientists, media educators, and activists to Vancouver for a Social Change Conference. The goal was for social change organisations to learn about effective marketing and behaviour change from professionals and each other.

The proceedings were published in Tools for Change, which is available at the Vancouver Pubic Library, and AFAIK basically nowhere else. Here’s what I found interesting:

Mark Sarner of manifest on Marketing

Social marketing is about changing the social climate for progressive ideas.

The ‘social sector’ (charities, N.G.O’s), needs to embrace marketing, because they are already doing it, just not well enough. You need to embrace competition. If your cause is not more important than the others you’re in the wrong organisation.

Develop a product, a social product. It must meet a social need, generate social value. A social product can be a commercial product: condoms, low-fat cookbooks, solar panels, etc. What do your customers want?

Stay focused and on message. Don’t dilute by attacking all problems at once. Focus on brands, ideas that have qualities and images that attract your target audience. Stand out from the crowd, take risks, be noticed.

Provide sound-bite solutions, as soon as you hook people with the problem.

Larry Wallack on Media Advocacy

What is the issue? What is the specific policy you want to advance? Who has the power to make that policy a reality? Who can put pressure on them? How does the general public stand on the issue?

Use compelling images – without good visuals you won’t get into print and video media. Use human focused statistics. Identify authentic ‘human interest’ voices. Journalists will want to speak to them.

Use evocative symbols: slogans, images, objects, martyrs, logos, names, etc.

Leanne Pippard

Opinion polls gather a largely uninformed public opinion.

(sorry that’s all there is in my notes for her)

Richard Pollay

Marketing is about producing what people want. Understand your target market. Focus your efforts on a specific market.

Advertising on local radio is very cost effective. A radio ad: No gimmicks, establish common ground, write the way you talk, use real people with real feelings, keep the message simple.

Start with a question, end with a headline.

Garfield Mahood of the NSRA on the anti-tobacco campaign

• Research: Know the issue inside-out. Know the players, the lobbyists, the government agencies, etc. Be a media friendly expert.
• Education: Get information to the involved parties. Spend money on advertising.
• Polarization: Embrace conflict, it will be almost impossible to achieve your goals with no conflict.
• Neutralization: Neutralize the opposition with targeted adverts and messages.
• Mobilization: Get supporters to write in.

Jim Mintz of the Centre of Excellence for Public Sector Marketing.

The best approach is always top down and bottom up. Get government to legislate away the undesirable behaviour, and get people to stop wanting to pursue it.

Your cause would benefit from a champion: An individual figurehead and leader.

Herb Chao Gunther of the Public Media Centre

The Public Media Centre spends 60% of their budget on advertising, full page ads:

It costs money. But if you’re afraid of money, you’re afraid of social change.

Have strong clear values, tell people about right and wrong. Provide moral leadership. Act like a winner.

Focus on the “muddled middle”. You don’t need to sell to your supporters, you probably can’t convince your opponents, so focus on the uninformed and undecided.

Marketing is premised on the fact that you can’t tell anybody anything they don’t already know – you’d be amazed at what people know.

Point fingers. Attack the enemy. Once the blame is shifted from consumers, they can join your fight.

You don’t need consensus, or committees. A free market of ideas and actions is much more effective. Lots of independent campaigns will be more effective than a mono-culture.

Susan Middlestadt on Behavioral Science

Determinants -> Behavior -> Outcome

Determinants of behavior:

• Perceived consequences: What good things will happen? What bad things?
• Perceived social norms: Who do you think will approve / disapprove?
• Efficacy and perceived skill: What would make it easier for you to engage in that behavior? More difficult?

Design interventions to act on the determinants.

Formal education settings such as classroom on environmental issues, eco-club, etc trigger central processing.

Non-formal settings can educate about social issues too: A match class or literacy class, where the examples and tests are about the environment. This employs peripheral processing.

Strategy: Analyze behavior patterns, segment your target audience, develop a plan, do it, monitor, revise.

Technology, Policies and Perceptions should be considered. Recycling example.

Define your target outcome. Research what behaviours, in what context and time frame, will achieve that outcome. Compare people who do the behavior to people who don’t, see which determinants change.

David Suzuki

I wrote his view on television up previously, in David Suzuki on Television.

His broad summary of the conference was this:

The challenge is to raise this playing field so that it doesn’t matter where you lie on the political spectrum – so that everyone agrees that air, water, soil, and biodiversity are crucial to our survival and to the health of our economy.

Same as women’s rights, slavery, child labour, etc.

For (much) more information on behaviour change, continue to the Behaviour Change Toolkit.

The gap between the conference, the write-up, my notes of the write up, and my blog of my notes of the write up, is bound to end up mis-representing people’s view. If I have mis-quoted or mis-represented you above, please let me know so I can correct. Thanks!

Of course people don’t watch television that way at all. They come home, they turn it on, and it’s there. And they tune in and out, assaulted by a barrage of images. By the time they go to bed at night, their brains are mush. They retain bits and pieces with no idea where it came from.

(From the highlights of Social Change Conference, 1995).

When confronted with the negative effects of television, people often claim “I only watch the Discovery / History / Nature channel”. Your brain still turns to mush. Put the TV in a cupboard.