So yesterday, you'll recall that we focused on these topics here.

So we had four overarching topics-- privacy, security, and society;

internet technologies; cloud computing; and ultimately, web development.

>> Did anyone have the bandwidth or the time

to watch a little John Oliver last night?

It's actually pretty amusing, if not a little frightening.

Any questions on anything we did yesterday?

Any clarifications?

Any questions that you want to make sure we touch on today in some form?

So clean slate.

>> So what's on the agenda for today?

So I thought we'd begin today with a look at what's generally

known as computational thinking-- at the risk of oversimplifying, thinking

like a computer, perhaps thinking like an engineer,

and trying to start to organize your thoughts

or to give you a better sense of what's involved in actually commanding

a computer to do something by way of programming.

And we'll keep it at a pretty high level, pretty much English,

but try to use of familiar examples to formalize how

you would go about solving problems.

>> And we will revisit some CS topics, like abstraction,

which came up a couple of times yesterday,

algorithms, and then representation.

And that's where we'll begin today in just a moment.

Then we'll take a look at programming.

We'll take a look at some fundamental constructs

with which you might be familiar and might even find quite intuitive.

>> We'll look, in fact, at a sample programming

environment that's very accessible, very playful, and indeed targeted

for ages 12 and up.

We will spend a few minutes there and then take things to a lower level

and actually talk about some of the algorithms and data structures,

so to speak, that programmers typically use

to solve problems far more efficiently than you might

be able to do without them altogether.

Then after lunch, we'll take a look at technology stacks, which is just

a fancy way of saying collections of technologies

that you might use to solve some problem.

And we'll talk about the alphabet soup of languages that exist today--

Java and Python and C++ and PHP and Ruby and all sorts of other things.

>> We'll take a look briefly at design patterns.

Programmers, over time, have adopted methodologies

that tend to help them solve problems more readily.

When you start to see yourself writing the same kind of code again and again,

people formalize those repetitions and ascribe names to them

and then use them and promote them, ultimately.

And we'll talk a little bit about mobile strategies,

like what does it mean to actually make a mobile app or a mobile website.

Do you do it for Android?

Do you do it for iOS?

Do you do it for both of those?

And what are the trade-offs?

And then finally, we'll take a look web programming, which

is a collective term really describing any time

you write software that's meant to run on the web,

whether on phones or desktops or laptops.

We'll take a brief look at databases and the design

therein, if only because almost any interesting web-based application

these days has some kind of database.

Otherwise, it would just be static content.

And a database allows you to make changes over time, whether yourself

or from users.

And we'll consider how you would go about designing

that database and the kind of jargon that might come up in an engineer's

discussion at a white board when actually implementing

an app for the first time.

>> We'll talk briefly about APIs, useful services

that you can use to stand on the shoulders of others, whether companies

or individuals, and solve your own problems more quickly.

And then we'll dabble perhaps a bit with JavaScript,

a programming language that's used both in browsers these days, but also

in servers.

And perhaps, we'll revisit, time permitting,

some of the hands-on web stuff we did yesterday and integrate the two

together before we adjourn.

>> So with that-- what's ahead-- is there anything missing that you

would like to make sure we insert and touch on at some point.

If it's springs to mind, bring it up before long.

But why don't we begin with a look at computational thinking.

>> And let me propose that computational thinking is, again,

sort of the high level description of what a computer scientist might do.

And indeed, let's start with three ingredients that

might go into computational thinking.

This is just one way of describing it.

We could certainly define this in any number of ways.

>> But let me propose, for the sake of today,

that the world's problems, all of the world's problems,

when approached by a computer scientist could

be viewed as what we'll call inputs, which

need to get fed into what we'll call algorithms, which then yield outputs.

In other words, the entire world of problem-solving I claim

can be distilled into these three ingredients.

So what do I mean by inputs?

Inputs is just what you're handed in order to solve.

>> For instance, here's an old school problem.

If I have a phone book here and I want to look something into it,

this is my input.

I have 1,000 or so pages in a phone book.

This is the input to my problem.

And I want to find something like Mike Smith, so a friend

whose name and number is hopefully in this address book.

>> This is before the days of cell phones, so I can't just search for it.

So I have to do it old school and actually search

these inputs for some answer.

And that answer is just going to be called the output.

So the input is the phone book.

The algorithm is whatever set of steps I use to find Mike Smith.

And the output is, hopefully, Mike Smith's phone number.

And this then would be just representative of most any problem

to with you are handed inputs and want to produce outputs.

>> So before we consider the process by which we can solve that problem,

finding Mike Smith and something like that,

let's consider the first and the last-- inputs and outputs.

Physically, of course, the input here is a whole bunch of paper glued together

in the form of a phone book.

But computers, of course-- laptops and desktops and even phones

these days-- those are electronic devices.

