What is functional programming?

What is functional programming? In a nutshell, functional programming is programming where we minimize the percentage of functions in our code that have side effects. What is a side effect? A side effect is either accessing random numbers, or accessing a global variable, or doing any kind of I/O.

So why is there a word for this? Well because functional functions are purely deterministic. You can call them up with a set of arguments, get a return value, wait a while, and then call them up with the same set of arguments and be guaranteed to get the same return value. This, as it turns out, is a powerful assumption to be able to make about a function.

If it accesses random numbers then it’s not deterministic. If it takes input then it might return a different result when something giving it that input changes. If it’s doing output then that output operation might fail. If it accesses a global variable then the global variable might have changed since the last time the function was called.

To put it plainly a functional function does not rely on it’s environment. It’s just a subroutine that only takes in arguments, does a calculation, and returns an answer. A functional function just does a computation.

So some of the advantages of it are that functional functions are easier to use. They tend to line up with how we tend to naturally write software. More on that later. There’s less internal state to think about. You don’t need to get a whole environment set up just to call the function. You can just pass the environment to it as an argument.

It’s more consistent so bugs are more reproducible. There’s no need to worry about race conditions. This means it’s easier to debug, and therefore more stable and more secure. It’s inherently thread safe. It’s faster because it makes no system calls. It has less error checking to deal with. It’s more portable because it doesn’t rely as heavily on system specific system calls. It’s also easier to copy and paste the code into a shared library if the project gets too big.

To put it plainly, maximizing the amount of your code that’s functional has nothing but advantages to it. How often in life do we come across something that has nothing but advantages?

If we’re writing a hypothetical project, like for example an image library then don’t write your code like this:

Img getImage(string filename);


Where you write a function that takes a file name as an argument, reads that file, and then returns an image object. This means that the file can only come from the disk, and can’t be directly taken from a network connection.
Instead write your code like this:

Img getImage(byte[] fileContents);
Img getImage(channel byte[] fileContents);

where it takes in either the entire contents of the file as an argument or some kind of channel that spews out the contents of the file one block of data at a time.

Don’t write your blur method like this:

class Img {
        void blur()
        {
                // blur this instance of the image.
        }
}

where you write the method to blur that instance of the image object. Odds are that your user will want to keep the original.
Instead write it like this:

class Img {
        Img blur()
        {
                // code
                return copyOfImageButBlurred;
        }
}

where we return a copy of the image that’s exactly the same except blurred. That’s not as efficient with memory, but we don’t have to be efficient with memory now.

If you’re writing an autopilot then don’t write your code like this:

int main()
{
        // get sensor data
        // react to input
        // get more sensor data
        // react to input some more
}

where we do random stuff in whatever order we feel like.
Instead add some organization to your code by writing it like this:

int main()
{
        state := initializeState();
        while(1) {
                input := getSensorInput();
                state, commands := processInputFunctionally(state, input);
                runCommands(commands);
        }
}

where we initialize the state, and then in a loop we gather sensor data, put that, and the state information into a big function with no side effects, and it will return the new state, and commands for what to do and then we execute those commands. This way the code is more modular. The main code for the autopilot can be cleanly removed and hooked into a simulator for testing.

But there’s more to it than that. Functional programming can be taken up a notch with functional programming languages. There are programming languages specifically designed to be functional.

Let’s look at the first one: Lisp. Lisp is a functional scripting language. In lisp variables are immutable. What does that mean? Remember earlier when I told you to write the blur function so it returns a blurred copy of the image? There’s a reason for that. As it turns out, statistically, most variables are set once and then never written to again. Those variables that are written to again tend to be written to in a loop.

As it turns out you can replace loops with recursion and then do away with having to modify the variable more than once and still be Turing complete.
This way people who read your code can assume that any variable will only be set once. This makes it easier to reason about what the code is doing.

If we’re going to create a language where functions will be called up frequently then we need a new syntax that makes calling functions easier.
And here’s what that looks like.

(sqrt (add (square a) (square b)))

As you can see there’s no need for commas. All arguments are separated by spaces, and the function name goes inside the parentheses.

