Head First Learn to Code: A Learner's Guide to Coding and Computational Thinking

What if you could shortcut your way to being cruely well informed, especially about something is well fundamental as learning to code. We're about to embark on a deep dive into exactly that that's good. Today we're cracking open head first, Learn to Code, A Learner's Guide to Coding and Computational Thinking by Eric Freeman.

Right. And this isn't your typical dry textbook, is it?

No, not at all. It's a guide praise for being accessible, really engaging. One reviewer even said it felt like a thousand pounds of books just been lifted off of your head.

Wow. And what's truly fascinating, I think is that the book itself, It explicitly states it's not for you know, kick butt programmers looking for a reference book, but specifically for a learner.

Yeah, that distinction feels important.

It really is. It's not just marketing talk. It highlights a very deliberate, scientifically backed mission.

And that mission is precisely what our deep dive is all about. Today. We're going to unpack the core principles that make learning code in enjoyable and genuinely effective. How this book helps you grasp foundational path on skills computational thinking without feeling overwhelmed.

Which is key.

Absolutely. So if you've ever felt like a complex topic was just this insurmountable mountain, then this deep dive into how to learn is definitely for you. Good stuff. Okay, so let's unpack this when we talk about headfirst? What makes their approach, so, I guess, revolutionary for tackling something as seemingly dense as coding.

Well, what's truly insightful here, I think, is how deeply their methodology is rooted in cognitive science, neurobiology, educational psychology. It's not just a collection of like clever tricks. It's engineered around metacognition, thinking about thinking exactly, thinking about your own thinking, or really learning how to learn effectively. The whole design is meant to ensure you get it then

So how does it actually do that? What are the mechanisms the things that, as they put it, bend your brain into submission?

Huh yeah, Well, for one, it leans really heavily into visual learning images, right, because studies show using images over just words can lead to well up to an eighty nine percent improvement and recall and transfer.

That's huge, it is.

And they also present concepts and pictures in unexpected ways, often with emotional content like humor or surprise, because your brain is actually tuned for novelty, you know, and the biochemistry of emotions helps cement memories.

I definitely noticed that it makes sense to It's like your brain is always looking for the unusual, the thing that makes it pause and go, huh, what's that?

Exactly that? And another clever technique is its personalized sort of conversational style.

Yeah, it reads like someone's talking to you, right.

Your brain believes you're in a conversation even while you're just reading, and that keeps you engaged. They also strategically use people in stories examples why people specifically, because quite simply, your brain pays more attention to people than it does to things. It's a built in bias.

Interesting, and the book mentions an eighty twenty approach. How does that fit into this learning philosophy.

It's very practical. They understand that for a beginner, the goal isn't to become an instant expert.

Overnight, right, avoid the overwhelming.

Precisely, the goal is to build a strong, usable foundation, So they focus on just the stuff you'll actually need to get started. Okay, they assume this won't be the only coding book you ever read, but it aims to be the most effective first step. It prevents that feeling of drowning and information that often happens when you try to learn everything at once.

That makes perfect sense, so for you, the listener the learner, the book isn't just about reading passively. It outlines very specific actions to really maximize this whole neuroscientific approach.

Actions are key.

Yeah, you're told to slow down, don't just read, but actively think, do the exercises, and even say to them with a pencil.

Yeah, the physical act, right.

They emphasize there's plenty of evidence that physical activity, well learning, actually boosts retention. You should also read all the There are no dumb questions, sidebars, Their core content not just filler.

Definitely not filler. Important stuff in there.

And kind of surprisingly, they suggest making it the last thing you read before bed. Why is that because apparently a significant part of learning and transferring information to long term memory happens after you put the book down during sleep. Ah, consolidation makes sense, So you're also encouraged to feel something. Even groaning at a bad joke is better than nothing because those emotions help memory formation.

Right engagement on any level, and.

Crucially, get sleep. As a book explains, you need to create a lot of new brain connections to learn programming.

It's demanding work for the brain.

Absolutely, these activities aren't optional. Their integral to the head first method, combined with intentional redundancy, really helps promote retention.

It's a very active approach to learning.

Okay, So here's where it gets really interesting, I think, moving from the how of learning to what you're actually learning. What is computational thinking and why should you care about gaining this skill even if you never become a professional coder.

