Vox

Leitura de 13 min

Could We All Be Right? Event vs. Construct Theories

Summary

In this episode of Developer Tea, host Jonathan Cattrall delves into the nature of theories and how they shape our opinions and disagreements as developers. He begins by acknowledging the common experience of disagreeing with respected colleagues and feeling self-conscious about it, framing this as more than just an ego issue.

Cattrall introduces two main types of theories: event theories and construct theories. Event theories are based on observable events and can be proven or disproven through evidence. They rely on the idea of proof and predictability, often leading people to think in binary terms of right or wrong. In contrast, construct theories are judged not by their accuracy but by their usefulness. They provide frameworks for viewing complex subjects and can coexist even when they offer different perspectives.

The discussion highlights how many developer arguments stem from treating construct theories as if they were event theories—trying to prove them right or wrong instead of evaluating their utility. Cattrall emphasizes that construct theories, such as teaching methods or programming design principles, are built from abstractions of multiple event theories and are valuable for their practical application. He encourages listeners to focus on learning from each other’s construct theories rather than debating their correctness, ultimately fostering a more collaborative and productive mindset in development work.

Recommendations

Books

  • Pragmatic Thinking and Learning — Andy Hunt’s book, which inspired this episode. It details information useful to developers, including the distinction between event theories and construct theories.
  • The Pragmatic Programmer — Another book by Andy Hunt, mentioned as a well-known work for developers, though not discussed in detail in this episode.

Topic Timeline

  • 00:00:00 — Introduction to developer disagreements and theories — Jonathan Cattrall opens the episode by discussing the common experience of disagreeing with smart developers and feeling self-conscious about it. He frames this as a human experience that goes beyond ego, introducing the episode’s focus on theories—why they collide and how sometimes everyone can be right. The goal is to help developers connect to their career purpose and have a positive influence.
  • 00:02:03 — Two main types of theories: event vs. construct — Cattrall explains that not all theories are created equal and introduces two main types: event theories and construct theories. He notes that even describing theories this way is itself a theory. This sets the stage for a deeper exploration of how these theories function and impact developer opinions and disagreements.
  • 00:04:27 — Defining event theories and their reliance on proof — Cattrall details event theories as those based on observable events where assertions can be made and tested. These theories are predicated on the idea of proof, aiming for replicability. He points out that people often wrongly flatten all theories into event-based ones, leading to binary thinking about right and wrong.
  • 00:06:35 — Introducing construct theories and their focus on usefulness — The host introduces construct theories, which are judged not by accuracy but by usefulness. Unlike event theories, construct theories provide frameworks for viewing things and can offer multiple valid perspectives on the same subject. Cattrall explains that many developer arguments involve construct theories, which are often built from stacks of event theories.
  • 00:08:43 — Examples of construct theories in development and teaching — Cattrall gives examples of construct theories, such as teaching methods or programming design principles, which abstract multiple event studies into a system. He emphasizes that construct theories are not easily provable but are valuable for their utility. This highlights how developers often debate the rightness of construct theories instead of assessing their usefulness.
  • 00:10:08 — Shifting focus from right/wrong to usefulness in arguments — Cattrall argues that developers should focus on whether construct theories are valuable or useful, rather than trying to prove them right or wrong. He suggests that differing opinions can be opportunities to learn from each other’s construct theories and develop new ones. This approach encourages collaboration over conflict.
  • 00:10:58 — Inspiration from Andy Hunt’s book and closing remarks — Cattrall shares that the episode’s inspiration comes from Andy Hunt’s book ‘Pragmatic Thinking and Learning,’ which details these theory types. He encourages listeners to check out the book and thanks sponsor Linode. The episode closes with a call to leave reviews and enjoy the tea.

Episode Info

  • Podcast: Developer Tea
  • Author: Jonathan Cutrell
  • Category: Technology Business Careers Society & Culture
  • Published: 2018-11-07T10:00:00Z
  • Duration: 00:12:03

References

Podcast Info

Transcript

[00:00:00] What was the last time you heard a smart developer say something that you disagreed with?

[00:00:11] And then you felt maybe self-conscious about disagreeing with them.

[00:00:16] This happens quite a lot to most developers because we, many of us, work with talented

[00:00:23] developers that we respect and that we appreciate the work that they do, and sometimes we disagree.

[00:00:32] This is a human experience, but there’s also more to the story than us just being human.

[00:00:38] It’s not just about our egos.

[00:00:41] In today’s episode, we’re going to talk a little bit about theories, why we have

[00:00:48] colliding theories, and when sometimes people are wrong, but sometimes everyone can be right.

[00:00:58] My name is Jonathan Cattrall and you’re listening to Developer T, and my goal on this show