While that’s certainly nice Lisp lacks an important feature: declarative programming. If we’re going to be writing lots of recursive functions then we need to make that easy to do. Most recursive functions will have some kind of if statement that checks the arguments so it knows when to stop. So why not add some special syntax to do exactly that?

factorial :: Int -> Int
factorial 0 = 1
factorial x = x * (factorial (x - 1))

This is what haskell code looks like. What we do is we declare multiple versions of the function, each of which has its own patterns to the arguments that it’s expecting. Then when we call the function it will try out one pattern after another until it finds one that fits and then it will run the associated version of the function. If you want to write a function that takes the factorial of something you can do that in just three lines of code in haskell.

This is known as declarative programming. In declarative programming we give the computer a set of declarations, and the pose it a query and it uses those declarations to figure out the answer to that query.

We can use pattern matching and declarative programming for more than that. Prolog is a scripting language based on predicate logic. In predicate logic we take the set of everything in the entire universe and use functions that return true or false, known as predicates, to filter out anything that’s not an answer until we get the set of all answers, and we can do so declaritively.

Here’s what that looks like.

is_smart(noah).
is_smart(nate).
is_smart(bob).

We can issue a query to this code through an interactive prompt that will list everyone who is smart. We can also create predicates that use other predicates to filter out invalid answers.

is_smart(noah).
is_smart(nate).
is_smart(bob).
has_computer(noah).
has_computer(nate).
is_programmer(X):- is_smart(X), has_computer(X).

The way this works is through backtracking. Here is a page that explains how that works internally: http://www.amzi.com/articles/prolog_under_the_hood.htm

Prolog has another feature: atoms. An atom is like a string except that it’s, ideally, immutable. Atoms are used as messages that get sent to functions. A lot of large programming projects send information around as strings, so why not make that easier and more efficient? That’s what prolog does. Any identifier that’s not a predicate and that does not start with an uppercase letter is assumed to be an atom.

Atoms show up in other languages as well, like for example erlang.
Erlang is a programming language that was intended to be used for distributed computing systems. It’s functional, concurrent, declarative, and part of it’s declarative nature means it can use atoms to match patterns against incoming messages.

Here we see something like that:

process_http(...) ->
        receive
                {get, ...} ->
                        // foo
                {post, ...} ->
                        // bar
        end.


This erlang function, when it reaches this chunk of code, will check it’s incoming channel for messages, and it will execute code foo if the message is a tuple that starts with the atom ‘get’, and it will execute code bar if it receives a tuple that begins with the atom ‘post’.

Erlang is specifically designed to be THE solution for distributed computing systems. It’s got almost everything you could want, except for buffering.
Erlang channels are unbuffered. It’s very easy to accidentally slurp up a huge file into memory that is too large to fit in memory on the computer that the erlang routine is running on. Unlike in golang where all channels are buffered so as to protect against running out of memory, erlang coroutines can run out of memory when loading a large file.

So how do we solve this problem? Earlier I suggested that we should write functions that load up images by taking the entire contents of the image file as an argument. What if the image is too big to fit into memory?

This is where lazy evaluation comes in. Lazy evaluation allows us to build infinitely large data structures. Lazy expressions are only executed when they’re needed. The way that works is that a function which is pure can be executed later instead of right now because it will return the same result either way.


Haskell is a lazy language. Every expression in Haskell is lazily executed. This enables us to write programs that will naturally process input as much as possible while still reading it. It’s not possible to tell when a chunk of code will be run in a lazy language, but we don’t have to care because it will give us the same result in the end anyways.

fib :: Int -> Int -> [Int]
fib a b = b : (fib (b + a) a)

The above code will return the entire Fibonacci sequence in a list. It returns a cell containing the first argument as the head, and the tail is a data structure which contains a function pointer to fib and the list of arguments.

But what if we have an error lazily loading the image? This is where monads come in. A monad is a thing that we can use to check for errors, and also use it for global variables. Here’s the idea: in C if we have a function that does IO then that IO might fail, so we need to be able to return an error indicator, but the function calling THAT function also does IO because something it called does IO.