That's a great question. At its core, computational thinking is about breaking down complex problems into achievable little actions that a computer can do for you.

Okay, step by step exactly.

But the deeper insight here, I think is that it's not just for computers. It's a fundamental shift in how you approach problem solving in any domain.

So it's broader than just code, much broader.

When you learn to code, you're not just memorizing syntax you become the director, the creator, gaining the ability to automate, analyze, innovate. This offers more time, more power, and frankly, more creative possibilities in areas far beyond traditional programming.

So it's like a mental superpower that gives you clarity. Then you give a great analogy in the book. It's like a nice recipe for phishing.

Yeah, I like that one.

A set of steps with simple instructions, maybe some conditions, a clear flow direction. The actual process of translating that clarity into code then boils down to what three main steps pretty much.

First, you craft your algorithm. Okay, this is where you turn the problem into that high level recipe or maybe pseudocode.

Pseudocode like half English half.

Code sort of.

Yeah. Writing out the steps in plain English or a mix before you dive into the specific programming language syntax. It clarifies your thinking.

Got it? Step one algorithm?

Then step two is you write your program. This is the actual coding stage, translating that recipe into specific instructions in a programming language, producing your.

Source code okay, the actual typing, right.

And finally step three you run your program. You hand that source code to the computer for inter running, evaluating, or executing.

You see if it works makes sense?

Now you mentioned programming languages. There are literally thousands out there, Java, CPHP, Swift. I mean, the list goes on.

Their names are a lot like the names of rock bands.

As the book says, huh exactly, So why does this book and why are we in this deep dive focusing specifically on Python.

Yeah, that's a really important question, especially for someone maybe already familiar with the broader landscape. Python was chosen for a very specific pedagogical reason.

Okay.

It's widely considered one of the best languages for beginners, mainly due to its readable and consistent design.

Readable how well, Unlike.

Some languages that demand really strict sometimes if verbose syntax, pythons, structure minimizes that friction. It looks a bit more like plain English, sometimes less intimidating, maybe definitely less intimidating. It also boasts powerful library support what they call modules or libraries, which means you don't have to build absolutely everything from scratch. There are pre built chunks of code for common tasks.

And a delightful, little surprising fact they share is that Python isn't named after the snake.

No, it's named from the creator's love of the Monty Python comedy troupe.

It tells you something about its approachable personality right totally.

And you really see Python's readability shine when you compare simple tasks like writing Hello World. In Java, it's multiple lines, kind of complex syntax.

Yeah, I've seen that public static void main stock exactly.

But in Python, it's just a single straightforward line print Hello.

Simple, very simple, And.

It's worth noting the book primarily focuses on Python version three, which is important because there are some significant differences from the older Python two.

Good to know. So, once you've embraced this head first learning method and you understand the core idea of computational thinking, what does this all mean for actually, you know, writing code, Let's get into some of the foundational components.

Absolutely. Think of these as the fundamental tools in your computational thinking toolkit. First up, you have variables. If you're building a program, you often need to store pieces of information and refer back to them later. Variables are simply names you can refer to over and over.

To recall a value, like dog named Cody.

Exactly like dog names Cody. And the book really emphasizes that good variable names are always clear and meaningful, which is just crucial for readable, understandable code.

Later on, right, not just x or y please no.

And those values that variables hold. They have data.

Types right, numbers, text correct.

Python handles these quite elegantly. You've got whole numbers which are integers, numbers with guescimal points, those are floating point numbers or floats, and text, which we call strings, usually wrapped in quotes. There are others too, like boollions.

We'll get to those. So you have data, how do you work with it?

You use operators. These are symbols like plus og for your basic math. Python also uses for exponentiation raising to a power.

Okay, standard math stuff.

Mostly, but the key takeaway for anyone writing code is understanding operator precedence, ah, the.

Order of operations pem.

Dot exactly, pemdas or please excuse my dear, and sally, parentheses, exponents, multiplication, division, addition, subtraction. Python follows that, but perhaps Even more crucial, especially early on, is the distinction between the single equal sign, which is used for assigning a value to.

A variable like dog name a cody.

Right, versus the double equal sign, which is used for checking if two values are equal, testing for equality.

Okay, assignment versus comparison. That seems like a really easy mistake to make.

Oh, it's a classic beginner mistake. The book makes sure to really hammer that point home. There are others too, like m for not equal.