[00:01:01] is to help driven developers like you connect to your career purpose so you can do better

[00:01:07] work and have a positive influence on the people around you.

[00:01:11] And in today’s episode, I want to discuss the idea of theories, but typically we don’t

[00:01:17] really ascribe the word theory to anything more than a guess.

[00:01:24] Theories have a long history in science, and you could say that science is essentially

[00:01:32] dependent on theories to even exist.

[00:01:35] We need theories to be able to test any kind of scientific method against them

[00:01:42] some kind of new information that either affirms or denies our theories.

[00:01:49] We have theories as developers.

[00:01:51] We have theories as humans, but not all theories are created equal.

[00:01:57] Not all theories are even made up of the same stuff.

[00:02:03] In fact, there are two main types of theories, and which one you are using, which one

[00:02:09] you are relying on for your opinion in a given moment can make a huge difference in how you

[00:02:16] parse and use both the theory and your opinion.

[00:02:22] We’re going to talk about those two types of theories right after we talk about today’s

[00:02:26] awesome sponsor, Linode.

[00:02:29] With Linode, you can instantly deploy and manage an SSD server in the Linode Cloud.

[00:02:33] You can get a server running in just a few seconds with your choice of Linux distribution,

[00:02:37] resources, and node location.

[00:02:39] Linode is going to give you essentially a $20 bill for their services.

[00:02:45] This is equivalent to four free months on their introductory plan.

[00:02:49] That’s a $5 month plan.

[00:02:51] That plan is no slouch.

[00:02:53] It gives you a gigabyte of RAM right out of the gate.

[00:02:57] You can also opt for higher memory plans.

[00:03:00] Those start at 16 gigabytes.

[00:03:02] Linode has a seven day money back guarantee, and they have hourly billing with a monthly

[00:03:07] cap on all of their plans and add-on services.

[00:03:11] You can do things like backups.

[00:03:13] You can have node balancers and Longview.

[00:03:16] Longview has all of these metrics that you can watch the performance of your server

[00:03:20] over time.

[00:03:21] They have 24-7 friendly customer support.

[00:03:24] They even have phone support available.

[00:03:27] Go and check it out.

[00:03:28] Oh, and by the way, all this runs on top of native SSD storage with a 40 gigabyte

[00:03:32] internal network.

[00:03:33] So if you’re doing some kind of multi-server, like internal networking stuff, then it’s

[00:03:39] going to be super fast.

[00:03:41] Go and check it out.

[00:03:42] Head over to Linode.com slash developer T. That’s Linode.com slash developer T,

[00:03:48] all one word, to get your $20 worth of credit.

[00:03:51] Use the promo code developer T 2018, developer T 2018.

[00:03:56] Thanks again to Linode for sponsoring today’s episode of developer T.

[00:04:00] So we’ve got two types of theories.

[00:04:04] These are two kind of species of theories that we can use in a given scenario.

[00:04:11] And even describing theories this way is itself a theory.

[00:04:17] We’re going to talk about which type that is in just a moment, but let’s talk about

[00:04:22] the first type of theory that we can use, and that is perhaps the most commonly

[00:04:27] accepted or relied upon type of theory, and that is event theory.

[00:04:32] An event theory is something that you can observe and then proceed to make assertions

[00:04:42] about.

[00:04:43] An event theory says that X will happen, and then you perform some kind of action

[00:04:50] and determine did X happen or not.

[00:04:53] Event theories are largely predicated on the idea of proof that you can reliably and consistently

[00:05:00] provide a proof that will essentially predict that that event is replicable.

[00:05:09] Now an event theory doesn’t necessarily have to have a perfect proof that explains

[00:05:15] it, and that’s kind of the, you know, we think about theories graduating into proof

[00:05:21] status.

[00:05:22] Imagine that a proof is something that is a proven theory, right?

[00:05:27] So this is kind of our, the etymology of this word has confused us a little bit,

[00:05:33] and we don’t always think about the other type of theory that we’re going to talk

[00:05:36] about in just a moment, but we almost always imagine that theories are either provable

[00:05:43] or not.

[00:05:44] Either they are true or they are untrue.

[00:05:47] And therefore we often wrongly state that something is either proving or disproving

[00:05:56] our theory.

[00:05:57] We watch some event occur, whether that’s an interpersonal event, maybe it’s an event

[00:06:03] in our code, maybe it’s a business event, something happens in the world, and we

[00:06:09] use that information to make a statement like, well, that’s not true because this

[00:06:16] happened.

[00:06:17] Your belief about this thing is untrue because I observed an event that disagreed with your

[00:06:25] belief.

[00:06:26] And these statements essentially flatten the concept of a theory into event-based