Ultimately what we tend to do in real life is either handle the errors if we can, or, more often, just throw the error up one until it reaches the top so the user can deal with the problem. That’s exactly what a monad does. A function which uses a monad in Haskell either returns a successful value or throws something up with an error value.

getImage :: Monad m => ByteString -> m Img
getImage [] = fail "Error: empty file"
getImage fileContents = do
    -- code
    return img
main :: IO ()
main = do
    c <- openFile "file.png"
    i <- getImage c
    foo
    bar

You can also chain together monad functions so that if any step in the process fails then it will just stop right there. You can also use them to chain together functions that access global variables.

I hope that you’ll try out some of the ideas I’ve presented here. No idea should go unchallenged forever, and I think the idea of “truly object oriented” needs to be challenged now. Unlike the vaguely defined idea of truly object oriented, functional programming has a precise definition. With functional programming you can apply this idea to your existing code bit by bit and see some immediate improvements.

It can be slightly hard to get into the habit of doing things in a functional way, but it’s well worth it.

The future is functional.

The Best Intro To Linux I Could Come Up With

I often need to explain to people what Linux is, but I couldn’t find any articles or videos that I think explain what it is sufficiently well. In an earlier blog post I lazily linked to a youtube video that explains how to install Linux mint, but now I’m going to explain it in more depth.

What is Linux?

The short answer is that Linux is an operating system kernel. Most people are unfamiliar with what an operating system is, much less a kernel. So let me explain. An operating system is merely a program, or series of programs that manages the hardware and software on your computer for you. When you download and install a program that program gets registered with the operating system, and when it runs it makes requests to the operating system to do things.

A kernel is just the core program of an operating system. You can’t use just a kernel on it’s own. You need other programs to run with it. There are many operating systems that use Linux. These are called “Linux distributions” You are probably already familiar with Microsoft Windows (which is an operating system), and you may have even used Mac OS X. Unfortunately Apple and Microsoft have created some widespread misconceptions about how operating systems work so let’s clear them up.

Microsoft does not sell computers. They do sell some hardware, but they are a software company first and foremost. Their main product is Microsoft Windows. Most places where you can get computers from sell computers from different various companies (Dell, Toshiba, etc) which have Microsoft Windows already installed. This has led many to believe that Windows is a part of the computer, rather than a program running on it.

Another misconception is the idea of “Mac Vs PC”. Apple released and advertisement campaign where they compared “Macs to PCs” which created the notion that there are only two options. It didn’t help that Apple’s Mac OS X operating system only likes to run on Macintosh computers, and that Apple doesn’t like anything else running on their machines.

Linux is a series of alternative operating systems. There are hundreds of Linux operating systems (AKA distributions, or distros), but the main ones for a beginner are Ubuntu and Linux Mint. Linux distros have the stereotype of being hard to use, so Ubuntu was made by a company called Canonical to be a user-friendly Linux distro; however they were recently accused by many of having lost touch with what their users want (the same old story every time, am I right?).

Thankfully the license that Linux distros are under encourage people to look at the code behind them, modify the code, and then give away the modified version for free, or for a price. The end user license agreements for Windows and Mac OS X say that you can’t do that. Linux’s license encourages that.

How do I get Linux?

Here are the home pages of some Linux distros:

Debian was thrown in there because that’s the one I use. Installing an operating system is different from installing other kinds of programs. You’ll need to download an ISO image, and then burn it to a DVD (like people did in the good old days), or a USB drive (many old computers don’t support this but all the modern ones do).

You might also want to back up all your files, have a Windows install disc, and also have defragmented your drive. The next step will be to reboot, but before we do let’s talk about a little bit of theory here. Your computer uses what’s called a BIOS (Basic Input Output System). When the computer starts it runs the POST (Power On Self Test) where it checks the hardware to make sure it’s not missing anything. At this point it will display the logo of the company that made your computer onto the screen very briefly (unless it’s been configured not to).

