How to hold effective, creative meetings

As a people manager, I’ve always been aware of the tendency of subordinates to want to agree with you – or at least to avoid having to voice a conflicting opinion.  At my most clear-headed, I’m careful to keep my opinions to myself until later in a discussion. Below are some excellent suggestions for getting a good, creative discussion going before you start to narrow your options. – Your Meetings Are Killing Employees’ Best Ideas. It Isn’t Your Fault. Here’s How to Fix Them

So what happens when a group gets together to discuss an important issue? Members show their affinity to the group by restating and confirming what other group members, and especially group leaders, have already said. Even those with important and pertinent information to share tend to forget that information or dismiss it as not really relevant in their eagerness to show their solidarity with the group and its views. They also set aside their own insights and focus on how to assist in the group’s chosen course of action. This is such a profound human instinct that most of us do it without realizing it.

All of this is great for having harmonious meetings that seem highly efficient, but it’s not so great for finding innovative solutions to problems or recognizing new threats or opportunities. Fortunately, although you can’t eliminate shared information bias, there are things you can do to lessen its effects and increase the chances that employees will share more of the good ideas and relevant information they have. For your next team meeting, follow these simple rules:

Have people bring notes.

Make sure each team member arrives at the meeting with a list of a few important points he or she plans to share. That way, if shared information bias causes them to forget or dismiss whatever they planned to say, they can refer to their notes and be reminded that they consider these points important.

Specifically ask for dissenting opinions.

As a group consensus emerges, pause the proceedings and say something like this: “It sounds like a lot of us agree. But right now, I would like to hear from anyone who has a different view.” If team members have other viewpoints but have hesitated to voice them, this invitation may bring those other viewpoints forward.

Go around the table.

You can follow up your request for dissenting opinions by going around the room and asking each team member to say what he or she thinks. I learned the power of this approach years ago when I taught a class and made it a practice to ask each class participant in turn to speak. One man who was somewhat shy and would never have volunteered to say anything consistently offered some of the most insightful comments of the whole group. If you’re not hearing from every person at a team meeting, you are likely missing valuable information.

If you’re the leader, speak last.

The leader or leaders of the team should make sure to gather everyone else’s input before offering their own. In most groups, members are highly attuned to leaders’ opinions and are especially eager to go along with them. If you speak up too early–even making it clear that yours is just one view and you want to hear others–team members will tend to look for ways to agree with what you’ve said rather than take the conversation in a different direction with insights or opinions of their own. By keeping your thoughts to yourself at least through the early part of the meeting, you’ll give them a chance to shine. And you’ll gain the benefit of hearing their best ideas.

When is a good time to re-brand?

Saw an interesting post in my e-mail today (care of the generally excellent CB Kickstart newsletter): When indeed is a good time to execute a rebrand for your organization? What should the purpose of a rebrand be? What should you look out for to make sure you’re not executing one for the wrong reasons? It all depends on your organization’s particular situation, but the Johnson Banks piece below is a nice little writeup on the topic.

Johnson Banks – Why brands change

When is a good time to re-brand?

One of the most powerful and legitimate reasons to change is a fundamental change in business circumstances – a merger, or a takeover, for example. Recently two London based property companies, Development Securities and Cathedral Group merged, and rather than subsume one into the other they created a new brand, U+I (United and Industrious). When Singapore airlines sold their majority stake in Virgin Atlantic, there was a point at which the Delta board would have looked at the Virgin brand and had to decide – do we keep it, or do we ‘fold’ it into our brand? Thus far, they have established clear links between the brands without formally merging them.

Sometimes an organisation’s core market changes. This might mean that a brand that was created to ‘fit’ with one product or market no longer works. So Shelter’s previous symbol used a piece of typewritten, ‘angry’ type, which matched their original mission to concentrate on the homeless. But a gradual switch in focus to bad housing meant that needed to be reflected in their rebrand.

When is a bad time to rebrand?

When the original commissioning team moves on, branding’s biggest biggest problems arrive. The first issue is boredom. After about three years, an internal team, their agencies, their advisors – everyone – has had enough, and people start to tinker. Yet, paradoxically, about two-to-three years in is precisely when a new brand has just started to seep into the public consciousness, and arguably that’s exactly when a brand should become more consistent, not less.

