[MUSIC] Let's take a look at the roadmap 
for the course what we'll be going 
through over these next eight weeks. 
We're going to start off with the topic 
of memory and data. 
How do we organize data in the memory of 
a computer system? 
And then we're going to move on to, how 
do we represent numbers? 
How do we encode different types of 
numbers? 
both integers and floating point numbers, 
in the bit patterns that we can put in 
memory. 
we'll then turn our attention to how we 
encode instructions, that basically the 
machine code. 
That the CPU will interpret to figure out 
what to do, what data to find in memory, 
where to find it, and what operations to 
perform on that data. 
This these instructions are normally 
represented in an assembly language 
that's a little bit more machine readable 
than those ones and zeros. 
this is one of the languages we'll be 
looking at. 
It's the X86 assembly language for the 
popular Intel processors that are in many 
of our computer systems today. 
However, any assembly language is really 
going to be very similar. 
So, we're hoping this is just a, an 
example of one possible assembly language 
albeit, a very common one. 
We'll then turn our attention to some 
approaches to managing how we keep track 
of our programs and how they're 
executing. 
Namely, what procedures are being 
executed, where a procedure should return 
when it completes. 
And that'll get us into the stack 
discipline, that we use for representing 
that information. 
we'll then turn our attention to 
representing some more complex things in 
memory besides just numbers namely arrays 
of values and structs more complicated 
data structures. 
where multiple values are represented in 
one entity. 
then we'll turn our attention to memory 
and caches. 
So, we'll be looking at memory from the 
point of view of performance. 
How a processor moves the data that it 
needs most often. 
And keeps it close to the CPU. 
By close we mean in a faster access 
memory rather than the slower larger 
memories that we might also have 
available. 
Then we'll turn our attention to two 
important Illusions that are common in 
modern computer systems. 
The first one is the concept of a process 
namely, a program that runs in parallel 
to a whole bunch of other processes. 
And, we have to figure out how to give 
the illusion that each process has full 
control over the processor, so that a 
programmer doesn't have to worry about. 
How to hand off control to another 
process, how to save the state it might 
need. 
All these things are going to be taken 
care of automatically, and this will help 
us touch on a little bit about how 
operating systems handle these things for 
us as programmers. 
The second illusion is, virtual memory, 
namely the ability to think about a huge 
memory that is available to each program, 
when in reality there's only a much 
smaller finite memory available. 
that is way, way smaller than the 
possible memory we may want to use. 
So, this will get us into how do we page 
different parts of memory from disc into 
the physical memory. 
And again, deal with some operating 
systems issues. 
Finally, we'll close the course with some 
issues in memory allocation. 
Namely, how do we decide where we put 
stuff in memory, and how does that impact 
performance? 
And lastly, how do we deal with higher 
level languages, like Java which abstract 
the away a lot of those memory allocation 
issues from us. 
And we'll compare Java to C, which is a 
lower level language, where we actually 
consider each of those memory allocations 
each one in turn and have to free up 
memory when we're done using it. 
Have to keep track of quite a few more 
things, than in a higher level managed 
language like Java. 
So, that's the road map for the course 
and we'll bringing you, we'll be bringing 
you back to this slide over and over 
again at the beginning of each section. 
to give you an orientation of where we 
are as we progress through the course. 
Before we start the first section, I'd 
like to talk about three little themes 
that are part of this course. 
The first one is, representation. 
We'll be coming back to these themes over 
and over again. 
Representation is the issue of how do we 
represent things in zeros and ones. 
And by things or everything, we mean 
numbers, characters, instructions 
pointers namely the addresses of that 
data in memory. 
And we'll be talking about how we do an 
efficient job of representing all of 
these different types of data items. 
the second little theme is, translation. 
namely, how do we go from language to 
language. 
You've heard me talk about a few already. 
I've mentioned Java as a high level 
language C, as a lower level language X86 
assembly language as something being 
closer to the machine code of the CPU. 
Well, to do those translations, as with 
any language, we need to do word by word 
translations. 
We need to do, translation of phrase 
structures, and eventually the larger 
grammar of the language itself. 
So, we're hoping that you know a language 
maybe like Java, as a programming 
language. 
You've seen that in an intro programming 
class, or maybe you've had C already. 
so we'll be talking about those 
languages, and encountering a few of the 
things in between, like Java byte-codes 
as well. 
That'll come near the end of the course. 
lastly, the, the third theme is control 
flow, namely how do computers orchestrate 
the many things they're doing and make it 
look like they're doing them all in 
parallel. 
When in fact, of course, they're only 
executing one instruction at a time? 
So, how do we keep track of where we are, 
when we call a method and then another 
and another and so on? 
what do we do when we hit a return 
statement? 
And how do we give the, the user the 
ability to run multiple programs 
seemingly at the same time? 
So, these are the little themes we'll be 
coming back to again and again throughout 
the course.