In the old days the BIOS would check different things on the computer to see what operating systems it could find. It would start with the DVD, and if there was no DVD then it went on to the hard drive (where Windows was preinstalled). If there was a DVD in the tray really ancient computers would try to run what’s on the DVD as an OS, and if it was actually just a movie on the disc it would give weird errors. Later ones would be smart enough to check if there was an OS on the disk.

Unfortunately, because everyone and their brother was using Windows anyways computer stores would reconfigure the BIOS to start with the hard drive, and only check the DVD tray, or USB drive second. This means that many of the users who have little ability to solve technical problems on their own will have a hard time installing Linux.

When the logo for the company that made the computer is displayed it will tell you to press a button to reconfigure the BIOS (usually F2), most of them will also tell you which button to press to choose which device to boot from (usually F12). Some users need guides that tell them exactly what to do step by step right down to which button to press, unfortunately there’s no universal way to install an OS. You’ll need to have some ability to solve technical problems on your own (though you won’t need very much).

Now we can reboot the computer with the USB stick still in (or the DVD still in the tray). Once we’ve selected the device to boot from Linux will be running and there will be a nice installer that you can follow. You can install Linux so that it’s a replacement for Windows, or you can set up your computer to ask you whether to use Windows or Linux when it starts up (this is called “dual booting”.) The installation process is very simple for Ubuntu and Linux Mint. Debian’s is more advanced, but I have no problem with it.

Once it’s installing it will probably take a while to run, so let’s go over the advantages of Linux. Linux is far more secure than Windows is. You’ll still run into technical problems with Linux, but security won’t be one of them. There’s no need for antivirus software for Linux. Linux is also much faster, and can run on much older hardware.

Unfortunately many of the programs you use on Windows will not run on Linux without WINE. WINE allows Linux to run Windows programs, but it eliminates some of the security Linux has. Thankfully most programs for Windows have Linux alternatives which are very compatible with the Windows versions.

Something you might want for Linux is this: The Linux Command Line By William Shotts

With that you’ll be able to solve technical problems, and automate daily tasks in ways that will make you wonder how you ever managed without it.

The story of wheely bot.

Some time ago I found a video series on how to program robots right here on programming robots, and I decided to try and make one named wheely bot. This is its story.

The first version was pretty simple. I ordered a simple body for it off of the Internet, as well as a motor controller circuit, and two wheel encoders. I used an Arduino uno that I already had laying around and programmed it to rotate itself and adjust its angle based off of what the angle of the wheels were. It knew what the angles of its wheels were based off of the wheel encoders, and it used a PID controller to adjust itself.

Unlike my previous attempts at robots this one didn’t just assume that the wheels had rotated by exactly what it told them to rotate by. Unfortunately there was a lot of wiring going to the Arduino and it began to become a little bit too much. To resolve this I tried buying some small breadboards to attach to the body, and put an Arduino Nano on them to help the Uno and reduce the wiring.

The idea was pretty simple: the Nano would gather sensor data, and use it to figure out what was going on, and the uno would control things and ask the Nano what was going on via I2C. This worked, but I still had a problem that had plagued the robot from the beginning: the wheel encoders weren’t very accurate. They were always up to ten degrees off from what the actual angle of the wheels were.

To fix this I tried getting four sonars, and decided to attach two to each side, and I came up with a math formula that would allow me to figure out what its angle to the wall was given the distances that the sonars were returning. This way it could find a wall and try to adjust itself.

I had even come up with a library for automagically calculating the accuracy of a given number that I got from a calculation.

It was around this time that tragedy struck. I had been using a two rechargeable double A batteries, and a 9v battery to power it because the motor driver need 12 volts to operate, however everything else needed 5 volts, so I had been using a 5v regulator. Unfortunately everything was drawing a lot of current, and that caused the regulator to break, and, weirdly enough, put out more than 5 volts. This fried basically everything.

After some panic over losing potentially everything, I bought two new arduinos, and they broke as well. So I tried buying a DC to DC converter which could offer more current, and not break as easily as well as get some 6v rechargeable batteries that could offer more current.