The next big problem is ‘not invented here’ syndrome. New teams, often new directors arrive, and the human desire to ‘make a mark’ kicks in. Someone lets the internal team tinker, and slowly things unravel. Every new business manager for every major branding company in the world keeps an eye out for changes at the top of major organisations – because this is when existing branding schemes are at their most vulnerable, new brooms are brought in, and the sweeping starts.

With some recent rebrands there’s also a sense of if in doubt blame the brand. At launch in 2007, the previous Southbank design scheme seemed like a powerful and flexible idea that could flex and modulate across the institution’s communications, but within five years had been relegated to just the ‘logo at the bottom of the poster’.

Why do so many websites offer 3 levels / plans for their SaaS product?

A random conversation I had this week at the Canadian Football League reminded me of a question I was asked and looked up the answer to nearly a decade ago: Why do so many websites offer three levels or plans to choose from when it comes time to purchase their product? And really, what is the optimal amount of choices to make available to a potential client?

The answer is multifaceted, but as you’d expect, the prevailing wisdom is that 3 choices – and elevating one as the best or most popular – works best. Here’s a quick rundown as to why.

The Centre Stage Effect. Formal psychological studies have been done on the positioning of products on a page, and it appears that consumers infer that the middle option is placed there because of its popularity (a self-fulfilling prophecy if there ever was one).

The Compromise Effect. UXmatters has a great paper on shortcut decision making; it mentions a research study that had one set of study participants be offered two microwaves at a $110 and $180 price point; participants chose fairly evenly, with a small majority preferring the cheaper option. But when a second set of study participants was offered three options, a clear winner emerged: The middle price point. The conclusion? When a consumer can’t decide whether to go high or low, a compromise option that sits in the middle is what our mostly logical minds push us towards.

Also: The Bandwagon Effect. Further, studies have illustrated that when consumers are pointed towards a choice and given the information that it is the most popular choice amongst their peers, the middle choice becomes even more compelling. Basically, consumers who may have little information at the time of their purchase as to what “level” fits them best will use whatever information is at hand – like the popularity of a choice – to finalize their decision.

Making scheduled posts in WordPress public so they can be scheduled / scraped on social media

The basics of scheduling in WordPress are quite simple: If you give a WordPress post a published date set in the future, it’ll remain “hidden” on your website until that date and time arrives. It’ll then appear, right on time, at the top of your list of public posts.

But here’s an interesting problem: Social media is now a major driver (maybe the driver) of traffic to digital media websites. When you schedule your post in WordPress, you’ll also naturally want to schedule that post to appear on Facebook and Twitter – but that would require the WordPress post to be public, which in its “future” post status isn’t yet.

The code snippet below can be placed in your theme’s functions.php file, and allows non-logged-in website visitors to view posts in the “future” post status as well as merely “publish”ed posts.