So once you have values and you can perform operations, how do you get your code to actually make decisions to react differently in different situations.

That's where Booleians and control flow come marching in.

Bullians, named after George Bull, the very.

Same Bullians are absolutely core to almost all algorithms. They represent simple true or false states in Python, that's true or false. Always capitalize just two values, just two, and these combine with logical operators like and, or and not to create conditions that your code can evaluate.

Okay, so true and false. Let you build conditions.

Exactly, and this leads us directly to decisions in your code using if else and l if statements, l if being short for else, if right.

So the head first method makes it clear your code isn't just a straight line. It has forks in the road.

Precisely, you can tell a computer if this condition is true, do X. Otherwise, if this other condition is true, do why, or maybe else just do z.

And the structure matters here In Python, right indentation absolutely critical.

What's key in Python, unlike some other languages that use curly braces or keywords, is that related statements. The code that belongs to an if or an else are grouped into code blocks purely by using consistent indentation, usually for spaces for spaces.

Got it, So that's decisions. What about doing things more than once, like repeating an action or processing a whole list of items?

Ah? Yeah, you definitely need to do things more than once. That's where loops become your best friend. They save you from writing the same.

Code over and over two main types.

Basically, yes, the wile statement repeats a block of code as long as a certain condition remains true.

Okay, keep going all this is true?

Right, And the four statement is used to iterate over sequences like going through each character in a string or each item in a list. We'll talk about later.

Iterating, stepping through things one by one.

Exactly now with wile loops, the book introduces the concept of the uh dreaded infinite loop.

Huh, where it never stops.

Exactly where your condition accidentally never becomes false and your program just runs forever or until you force quit it.

How do you escape that?

Well, ideally you write your condition correctly, but Python offers the break statement as an eject button to jump out of a loop prematurely, even if the main condition is still technically true.

Handy escape had very handy sometimes so for you the listener.

The real insight here, I think, is that these aren't just isolated technical terms to memorize variables, operators, booleans, loops. They're the fundamental vocabulary in grammar. They let you have a structured logical conversation with your computer.

Well put, and the book does an excellent job of demystifying what can feel intimidating at first. It also stresses something really important, understanding errors.

Oh yeah, bugs bugs.

Syntax errors which are like typos or grammar mistakes, semantic errors, which are logic errors the code runs but does the wrong thing. Often the trickiest to debug, and runtime errors where something goes wrong during execution, like trying to open a file that isn't there. Understanding these just a natural part of coding life. Learning to debug is a crucial skill every programmer develops. It's not failure, it's just part of the process.

Okay, embracing the Error's got it. So once you've got these basic building blocks down, the next challenges, well, how do you handle lots of data and how do you keep your quote organized and reusable as programs get bigger.

Yeah, that's a crucial step up in complexity. This is where powerful data structures and the concept of abstraction become absolutely in valuable.

Let's start with data structures like lists exactly.

Lists are Python's fundamental ordered data type. They let you store collections of items, like a shopping list or a list of.

Scores, ordered meaning the position batters.

Yes, each item resides at a specific location or index. And really importantly, these indexes start at.

Zero, not one, ah the classic zero based indexing.

The classic lists are also which means you can change their contents after they're created. Ad items, remove items, change items, flexible, very flexible, and they can even hold heterogeneous values, meaning you can mix different types of data like numbers and strings within the same list. The book shows how simple operations like append to add a new value to the end or dell to remove an item by its index are foundational.

Okay, so lists are ordered collections. What if the order doesn't matter so much, but you need to access data using something more descriptive than just a numerical index.

That's the perfect use case for dictionaries. Unlike lists, dictionaries are an unordered data type, or more accurately, these days, they maintain insertion order in modern Python. But the key idea is you don't access things by numerical position.

How do you access them?

Each value is accessed by a unique key. Think of it like a real world dictionary. The key is the word you look up, and the value is the definition.

Got it. So keys could be words.

Names, keys can be numbers, strings, even booleians. In some cases, the corresponding values can be any Python type at all. Dictionaries are incredibly flexible for storing related pieces of information, like pairing a person's name the key with their age the value.

How do you make one?

You usually create an empty one with curly braces. Then you can add key value pairs, check if a specific key already exists using the in operator, and iterate through the keys or values.

Sounds powerful for organizing related.