Since I was tight on money I decided to use a raspberry pi zero that I had laying around as the control brain, and use the new Arduino Uno that I had as the sensor brain/motor controller.

Since programming a raspberry pi zero is different than programming an Arduino I have not yet been able to get all of my original code (located here) to work yet, but I have however added a new feature: unlike the previous wheely bot, the new one has a USB Wi-Fi adapter that connects to my home network, and allows me to remotely login to it, and remote control it.

I’ve finally gotten the remote control program working, as well as the on board camera that I had added to the raspberry pi zero. Now I finally have a remote control toy with an onboard camera like I’ve always wanted as a kid.

You can find the new and improved Wheely bot source codes (“codes” because there’s more than one program) here   ,here, and here.

There’s also a youtube video: here

How Electricity Works: Part 7 Why Some Electrical Sockets Have Three Holes

Earlier in this series I told you how voltage can be thought of like the height that electricity starts at, and that it’s “height” is relative; however height can also be measured as an absolute, and so can voltage.

You can measure the height of a hot air balloon from the center of the Earth if you really want to, but your ruler won’t do that for you unless you can get it to reach the center of the Earth.

Similarly your multimeter won’t measure the absolute voltage unless you attach it to something that actually does have zero voltage. What exactly can have zero voltage? Do insulators have zero voltage? Does a rubber balloon have zero voltage? Not if you rub it against your hair.

Voltage is what comes from charge. Whenever you have charge you have voltage, and whenever you have voltage you have charge. If high voltages can kill you by putting too much current through your heart, then that means that too much charge can kill you.

Electrons and protons are dangerous little things. A small amount of them (like the amount in a charged balloon) isn’t enough to hurt you, but if there’s too much then that can cause problems. The problems come from the fact that having too many charged things (like electrons or protons) in a small space without an opposite charge to cancel them out will cause the voltage at any point near them to be too high.

This is sort of like how having too much mass in one spot will cause their gravity to become stronger.  So how do you get those electrons/protons apart so that they’re not so concentrated and don’t have so much voltage? You let them enter a big conductor. Remember: like charges repel. If a bunch of electrons are all close to each other then they’re trying to get away from each other; however they can only move through conductors.

If you hook up a giant conductor to your giant, charged, helium balloon of death that is, for example, the size of the Earth then that will neutralize the threat. This is why any electronic with a metal case that plugs into the wall has a third prong on it.

That third bit of metal connects the metal case straight into the ground because the ground conducts electricity. If part of the circuit that connects directly to one of the two metal prongs on the plug touches the metal case, then the charge from the outlet will go into the ground, and hopefully not hurt you when you touch the metal case.

How Electricity Works: Part 5: The Resistance

In the last post I talked about power, now let’s talk about how to figure out how much power a circuit uses. Pretty much any circuit out there can be thought of as being sort of like one big resistor. It has a resistance. The resistance of a circuit can vary depending on really anything we want it to vary on, but the same rules still apply: if we put a voltage across it, then:

Where E is the voltage, I is the current, and R is the resistance of the circuit. Remember: electrons are like rain drops falling from the sky. As they lose height (voltage) at a certain speed (current) they release energy over time. The amount of power they give off is equal to the height they start at (voltage) times the rate at which they lose it (current).

In other words:

Since

and
then

Isn’t math fun? If you’re as awesome as I am then you can just look at that formula and tell that the higher the resistance, the less power it will use (for a voltage source). If the resistance is too low then it will use a lot of power. In other words it will be pulling energy out at a fast rate. Where does that energy go? Well it depends on what kind of circuit this is, but if it’s just a plain old resistor then it’s being lost as heat, and if too much heat is coming out of it then it might explode.

All resistors have their own rating for how much power they can safely handle before they abuse it explode. But not to worry, we can protect it with another resistor.

Like this:

voltage-divider

I’m the best at drawing stuff.  So R1 might be our big, bulky resistor, while R2 might be our small, wimpy one. To calculate how much power is going through each (since we’re so concerned about it) we just calculate the current going through each, and multiply it by the resistance across each one.