// Allow site visitors (people not logged in to WordPress) to view posts in the "future" post status.
function show_future_posts_pre_get_posts($query) {
    if ( is_single() && !is_admin() && $query->is_main_query() ) { 
        if ( !is_user_logged_in() ) {
            $query->set("post_status", array("publish", "future")); 
add_filter('pre_get_posts', 'show_future_posts_pre_get_posts');


How to get WordPress post permalinks directly from the MySQL database

While generating a CSV of old-and-new URLs for a site I’ve been busy migrating to WordPress, I ran into this brilliant bit of semi-working code to get the permalink for Posts using a pure SQL query (for MySQL):

SELECT wpp.post_title, wpp.guid, wpp.post_date,
       REPLACE( REPLACE( REPLACE( REPLACE( wpo.option_value, '%year%', DATE_FORMAT(wpp.post_date,'%Y') ), '%monthnum%', DATE_FORMAT(wpp.post_date, '%m') ), '%day%', DATE_FORMAT(wpp.post_date, '%d') ), '%postname%', wpp.post_name ) AS permalink
  FROM wp_posts wpp
  JOIN wp_options wpo
    ON wpo.option_name = 'permalink_structure'
 WHERE wpp.post_type = 'post'
   AND wpp.post_status = 'publish'
 ORDER BY wpp.post_date DESC;


How to disable WordPress’s internal search system (while still using its search page templates)

On websites like ( ) and Maclean’s ( ), the amount of content on those WordPress websites long ago exceeded the level that the built-in WordPress search system can capably handle.

Third-party search solutions such as Google CSE (Custom Search Engine) are being utilized instead, but there is a momentary slowdown before the page loads that is caused by the WordPress site executing its own internal search query before it displays the search results page. In order to remove this delay (and the unnecessary database request), add the following code to the theme’s functions.php file:

// Disable WordPress's internal search query (as much as we can), letting Google CSE handle that.
function internal_search_disable( $query ) {
    if ( !is_admin() && $query->is_main_query() ) {
        if ( $query->is_search ) {
            // Add a filter that effectively returns no results ever.
            add_filter('posts_where', 'internal_search_filter_where');
    return $query;
add_action('pre_get_posts', 'internal_search_disable');
// The WHERE search filter for disabling the internal search system.
function internal_search_filter_where( $where = '' ) {
    $where = " AND 0 = 1";
    // Once added, remove the filter to stop affecting other queries on the page.
    remove_filter('posts_where', 'internal_search_filter_where');
    return $where;

How to add an AJAX function / URL to WordPress

Put this function in your theme’s functions.php (or even better, in an ajax.php file in the theme that is require’d in):

/* The function ajax_read_more() will be called when the following URL is requested
 * from WordPress:
function ajax_read_more() {
    // Take in a few input parameters from $_GET or $_POST (depending on how you're passing the values) about
    // what data to retrieve and display.
    $num_limit = (int) $_POST['limit'];
    $str_category_name = filter_var($_POST['category_name'], FILTER_SANITIZE_STRING);
    // Call some built-in WordPress functions just to demonstrate that we can.
    $user_id = get_current_user_id();
    // Now let's return some JSON data to whatever called this URL (we can return HTML, XML or whatever else too,
    // just make sure to set the appropriate Content-Type header).
    $arr_sample_data = array('key' => 'value');
    echo json_encode($arr_sample_data);
    exit; // You must use exit to end an AJAX function in WordPress, or it'll append a 0 to the output.
add_action( 'wp_ajax_read_more', 'ajax_read_more' ); // This action exposes the AJAX action "read_more" to logged-in WordPress users.
add_action( 'wp_ajax_nopriv_read_more', 'ajax_read_more' ); // This action exposes the AJAX action "read_more" to anonymous (not logged in) WordPress users.

Then all you need to do is write a jQuery or even just a regular HTML form that submits a request to your new AJAX URL:

    type: 'get',
    url: '/wp-admin/admin-ajax.php?action=read_more&limit=5',
    dataType: 'json'
.done( function( response ) {

One last thing – visit your WordPress site’s Permalinks page in order to rebuild the list of URLs WordPress will respond to. This will make your new URL (for the AJAX function) active.

Forcing images to conform to a 16:9 aspect ratio

In the Bootstrap front-end framework, you can add the classes embed-responsive embed-responsive-16by9 or embed-responsive embed-responsive-4by3 on a DIV that wraps an IFRAME, EMBED or OBJECT element to ensure that video players always conform to a 16:9 aspect ratio on your responsive website (more info).

But what about images? In cases where content has been migrated onto a WordPress site, re-creating all thumbnails in the proper aspect ratio may just not be doable – or you may simply not have the controls in place to ensure that all images are of the correct aspect ratio. Luckily there appears to be a trick in CSS that can force aspect ratios. To get it to work, you’ll need to write CSS for a DIV that wraps the actual IMG tag like so:

.img-responsive-16by9 {
    display: block;
    height: 0;
    padding-bottom: 56.25%;
    overflow: hidden;

That’ll force the image output with the HTML illustrated below to respect a 16:9 aspect ratio:

<div class="img-responsive-16by9">
    <img src="">

Why I mostly hire generalists

I’ve had the pleasure of getting to build the in-house web development team at Rogers Media for a few years now up from just myself and one other developer to a staff of fifteen. I’m of the school of thought that software development teams are best kept small: It requires a smaller web of communication, individual team members maintain a high level of impact on the product they’re building (avoiding a loss of motivation due to the Ringelmann effect), and team stability (that is, people constantly joining or leaving the team) is usually greatly improved.

But there’s a potential downside that has to be addressed: Software is complex, and the requirements of web development often extremely so. How does a small team come through with everything that’s needed to make a project work? My answer has been to build the core of the team around generalists – people who tend to be very good in one area of development, but also knowledgeable and capable in most others as well.

Here’s an excerpt from the Pragmatic Programmer series titled Be A Generalist that speaks to why generalists are the answer to meeting a modern business product’s software needs:

For at least a couple of decades, desperate managers and business owners have been pretending that software development is a manufacturing process at heart. Requirements specifications are created, and architects turn these specifications into a high-level technical vision. Designers fill out the architecture with detailed design documentation, which is handed to robot-like coders, who hold pulp-fiction novels in one hand while sleepily typing in the design’s implementation with the other. Finally, Inspector 12 receives the completed code, which doesn’t receive her stamp of approval unless it meets the original specifications.

It’s no surprise that managers want software development to be like manufacturing. Managers understand how to make manufacturing work. We have decades of experience in how to build physical objects efficiently and accurately. So, applying what we’ve learned from manufacturing, we should be able to optimize the software development process into the well-tuned engine that our manufacturing plants have become.

In the so-called software factory, the employees are specialists. They sit at their place in the assembly line, fastening Java components together or rounding the rough edges of a Visual Basic application on their software lathes. Inspector 12 is a tester by trade. Software components move down the line, and she tests and stamps them in the same way each day. J2EE designers design J2EE applications. C++ coders code in C++. The world is very clean and compartmentalized.

Unfortunately, the manufacturing analogy doesn’t work. Software is at least as malleable as software requirements. Things change in business, and businesspeople know that software is soft and can be changed to meet those requirements. This means architecture, designs, code, and tests must all be created and revised in a fashion more agile than the leanest manufacturing processes can provide.

In this kind of rapidly changing environment, the flexible will survive. When the pressure is on, a smart businessperson will turn to a software professional can solve the problem at hand. So, how do you become that person whose name comes up when they’re looking for a superhero to save the day? The key is to be able to solve the problems that may arise.

What are those problems? That’s right: you don’t know. Neither do I. What I do know is that those problems are as diverse as deployment issues, critical design flaws that need to be solved and quickly reimplemented, heterogenous system integration, and rapid, ad hoc report generation. Faced with a problem set as diverse as this, poor Inspector 12 would be passed over pretty quickly.

The label jack-of-all-trades—master of none is normally meant to be derogatory, implying that the labelee lacks the focus to really dive into a subject and master it. But, when your online shopping application is on the fritz, and you’re losing orders by the hundreds as each hour passes, it’s the jackof-all-trades who not only knows how the application’s code works but can also do low-level UNIX debugging of your web server processes, analyze your RDBM’s configuration for potential performance bottlenecks, and check your network’s router configuration for hard-to-find problems.

And, more important, after finding the problem, the jack-of-all-trades can quickly make architecture and design decisions, implement code fixes, and deploy a new fixed system to production. In this scenario, the manufacturing scenario seems quaint at best and critically flawed at worst.

Another way in which the software factory breaks down is in that, although in an assembly line the work keeps coming in a steady flow, software projects are usually very cyclical. Not only is the actual flow of projects cyclical, but the work inside a project is cyclical. A coder sits on the bench while requirements are being specified, architected, and designed, or the coder multitasks across many projects. The problem with multitasking coders is that, despite the software factory’s intentions, when the rubber meets the road, the coders rely a great deal on context and experience to get their jobs done. Requirements, architecture, and design documents can be a great head start, but ultimately if the programmers don’t understand what the system is supposed to do, they won’t be able to create a good implementation of the system.

Of course, I’m not just picking on coders here. The same is true at nearly every spot on the software assembly line. Context matters, and multitasking doesn’t quite work. As a result, we have an inefficient manufacturing system. There have been various attempts to solve this problem of inefficiency without departing from the manufacturing-inspired system, but we have not yet figured out how to optimize our software factories to an acceptable level.

If you are just a coder or a tester or a designer or an architect, you’re going to find yourself sitting idle or doing busywork during the ebbs of your business’s project flow. If you are just a J2EE programmer or a .NET programmer or a UNIX systems programmer, you’re not going to have much to contribute when the focus of a project or a company shifts, even temporarily, out of your focus area. It’s not about where you sit on the perceived value chain of project work (where the architect holds the highest spot of royalty). It’s about how generally useful you make yourself.



Hacking the Budweiser Red Light (Part I): Identifying the network traffic that activates the light

The Budweiser Red Light is one of the best pieces of marketing I’ve ever seen. And while I’m enough of a hockey fan to want to pick up one of these anyways, the real prize is in figuring out how to make the thing go off whenever I choose.

Where to get started? While I’ve seen an attempt to use/modify the Electric Imp card inside the light to accept requests, I thought my approach might be simpler: Sniff the network traffic to and from the light, replicate it to sound the alarm.

The instruments used to sniff the traffic were as follows:

  • A MacBook Pro (to set up Internet Sharing upon for the Red Light to connect to)
  • My Android OS smartphone (to install and pair to the Red Light using the app Budweiser developed for that purpose)
  • WireShark (a network protocol analyzer) installed on the MacBook Pro, which also requires XQuartz


I kept careful notes in case someone else wanted to replicate this experiment; those instructions are:

  1. Enable Internet Sharing on the MacBook Pro, and make sure you set no password or key. (At home where I have an Windows 8.1 PC, I had attempted to set up a Wi-Fi hotspot but the Red Light appeared to have difficulty getting on that network.) I named my new Wi-Fi access point “BudRedLight”.
  2. I had my Android OS smartphone join the Wi-Fi access point of “BudRedLight”, which it did without issue.
  3. In order to sniff its traffic, we’ll need to get the Red Light on the “BudRedLight” access point as well. This means installing and setting up the official Budweiser Red Lights app, and using the interesting flashing light method of sending the Wi-Fi connection details from the phone to the Red Light.
  4. Once that’s done, I left the app open on the phone, specifically staying on the screen that provided the “TEST YOUR LIGHT” button. The plan was to capture what was received by the Red Light once this was pressed.
  5. Now that the Red Light and my phone were both on the “BudRedLight” access point, it was time to boot up WireShark on the MacBook Pro (I had to start XQuartz first so WireShark would run).
  6. Let’s get WireShark listening to the traffic coming in and out of “BudRedLight”: Select the Capture menu option, and then Options. Unclick the “Use promiscuous mode on all interfaces option” (this will cut down on the amount of noise being captured). Instead, double-click on the Wi-Fi listing, and within it check the “Capture packets in promiscuous mode” option and hit OK. (Need a visual guide? Here’s a screenshot.)
  7. Okay – we’re now capturing traffic! Tap the “TEST YOUR LIGHT“; this will make your phone send a HTTPS request up to some remote server, which in turn appears to send a TCP [PSH, ACK] packet to the Red Light. In the screenshot of WireShark below, I pressed the “TEST YOUR LIGHT” twice, resulting in the two [PSH, ACK] packets listed:bud-red-light-tcp-psh-ack-traffic
  8. So what’s in that packet? Only 234 bytes of it contain actual data, so let’s see what that looks like (via WireShark):bud-red-light-packet-inspection

Next Steps

So we’ve got an example of the data used to set off the Red Light, but we don’t really know what’s contained in that data.

Deep packet inspection isn’t really my thing, so at this point I’ve started asking around for possibilities. Here are the early contenders:

  • Use tcpreplay, Ostinato or some other application to “replay” sending of the packet shown above to the Red Light; maybe we don’t really even need to know what’s in the packet and this will set it off.
  • Find and use some other utility (or person!) that can tell us how to further decipher what’s in the data seen above.

If you’d like to help out, you certainly can! I’ve uploaded a zipfile of a PCAP file containing the packet I’ve displayed above. Feel free to try and dicipher or replay sending of that packet on your own! Please leave a comment if you do so; it’d be great to solve this for everyone.