Info, extremely powerful.

So lists and dictionaries help manage data. But what about keeping the actual code itself, clean, organized, and especially reusable.

Ah, now you're talking about the superpower of functions.

Okay.

Functions are the fundamental way to abstract your code. Abstract meaning meaning bundling a sequence of instructions together into a reusable package or block. You give that block a name, the function name. Then whenever you need to perform that sequence of tasks, you just call the function by its name, so.

You don't have to rewrite the steps every time exactly.

It lets you forget all the nitty gritty details inside the function and think about your program at a higher level. It's like having a custom tool specifically designed for a recurring job.

Makes sense. The book mentions parameters and arguments.

Yes, a key distinction that trips people up sometimes. Parameters are the placeholder names you define in the function definition the inputs of the function. Expects Arguments are the actual values you pass to the function when you call it.

Parameters and definition arguments in the call got it.

And related to functions, there's the very important concept of scope. Scope like where things are visible precisely, scope describes where a variable is visible or accessible within your code. Local variables are variables created inside a function. They only exist while that function is running temporary, temporary, exactly. Global variables are defined outside of any function and can potentially be

Can you change global variables from inside a function?

You can using the global keyword, But the book wisely notes, and it's generally good advice that doing this too much can lead to issues with large programs. It can make code harder to understand and debug if functions are unexpectedly changing things far away.

Okay, so use globals sparingly.

Generally yes. Python also adds some nice flexibility to functions with default values and keywords for parameters. This lets you call functions with fewer arguments sometimes or provide them in a different order using keywords, making calls more descriptive.

Write more options. So really understanding these data structures lists dictionaries in the power of functions isn't just about memorizing syntax again, definitely not It's about gaining the fundamental tools to manage complexity in your programs. Thinking about data in these structured ways, abstracting code into functions. It really transforms how you approach problems, leading to more robust, readable, and maintainable solutions down the line.

Absolutely, it's about building bigger things without getting lost in the details.

Okay, all right, we've built but a pretty solid foundation. Now we've got variables, decisions, loops, ways to structure data, ways to organize code with functions. How do we step it up? How do we tackle truly complex problems, maybe create interactive applications, or even connect our code to the vast world of online data.

Yeah, now we move into some even more sophisticated but really powerful concepts. First up, let's talk about modules.

Modules like those libraries you.

Mentioned earlier exactly.

Think of modules as a way to package collections of functions and variables into separate Python files files, ending and notch. Why this makes it super easy to share and reuse code across different projects, or even share code with.

Others, so you can import functionality someone else wrote.

Precisely and the book thoroughly explains a specif it's a slightly weird looking convention. If name equals a.

Main, yeah, I've seen that. What's it for?

It's actually incredibly practical. It allows a Python file to act in two ways. If you run the file directly, the code inside that if block executes maybe some test code for the module itself.

Okay.

But if another Python file imports your file as a module, the code inside that if block does not run automatically. It lets you create reusable libraries that don't unexpectedly execute code just by being imported.

Clever. Okay, So modules help organize and share code. What about tackling really complex structures? I hear about objects and classes a lot Object oriented programming OOP.

Yes, OOP. The book describes this as the ultimate incode reuse, and that's a pretty fair description. Why ultimate because objects fundamentally bundle state and behavior together. Instead of having separate pieces of data floating around and separate functions that operate on that data, an object encapsulates both. It has data its attributes, and it can do things its methods.

Okay, state and behavior bundled. Can you give an example?

The book uses a fantastic analogy. A car a car has state. Right, it's make model current fuel level attributes exactly, and it has behavior It can start, turn off, drive break befits perfect. The Python turtle module, which lets you draw graphics, demonstrates this beautifully.

Yeah.

When you create a turtle object like slow poke turtle turtle, each turtle instance, each object has its own position, heading, color, its state, and its own methods to move forward, turn, change color, its behavior.

So multiple turtles can exist independently.

Right. And the blueprint for creating these objects is called the class classes.

The blueprint object is the.

Instance you got it.

A class is the blueprint maybe a dog class, and an object is a specific instance created from that blueprint, like Cody Eul's dog.

And when you create that object, Cody.

When an object is created, a special method called in often called the constructor, runs automatically. Its job is to initialize the object, set up its initial state, and the self parameter you see in class methods is crucial here. It refers to the specific instance, the object itself.