[00:06:32] theories only.

[00:06:35] But there’s another kind of theory, perhaps a more commonly used type of theory that

[00:06:42] is often misunderstood, and that’s called a construct theory.

[00:06:48] A construct theory is judged not based off of its accuracy, but instead based off of

[00:06:54] its usefulness.

[00:06:55] What does this mean?

[00:06:58] Well, having these two types of theories, as we said before, even this episode is

[00:07:04] using a construct theory to describe theories themselves.

[00:07:10] In other words, there’s no way to prove that there are only two types of theories.

[00:07:17] There’s no event that we can observe that kind of perfectly slices up every possible

[00:07:24] type of theory that’s out there and easily categorizes them into one or the other.

[00:07:31] Instead, a construct theory provides a framework for viewing things.

[00:07:39] We can have many types of construct theories that are not necessarily in agreement with

[00:07:44] each other describing the same subject matter from different points of view, and all of

[00:07:51] them could be useful.

[00:07:54] And as it turns out, this actually happens a lot for developers.

[00:07:58] We have construct theories about how to design programs in a way that is most accessible

[00:08:05] to other people.

[00:08:06] We have construct theories about how to best run a business or how to best run an interview.

[00:08:14] And we end up building our opinions largely based on these construct theories.

[00:08:21] A lot of times, our construct theories are built off of perhaps many stacks of

[00:08:27] event theories.

[00:08:29] We use science to describe the ways that things interact, and then we kind of abstract

[00:08:36] away from multiple of those event theories.

[00:08:40] We abstract them into a single construct theory.

[00:08:43] A good example of this might be a teaching method.

[00:08:47] A teaching method takes multiple studies, multiple even controlled case studies, for

[00:08:54] example, and tries to draw out various principles or ways of thinking, ways of doing, ways

[00:09:02] of operating, and builds a system from all of those studies, builds a system that operates

[00:09:10] as a theory for how to teach.

[00:09:15] This theory is not going to be easily provable.

[00:09:19] Perhaps we can judge various construct theories based on their usefulness after the fact,

[00:09:26] but it’s difficult to look directly at a construct theory and decide, is this useful

[00:09:32] or is it not?

[00:09:35] A construct theory doesn’t necessarily have to have other proven theories that back

[00:09:42] it up.

[00:09:43] If it is useful, if it provides some accurate depiction or some utility to the person who

[00:09:51] is using it as the tool that it is, then that construct theory might provide more

[00:09:59] value than other theories.

[00:10:01] Ultimately, a lot of our arguments as developers are trying to argue whether a

[00:10:08] construct theory is right or not.

[00:10:12] Instead, what we should be looking at is, are these construct theories valuable or not?

[00:10:19] Are they useful to someone?

[00:10:22] Perhaps they’re not useful to me, but that doesn’t necessarily mean that they’re

[00:10:25] not going to be useful to you.

[00:10:27] And so if you have strong opinions about something and I have strong opinions that

[00:10:31] differ from yours, that doesn’t mean that we have to decide who’s right or who’s

[00:10:37] wrong.

[00:10:38] Instead, perhaps we can learn from each other’s construct theories.

[00:10:43] Perhaps we can develop new construct theories.

[00:10:47] And maybe we can focus on things that are more valuable than trying to prove the

[00:10:52] unprovable.

[00:10:53] I’d encourage you, as kind of a takeaway note on today’s episode, if you’re

[00:10:58] interested in learning a little bit more, the inspiration from this episode comes

[00:11:02] from Andy Hunt’s book, Pragmatic Thinking and Learning.

[00:11:07] If you’re not familiar with Andy Hunt, then perhaps you’ve heard of his other

[00:11:10] book, The Pragmatic Programmer.

[00:11:13] And in this book, Andy Hunt details a lot of information that is useful to

[00:11:18] developers.

[00:11:19] One of the things, and just a sidebar, was a note about these different types of

[00:11:24] theories, construct theories and event theories.

[00:11:26] I encourage you to go and pick up that book.

[00:11:28] Thank you so much for listening to today’s episode of Developer Tea.

[00:11:32] Thank you again to today’s sponsor, Linode.

[00:11:34] You can get $20 worth of Linode credit by using the code DEVELOPERTEA2018 at

[00:11:39] checkout.

[00:11:40] Head over to linode.com slash developer tea to get started today.

[00:11:43] Thank you so much for listening.

[00:11:45] If you haven’t yet taken a moment to leave a review in iTunes, this is the

[00:11:49] best way to help other developers like you find and listen to Developer Tea.

[00:11:55] Thanks so much for listening and until next time, enjoy your tea.

Visão de gráfico