Since they’re in series that means that the current through both of them is the same, and that their resistances add up. So:

And for the voltages: they’re the current multiplied by the voltage.

This is known as the voltage divider rule. Note that for any number of resistors in series each one will be “dropping” a voltage (i.e. it will have a voltage across it), and that the voltages across all the resistors add up to V. Also note that the biggest resistor gets the most voltage, and therefore the most power.

To get the power we just multiply that by the current we calculate earlier (which is a long formula to write out).

How electricity works. Part 6: voltage and current sources.

One of the things that confused me about current was how batteries would specify a current on them even though the current is supposed to vary depending on the resistance based on ohm’s law.

So here’s how that actually works: there are two kinds of electrical power supplies: voltage sources, and current sources. Ideally voltage sources always offer the same voltage across them regardless of how little resistance you put across it, and ideally a current source will push the same current through a circuit regardless of how much resistance the circuit has.

If you place a really high resistance across a voltage source then the current going through the resistor will be low, an thus there will be very little power being used, and if you place a high resistance across a current source then the voltage across the resistor will be really high, while the current remains constant so it would be using quite a lot of power.

However in real life we don’t have ideal voltage and current sources. In real life voltage sources can be thought of as being like this:

real-voltage-source

As you can see a real voltage source is basically an ideal voltage source but with a resistor in series with it. This resistance is usually pretty low, but it means that if you short out the circuit then the voltage between the two terminals is zero. Also if you put too small of a resistance across it then the voltage goes down as the internal resistor of the voltage source is dropping almost all of the voltage.

If the current that your circuit is drawing is above the current that the power source specifies then that will blow up that resistor and/or the battery, or at the very least the voltage will drop.

In addition to voltage sources having a secret resistor, current sources have one too.

real-current-source

Usually the internal resistance of a current source is pretty high. What this means is that if you put a resistor across its terminals that has too high of a resistance, then you won’t get very much current because more of that current can go through the internal resistor.

Every power source has these flaws. Whether they’re batteries, electrical outlets, power adapters, solar panels, or whatever other crazy sources of electrical energy we come up with.

How electricity works part 4: power

When most people hear the word power they probably think of this:

Or they might think of the idea of “energy”, but energy and power are actually two different things. Energy is defined as the ability to do “work” which in physics is a force that is done over a distance that is parallel to the force.

Basically: energy is the ability to do stuff. Power is the rate at which energy is transferred from one thing to another. Energy is measured in Joules, and power is measured in watts, and one watt is equal to one Joule being transferred per second.

This is relevant to electronics because electrical devices like light-bulbs have a rating telling you how much POWER it uses. A light-bulb that is left on overnight will use more energy than one that is left on for an hour, so the light-bulb manufacturers tell you how much power it will use, and let you figure out how much energy it will use given how long you want it to run.

They could probably tell you how much energy it will use, but that would imply that it was engineered to burn out after using a specific amount of energy, and that would be unethical. The power companies do however keep track of how much energy you’ve used. They keep track of it not in “joules” but in kilowatt-hours. Basically one thousand watts being used for one hour which is equal to 3.6 million joules (a joule is not a lot of energy).

It’s also important to understand that the power that a circuit uses is the current going through it multiplied by the voltage across it. So in other words the electrons are losing energy as they “fall”, and the voltage (or “height”) indicates how much energy they had initially, and the current (or “rate of falling”) indicates how quickly the energy from that electron is extracted and used for whatever you were hoping to do with it.

Therefore if you have a circuit with a low resistance, and you put a high voltage across it it will start to use a lot of power. This might not always be a bad thing though. Sometimes using a lot of power can be a good thing. If I built a machine for picking up big heavy boxes then I’d like the motors to be able to be able to use a lot of power so that it can pick up the heavy box more quickly. Or maybe I have a light-bulb, and I want it to be REALLY bright, so I want one that uses a lot of power because that means it can use a lot of energy very quickly for being bright.