Okay, and oop gets even more powerful with inheritance, right.

Absolutely. Inheritance is where classes can subclass or inherit from other classes. For example, you could have a service dog class that inherits from the dog class.

So service dog automatically gets all the dog attributes and methods exactly.

It gains the behaviors and attributes of its superclass, the dog class. In this case, then you can add specific things just for service dogs.

That sounds incredibly useful for avoiding repetition and related to that, polymorphism that sounds complex.

It sounds complex, but the concept is incredibly powerful and actually simplifies things. Polymorphism means many forms. In OOP. It means you can treat different objects that share a common superclass or implement the same methods in a uniform way. Like like you could have a list containing different kinds of dog objects service dog, poodle, guide dog, loop through the list and call the bark method on each one, even if their specific bark implementation is slightly different. Your

Ah okay, treat different things the same way if.

They share behavior precisely.

The book also shows how subclasses can redefine behavior inherited from their superclass. That's called overwriting methods. So a poodle might bark differently than a generic dog.

Got it? Inheritance polymorphism powerful.

Stuff very and while inheritance is powerful, the book briefly touches on composition two, building complex objects by putting other objects together. It's another key technique for flexible design, sometimes favored over deep complex inheritance trees.

Okay, soop is one way to handle complexity. Yeah, but sometimes you need a completely different way of thinking about problems, right, like recursion Exactly.

Recursion is a fascinating and different style of computational thinking where a function actually calls itself.

WHOA how does that not go on forever?

Ah? That's the key. A recursive function needs two critical parts. First, a base case. This is a simple direct solution for the smallest version of the problem, which stops.

The recursion the execondition right.

And second, a recursive case. This is where the function breaks the problem down into a slightly smaller or simpler version of itself and then calls itself With that smaller version, each call gets closer to the base case.

Okay, so it needs to eventually hit that base case.

It must eventually hit the base case otherwise you do get infinite recursion, similar to an infinite loop. Python uses something called a call stack behind the scenes to keep track of all these nested function calls.

Can you give an example where recursion is useful.

The classic example which the book uses is calculating the Fibonacci sequence, where each number is the sum of the two preceding ones. It maps very naturally to a recursive definition, but simple recursion can sometimes be inefficient recalculating the same values over and over. So the book also introduces a brilliant an optimization technique called memoization.

Memmoization like writing memos, sort of.

It involves using a dictionary remember those to cash or store the results of previous calculations. Before computing a value, the function checks if it's already in the cash. If so, it just returns the stored value instantly, so.

It avoids redoing work exactly.

This can dramatically reduce computation time. The book shows how it makes computing, say, the one hundredth Fibonacci number, feasible in under a second, whereas naive recursion would take well practically forever.

Wow, and recursion isn't just for numbers, right.

Not at all. You see recursion in striking visual forms too, like fractals. Think of the cock snowflake, where the same pattern repeats at smaller and smaller scales. It's a beautiful illustration of a recursive process.

Cool. Okay, so we have ways to structure complex code. But what about making data actually stick around after your program finishes running? Saving things?

Ah? Yes, persistence, Making data persist beyond the execution of the program. That almost always means saving and retrieving data from files using persistent.

Storage like text files.

Spreadsheets could be text files, CSV files, Jason files. The basic process involves file operations. First, you open a file and you have to specify a mode like R for reading or W.

For writing, and the book gives a warning about.

W, a big warning. Using W for write mode will overwrite the file if it already exists, all previous content gone, so you use it with caution. There's also a for a pending adding.

To the end safer for adding data much safer.

Once a file is open, you can read its entire content using dot read, or read it line by line with dot redline, or often the easiest way is to just iterate over the file object with a four loop. Because Python treats a file as a sequence.

Of lines okay and critically.

Critically, You must always remember to close the file when you're done. This ensures any buffer changes are actually written to the disc and releases the file resources. Forgetting to close can lead to data loss or corruption.

Got it open operate clothes. The book uses a game.

Example, Yeah, the Crazy Libs game. It's a great practical example. It illustrates reading story template text from one file, getting input from the user, and then writing a new completed story file. It also helps clarify the difference between relative file.

Paths like datastory dot txt in.

The current folder right relative to where your script is running, versus an absolute path.

Like see users your documentstory dot.

