Nope! There are 4 floors to mop (8, 9, 10 and 11) but only 3 hours to work (8-9, 9-10, and 10-11).

Whoa — we count floors 8-11 and hours 8-11 differently? You bet. And somehow, if the boss said "Mop floors 8 to 11 on April 8th to 11th" everything would be ok.

Today let’s unravel this counting mystery.

Basic Counting

Numbers help us know "how many". Take a numbered list of houses:

There’s 52 houses there. Don’t count each one: the addresses count for us! The numbers label the houses one by one, just as we’d do. We can just read the last item - 1 to 52 is 52 houses.

Examples:

• Employee ID cards from 1 to 3493. There are 3493 employees.
• Days of the month from 1 to 31. There are 31 days in that month.

What Does Subtraction Mean?

We often see numbers as points on a line:

These points can be houses, floors, or plain integers. Whatever they are, they’re labeled so we can count them easily. 1 to 10 means ten items.

But what about a range like 8 to 11? How many items are there?

We’d probably try subtraction: 11 - 8 = 3, right? But here’s the key:

• Subtraction is a span between numbers, not a count

The equation 11 - 8 = 3 means there are 3 "spans" between 8 and 11, but four numbers in that range!

A span is a distance measure, like time from 8am and 11am (3 hours) or the distance between 8 and 11 inches (3 inches).

But when counting floors, we aren’t asking for the distance between floors 8 to 11 (which is in fact 3 floors or 30 feet, assuming 10 feet per floor). We want a count of how many items the range "8 to 11" includes!

Working With Spans and Counts

Realizing there are two types of counting was a big mental shift. We have two possible choices when "counting" from a to b:

• Distance from a to b: b - a [regular subtraction]
• Number of items from a to b: b - a + 1 (span touches extra element)

Ok, the formulas work. But why does a count need an extra element?

Well, the shortest span (distance 1) actually touches two numbers:

A span is a line segment with a start and end; a span of distance 1 covers 2 points. As we grow the span, we gobble up more points and are always "one ahead".

