---
title: Don't Worry, There's a Method to the Meeting
teaser: 'Make meetings productive by treating them like coding functions.

  '
tags: javascript,haskell,communication,consulting,playbook
author:
- Sean Doyle
- Keiran King
published_on: 2020-04-17
---

Everyone hates meetings.

Most folks think they're a waste of time, with good reason. Meetings often happen just because someone put it on the schedule or a manager wants updates.

At thoughtbot, meetings tend to be short and focused:

- Early in the week, we have an [iteration planning meeting (IPM)] to prioritize work, usually by grooming a backlog of tickets.
- Late in the week, we hold a [retrospective] to reflect on the work we did and adjust our process for next week.

What makes a meeting useful? Talking about product development meetings at Basecamp, [Shape Up](https://basecamp.com/shapeup) author Ryan Singer says that "the *output* ... is a cycle plan."

## Functional meetings

Like a useful method or function, **a useful meeting should have known inputs and outputs**. Here's what IPMs and retro meetings might look like as JavaScript functions:

```
function ipm(ungroomedBacklog) {
  // what happens in the meeting
  // ...
  return groomedBacklog;
}
```

```
function retro(workweekExperiences, previousActionItems = []) {
  // what happens in the meeting
  // ...
  return actionItems;
}
```

**Known inputs, known outputs.** A retro takes in the team's experiences over the past week, as well as any outstanding action items, and produces a new list of action items. When that's done, the meeting ends.

By contrast, a typical meeting might look like this:

```
function arbitraryMeeting(...updates) {
  // what happens in the meeting
  // ...
}
```

With unknown inputs and no defined output, it's impossible to know why a meeting is taking place, what should happen in it, or when it's over.

Just as well-conceived functions are scoped to their purpose, **a well-conceived meeting can be scoped with an agenda that states the desired output**. Topics that don't contribute to that goal can be discussed elsewhere.

[Type signatures], which define inputs and outputs for a function, express the analogy even more succinctly. Here's what our meetings might look like as Haskell type signatures (with the final example '[stringly-typed]'):

```
ipm :: UngroomedBacklog -> GroomedBacklog

retro :: [WorkweekExperience] -> [ActionItems] -> [ActionItems]

arbitrary_meeting :: String -> String
```

Apply a method to your meetings and enjoy many happy `return`s.

*Thanks to [Joël Quenneville] for Haskell and type signature help.*

[iteration planning meeting (IPM)]: https://thoughtbot.com/playbook/planning/manage-priorities-with-a-lightweight-process
[retrospective]: https://thoughtbot.com/playbook/planning/meet-weekly-to-discuss-successes-failures-and-plans
[Type signatures]: https://developer.mozilla.org/en-US/docs/Glossary/Signature/Function
[stringly-typed]: https://www.techopedia.com/definition/31876/stringly-typed
[Joël Quenneville]: https://twitter.com/joelquen