It’s important to understand: efficiency is what’s important. I don’t want to buy a light-bulb that uses a lot of power yet doesn’t make a lot of light (presumably it just heats up a bunch). That would be a ripoff. Unfortunately the light-bulbs that can use a lot of power without dying tend to be very inefficient, while the light-bulbs that are really efficient can’t have a lot of power going through them or they die.

This is true of not just light-bulbs but pretty much everything. Machines that are powerful enough to move mountains tend to be inefficient at doing so.

How electricity works part 3: ohm’s law.

Because I didn’t understand voltage growing up I kind of rejected the idea of ohm’s law when I learned it because it didn’t make sense to me. I misunderstood voltage as being the rate that electrons flow through a wire, but apparently that’s what current is too?

Now I finally understand how it works: voltage is the “height” that the electrons are at, and current is the rate that they “fall down”. Current is measured in amps, and one amp is equal to one coulomb of charge going through the device per second.

Also pretty much everything has “electrical resistance” in addition to mass, charge, density, and those kinds of things. Whenever you put a voltage across some particular thing, the electrons will “fall down” through that material, and the rate of falling is the called the current.

The object that the current is going through is sort of like the atmosphere of a planet, I guess. It slows things down. Resistance is kind of like the thickness of that atmosphere. So when a voltage is placed across something, a current will pass through it, and the following formula will apply:

where E is the voltage (short for “electromotive force” because obviously), I is the current, And R is the resistance. Many people get confused about the cause and effect here: “So putting a voltage across something causes the current to happen afterwards?” You might be saying to yourself, out loud, in a room full of people.

Try not to think of it as so much “cause and effect” but more as “any time there is a voltage across a resistance there will be a current, and any time there is a current going through a resistance there will be a voltage, and any time there’s a current traveling across a voltage there will be a resistance between the two”.

Basically the current and the voltage happen pretty much simultaneously. To fully understand this try playing around with the math to see how all of this works out with different resistances, currents, and voltages.

Here are a few handy things to keep in mind: if you have some kind of hypothetical electrical device that is supposed to have a resistance (like some kind of “resistor”) then placing two of them in series doubles the amount of resistor that the electrons have to fall through, and therefore doubles the resistance. The resistances add up when the are put “in series” like this:
series

Meanwhile putting them side by side with each other will cut the resistance in half because if the voltage across them is the same, then they each have the same amount of current going through each of them. This means that all together they have twice as much current going through this whole circuit than if there was only one of these things. Twice the current with the same voltage means half the resistance if you do the math.

For any number of resistors “in parallel” like this the following rule will apply:

parallel

R is the total resistance of the circuit, and R1, R2, R3, and so forth are the resistors in parallel.
This means that as you add more resistors in parallel the resistance of the entire thing goes down. Adding something with a big resistance in parallel causes it to go down less than putting something with almost no resistance in parallel because math.

This is important because it means that although a single circuit (like just one resistor) might have a big resistance, and therefore not use much current, it can still be a part of a much bigger circuit that has a lot of parts, and therefore, as a whole, has very little resistance and uses a lot of current.

So in other words all circuit have a resistance, and will have a current going through them when a voltage is placed across them, and the same is true for any circuit that this circuit is made of.

Note that the resistance that a circuit has can change, and so can the current going through it, and the voltage across it; however ohm’s law will always be true for that circuit no matter what the situation.

How electricity works. Part 2: voltage

When I was growing up I would often read through a bunch of explanations on electricity that always described voltage as “being like electrical pressure”. Now I understand what voltage is, and I still have no clue what that was supposed to mean. Here’s what voltage actually is, but first an analogy:

Electrical charge is sort of like gravity. If you have a positive charge and a negative charge, and hold them some distance away from each other there will be potential energy stored in the distance they are from each other. They want to go to each other, to hold that charge in her arms and say “I love you” before they kiss and the credits role, but sadly the charges cannot meet as cruel fate (i.e. me trying to explain something) is holding them back, but as soon as I let go then all of that potential energy will become kinetic energy as they smash into each other.