Here’s another way to think about it. A span of 3 means we start with an item (#8) and count out 3 more (#9, #10, #11). So, a span of N includes 1 original item and N new items, for a total of N + 1 items.

I like seeing new viewpoints; use what works for you.

The Fencepost Problem

The confusion between spans and counts is commonly called the fencepost problem. Are you counting the posts (points) or the distance between them (fence spans)?

The question goes like this:

You’re building a fence 100 feet long, with posts every 10 feet. How many posts do you need?

Here’s how to think about it with our new mental model:

Hrm, we want a fence 100 feet long. Ok: that’s a span of ten, 10-foot segments. But we want the number of posts: how many posts do those ten segments touch? Well, a span always touches an extra point, so ten segments means 11 posts.

11 fenceposts it is. But the problem isn’t natural for me - I have to think about spans vs points. I’d double-check with a smaller example - a fence of length 10 would have 2 posts, so yes, we need an "extra post".

A few more examples:

• Working Days: I worked April 8th to April 11th. How many days did I work? Well, that’s a span of 3 (11-8), but we "touch" 4 days: April 8, 9, 10, 11. So I worked 4 days.
• Hours: Hours are like spans. Working from 8 to 11 means you are covering the spans 8-9, 9-10, and 10-11. 8 to 11 means a "time" of 3 hours.
• Seconds: I start a race, and the start time at 12:01:08 (12 hours, 1 minute, 8 seconds). It ends at 12:01:11. How did it go? 11 - 8 = 3 seconds. (Short race)

Interesting, eh? Some units of time are measured with spans (seconds) and others are items to be counted (days).

The measuring type depends on the context. We see small units of time as "instants" and want the duration between those instants, not the "number" of instants we touched.

We see days as a large fuzzy blob covering a time period (9am-5am) — and we want to know how many blobs we covered. Saying you worked April 8 to April 9th implies you worked a timespan of 9am-5pm on two days.

The counting type depends on the context - but at least you know why we count them differently.

Final Thoughts

Counting isn’t simple. The fencepost problem and other "off by one" boundary errors are notoriously common. But don’t just remember a special trick (add 1) - remember there are two ways to measure something:

• Are we measuring a difference (distance, time)? Then do regular subtraction to get a span.
• Are we counting items? Then subtract and add 1 (b - a + 1) - we want the number of items the span touches.

It’s not easy to recognize the difference - used to having one way to measure. Try a simple example (a fence 10 feet long) to test if you’ve got a count or span.

I’ve run into the fencepost problem many times, but the articles I read just told me how to fix it. No, no, no - why does it happen?

It turns out we often use the same approach for two different types of counting. And while the right method may not be obvious, at least we know to try both approaches. Happy math.

• Networking is about communication
• Text is the simplest way to communicate
• Protocols are standards for reading and writing text

Beneath the details, networking is an IM conversation. Here's what I wish someone told me when learning how computers communicate.

TCP: The Text Layer

The Transmission Control Protocol (TCP) provides the handy illusion that we can "just" send text between two computers. TCP relies on lower levels and can send binary data, but ignore that for now:

• TCP lets us Instant Message between computers

We IM with Telnet, the 'notepad' of networking: telnet sends and receives plain text using TCP. It's a chat client peacefully free of ads and unsolicited buddy requests.

Let's talk to Google using telnet (or putty, a better utility):

telnet google.com 80
[connecting...]
Hello Mr. Google!

We connect to google.com on port 80 (the default for web requests) and send the message "Hello Mr. Google!". We press Enter a few times and await the reply:

<html>
...
<h1>Bad Request</h1>
Your client has issued a malformed or illegal request
...
</html>

Malformed? Illegal? The mighty Google is not pleased. It didn't understand us and sent HTML telling the same.

But, we had a conversation: text went in, and text came back. In other words: 

Protocols: The Forms To Fill Out

Unstructured chats is too carefree -- how does the server know what we want to do? We need a protocol (standard way of communicating) if we're going to make sense.

We use protocols all the time

• Putting to: and from: addresses in certain places on an envelope
• Filling out bank forms (special place for account number, deposit amount, etc.)
• Saying "Roger" or "10-4" to indicate a radio request was understood

Protocols make communication clear.

Case Study: The HTTP Protocol

We see HTTP in every url: http://google.com/. What does it mean?

• Connect to server google.com (Using TCP, port 80 by default)
• Ask for the resource "/" (the default resource)
• Format the request using the Hypertext Transport Protocol

HTTP is the "form to fill out" when asking for the resource. Using the HTTP format, the above request looks like this:

GET / HTTP/1.0

Remember, it's just text! We're asking for a file, through an IM session, using the format: [Command] [Resource] [Protocol Name/Version].

This command is "IM'd" to the server (your browser adds extra info, a detail for another time). Google's server returns this response:

HTTP/1.0 200 OK
Cache-Control: private, max-age=0
Date: Sun, 15 Mar 2009 03:13:39 GMT
Expires: -1
Content-Type: text/html; charset=ISO-8859-1
Set-Cookie: PREF=ID=5cc6...
Server: gws
Connection: Close

<html>
(Google web page, search box, and cute logo)
</html>

Yowza. The bottom part is HTML for the browser to display. But why the junk up top?

Well, suppose we just got the raw HTML to display. But what about errors: if the server crashed, the file wasn't there, or google just didn't like us?

Some metadata (data about data) is useful. When we order a book from Amazon we expect a packing slip describing the order: the intended recipient, price, return information, etc. You don't want a naked book just thrown on your doorstep.

Protocols are similar: the recipient wants to know if everything was OK. Here we see infamous status codes like 404 (resource not found) or 200 (everything OK). These headers aren't the real data -- they're the packing slip from the server.

Insights From Protocols

Studying existing, popular systems is a great way to understand engineering decisions. Here are a few:

Binary vs Plain Text

Binary data is more efficient than text, but more difficult to debug and generate (how many hex editors do you know to use?). Lower-level protocols, the backbone of the internet, use binary data to maintain performance. Application-level protocols (HTTP and above) use text data for ease of interoperability. You don't have religious wars about endian issues with HTTP.

Stateful vs. Stateless

Some protocols are stateful, which means the server remembers the chat with the client. With SMTP, for example, the client opens a connection and issues commands one at a time (such as adding recipients to an email), and closes the connection. Stateful communication is useful in transactions that have many steps or conditions.

Stateless communication is simpler: you send the entire transaction as one request. Each "instant message" stands on its own and doesn't need the others. HTTP is stateless: you can request a webpage without introducing yourself to the server.

Extensibility

We can't think of everything beforehand. How do we extend old protocols for new users?

HTTP has a simple and effective "header" structure: a metadata preamble that looks like "Header:Value".

If you don't recognize the header sent (new client, old server) just ignore it. If you were expecting a header but don't see it (old client, new server), just use a default. It's like having an "Anything else to tell us?" section in a survey.

Error Correction & Reliability

It's the job of lower-level protocols like TCP to make sure data is transmitted reliably. But higher-level protocols (like HTTP) need to make sure it's the right data. How are errors handled and communicated? Can the client just retry or does the server need to reset state?

HTTP comes with its own set of error codes to handle a variety of situations.

Availability

The neat thing about networking is that works on one computer. Memcached is a great service to cache data. And guess what? It uses plain-old text commands (over TCP) to save and retrieve data.

You don't need complex COM objects or DLLs - you start a Memcached server, send text in, and get text out. It's language-neutral and easy to access because any decent OS supports networking. You can even telnet into Memcached to debug it.

Wireless routers are similar: they have a control panel available through HTTP. There's no "router configuration program" -- you just connect to it with your browser. The router serves up webpages, and when you submit data it makes the necessary configuration changes.

Protocols like HTTP are so popular you can assume the user has a client.

Layering Protocols

Protocols can be layered. We might write a resume, which is part of a larger application, which is stuffed into an envelope. Each segment has its own format, blissfully unaware of the others. Your envelope doesn't care about the resume -- it just wants the to: and from: addresses written correctly.

Many protocols rely on HTTP because it's so widely used (rather than starting from scratch, like Memcached, which needs efficiency). HTTP has well-understood methods to define resources (URLs) and commands (GET and POST), so why not use them?

Web services do just that. The SOAP protocol crams XML inside of HTTP commands. The REST protocol embraces HTTP and uses the existing verbs as much as possible.

Remember: It's All Made Up

Networking involves human conventions. Because plain text is ubiquitous and easy to use, it is the basis for most protocols. And TCP is the simplest, most-supported way to exchange text.

Remembering that everything is a plain text IM conversation helps me wrap my head around the inevitable networking issues. And sometimes you need to jump into HTTP to understand compression and caching.

Don't just memorize the details; see protocols as strategies to solve communication problems. Happy networking.

You can’t, not while exponents are repeated multiplication. Today our mental model is due for an upgrade.

Viewing arithmetic as transformations

Let’s step back — how do we learn arithmetic? We’re taught that numbers are counts of something (fingers), addition is combing counts (3 + 4 = 7) and multiplication is repeated addition (2 times 3 = 2 + 2 + 2 = 6).

This interpretation works for nice round numbers like 2 and 10. Strange concepts like -1 and sqrt(2) don’t work. Why?

Our model was incomplete. Numbers aren’t just a count; a better viewpoint is a position on a line. This position can be negative (-1), between other numbers (sqrt(2)), or in another dimension (i).

Arithmetic became a way to transform a number: Addition was sliding (+3 means slide 3 units to the right), and multiplication was scaling (times 3 means scale it up 3x).

So what are exponents?

Enter the Expand-o-tron™

Let me introduce the Expand-o-tron 3000.

Yes, this device looks like a shoddy microwave — but instead of heating food, it grows numbers. Put a number in and a new one comes out. Here’s how:

• Start with 1.0
• Set the growth to the desired change after one second (2x, 3x, 10.3x)
• Set the time to the number of seconds
• Push the button

And shazam! The bell rings and we pull out our shiny new number. Suppose we want to change 1.0 into 9:

• Put 1.0 in the expand-o-tron
• Set the change for “3x” growth, and the time for 2 seconds
• Push the button

The number starts transforming as soon as we begin: We see 1.0, 1.1, 1.2… and just as finish the first second, we’re at 3.0. But it keeps going: 3.1, 3.5, 4.0, 6.0, 7.5. As just as we finish the 2nd second we’re at 9.0. Behold our shiny new number!

Mathematically, the expand-o-tron (exponent function) does this:

or

For example, 3^2 = 9/1. The base is the amount to grow each unit (3x), and the exponent is the amount of time (2). A formula like 2^n means “Use the expand-o-tron at 2x growth for n seconds”.

We always start with 1.0 in the expand-o-tron to see how it changes a single unit. If we want to see what would happen if we started with 3.0 in the expand-o-tron, we just scale up the final result. For example:

• “Start with 1 and double 3 times” means 1 * 2^3 = 1 * 2 * 2 * 2 = 8
• “Start with 3 and double 3 times” means 3 * 2^3 = 3 * 2 * 2 * 2 = 24

Whenever you see an plain exponent by itself (like 2^3), we’re starting with 1.0.

Understanding the Exponential Scaling Factor

When multiplying, we can just state the final scaling factor. Want it 8 times larger? Multiply by 8. Done.

Exponents are a bit… finnicky:

You: I’d like to grow this number.
Expand-o-tron: Ok, stick it in.
You: How big will it get?
Expand-o-tron: Gee, I dunno. Let’s find out…
You: Find out? I was hoping you’d kn-
Expand-o-tron: Shh!!! It’s growing! It’s growing!
You: …
Expand-o-tron: It’s done! My masterpiece is alive!
You: Can I go now?

The expand-o-tron is indirect. Just looking at it, you’re not sure what it’ll do: What does 3^10 mean to you? How does it make you feel? Instead of a nice tidy scaling factor, exponents want us to feel, relive, even smell the growing process. Whatever you end with is your scaling factor.

It sounds roundabout and annoying. You know why? Most things in nature don’t know where they’ll end up!

Do you think bacteria plans on doubling every 14 hours? No — it just eats the moldy bread you forgot about in the fridge as fast as it can, and as it gets more it starts growing even faster. To predict the behavior, we use how fast they’re growing (current rate) and how long they’ll be changing (time) to figure out their final value.

The answer has to be worked out — exponents are a way of saying “Begin with these conditions, start changing, and see where you end up”. The expand-o-tron (or our calculator) does the work by crunching the numbers to get the final scaling factor. But someone has to do it.

Understanding Fractional Powers

Let’s see if the expand-o-tron can help us understand exponents. First up: what does at 2^1.5 mean?

It’s confusing when we think of repeated multiplication. But the expand-o-tron makes it simple: 1.5 is just the amount of time in the machine.

• 2^1 means 1 second in the machine (2x growth)
• 2^2 means 2 seconds in the machine (4x growth)

2^1.5 means 1.5 seconds in the machine, so somewhere between 2x and 4x growth (more later). The idea of “repeated counting” had us stuck.

Multiplying exponents

What if we want to two growth cycles back-to-back? Let’s say we use the machine for 2 seconds, and then use it for 3 seconds at the exact same power:

Think about your regular microwave — isn’t this the same as one continuous cycle of 5 seconds? It sure is. As long as the power setting (base) stayed the same, we can just add the time:

Again, the expand-o-tron gives us a scaling factor to change our number. To get the total effect from two consecutive uses, we just multiply the scaling factors together.

Square roots

Let’s keep going. Let’s say we’re at power level a and grow for 3 seconds:

Not too bad. Now what would growing for half that time look like? It’d be 1.5 seconds:

Now what would happen if we did that twice?

partial growth * partial growth = full growth

Looking at this equation, we see “partial growth” is the square root of full growth! If we divide the time in half we get the square root scaling factor. And if we divide the time in thirds?

partial growth * partial growth * partial growth = full growth

And we get the cube root! For me, this is an intuitive reason why dividing the exponents gives roots: we split the time into equal amounts, so each “partial growth” period must have the same effect. If three identical effects are multiplied together, it means they’re each a cube root.

Negative exponents

Now we’re on a roll — what does a negative exponent mean? Negative seconds means going back in time! If going forward grows by a scaling factor, going backwards should shrink by it.

The sentence means “1 second ago, we were at half our current amount (1/2^1)”. In fact, this is a neat part of any exponential graph, like 2^x:

Pick a point like 3.5 seconds (2^3.5 = 11.3). One second in the future we’ll be at double our current amount (2^4.5 = 22.5). One second ago we were at half our amount (2^2.5 = 5.65).

This works for any number! Wherever 1 million is, we were at 500,000 one second before it. Try it below:

Taking the zeroth power

Now let’s try the tricky stuff: what does 3^0 mean? Well, we set the machine for 3x growth, and use it for… zero seconds. Zero seconds means we don’t even use the machine!

Our new and old values are the same (new = old), so the scaling factor is 1. Using 0 as the time (power) means there’s no change at all. The scaling factor is always 1.

Taking zero as a base

How do we interpret 0^x? Well, our growth amount is “0x” — after a second, the expand-o-tron obliterates the number and turns it to zero. But if we’ve obliterated the number after 1 second, it really means any amount of time will destroy the number:

0^(1/n) = nth root of 0^1 = nth root of 0 = 0

No matter the tiny power we raise it to, it will be some root of 0.

Zero to the zeroth power

At last, the dreaded 0^0. What does it mean?

The expand-o-tron to the rescue: 0^0 means a 0x growth for 0 seconds!

Although we planned on obliterating the number, we never used the machine. No usage means new = old, and the scaling factor is 1. 0^0 = 1 * 0^0 = 1 * 1 = 1 — it doesn’t change our original number. Mystery solved!

(For the math geeks: Defining 0^0 as 1 makes many theorems work smoothly. In reality, 0^0 depends on the scenario (continuous or discrete) and is under debate. The microwave analogy isn’t about rigor — it helps me see why it should be 1, in a way that “repeated counting” does not.)

Advanced: Repeated Exponents (a to the b to the c)

Repeated exponents are tricky. What does

mean? It’s “repeated multiplication, repeated” — another way of saying “do that exponent thing once, and do it again”. Let’s dissect it:

• First, I want to grow by doubling each second: do that for 3 seconds (2^3)
• Then, whatever my number is (8x), I want to grow by that new amount for 4 seconds (8^4)

The first exponent (^3) just knows to take “2″ and grow it by itself 3 times. The next exponent (^4) just knows to take the previous amount (8) and grow it by itself 4 times. Each time unit in “Phase II” is the same as repeating all of Phase I:

This is where the repeated counting interpretation helps get our bearings. But then we bring out the expand-o-tron: we grow for 3 seconds in Phase I, and redo that for 4 more seconds. It works for fractional powers — for example,

means “Grow for 3.1 seconds, and use that new growth rate for 4.2 seconds”. We can smush together the time (3.1 × 4.2) like this:

It’s different, so try some examples:

• (2^1)^x means “Grow at 2 for 1 second, and ‘do that growth’ for x more seconds”.
• 7 = (7^0.5)^2 means “We can jump to 7 all at once. Or, we can plan on growing to 7 but only use half the time (sqrt(7)). But we can do that process for 2 seconds, which gives us the full amount (sqrt(7) squared = 7).”

We’re like kids learning that 3 times 7 = 7 times 3. (Or that a% of b = b% of a — it’s true!).

Advanced: Rewriting Exponents For The Grower

The expand-o-tron is a bit strange: numbers start growing the instant they’re inside, but we specify the desired growth at the end of each second.

We say we want 2x growth at the end of the first second. But how do we know what rate to start off with? How fast should we be growing at 0.5 seconds? It can’t be the full amount, or else we’ll overshoot our goal as our interest compounds.

Here’s the key: Growth curves written like 2^x are from the observer’s viewpoint, not the grower.

The value “2″ is measured at the end of the interval and we work backwards to create the exponent. This is convenient for us, but not the growing quantity — bacteria, radioactive elements and money don’t care about lining up with our ending intervals!

No, these critters know their current, instantaneous growth rate, and don’t try to line it up with our boundaries. It’s just like
understanding radians vs. degrees”:http://betterexplained.com/articles/intuitive-guide-to-angles-degrees-and-radians/ — radians are “natural” because they are measured from the mover’s viewpoint.

To get into the grower’s viewpoint, we use the magical number e. There’s much more to say, but we can convert any “observer-focused” formula like 2^x into a “grower-focused” one:

In this case, ln(2) = .693 = 69.3% is the instantaneous growth rate needed to look like 2^x to an observer. When you enter “2x growth at the end of each period”, the expand-o-tron knows to grow the number at a rate of 69.3%.

We’ll save these details for another day — just remember the difference between the grower’s instantaneous growth rate (which the bacteria controls) and the observer’s chart that’s measured at the end of each interval. Underneath it all, every exponential curve is a scaled version of e^x:

Every exponent is a variation of e, just like every number is a scaled version of 1.

Why use this analogy?

Does the expand-o-tron exist? Do numbers really gather up in a line? Nope — they’re ways of looking at the world.

The expand-o-tron removes the mental hiccups when seeing 2^1.5 or even 0^0: it’s just 0x growth for 0 seconds, which doesn’t change the number. Everything from slide rules to Euler’s formula begins to click once we recognize the core theme of growth — even beasts like i^i can be tamed.

Friends don’t let friends think of exponents as repeated multiplication. Happy math.