>> And at the end of the day, what's the only input to a computer?

Well, it's something like this power cord here.

I plug it into the wall, and I get a flow of electrons,

which allows me to run the machine.

Or maybe those electrons are created by way of my battery.

But at the end of the day, that's the only thing going into my laptop.

And so much interesting stuff is ultimately

coming out, whether by way of the printer

or the screen or audially or the like.

>> So if all we have as our fundamental input to a computer

is electricity, so just electrons going in and or out,

and so how can we use that input to actually represent information?

In other words, how do we get from a simple flow of electricity

to representing actual numbers or actual letters

or actual images on the screen or actual movies or e-mails

or any number of these higher level concepts,

if you will, that at the end of the day somehow

have to be stored in this electronic mechanical device

using only those simple ingredients-- electrons coming in and out?

>> So it would seem that, in the simplest form,

the only kind of states I have in my world, so

to speak-- conditions in my world-- is either

I have electrons flowing, electricity flowing, or I do not-- so on, off.

And let's formalize on and off, as a computer scientist might,

with just 1 and 0.

Let's just describe some arbitrary but consistent number to it.

1 means on, 0 means off.

Or you might also view this as true means on and false means.

You could also do black and white or red and blue.

You just need two descriptors.

And a computer scientists would generally just use 0 and 1.

>> So if that's the case, my only alphabet is consisting of 0's and 1's, how

could I possibly get to even the number 2 in a computer, let alone the number 3

or a letter of the alphabet or an image or a movie?

How do we sort of bootstrap ourselves from this basic principle

of 0's and 1's and actually represent something more interesting?

>> Well, let's put that question on hold for just a moment

and consider something hopefully familiar,

even if you haven't really thought about it in any detail for 10, 20, 30, 40, 50

more years.

This is what?

How would you pronounce that?

Not a trick question.

A number, but what is it?

1, 2, 3, or 123.

And I liked how you said 1, 2, 3, because that's one way of viewing it.

1, 2, 3, it's a sequence of three symbols.

It's pictures that we now have words for.

And if you sort of read them all together, a typical human in English

would say 123.

And that's sort of a higher level concept,

feels like a reasonably big number.

>> But how did we get there?

Well, it might be a while since you've thought about it like this,

but back in my day, I kind of learned this

as the 1's column, the 10's column, and the 100's column.

So as Lakisa says, it is 1, 2, 3, but it's also 123.

But how do we get from the former to the latter?

>> Well, you would typically do in the 100's column, I have a 1.

So that's like saying 100 times 1.

And then in 10's column, I have 2.

So that's like saying 10 times 2.

In the 1's column, I have 3.

So that's like saying 1 times 3.

>> And if I add these things together, this, of course,

is 100 plus the 10 plus 3.

And oh, that's why I get this higher level notion of 123.

It's just basic math, whereby these symbols have weights to them, if you

will, placeholder or column values.

And once I multiply everything out, I get this number.

>> So how many of you know how to speak binary-- 0's and 1's-- like a computer?

OK, perfect, no one, or none of you think you do.

But I would claim you actually know this already.

We just need to sort of tweak our mental model a little bit.

But the process is exactly the same.

>> Let me leave this one up there and instead pull this down for a moment.

In the world of computers, we only have 0's and 1's.

And so the thing that's going to change is what?

Well, in my human world, the decimal system, dec meaning 10,

I have how many digits at my disposal?

10, right?

0 through 9, of course.

>> And that's why we have the 10's place and the 100's place.

Where is that coming from?

Well, this is 10 to the power of 0.

This is 10 to the power of 1, 10 to the power of 2, and so forth.

You just keep multiplying your columns by 10, starting off with just 1

in the rightmost one here.

>> So in the world of computers, if you only

have binary-- bi meaning 2-- or 0's and 1's, we just

really need to change the base of that math.

So in other words, now we'll just have the 1's column and the--

where is this going-- the 2's column, the 4's column, and maybe beyond.

Why is that?

Well, this is 2 the 0-th power.

This is 2 the 1.

This is 2 to the 2, and so on.

>> So whereas here, we have 1, 10's, 100's, 1,000's, 10,000's, 100,000's, 1

millions, and so forth, here we have 1, 2, 4, 8, 16, 32, 64.

You just keep multiplying by 2, instead of keep multiplying by 10.

So now, if the goal at hand is to represent

numbers using only 0's and 1's, let's consider how we get there.

>> This, of course, is the pattern 0 0 0, but what number conceptually

does it represent?

Well, 4 times 0 plus 2 times 0 plus 1 times 0, let's add those together.

4 times 0 is, of course, 0, plus 2 times 0 is, of course, 0 plus 1 times 0

is, of course, 0.

So ah, this represents the number we humans know as 0.

>> Well, now, let's very quickly fast forward.