Since charge is like gravity, we can use gravity as an analogy for things. If you have a ball that you’re holding in the air then the ball “wants” to go down. The ball has potential energy which is equal to its weight times the height it is at. We can describe the potential for potential energy from gravity at any point in the universe by multiplying the pull of gravity at that point by that points height.

On Mars there’s some point off the ground where you could have precisely: a lot of energy if you were to drop a bowling ball from that height, but you’d have a lot less energy if it was a tennis ball. What I’m talking about is a number that you multiply by the mass of the object in question to get the amount of potential energy it would have if it was held at that point, which is a great way of measuring how dead you would be if you fell from that point. This hypothetical measurement could be taken at any point around any planet.

Why is this relevant? Because we have this exact sort of thing with charge. It’s called “voltage”. Voltage is the amount of potential energy at a point per the amount of charge you could put at that point.
Five volts is equal to five joules of energy for every coulomb you could put there.

Now that I’ve explained that it’s time to introduce you to Mr. Multimeter:
IMG_20150708_165905

This is Mr. Multimeter. As you can see he has googly eyes because of course he does. Mr. Multimeter has two wires that come off of him. One of these wires is black, and the other is red. Mr. Multimeter can measure the voltage between these two wires. Let that sink in for a second. That might sound like it doesn’t make sense, but consider this:

If we have a hot air balloon that’s a kilometer up, then it’s a kilometer up from the ground. That’s what people mean when they say “5000 feet in the air”. They are measuring feat from the ground and not the center of the Earth. In other words: height is relative. Much the same voltage is relative.
Mr. Multimeter measures voltage from the “ground” (i.e. the black wire) to whatever voltage is at the red wire.

When a circuit makes “5 volts” at one of its outputs it makes it 5 volts from the ground. If two circuits don’t have the same “ground” (i.e. they are at different “heights”) then 5 volts to one circuit is a different voltage to another circuit; however hooking their grounds together makes them the same ground.

That said here’s a word of warning: be careful about hooking the grounds together of two things that both plug into a wall for energy. Often the ground of one device can be traced directly back to one of the metal prongs on the plug that goes into the wall.

Here’s a crudely drawn illustration made with professional image editing software to help explain:
the-grounding-problem-explained

Most devices that the normals use don’t connect their “grounds”. As such many of the AC to DC converters they use just hook the ground of the device directly up to the outlet. So if two grounds are connected for two things that plug into a wall then you might short out the electrical outlet.

How electricity works. Part 1: charge

After checking through the posts I’ve made I found out that I haven’t yet explained one of the things that most
confused me growing up: electricity. So I will be attempting to explain how electricity works in a way that I think might be more helpful.

First let’s talk about charge.
When people hear the word “atom” they probably think of this:
atom

“You’ve got your proton in the center, and your electron orbiting around it, and the proton has a positive charge, and the electron has a negative charge.” -Every teacher ever.

“Wait, am I supposed to know what this “charge” thing is? ” -My thoughts when I heard this as a child.

Charge is sort of like mass. All things in the universe have mass. If you have something in front of you then that has mass, and density, and volume, and a bunch of other things that describe it. Mass, and density, and volume aren’t things that exist inside of something (or at least I don’t think they do) they are properties OF that thing, and the same can be said of charge.

All things have a charge, but unlike mass, and volume, and density, the charge of an object can not only be zero, but it can be negative. Most objects we usually deal with have little to no charge because the world ordinary people live in is boring, and by extension they are too. because then things would be flying all over the place all the time.

Here’s some facts about charge:
*The standard unit for charge is the coulomb.
When two positively charged objects are close to each other one will be pushed away with a force equal to this:

K is coulomb’s constant, Q1 is the charge of the first object, Q2 is the charge of the second object, and r is the distance between their centers. It’s a lot like Newton’s formula for gravitation, except that the constant is way higher.

The first object will feel this force pushing it away from the second object, and the second object will have the equal and opposite force pushing it the other way as depicted in my crudely drawn diagram:

Two blue circles with black arrows that point outwards.

The same is true for two negatively charged objects, and a positive object will be attracted to a negative object with the same force, and vice versa.

So in other words: like objects repel, and unlike items attract.