Txt exactly the full unambiguous address of the file on the computer's filesystem.

And when dealing with external things like files, errors can happen right the file might not be there, or you might not have permission.

Absolutely things can go wrong that are outside your program's direct control. This is where exception handling becomes vital.

Try accept precisely.

Python provides try accept blocks you put the code that might cause a runtime error, like opening a file inside the triyblock. If an error, an exception occurs, the code in the corresponding accept block runs instead of the program just crashing.

So it lets your program gracefully handle unexpected problems.

Exactly, It prevents abrupt crashes and lets you provide feedback to the user or try an alternative action. It's essential for robust programs.

Okay, so files, let us save data locally. But what about connecting to the wider world getting data from the internet.

Ah, now we're talking webapis, Application programming interfaces epis.

I hear that term all the time, you do.

They are essentially documented sets of rules and functions that allow your code to interact with other programs or services, usually over the Internet. It's how different software systems talk to each other.

So when I use an app on my phone that shows weather data, it's probably using a weather API.

Almost certainly, it's sending a request to a weather service's API and getting back the forecast data.

And these requests use web addresses URLs, yes, uniform resource locators just like the dress as you type into your web browser.

Your Python code can send requests to specific API URLs, and a fantastic Python module for doing this easily is called requests. You usually need to install it first, like PITP install requests.

Okay, request module. Yeah, and when you make a request you get a response back.

You get a response back which includes data but also a status code. You've probably seen four h four not found in your browser. Oh yeah, that's an HTTP status code. A code of two hundred generally means Okay, the request was successful and satisfied. There are many other codes indicating different outcomes, and.

The data itself often comes back in a specific format like JSON.

Very often.

Yes.

Jason JavaScript object notation has become a very common general purpose text format for exchanging data between web services and applications. It's designed to be human readable but also easy for machines.

To parse, and it looks kind of like It.

Looks extremely similar to Python dictionaries and lists, lots of curly braces for objects dictionaries and square brackets for a rays like lists with key value.

Pair, so Python can handle it easily, very easily.

Python has a built in Jason module that can directly translate Jason formatted tech strings into Python dictionary or list objects, and vice versa. Makes working with WebAPI data incredibly convenient.

Cool. Does the book give a real world example?

It does a fun one using the open Notify API to get the current geographical location of the International Space Station ISS.

No way.

Yeah, you send a request to their api URL, get back a Jason response containing the latitude and longitude, and you can then display it. It really shows how you can connect your Python code to live real world data streams.

That's amazing. So really, for you the learner, these advanced concepts, modules, oep recursion, file handling, APIs, they aren't just about adding more complex syntax, not at all. It's about elevating your capabilities for managing complex data and code efficiently with objects and modules, to making your programs persistent with fileiles, to making them aware of and interactive with the vast outside

Absolutely, they open up a whole new level of possibility.

We've covered a really remarkable amount of ground today, haven't we. We certainly have, moving all the way from the philosophical underpinnings of how to learn to code effectively, digging into the head first method.

The cognitive science behind it.

Right then through the very syntax that brings code to life. Variables loops, functions, and then into these more complex systems like objects, dealing with recursion, interacting with files, and even web APIs.

It's quite the journey.

It really is, this deep dive I hope has shown you not just what coding is, but how it can be taught effectively, enjoyably and the genuinely exciting real world applications that open up once you grasp.

These concepts and if we try and connect this all back to the bigger picture. The book itself poses a pretty provocative thought right near the end in its conclusion. It really resonates I think with the journey we've.

Just discussed, what does it say?

It asks the reader directly, have you considered a career encoding? And it goes on if you're reading this page, you've covered a huge distance in this book. The exciting and daunting thing is that this book just scratches the surface of software development.

Scratches the surface.

Wow yep. And then it adds, if nothing else, we hope you'll consider our suggestion as you clearly have the right stuff to take this even further. It's quite an encouraging nudge.

That's a powerful message. So for you, the learner, listening to this. This journey isn't just about understanding one particular book, is it.

No, it's much broader.

It's about recognizing the vast creative possibilities that computational thinking unlocks. It's about building a foundational skill, a way of thinking that empowers you to not just understand the technology shaping our world, but potentially to shape it yourself.

It puts you in the driver's seat.

Absolutely so. The question the book leaves you with, and maybe we leave you with two, is what will you build next?