Learn the fundamentals of Computer Science with a quick breakdown of jargon that every software engineer should know. Over 100 technical concepts from the CS curriculum are explained to provide a foundation for programmers.

#compsci #programming #tech

🔗 Resources

- Computer Science https://undergrad.cs.umd.edu/what-computer-science
- CS101 Stanford https://online.stanford.edu/courses/soe-ycscs101-sp-computer-science-101
- Controversial Developer Opinions https://youtu.be/goy4lZfDtCE
- Design Patterns https://youtu.be/tv-_1er1mWI


🔥 Get More Content - Upgrade to PRO

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font

🔖 Topics Covered

Turning Machine
CPU
Transistor
Bit
Byte
Character Encoding ASCII
Binary
Hexadecimal
Nibble
Machine Code
RAM
Memory Address
I/O
Kernel (Drivers)
Shell
Command Line Interface
SSH
Mainframe
Programming Language
Abstraction
Interpreted
Compiled
Executable
Data Types
Variable
Dynamic Typing
Static Typing
Pointer
Garbage Collector
int 
signed / unsigned
float 
Double
Char
string
Big endian
Little endian
Array
Linked List
Set
Stack
Queue
Hash
Tree
Graph
Nodes and Edges
Algorithms
Functions
Return
Arguments
Operators
Boolean
Expression
Statement
Conditional Logic
While Loop
For Loop
Iterable
Void
Recursion
Call Stack
Stack Overflow
Base Condition
Big-O
Time Complexity
Space Complexity
Brute Force
Divide and conquer
Dynamic Programming
Memoization
Greedy
Dijkstra's Shortest Path
Backtracking
Declarative
Functional Language
Imperative
Procedural Language
Multiparadigm
OOP
Class
Properties
Methods
Inheritance
Design Patterns
Instantiate
Heap Memory
Reference
Threads
Parallelism
Concurrency
Bare Metal
Virtual Machine
IP Address
URL
DNS
TCP
Packets. 
SSL
HTTP
API
Printers
2024-02-04T05:27:32.728Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
eeeb72db-8071-4e20-bda5-155c02c58c07
9c6a0c7585d2641ec9e087582268de9f831f3bfa802199d309cdc8280c8d4952
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
What's the first thing you should do when your code throws an error?
Obviously, you should change nothing and try to run it again a few times.
If that doesn't work, you're gonna need a computer science degree.
The awesome thing about software engineering is that you can learn to code and get a high paying job, while literally having no idea how anything actually works.
It all just feels like magic.
Like a pilot driving a giant metal tube in the sky while knowing
nothing about aerodynamics.
Mother of God, no.
Holy shit.
Shit.
Welcome to computer science 101.
In today's video, you'll learn the science behind the garbage code you've been writing by learning 101 different computer science terms and concepts.
This is a computer.
It's just a piece of tape that holds ones and zeros along with a device that can read and write to it.
It's called a Turing machine and in theory, it can compute anything, like the graphics in this video or the algorithm that recommended that you watch it.
At the core of modern computers, we have the central processing unit.
If we crack rack it open, we find a piece of silicon that contains billions of tiny transistors, which are like microscopic on off switches.
The value at one of these switches is called a bit end is the smallest piece of information a computer can use.
However, 1 bit by itself is not very useful, so they come in a package of 8 called a byte.
1 byte can represent 250 6 different values, like all the characters that you type on your keyboard.
In fact, when you type into your keyboard, the character produced is actually mapped to a binary value in a character encoding like ASCII or utf8 binary is just a system for counting, like the base ten system you normally use when counting seeing on your fingers, but it only has 2 characters, 1 and 0.
Humans have a hard time reading binary, so most often it's represented in a hexadecimal base 16 format, where ten numbers and 6 letters can represent a 4 bit group called a nibble.
As a developer, when you write code in a programming language, it will actually be converted into machine code, which is a binary format that can be decoded and executed by the CPU.
What it doesn't do though is store data for your applications.
For that, computers have random access memory or RAM.
It's like a neighborhood, and inside of every house lives a byte.
Every location has a memory address, which the CPU can read and write too.
You can think of the CPU and RAM as the brain of the computer.
But in order for a computer to be useful, it needs to handle input and output.
An input device might be the keyboard and mouse, while an output device might be your monitor.
Luckily, most developers don't need to worry about how this hardware fits together because we have operating system kernels, like Linux, Mac, and Windows that control all hardware resources via device drivers.
Now, to start hacking on the operating system, your first entry point is the shell, which is a program that is the operating system to the end user.
It's called a shell because it wraps the kernel.
It takes a line of text as input and produces an output.
At this is called a command line interface.
Not only can it connect to your own computer, but with the secure shell protocol, it can also connect to remote computers a network.
Now that you have access to the mainframe, it's time to pick a programming language, which is a tool that uses the abstraction principle to make computers practical to work with for humans by simplifying different systems layer by layer.
Some languages like Python are interpreted.
That means there's a program called an interpreter that will execute each line of code 1 by 1.
Other languages like c plus plus are compiled.
They use a compiler to convert the entire program into machine code in advance before the CPU attempts to execute it.
This results in an executable file that can be run by the operating system without any extra dependencies.
Now every every programming language has a variety of built in data types to represent the data we're working with in our code.
Instead of bytes, we work with more human friendly things select characters and numbers.
Now, the most fundamental way to use data in your application is to declare a variable.
This attaches a name to a data point, allowing you to reuse it somewhere else in your code.
Python is a dynamically typed language, which means we don't need to tell the program exactly which data type is assigned to a variable.
It just figures it out automatically.
However, other languages like C are statically typed, and that means you need to specify the data type of a variable in your code.
When you define a variable, its value is stored somewhere in memory on the hardware, and you may need to allocate and free up memory already throughout the program.
A pointer is a variable whose value is the memory address of another variable, which can be used for low level memory control.
Many languages don't want to deal with low level memory management and instead implement a garbage collector, which automatically allocates and deallocates memory when an object is no longer referenced in the program.
Carpet day.
No.
Now, the data types available are different in every programming language, but typically you'll find int to represent whole numbers, switch may or may not be signed or unsigned to represent negative numbers as well.
When numbers require a decimal point, they typically use the floating point type.
It's called a float because there's only enough memory to represent a certain range of numbers at a certain precision, and is basically a form of scientific notation to make computers faster.
If you need more range or precision, many languages also have a double that doubles the amount of memory used for the number.
Now when it comes to characters, you'll typically find the char data type to represent a single character or more commonly a string to represent multiple characters together.
Ultimately, these characters triggers get stored in a memory address somewhere, but they need to be stored in a certain order.
When the order starts with the most significant byte and the smallest memory address, it's called big endian or vice versa, if the least significant byte is stored in the smallest address, it's called little endian.
When it comes to practical software for engineering.
One of the most fundamental things we do is organize data into data structures.
The most useful data structure is probably the array or list.
Just like a shopping list.
It organizes multiple data points and order.
However, it also maintains an index of integers that starts at 0 and goes up for every new item in the list.
That can be useful, but you don't actually need an index to create a list of items.
Another option is a link list where each item has a pointer to the next item in front of Another option is a stack that follows the last in first out principle.
It's like stacking a set of plates, then when you want to access data, you pop the last one off the top.
The inverse option is a q, which is first in first out.
Just like when you get into the breadline, the first person there is the first one to be fed.
Now, another extremely useful data structure is the hash, which might also be called a map or dictionary.
It's like an array, but instead of an index of integers, you define the keys that point to each individual item, giving you a collection of key value pairs.
In many cases though, it's not efficient to organize data in a linear way.
To address that problem, we have trees, which organize nodes together in a hierarchy that can often be traversed more quickly.
This can sometimes be too rigid of data structure though.
So instead, a graph can be created to connect multiple nodes together in a virtually unlimited number of ways.
A graph has a node for the data and an edge for the relationship between the data points.
Data structures are essential, but they don't do anything by themselves.
To do something useful, you'll need to code up an algorithm, which is just code that solves a problem.
I took the initiative in creating the Internet.
In our code, we have several mechanisms for implementing algorithms.
The most fundamental of which is a function, which is a block of code that takes an input then does something and returns an output.
Like a variable, a function has a name and it can called from other parts of your code with different input parameters called arguments.
One thing you might do in the function body is compare one value to another.
Every language has a variety of built in operators like equality, greater than, and less than that you can use to compare 2 values.
If a is greater than b, then it forms a value of true, but if b is greater than a, then the value is false.
True false is what's known as a boolean data type and whenever your code produces value like this, it's known as an expression, but not all code will produce a value.
Sometimes your code will simply do something which is known as a statement.
A good example is the if statement which handles conditional logic.
For example, if the condition is true, it will execute this code, otherwise it will short circuit and run the code inside of the else block.
Another very common type of statement is a loop.
A while loop will run this block of code over and over again until the condition in the parenthesis becomes false.
That can be useful, but more often than not, you'll want to loop over an iterable data type like an array.
Most languages have a for loop that can run some code for every object in the array or iterable data structure.
Now in some cases, a function may not have an output, which is generally called a void function.
An interesting thing about functions is that they can call themselves.
When a function calls itself, it's called recursion because when done like this by default, it will recurse forever creating an infinite loop.
That happens because when you call a function, the programming language will put it into memory on what's known as the call stack, which is a short term chunk of memory for executing your code.
When a function keeps calling itself, the language will keep pushing frames onto the call stack until you get a stack overflow error.
To avoid this, your algorithm needs a base condition so it knows when to terminate the loop.
Now, when you write an algorithm, you'll need to determine if it's any good, and the system for doing that is called big o notation.
It's a standard format for approximating the performance have an algorithm at scale.
It may reference time complexity, which is how fast your algorithm will run, and space complexity, which deals with how much memory is required to run it.
Developers have many different algorithm types at their disposal.
The most crude option is brute force, where you might loop over every possible combination to hack somebody's credit card pin.
A more sophisticated approach might be divide and conquer, like binary search where you cut the problem in half multiple times until you find what you're looking for.
Another option is dynamic programming algorithms, where a problem is broken down into multiple smaller sub problems and the result of each computation is stored for later use using a technique called memoization.
That means if a function has already been called, it will use the existing value instead of recomputing it again from scratch.
Then we have greedy algorithms that will make the choice that is most beneficial in the short term without considering the problem as a whole.
One example of this is Dijkstra's shortest path algorithm.
On the flip side, we have backtracking algorithms, which take a more incremental approach by looking at all the possible options, like a rat in a maze exploring all the different potential paths.
Now, when it comes to implementing your code, there are always multiple ways to get the job done.
One aiming paradigm is declarative, where your code describes what the program does and the outcome, but doesn't care about things like control flow.
This style of programming is often associated with functional languages like Haskell.
The other paradigm is imperative programming, where your code uses statements like if and while, providing explicit instructions about how to produce an outcome.
It's associated with procedural languages like C.
Today, most general purpose languages like Python, JavaScript, Hotline, Swift, and so on are multi paradigm, which means they support all these options at the same time, in addition to object oriented programming.
The idea behind OOP is that you use classes to write a blueprint for the data or objects in your code.
A class can encapsulate variables, which are commonly called properties, as well as functions, which are usually called methods in this context.
It's a common way to organize and reuse code because classes can share behaviors between each other through inheritance, where a subclass can extend and override the behaviors of the parent class.
And it opens the door to all kinds have other ideas called design patterns.
Now, a class by itself doesn't actually do anything.
Instead, it's used to instantiate objects, which are actual chunks of data that live in your computer's memory.
Often, you'll want to reference the same object over and over again in your code.
When data is long lived, it can't go in the call stack.
Instead, most languages have a separate area of memory hold the heap, which unlike the call stack can grow and shrink based on how your application is used.
It also allows you to pass objects by reference, which means you can use the same object in multiple variables without increasing the memory footprint because it always points to the same chunk of memory in the heap.
Now, what's interesting is that if we go back to the CPU that we talked about in the beginning, you'll notice that it contains multiple threads.
A thread takes the physical CPU core in breaks into virtual cores that allow it to run code simultaneously.
There are some programming languages that support parallelism where you can write code that literally executes on 2 different threads at the same time.
However, many languages out there are only single threaded, but that doesn't mean they can't do 2 things at the same time.
Instead, they implement concurrency models like an event loop or coroutines that can pause or delay the normal execution of code to handle multiple job's on a single thread at the same time.
Now, in modern computing, we're rarely working with the bare metal CPU and RAM.
Instead, we work in the cloud with a virtual machine, which is just a piece set software that simulates hardware that allows us to take really big computers and split them up into a bunch of smaller virtual computers.
These machines are the backbone of the Internet and are connected via the Internet protocol.
Each machine has a unique IP address to identify it on the network.
Work.
That IP address is usually alias to a URL that is registered in a global database called the domain name service.
Now to establish a connection, in.
The 2 computers will perform a TCP handshake, which will allow them to exchange messages called packets.
On top of that, there's usually security layer like SSL to encrypt and decrypt the messages over the network.
Now the 2 computers can securely share data with the hypertext transfer for protocol.
The client may request a web page, then the server will respond with some HTML.
Modern servers provide a standardized way for a client to request data, which is called an application programming interface or API.
The most common architecture is REST, where URLs are mapped to different data entities available on the server.
And that brings us to our final topic, mother effing printers.
You're gonna need to learn how these things work inside fighting out, because every time you go to grandma's house, she's going to ask you to fix it, which shouldn't be a problem for a computer scientist like you.
Thanks for watching, and I will see you in the next one.

Speaker 0: What's the first thing you should do when your code throws an error? Obviously, you should change nothing and try to run it again a few times. If that doesn't work, you're gonna need a computer science degree. The awesome thing about software engineering is that you can learn to code and get a high paying job, while literally having no idea how anything actually works. It all just feels like magic.

Like a pilot driving a giant metal tube in the sky while knowing

Speaker 1: nothing about aerodynamics. Mother of God, no. Holy shit.

Speaker 0: Shit. Welcome to computer science 101. In today's video, you'll learn the science behind the garbage code you've been writing by learning 101 different computer science terms and concepts. This is a computer. It's just a piece of tape that holds ones and zeros along with a device that can read and write to it.

It's called a Turing machine and in theory, it can compute anything, like the graphics in this video or the algorithm that recommended that you watch it. At the core of modern computers, we have the central processing unit. If we crack rack it open, we find a piece of silicon that contains billions of tiny transistors, which are like microscopic on off switches. The value at one of these switches is called a bit end is the smallest piece of information a computer can use. However, 1 bit by itself is not very useful, so they come in a package of 8 called a byte.

1 byte can represent 250 6 different values, like all the characters that you type on your keyboard. In fact, when you type into your keyboard, the character produced is actually mapped to a binary value in a character encoding like ASCII or utf8 binary is just a system for counting, like the base ten system you normally use when counting seeing on your fingers, but it only has 2 characters, 1 and 0. Humans have a hard time reading binary, so most often it's represented in a hexadecimal base 16 format, where ten numbers and 6 letters can represent a 4 bit group called a nibble. As a developer, when you write code in a programming language, it will actually be converted into machine code, which is a binary format that can be decoded and executed by the CPU. What it doesn't do though is store data for your applications.

For that, computers have random access memory or RAM. It's like a neighborhood, and inside of every house lives a byte. Every location has a memory address, which the CPU can read and write too. You can think of the CPU and RAM as the brain of the computer. But in order for a computer to be useful, it needs to handle input and output.

An input device might be the keyboard and mouse, while an output device might be your monitor. Luckily, most developers don't need to worry about how this hardware fits together because we have operating system kernels, like Linux, Mac, and Windows that control all hardware resources via device drivers. Now, to start hacking on the operating system, your first entry point is the shell, which is a program that is the operating system to the end user. It's called a shell because it wraps the kernel. It takes a line of text as input and produces an output.

At this is called a command line interface. Not only can it connect to your own computer, but with the secure shell protocol, it can also connect to remote computers a network. Now that you have access to the mainframe, it's time to pick a programming language, which is a tool that uses the abstraction principle to make computers practical to work with for humans by simplifying different systems layer by layer. Some languages like Python are interpreted. That means there's a program called an interpreter that will execute each line of code 1 by 1.

Other languages like c plus plus are compiled. They use a compiler to convert the entire program into machine code in advance before the CPU attempts to execute it. This results in an executable file that can be run by the operating system without any extra dependencies. Now every every programming language has a variety of built in data types to represent the data we're working with in our code. Instead of bytes, we work with more human friendly things select characters and numbers.

Now, the most fundamental way to use data in your application is to declare a variable. This attaches a name to a data point, allowing you to reuse it somewhere else in your code. Python is a dynamically typed language, which means we don't need to tell the program exactly which data type is assigned to a variable. It just figures it out automatically. However, other languages like C are statically typed, and that means you need to specify the data type of a variable in your code.

When you define a variable, its value is stored somewhere in memory on the hardware, and you may need to allocate and free up memory already throughout the program. A pointer is a variable whose value is the memory address of another variable, which can be used for low level memory control. Many languages don't want to deal with low level memory management and instead implement a garbage collector, which automatically allocates and deallocates memory when an object is no longer referenced in the program.

Speaker 1: Carpet day. No.

Speaker 0: Now, the data types available are different in every programming language, but typically you'll find int to represent whole numbers, switch may or may not be signed or unsigned to represent negative numbers as well. When numbers require a decimal point, they typically use the floating point type. It's called a float because there's only enough memory to represent a certain range of numbers at a certain precision, and is basically a form of scientific notation to make computers faster. If you need more range or precision, many languages also have a double that doubles the amount of memory used for the number. Now when it comes to characters, you'll typically find the char data type to represent a single character or more commonly a string to represent multiple characters together.

Ultimately, these characters triggers get stored in a memory address somewhere, but they need to be stored in a certain order. When the order starts with the most significant byte and the smallest memory address, it's called big endian or vice versa, if the least significant byte is stored in the smallest address, it's called little endian. When it comes to practical software for engineering. One of the most fundamental things we do is organize data into data structures. The most useful data structure is probably the array or list.

Just like a shopping list. It organizes multiple data points and order. However, it also maintains an index of integers that starts at 0 and goes up for every new item in the list. That can be useful, but you don't actually need an index to create a list of items. Another option is a link list where each item has a pointer to the next item in front of Another option is a stack that follows the last in first out principle.

It's like stacking a set of plates, then when you want to access data, you pop the last one off the top. The inverse option is a q, which is first in first out. Just like when you get into the breadline, the first person there is the first one to be fed. Now, another extremely useful data structure is the hash, which might also be called a map or dictionary. It's like an array, but instead of an index of integers, you define the keys that point to each individual item, giving you a collection of key value pairs.

In many cases though, it's not efficient to organize data in a linear way. To address that problem, we have trees, which organize nodes together in a hierarchy that can often be traversed more quickly. This can sometimes be too rigid of data structure though. So instead, a graph can be created to connect multiple nodes together in a virtually unlimited number of ways. A graph has a node for the data and an edge for the relationship between the data points.

Data structures are essential, but they don't do anything by themselves. To do something useful, you'll need to code up an algorithm, which is just code that solves a problem. I took the initiative in creating the Internet. In our code, we have several mechanisms for implementing algorithms. The most fundamental of which is a function, which is a block of code that takes an input then does something and returns an output.

Like a variable, a function has a name and it can called from other parts of your code with different input parameters called arguments. One thing you might do in the function body is compare one value to another. Every language has a variety of built in operators like equality, greater than, and less than that you can use to compare 2 values. If a is greater than b, then it forms a value of true, but if b is greater than a, then the value is false. True false is what's known as a boolean data type and whenever your code produces value like this, it's known as an expression, but not all code will produce a value.

Sometimes your code will simply do something which is known as a statement. A good example is the if statement which handles conditional logic. For example, if the condition is true, it will execute this code, otherwise it will short circuit and run the code inside of the else block. Another very common type of statement is a loop. A while loop will run this block of code over and over again until the condition in the parenthesis becomes false.

That can be useful, but more often than not, you'll want to loop over an iterable data type like an array. Most languages have a for loop that can run some code for every object in the array or iterable data structure. Now in some cases, a function may not have an output, which is generally called a void function. An interesting thing about functions is that they can call themselves. When a function calls itself, it's called recursion because when done like this by default, it will recurse forever creating an infinite loop.

That happens because when you call a function, the programming language will put it into memory on what's known as the call stack, which is a short term chunk of memory for executing your code. When a function keeps calling itself, the language will keep pushing frames onto the call stack until you get a stack overflow error. To avoid this, your algorithm needs a base condition so it knows when to terminate the loop. Now, when you write an algorithm, you'll need to determine if it's any good, and the system for doing that is called big o notation. It's a standard format for approximating the performance have an algorithm at scale.

It may reference time complexity, which is how fast your algorithm will run, and space complexity, which deals with how much memory is required to run it. Developers have many different algorithm types at their disposal. The most crude option is brute force, where you might loop over every possible combination to hack somebody's credit card pin. A more sophisticated approach might be divide and conquer, like binary search where you cut the problem in half multiple times until you find what you're looking for. Another option is dynamic programming algorithms, where a problem is broken down into multiple smaller sub problems and the result of each computation is stored for later use using a technique called memoization.

That means if a function has already been called, it will use the existing value instead of recomputing it again from scratch. Then we have greedy algorithms that will make the choice that is most beneficial in the short term without considering the problem as a whole. One example of this is Dijkstra's shortest path algorithm. On the flip side, we have backtracking algorithms, which take a more incremental approach by looking at all the possible options, like a rat in a maze exploring all the different potential paths. Now, when it comes to implementing your code, there are always multiple ways to get the job done.

One aiming paradigm is declarative, where your code describes what the program does and the outcome, but doesn't care about things like control flow. This style of programming is often associated with functional languages like Haskell. The other paradigm is imperative programming, where your code uses statements like if and while, providing explicit instructions about how to produce an outcome. It's associated with procedural languages like C. Today, most general purpose languages like Python, JavaScript, Hotline, Swift, and so on are multi paradigm, which means they support all these options at the same time, in addition to object oriented programming.

The idea behind OOP is that you use classes to write a blueprint for the data or objects in your code. A class can encapsulate variables, which are commonly called properties, as well as functions, which are usually called methods in this context. It's a common way to organize and reuse code because classes can share behaviors between each other through inheritance, where a subclass can extend and override the behaviors of the parent class. And it opens the door to all kinds have other ideas called design patterns. Now, a class by itself doesn't actually do anything.

Instead, it's used to instantiate objects, which are actual chunks of data that live in your computer's memory. Often, you'll want to reference the same object over and over again in your code. When data is long lived, it can't go in the call stack. Instead, most languages have a separate area of memory hold the heap, which unlike the call stack can grow and shrink based on how your application is used. It also allows you to pass objects by reference, which means you can use the same object in multiple variables without increasing the memory footprint because it always points to the same chunk of memory in the heap.

Now, what's interesting is that if we go back to the CPU that we talked about in the beginning, you'll notice that it contains multiple threads. A thread takes the physical CPU core in breaks into virtual cores that allow it to run code simultaneously. There are some programming languages that support parallelism where you can write code that literally executes on 2 different threads at the same time. However, many languages out there are only single threaded, but that doesn't mean they can't do 2 things at the same time. Instead, they implement concurrency models like an event loop or coroutines that can pause or delay the normal execution of code to handle multiple job's on a single thread at the same time.

Now, in modern computing, we're rarely working with the bare metal CPU and RAM. Instead, we work in the cloud with a virtual machine, which is just a piece set software that simulates hardware that allows us to take really big computers and split them up into a bunch of smaller virtual computers. These machines are the backbone of the Internet and are connected via the Internet protocol. Each machine has a unique IP address to identify it on the network. Work.

That IP address is usually alias to a URL that is registered in a global database called the domain name service. Now to establish a connection, in. The 2 computers will perform a TCP handshake, which will allow them to exchange messages called packets. On top of that, there's usually security layer like SSL to encrypt and decrypt the messages over the network. Now the 2 computers can securely share data with the hypertext transfer for protocol.

The client may request a web page, then the server will respond with some HTML. Modern servers provide a standardized way for a client to request data, which is called an application programming interface or API. The most common architecture is REST, where URLs are mapped to different data entities available on the server. And that brings us to our final topic, mother effing printers. You're gonna need to learn how these things work inside fighting out, because every time you go to grandma's house, she's going to ask you to fix it, which shouldn't be a problem for a computer scientist like you.

Thanks for watching, and I will see you in the next one.
What's the first thing you should do when your code throws an error? Obviously, you should change nothing and try to run it again a few times. If that doesn't work, you're gonna need a computer science degree. The awesome thing about software engineering is that you can learn to code and get a high paying job, while literally having no idea how anything actually works. It all just feels like magic. Like a pilot driving a giant metal tube in the sky while knowing nothing about aerodynamics. Mother of God, no. Holy shit. Shit. Welcome to computer science 101. In today's video, you'll learn the science behind the garbage code you've been writing by learning 101 different computer science terms and concepts. This is a computer. It's just a piece of tape that holds ones and zeros along with a device that can read and write to it. It's called a Turing machine and in theory, it can compute anything, like the graphics in this video or the algorithm that recommended that you watch it. At the core of modern computers, we have the central processing unit. If we crack rack it open, we find a piece of silicon that contains billions of tiny transistors, which are like microscopic on off switches. The value at one of these switches is called a bit end is the smallest piece of information a computer can use.
computer science
computers
physics
aircraft
electronics
science
software development
software
engineering
ibm
technology
aerospace
programming
However, 1 bit by itself is not very useful, so they come in a package of 8 called a byte. 1 byte can represent 250 6 different values, like all the characters that you type on your keyboard. In fact, when you type into your keyboard, the character produced is actually mapped to a binary value in a character encoding like ASCII or utf8 binary is just a system for counting, like the base ten system you normally use when counting seeing on your fingers, but it only has 2 characters, 1 and 0.
Humans have a hard time reading binary, so most often it's represented in a hexadecimal base 16 format, where ten numbers and 6 letters can represent a 4 bit group called a nibble. As a developer, when you write code in a programming language, it will actually be converted into machine code, which is a binary format that can be decoded and executed by the CPU. What it doesn't do though is store data for your applications. For that, computers have random access memory or RAM. It's like a neighborhood, and inside of every house lives a byte. Every location has a memory address, which the CPU can read and write too. You can think of the CPU and RAM as the brain of the computer. But in order for a computer to be useful, it needs to handle input and output. An input device might be the keyboard and mouse, while an output device might be your monitor. Luckily, most developers don't need to worry about how this hardware fits together because we have operating system kernels, like Linux, Mac, and Windows that control all hardware resources via device drivers. Now, to start hacking on the operating system, your first entry point is the shell, which is a program that is the operating system to the end user.
electronics
programming
computer science
computers
It's called a shell because it wraps the kernel. It takes a line of text as input and produces an output. At this is called a command line interface.
Not only can it connect to your own computer, but with the secure shell protocol, it can also connect to remote computers a network. Now that you have access to the mainframe, it's time to pick a programming language, which is a tool that uses the abstraction principle to make computers practical to work with for humans by simplifying different systems layer by layer. Some languages like Python are interpreted. That means there's a program called an interpreter that will execute each line of code 1 by 1. Other languages like c plus plus are compiled. They use a compiler to convert the entire program into machine code in advance before the CPU attempts to execute it. This results in an executable file that can be run by the operating system without any extra dependencies. Now every every programming language has a variety of built in data types to represent the data we're working with in our code. Instead of bytes, we work with more human friendly things select characters and numbers. Now, the most fundamental way to use data in your application is to declare a variable. This attaches a name to a data point, allowing you to reuse it somewhere else in your code. Python is a dynamically typed language, which means we don't need to tell the program exactly which data type is assigned to a variable. It just figures it out automatically. However, other languages like C are statically typed, and that means you need to specify the data type of a variable in your code. When you define a variable, its value is stored somewhere in memory on the hardware, and you may need to allocate and free up memory already throughout the program.
languages
data
data management
networking
programming
databases
computer science
computers
data analysis
software development
A pointer is a variable whose value is the memory address of another variable, which can be used for low level memory control. Many languages don't want to deal with low level memory management and instead implement a garbage collector, which automatically allocates and deallocates memory when an object is no longer referenced in the program.
Carpet day. No. Now, the data types available are different in every programming language, but typically you'll find int to represent whole numbers, switch may or may not be signed or unsigned to represent negative numbers as well. When numbers require a decimal point, they typically use the floating point type.
data
It's called a float because there's only enough memory to represent a certain range of numbers at a certain precision, and is basically a form of scientific notation to make computers faster.
If you need more range or precision, many languages also have a double that doubles the amount of memory used for the number. Now when it comes to characters, you'll typically find the char data type to represent a single character or more commonly a string to represent multiple characters together.
languages
Ultimately, these characters triggers get stored in a memory address somewhere, but they need to be stored in a certain order. When the order starts with the most significant byte and the smallest memory address, it's called big endian or vice versa, if the least significant byte is stored in the smallest address, it's called little endian.
When it comes to practical software for engineering. One of the most fundamental things we do is organize data into data structures. The most useful data structure is probably the array or list. Just like a shopping list. It organizes multiple data points and order. However, it also maintains an index of integers that starts at 0 and goes up for every new item in the list.
data management
data
databases
data analysis
engineering
That can be useful, but you don't actually need an index to create a list of items. Another option is a link list where each item has a pointer to the next item in front of Another option is a stack that follows the last in first out principle. It's like stacking a set of plates, then when you want to access data, you pop the last one off the top. The inverse option is a q, which is first in first out. Just like when you get into the breadline, the first person there is the first one to be fed. Now, another extremely useful data structure is the hash, which might also be called a map or dictionary. It's like an array, but instead of an index of integers, you define the keys that point to each individual item, giving you a collection of key value pairs. In many cases though, it's not efficient to organize data in a linear way. To address that problem, we have trees, which organize nodes together in a hierarchy that can often be traversed more quickly. This can sometimes be too rigid of data structure though. So instead, a graph can be created to connect multiple nodes together in a virtually unlimited number of ways.
A graph has a node for the data and an edge for the relationship between the data points. Data structures are essential, but they don't do anything by themselves. To do something useful, you'll need to code up an algorithm, which is just code that solves a problem. I took the initiative in creating the Internet. In our code, we have several mechanisms for implementing algorithms. The most fundamental of which is a function, which is a block of code that takes an input then does something and returns an output. Like a variable, a function has a name and it can called from other parts of your code with different input parameters called arguments.
data
programming
data management
internet
databases
One thing you might do in the function body is compare one value to another.
Every language has a variety of built in operators like equality, greater than, and less than that you can use to compare 2 values. If a is greater than b, then it forms a value of true, but if b is greater than a, then the value is false. True false is what's known as a boolean data type and whenever your code produces value like this, it's known as an expression, but not all code will produce a value. Sometimes your code will simply do something which is known as a statement. A good example is the if statement which handles conditional logic. For example, if the condition is true, it will execute this code, otherwise it will short circuit and run the code inside of the else block. Another very common type of statement is a loop. A while loop will run this block of code over and over again until the condition in the parenthesis becomes false. That can be useful, but more often than not, you'll want to loop over an iterable data type like an array.
logic
logical reasoning
programming
Most languages have a for loop that can run some code for every object in the array or iterable data structure. Now in some cases, a function may not have an output, which is generally called a void function. An interesting thing about functions is that they can call themselves. When a function calls itself, it's called recursion because when done like this by default, it will recurse forever creating an infinite loop. That happens because when you call a function, the programming language will put it into memory on what's known as the call stack, which is a short term chunk of memory for executing your code. When a function keeps calling itself, the language will keep pushing frames onto the call stack until you get a stack overflow error. To avoid this, your algorithm needs a base condition so it knows when to terminate the loop.
Now, when you write an algorithm, you'll need to determine if it's any good, and the system for doing that is called big o notation. It's a standard format for approximating the performance have an algorithm at scale. It may reference time complexity, which is how fast your algorithm will run, and space complexity, which deals with how much memory is required to run it. Developers have many different algorithm types at their disposal. The most crude option is brute force, where you might loop over every possible combination to hack somebody's credit card pin. A more sophisticated approach might be divide and conquer, like binary search where you cut the problem in half multiple times until you find what you're looking for. Another option is dynamic programming algorithms, where a problem is broken down into multiple smaller sub problems and the result of each computation is stored for later use using a technique called memoization. That means if a function has already been called, it will use the existing value instead of recomputing it again from scratch.
programming
machine learning
artificial intelligence
operations
deep learning
software development
Then we have greedy algorithms that will make the choice that is most beneficial in the short term without considering the problem as a whole.
One example of this is Dijkstra's shortest path algorithm. On the flip side, we have backtracking algorithms, which take a more incremental approach by looking at all the possible options, like a rat in a maze exploring all the different potential paths. Now, when it comes to implementing your code, there are always multiple ways to get the job done. One aiming paradigm is declarative, where your code describes what the program does and the outcome, but doesn't care about things like control flow. This style of programming is often associated with functional languages like Haskell. The other paradigm is imperative programming, where your code uses statements like if and while, providing explicit instructions about how to produce an outcome. It's associated with procedural languages like C. Today, most general purpose languages like Python, JavaScript, Hotline, Swift, and so on are multi paradigm, which means they support all these options at the same time, in addition to object oriented programming. The idea behind OOP is that you use classes to write a blueprint for the data or objects in your code. A class can encapsulate variables, which are commonly called properties, as well as functions, which are usually called methods in this context. It's a common way to organize and reuse code because classes can share behaviors between each other through inheritance, where a subclass can extend and override the behaviors of the parent class.
languages
programming
intellectual property
software development
ideologies
systems
software
operations
robotics
machine learning
And it opens the door to all kinds have other ideas called design patterns. Now, a class by itself doesn't actually do anything. Instead, it's used to instantiate objects, which are actual chunks of data that live in your computer's memory. Often, you'll want to reference the same object over and over again in your code.
programming
When data is long lived, it can't go in the call stack. Instead, most languages have a separate area of memory hold the heap, which unlike the call stack can grow and shrink based on how your application is used. It also allows you to pass objects by reference, which means you can use the same object in multiple variables without increasing the memory footprint because it always points to the same chunk of memory in the heap. Now, what's interesting is that if we go back to the CPU that we talked about in the beginning, you'll notice that it contains multiple threads. A thread takes the physical CPU core in breaks into virtual cores that allow it to run code simultaneously. There are some programming languages that support parallelism where you can write code that literally executes on 2 different threads at the same time.
However, many languages out there are only single threaded, but that doesn't mean they can't do 2 things at the same time. Instead, they implement concurrency models like an event loop or coroutines that can pause or delay the normal execution of code to handle multiple job's on a single thread at the same time. Now, in modern computing, we're rarely working with the bare metal CPU and RAM. Instead, we work in the cloud with a virtual machine, which is just a piece set software that simulates hardware that allows us to take really big computers and split them up into a bunch of smaller virtual computers. These machines are the backbone of the Internet and are connected via the Internet protocol. Each machine has a unique IP address to identify it on the network. Work. That IP address is usually alias to a URL that is registered in a global database called the domain name service. Now to establish a connection, in. The 2 computers will perform a TCP handshake, which will allow them to exchange messages called packets. On top of that, there's usually security layer like SSL to encrypt and decrypt the messages over the network. Now the 2 computers can securely share data with the hypertext transfer for protocol. The client may request a web page, then the server will respond with some HTML. Modern servers provide a standardized way for a client to request data, which is called an application programming interface or API. The most common architecture is REST, where URLs are mapped to different data entities available on the server. And that brings us to our final topic, mother effing printers. You're gonna need to learn how these things work inside fighting out, because every time you go to grandma's house, she's going to ask you to fix it, which shouldn't be a problem for a computer scientist like you.
networking
internet
computers
architecture
databases
computer science
security
infrastructure
programming
telecommunications
data management
crafts
Thanks for watching, and I will see you in the next one.
What's the first thing you should do when your code throws an error? Obviously, you should change nothing and try to run it again a few times. If that doesn't work, you're gonna need a computer science degree. The awesome thing about software engineering is that you can learn to code and get a high paying job, while literally having no idea how anything actually works. It all just feels like magic. Like a pilot driving a giant metal tube in the sky while knowing nothing about aerodynamics. Mother of God, no. Holy shit. Shit. Welcome to computer science 101. In today's video, you'll learn the science behind the garbage code you've been writing by learning 101 different computer science terms and concepts. This is a computer. It's just a piece of tape that holds ones and zeros along with a device that can read and write to it. It's called a Turing machine and in theory, it can compute anything, like the graphics in this video or the algorithm that recommended that you watch it. At the core of modern computers, we have the central processing unit. If we crack rack it open, we find a piece of silicon that contains billions of tiny transistors, which are like microscopic on off switches. The value at one of these switches is called a bit end is the smallest piece of information a computer can use. However, 1 bit by itself is not very useful, so they come in a package of 8 called a byte. 1 byte can represent 250 6 different values, like all the characters that you type on your keyboard. In fact, when you type into your keyboard, the character produced is actually mapped to a binary value in a character encoding like ASCII or utf8 binary is just a system for counting, like the base ten system you normally use when counting seeing on your fingers, but it only has 2 characters, 1 and 0. Humans have a hard time reading binary, so most often it's represented in a hexadecimal base 16 format, where ten numbers and 6 letters can represent a 4 bit group called a nibble. As a developer, when you write code in a programming language, it will actually be converted into machine code, which is a binary format that can be decoded and executed by the CPU. What it doesn't do though is store data for your applications. For that, computers have random access memory or RAM. It's like a neighborhood, and inside of every house lives a byte. Every location has a memory address, which the CPU can read and write too. You can think of the CPU and RAM as the brain of the computer. But in order for a computer to be useful, it needs to handle input and output. An input device might be the keyboard and mouse, while an output device might be your monitor. Luckily, most developers don't need to worry about how this hardware fits together because we have operating system kernels, like Linux, Mac, and Windows that control all hardware resources via device drivers. Now, to start hacking on the operating system, your first entry point is the shell, which is a program that is the operating system to the end user. It's called a shell because it wraps the kernel. It takes a line of text as input and produces an output. At this is called a command line interface. Not only can it connect to your own computer, but with the secure shell protocol, it can also connect to remote computers a network. Now that you have access to the mainframe, it's time to pick a programming language, which is a tool that uses the abstraction principle to make computers practical to work with for humans by simplifying different systems layer by layer. Some languages like Python are interpreted. That means there's a program called an interpreter that will execute each line of code 1 by 1. Other languages like c plus plus are compiled. They use a compiler to convert the entire program into machine code in advance before the CPU attempts to execute it. This results in an executable file that can be run by the operating system without any extra dependencies. Now every every programming language has a variety of built in data types to represent the data we're working with in our code. Instead of bytes, we work with more human friendly things select characters and numbers. Now, the most fundamental way to use data in your application is to declare a variable. This attaches a name to a data point, allowing you to reuse it somewhere else in your code. Python is a dynamically typed language, which means we don't need to tell the program exactly which data type is assigned to a variable. It just figures it out automatically. However, other languages like C are statically typed, and that means you need to specify the data type of a variable in your code. When you define a variable, its value is stored somewhere in memory on the hardware, and you may need to allocate and free up memory already throughout the program. A pointer is a variable whose value is the memory address of another variable, which can be used for low level memory control. Many languages don't want to deal with low level memory management and instead implement a garbage collector, which automatically allocates and deallocates memory when an object is no longer referenced in the program. Carpet day. No. Now, the data types available are different in every programming language, but typically you'll find int to represent whole numbers, switch may or may not be signed or unsigned to represent negative numbers as well. When numbers require a decimal point, they typically use the floating point type. It's called a float because there's only enough memory to represent a certain range of numbers at a certain precision, and is basically a form of scientific notation to make computers faster. If you need more range or precision, many languages also have a double that doubles the amount of memory used for the number. Now when it comes to characters, you'll typically find the char data type to represent a single character or more commonly a string to represent multiple characters together. Ultimately, these characters triggers get stored in a memory address somewhere, but they need to be stored in a certain order. When the order starts with the most significant byte and the smallest memory address, it's called big endian or vice versa, if the least significant byte is stored in the smallest address, it's called little endian. When it comes to practical software for engineering. One of the most fundamental things we do is organize data into data structures. The most useful data structure is probably the array or list. Just like a shopping list. It organizes multiple data points and order. However, it also maintains an index of integers that starts at 0 and goes up for every new item in the list. That can be useful, but you don't actually need an index to create a list of items. Another option is a link list where each item has a pointer to the next item in front of Another option is a stack that follows the last in first out principle. It's like stacking a set of plates, then when you want to access data, you pop the last one off the top. The inverse option is a q, which is first in first out. Just like when you get into the breadline, the first person there is the first one to be fed. Now, another extremely useful data structure is the hash, which might also be called a map or dictionary. It's like an array, but instead of an index of integers, you define the keys that point to each individual item, giving you a collection of key value pairs. In many cases though, it's not efficient to organize data in a linear way. To address that problem, we have trees, which organize nodes together in a hierarchy that can often be traversed more quickly. This can sometimes be too rigid of data structure though. So instead, a graph can be created to connect multiple nodes together in a virtually unlimited number of ways. A graph has a node for the data and an edge for the relationship between the data points. Data structures are essential, but they don't do anything by themselves. To do something useful, you'll need to code up an algorithm, which is just code that solves a problem. I took the initiative in creating the Internet. In our code, we have several mechanisms for implementing algorithms. The most fundamental of which is a function, which is a block of code that takes an input then does something and returns an output. Like a variable, a function has a name and it can called from other parts of your code with different input parameters called arguments. One thing you might do in the function body is compare one value to another. Every language has a variety of built in operators like equality, greater than, and less than that you can use to compare 2 values. If a is greater than b, then it forms a value of true, but if b is greater than a, then the value is false. True false is what's known as a boolean data type and whenever your code produces value like this, it's known as an expression, but not all code will produce a value. Sometimes your code will simply do something which is known as a statement. A good example is the if statement which handles conditional logic. For example, if the condition is true, it will execute this code, otherwise it will short circuit and run the code inside of the else block. Another very common type of statement is a loop. A while loop will run this block of code over and over again until the condition in the parenthesis becomes false. That can be useful, but more often than not, you'll want to loop over an iterable data type like an array. Most languages have a for loop that can run some code for every object in the array or iterable data structure. Now in some cases, a function may not have an output, which is generally called a void function. An interesting thing about functions is that they can call themselves. When a function calls itself, it's called recursion because when done like this by default, it will recurse forever creating an infinite loop. That happens because when you call a function, the programming language will put it into memory on what's known as the call stack, which is a short term chunk of memory for executing your code. When a function keeps calling itself, the language will keep pushing frames onto the call stack until you get a stack overflow error. To avoid this, your algorithm needs a base condition so it knows when to terminate the loop. Now, when you write an algorithm, you'll need to determine if it's any good, and the system for doing that is called big o notation. It's a standard format for approximating the performance have an algorithm at scale. It may reference time complexity, which is how fast your algorithm will run, and space complexity, which deals with how much memory is required to run it. Developers have many different algorithm types at their disposal. The most crude option is brute force, where you might loop over every possible combination to hack somebody's credit card pin. A more sophisticated approach might be divide and conquer, like binary search where you cut the problem in half multiple times until you find what you're looking for. Another option is dynamic programming algorithms, where a problem is broken down into multiple smaller sub problems and the result of each computation is stored for later use using a technique called memoization. That means if a function has already been called, it will use the existing value instead of recomputing it again from scratch. Then we have greedy algorithms that will make the choice that is most beneficial in the short term without considering the problem as a whole. One example of this is Dijkstra's shortest path algorithm. On the flip side, we have backtracking algorithms, which take a more incremental approach by looking at all the possible options, like a rat in a maze exploring all the different potential paths. Now, when it comes to implementing your code, there are always multiple ways to get the job done. One aiming paradigm is declarative, where your code describes what the program does and the outcome, but doesn't care about things like control flow. This style of programming is often associated with functional languages like Haskell. The other paradigm is imperative programming, where your code uses statements like if and while, providing explicit instructions about how to produce an outcome. It's associated with procedural languages like C. Today, most general purpose languages like Python, JavaScript, Hotline, Swift, and so on are multi paradigm, which means they support all these options at the same time, in addition to object oriented programming. The idea behind OOP is that you use classes to write a blueprint for the data or objects in your code. A class can encapsulate variables, which are commonly called properties, as well as functions, which are usually called methods in this context. It's a common way to organize and reuse code because classes can share behaviors between each other through inheritance, where a subclass can extend and override the behaviors of the parent class. And it opens the door to all kinds have other ideas called design patterns. Now, a class by itself doesn't actually do anything. Instead, it's used to instantiate objects, which are actual chunks of data that live in your computer's memory. Often, you'll want to reference the same object over and over again in your code. When data is long lived, it can't go in the call stack. Instead, most languages have a separate area of memory hold the heap, which unlike the call stack can grow and shrink based on how your application is used. It also allows you to pass objects by reference, which means you can use the same object in multiple variables without increasing the memory footprint because it always points to the same chunk of memory in the heap. Now, what's interesting is that if we go back to the CPU that we talked about in the beginning, you'll notice that it contains multiple threads. A thread takes the physical CPU core in breaks into virtual cores that allow it to run code simultaneously. There are some programming languages that support parallelism where you can write code that literally executes on 2 different threads at the same time. However, many languages out there are only single threaded, but that doesn't mean they can't do 2 things at the same time. Instead, they implement concurrency models like an event loop or coroutines that can pause or delay the normal execution of code to handle multiple job's on a single thread at the same time. Now, in modern computing, we're rarely working with the bare metal CPU and RAM. Instead, we work in the cloud with a virtual machine, which is just a piece set software that simulates hardware that allows us to take really big computers and split them up into a bunch of smaller virtual computers. These machines are the backbone of the Internet and are connected via the Internet protocol. Each machine has a unique IP address to identify it on the network. Work. That IP address is usually alias to a URL that is registered in a global database called the domain name service. Now to establish a connection, in. The 2 computers will perform a TCP handshake, which will allow them to exchange messages called packets. On top of that, there's usually security layer like SSL to encrypt and decrypt the messages over the network. Now the 2 computers can securely share data with the hypertext transfer for protocol. The client may request a web page, then the server will respond with some HTML. Modern servers provide a standardized way for a client to request data, which is called an application programming interface or API. The most common architecture is REST, where URLs are mapped to different data entities available on the server. And that brings us to our final topic, mother effing printers. You're gonna need to learn how these things work inside fighting out, because every time you go to grandma's house, she's going to ask you to fix it, which shouldn't be a problem for a computer scientist like you. Thanks for watching, and I will see you in the next one.
What's
what's
the
the
first
first
thing
thing
you
you
should
should
do
do
when
when
your
your
code
code
throws
throws
an
an
error?
error
Obviously,
obviously
you
you
should
should
change
change
nothing
nothing
and
and
try
try
to
to
run
run
it
it
again
again
a
a
few
few
times.
times
If
if
that
that
doesn't
doesn't
work,
work
you're
you're
gonna
gonna
need
need
a
a
computer
computer
science
science
degree.
degree
The
the
awesome
awesome
thing
thing
about
about
software
software
engineering
engineering
is
is
that
that
you
you
can
can
learn
learn
to
to
code
code
and
and
get
get
a
a
high
high
paying
paying
job,
job
while
while
literally
literally
having
having
no
no
idea
idea
how
how
anything
anything
actually
actually
works.
works
It
it
all
all
just
just
feels
feels
like
like
magic.
magic
Like
like
a
a
pilot
pilot
driving
driving
a
a
giant
giant
metal
metal
tube
tube
in
in
the
the
sky
sky
while
while
knowing
knowing
nothing
nothing
about
about
aerodynamics.
aerodynamics
Mother
mother
of
of
God,
god
no.
no
Holy
holy
shit.
shit
Shit.
shit
Welcome
welcome
to
to
computer
computer
science
science
101.
101
In
in
today's
today's
video,
video
you'll
you'll
learn
learn
the
the
science
science
behind
behind
the
the
garbage
garbage
code
code
you've
you've
been
been
writing
writing
by
by
learning
learning
101
101
different
different
computer
computer
science
science
terms
terms
and
and
concepts.
concepts
This
this
is
is
a
a
computer.
computer
It's
it's
just
just
a
a
piece
piece
of
of
tape
tape
that
that
holds
holds
ones
ones
and
and
zeros
zeros
along
along
with
with
a
a
device
device
that
that
can
can
read
read
and
and
write
write
to
to
it.
it
It's
it's
called
called
a
a
Turing
turing
machine
machine
and
and
in
in
theory,
theory
it
it
can
can
compute
compute
anything,
anything
like
like
the
the
graphics
graphics
in
in
this
this
video
video
or
or
the
the
algorithm
algorithm
that
that
recommended
recommended
that
that
you
you
watch
watch
it.
it
At
at
the
the
core
core
of
of
modern
modern
computers,
computers
we
we
have
have
the
the
central
central
processing
processing
unit.
unit
If
if
we
we
crack
crack
rack
rack
it
it
open,
open
we
we
find
find
a
a
piece
piece
of
of
silicon
silicon
that
that
contains
contains
billions
billions
of
of
tiny
tiny
transistors,
transistors
which
which
are
are
like
like
microscopic
microscopic
on
on
off
off
switches.
switches
The
the
value
value
at
at
one
one
of
of
these
these
switches
switches
is
is
called
called
a
a
bit
bit
end
end
is
is
the
the
smallest
smallest
piece
piece
of
of
information
information
a
a
computer
computer
can
can
use.
use
However,
however
1
1
bit
bit
by
by
itself
itself
is
is
not
not
very
very
useful,
useful
so
so
they
they
come
come
in
in
a
a
package
package
of
of
8
8
called
called
a
a
byte.
byte
1
1
byte
byte
can
can
represent
represent
250
250
6
6
different
different
values,
values
like
like
all
all
the
the
characters
characters
that
that
you
you
type
type
on
on
your
your
keyboard.
keyboard
In
in
fact,
fact
when
when
you
you
type
type
into
into
your
your
keyboard,
keyboard
the
the
character
character
produced
produced
is
is
actually
actually
mapped
mapped
to
to
a
a
binary
binary
value
value
in
in
a
a
character
character
encoding
encoding
like
like
ASCII
ascii
or
or
utf8
utf8
binary
binary
is
is
just
just
a
a
system
system
for
for
counting,
counting
like
like
the
the
base
base
ten
ten
system
system
you
you
normally
normally
use
use
when
when
counting
counting
seeing
seeing
on
on
your
your
fingers,
fingers
but
but
it
it
only
only
has
has
2
2
characters,
characters
1
1
and
and
0.
0
Humans
humans
have
have
a
a
hard
hard
time
time
reading
reading
binary,
binary
so
so
most
most
often
often
it's
it's
represented
represented
in
in
a
a
hexadecimal
hexadecimal
base
base
16
16
format,
format
where
where
ten
ten
numbers
numbers
and
and
6
6
letters
letters
can
can
represent
represent
a
a
4
4
bit
bit
group
group
called
called
a
a
nibble.
nibble
As
as
a
a
developer,
developer
when
when
you
you
write
write
code
code
in
in
a
a
programming
programming
language,
language
it
it
will
will
actually
actually
be
be
converted
converted
into
into
machine
machine
code,
code
which
which
is
is
a
a
binary
binary
format
format
that
that
can
can
be
be
decoded
decoded
and
and
executed
executed
by
by
the
the
CPU.
cpu
What
what
it
it
doesn't
doesn't
do
do
though
though
is
is
store
store
data
data
for
for
your
your
applications.
applications
For
for
that,
that
computers
computers
have
have
random
random
access
access
memory
memory
or
or
RAM.
ram
It's
it's
like
like
a
a
neighborhood,
neighborhood
and
and
inside
inside
of
of
every
every
house
house
lives
lives
a
a
byte.
byte
Every
every
location
location
has
has
a
a
memory
memory
address,
address
which
which
the
the
CPU
cpu
can
can
read
read
and
and
write
write
too.
too
You
you
can
can
think
think
of
of
the
the
CPU
cpu
and
and
RAM
ram
as
as
the
the
brain
brain
of
of
the
the
computer.
computer
But
but
in
in
order
order
for
for
a
a
computer
computer
to
to
be
be
useful,
useful
it
it
needs
needs
to
to
handle
handle
input
input
and
and
output.
output
An
an
input
input
device
device
might
might
be
be
the
the
keyboard
keyboard
and
and
mouse,
mouse
while
while
an
an
output
output
device
device
might
might
be
be
your
your
monitor.
monitor
Luckily,
luckily
most
most
developers
developers
don't
don't
need
need
to
to
worry
worry
about
about
how
how
this
this
hardware
hardware
fits
fits
together
together
because
because
we
we
have
have
operating
operating
system
system
kernels,
kernels
like
like
Linux,
linux
Mac,
mac
and
and
Windows
windows
that
that
control
control
all
all
hardware
hardware
resources
resources
via
via
device
device
drivers.
drivers
Now,
now
to
to
start
start
hacking
hacking
on
on
the
the
operating
operating
system,
system
your
your
first
first
entry
entry
point
point
is
is
the
the
shell,
shell
which
which
is
is
a
a
program
program
that
that
is
is
the
the
operating
operating
system
system
to
to
the
the
end
end
user.
user
It's
it's
called
called
a
a
shell
shell
because
because
it
it
wraps
wraps
the
the
kernel.
kernel
It
it
takes
takes
a
a
line
line
of
of
text
text
as
as
input
input
and
and
produces
produces
an
an
output.
output
At
at
this
this
is
is
called
called
a
a
command
command
line
line
interface.
interface
Not
not
only
only
can
can
it
it
connect
connect
to
to
your
your
own
own
computer,
computer
but
but
with
with
the
the
secure
secure
shell
shell
protocol,
protocol
it
it
can
can
also
also
connect
connect
to
to
remote
remote
computers
computers
a
a
network.
network
Now
now
that
that
you
you
have
have
access
access
to
to
the
the
mainframe,
mainframe
it's
it's
time
time
to
to
pick
pick
a
a
programming
programming
language,
language
which
which
is
is
a
a
tool
tool
that
that
uses
uses
the
the
abstraction
abstraction
principle
principle
to
to
make
make
computers
computers
practical
practical
to
to
work
work
with
with
for
for
humans
humans
by
by
simplifying
simplifying
different
different
systems
systems
layer
layer
by
by
layer.
layer
Some
some
languages
languages
like
like
Python
python
are
are
interpreted.
interpreted
That
that
means
means
there's
there's
a
a
program
program
called
called
an
an
interpreter
interpreter
that
that
will
will
execute
execute
each
each
line
line
of
of
code
code
1
1
by
by
1.
1
Other
other
languages
languages
like
like
c
c
plus
plus
plus
plus
are
are
compiled.
compiled
They
they
use
use
a
a
compiler
compiler
to
to
convert
convert
the
the
entire
entire
program
program
into
into
machine
machine
code
code
in
in
advance
advance
before
before
the
the
CPU
cpu
attempts
attempts
to
to
execute
execute
it.
it
This
this
results
results
in
in
an
an
executable
executable
file
file
that
that
can
can
be
be
run
run
by
by
the
the
operating
operating
system
system
without
without
any
any
extra
extra
dependencies.
dependencies
Now
now
every
every
every
every
programming
programming
language
language
has
has
a
a
variety
variety
of
of
built
built
in
in
data
data
types
types
to
to
represent
represent
the
the
data
data
we're
we're
working
working
with
with
in
in
our
our
code.
code
Instead
instead
of
of
bytes,
bytes
we
we
work
work
with
with
more
more
human
human
friendly
friendly
things
things
select
select
characters
characters
and
and
numbers.
numbers
Now,
now
the
the
most
most
fundamental
fundamental
way
way
to
to
use
use
data
data
in
in
your
your
application
application
is
is
to
to
declare
declare
a
a
variable.
variable
This
this
attaches
attaches
a
a
name
name
to
to
a
a
data
data
point,
point
allowing
allowing
you
you
to
to
reuse
reuse
it
it
somewhere
somewhere
else
else
in
in
your
your
code.
code
Python
python
is
is
a
a
dynamically
dynamically
typed
typed
language,
language
which
which
means
means
we
we
don't
don't
need
need
to
to
tell
tell
the
the
program
program
exactly
exactly
which
which
data
data
type
type
is
is
assigned
assigned
to
to
a
a
variable.
variable
It
it
just
just
figures
figures
it
it
out
out
automatically.
automatically
However,
however
other
other
languages
languages
like
like
C
c
are
are
statically
statically
typed,
typed
and
and
that
that
means
means
you
you
need
need
to
to
specify
specify
the
the
data
data
type
type
of
of
a
a
variable
variable
in
in
your
your
code.
code
When
when
you
you
define
define
a
a
variable,
variable
its
its
value
value
is
is
stored
stored
somewhere
somewhere
in
in
memory
memory
on
on
the
the
hardware,
hardware
and
and
you
you
may
may
need
need
to
to
allocate
allocate
and
and
free
free
up
up
memory
memory
already
already
throughout
throughout
the
the
program.
program
A
a
pointer
pointer
is
is
a
a
variable
variable
whose
whose
value
value
is
is
the
the
memory
memory
address
address
of
of
another
another
variable,
variable
which
which
can
can
be
be
used
used
for
for
low
low
level
level
memory
memory
control.
control
Many
many
languages
languages
don't
don't
want
want
to
to
deal
deal
with
with
low
low
level
level
memory
memory
management
management
and
and
instead
instead
implement
implement
a
a
garbage
garbage
collector,
collector
which
which
automatically
automatically
allocates
allocates
and
and
deallocates
deallocates
memory
memory
when
when
an
an
object
object
is
is
no
no
longer
longer
referenced
referenced
in
in
the
the
program.
program
Carpet
carpet
day.
day
No.
no
Now,
now
the
the
data
data
types
types
available
available
are
are
different
different
in
in
every
every
programming
programming
language,
language
but
but
typically
typically
you'll
you'll
find
find
int
int
to
to
represent
represent
whole
whole
numbers,
numbers
switch
switch
may
may
or
or
may
may
not
not
be
be
signed
signed
or
or
unsigned
unsigned
to
to
represent
represent
negative
negative
numbers
numbers
as
as
well.
well
When
when
numbers
numbers
require
require
a
a
decimal
decimal
point,
point
they
they
typically
typically
use
use
the
the
floating
floating
point
point
type.
type
It's
it's
called
called
a
a
float
float
because
because
there's
there's
only
only
enough
enough
memory
memory
to
to
represent
represent
a
a
certain
certain
range
range
of
of
numbers
numbers
at
at
a
a
certain
certain
precision,
precision
and
and
is
is
basically
basically
a
a
form
form
of
of
scientific
scientific
notation
notation
to
to
make
make
computers
computers
faster.
faster
If
if
you
you
need
need
more
more
range
range
or
or
precision,
precision
many
many
languages
languages
also
also
have
have
a
a
double
double
that
that
doubles
doubles
the
the
amount
amount
of
of
memory
memory
used
used
for
for
the
the
number.
number
Now
now
when
when
it
it
comes
comes
to
to
characters,
characters
you'll
you'll
typically
typically
find
find
the
the
char
char
data
data
type
type
to
to
represent
represent
a
a
single
single
character
character
or
or
more
more
commonly
commonly
a
a
string
string
to
to
represent
represent
multiple
multiple
characters
characters
together.
together
Ultimately,
ultimately
these
these
characters
characters
triggers
triggers
get
get
stored
stored
in
in
a
a
memory
memory
address
address
somewhere,
somewhere
but
but
they
they
need
need
to
to
be
be
stored
stored
in
in
a
a
certain
certain
order.
order
When
when
the
the
order
order
starts
starts
with
with
the
the
most
most
significant
significant
byte
byte
and
and
the
the
smallest
smallest
memory
memory
address,
address
it's
it's
called
called
big
big
endian
endian
or
or
vice
vice
versa,
versa
if
if
the
the
least
least
significant
significant
byte
byte
is
is
stored
stored
in
in
the
the
smallest
smallest
address,
address
it's
it's
called
called
little
little
endian.
endian
When
when
it
it
comes
comes
to
to
practical
practical
software
software
for
for
engineering.
engineering
One
one
of
of
the
the
most
most
fundamental
fundamental
things
things
we
we
do
do
is
is
organize
organize
data
data
into
into
data
data
structures.
structures
The
the
most
most
useful
useful
data
data
structure
structure
is
is
probably
probably
the
the
array
array
or
or
list.
list
Just
just
like
like
a
a
shopping
shopping
list.
list
It
it
organizes
organizes
multiple
multiple
data
data
points
points
and
and
order.
order
However,
however
it
it
also
also
maintains
maintains
an
an
index
index
of
of
integers
integers
that
that
starts
starts
at
at
0
0
and
and
goes
goes
up
up
for
for
every
every
new
new
item
item
in
in
the
the
list.
list
That
that
can
can
be
be
useful,
useful
but
but
you
you
don't
don't
actually
actually
need
need
an
an
index
index
to
to
create
create
a
a
list
list
of
of
items.
items
Another
another
option
option
is
is
a
a
link
link
list
list
where
where
each
each
item
item
has
has
a
a
pointer
pointer
to
to
the
the
next
next
item
item
in
in
front
front
of
of
Another
another
option
option
is
is
a
a
stack
stack
that
that
follows
follows
the
the
last
last
in
in
first
first
out
out
principle.
principle
It's
it's
like
like
stacking
stacking
a
a
set
set
of
of
plates,
plates
then
then
when
when
you
you
want
want
to
to
access
access
data,
data
you
you
pop
pop
the
the
last
last
one
one
off
off
the
the
top.
top
The
the
inverse
inverse
option
option
is
is
a
a
q,
q
which
which
is
is
first
first
in
in
first
first
out.
out
Just
just
like
like
when
when
you
you
get
get
into
into
the
the
breadline,
breadline
the
the
first
first
person
person
there
there
is
is
the
the
first
first
one
one
to
to
be
be
fed.
fed
Now,
now
another
another
extremely
extremely
useful
useful
data
data
structure
structure
is
is
the
the
hash,
hash
which
which
might
might
also
also
be
be
called
called
a
a
map
map
or
or
dictionary.
dictionary
It's
it's
like
like
an
an
array,
array
but
but
instead
instead
of
of
an
an
index
index
of
of
integers,
integers
you
you
define
define
the
the
keys
keys
that
that
point
point
to
to
each
each
individual
individual
item,
item
giving
giving
you
you
a
a
collection
collection
of
of
key
key
value
value
pairs.
pairs
In
in
many
many
cases
cases
though,
though
it's
it's
not
not
efficient
efficient
to
to
organize
organize
data
data
in
in
a
a
linear
linear
way.
way
To
to
address
address
that
that
problem,
problem
we
we
have
have
trees,
trees
which
which
organize
organize
nodes
nodes
together
together
in
in
a
a
hierarchy
hierarchy
that
that
can
can
often
often
be
be
traversed
traversed
more
more
quickly.
quickly
This
this
can
can
sometimes
sometimes
be
be
too
too
rigid
rigid
of
of
data
data
structure
structure
though.
though
So
so
instead,
instead
a
a
graph
graph
can
can
be
be
created
created
to
to
connect
connect
multiple
multiple
nodes
nodes
together
together
in
in
a
a
virtually
virtually
unlimited
unlimited
number
number
of
of
ways.
ways
A
a
graph
graph
has
has
a
a
node
node
for
for
the
the
data
data
and
and
an
an
edge
edge
for
for
the
the
relationship
relationship
between
between
the
the
data
data
points.
points
Data
data
structures
structures
are
are
essential,
essential
but
but
they
they
don't
don't
do
do
anything
anything
by
by
themselves.
themselves
To
to
do
do
something
something
useful,
useful
you'll
you'll
need
need
to
to
code
code
up
up
an
an
algorithm,
algorithm
which
which
is
is
just
just
code
code
that
that
solves
solves
a
a
problem.
problem
I
i
took
took
the
the
initiative
initiative
in
in
creating
creating
the
the
Internet.
internet
In
in
our
our
code,
code
we
we
have
have
several
several
mechanisms
mechanisms
for
for
implementing
implementing
algorithms.
algorithms
The
the
most
most
fundamental
fundamental
of
of
which
which
is
is
a
a
function,
function
which
which
is
is
a
a
block
block
of
of
code
code
that
that
takes
takes
an
an
input
input
then
then
does
does
something
something
and
and
returns
returns
an
an
output.
output
Like
like
a
a
variable,
variable
a
a
function
function
has
has
a
a
name
name
and
and
it
it
can
can
called
called
from
from
other
other
parts
parts
of
of
your
your
code
code
with
with
different
different
input
input
parameters
parameters
called
called
arguments.
arguments
One
one
thing
thing
you
you
might
might
do
do
in
in
the
the
function
function
body
body
is
is
compare
compare
one
one
value
value
to
to
another.
another
Every
every
language
language
has
has
a
a
variety
variety
of
of
built
built
in
in
operators
operators
like
like
equality,
equality
greater
greater
than,
than
and
and
less
less
than
than
that
that
you
you
can
can
use
use
to
to
compare
compare
2
2
values.
values
If
if
a
a
is
is
greater
greater
than
than
b,
b
then
then
it
it
forms
forms
a
a
value
value
of
of
true,
true
but
but
if
if
b
b
is
is
greater
greater
than
than
a,
a
then
then
the
the
value
value
is
is
false.
false
True
true
false
false
is
is
what's
what's
known
known
as
as
a
a
boolean
boolean
data
data
type
type
and
and
whenever
whenever
your
your
code
code
produces
produces
value
value
like
like
this,
this
it's
it's
known
known
as
as
an
an
expression,
expression
but
but
not
not
all
all
code
code
will
will
produce
produce
a
a
value.
value
Sometimes
sometimes
your
your
code
code
will
will
simply
simply
do
do
something
something
which
which
is
is
known
known
as
as
a
a
statement.
statement
A
a
good
good
example
example
is
is
the
the
if
if
statement
statement
which
which
handles
handles
conditional
conditional
logic.
logic
For
for
example,
example
if
if
the
the
condition
condition
is
is
true,
true
it
it
will
will
execute
execute
this
this
code,
code
otherwise
otherwise
it
it
will
will
short
short
circuit
circuit
and
and
run
run
the
the
code
code
inside
inside
of
of
the
the
else
else
block.
block
Another
another
very
very
common
common
type
type
of
of
statement
statement
is
is
a
a
loop.
loop
A
a
while
while
loop
loop
will
will
run
run
this
this
block
block
of
of
code
code
over
over
and
and
over
over
again
again
until
until
the
the
condition
condition
in
in
the
the
parenthesis
parenthesis
becomes
becomes
false.
false
That
that
can
can
be
be
useful,
useful
but
but
more
more
often
often
than
than
not,
not
you'll
you'll
want
want
to
to
loop
loop
over
over
an
an
iterable
iterable
data
data
type
type
like
like
an
an
array.
array
Most
most
languages
languages
have
have
a
a
for
for
loop
loop
that
that
can
can
run
run
some
some
code
code
for
for
every
every
object
object
in
in
the
the
array
array
or
or
iterable
iterable
data
data
structure.
structure
Now
now
in
in
some
some
cases,
cases
a
a
function
function
may
may
not
not
have
have
an
an
output,
output
which
which
is
is
generally
generally
called
called
a
a
void
void
function.
function
An
an
interesting
interesting
thing
thing
about
about
functions
functions
is
is
that
that
they
they
can
can
call
call
themselves.
themselves
When
when
a
a
function
function
calls
calls
itself,
itself
it's
it's
called
called
recursion
recursion
because
because
when
when
done
done
like
like
this
this
by
by
default,
default
it
it
will
will
recurse
recurse
forever
forever
creating
creating
an
an
infinite
infinite
loop.
loop
That
that
happens
happens
because
because
when
when
you
you
call
call
a
a
function,
function
the
the
programming
programming
language
language
will
will
put
put
it
it
into
into
memory
memory
on
on
what's
what's
known
known
as
as
the
the
call
call
stack,
stack
which
which
is
is
a
a
short
short
term
term
chunk
chunk
of
of
memory
memory
for
for
executing
executing
your
your
code.
code
When
when
a
a
function
function
keeps
keeps
calling
calling
itself,
itself
the
the
language
language
will
will
keep
keep
pushing
pushing
frames
frames
onto
onto
the
the
call
call
stack
stack
until
until
you
you
get
get
a
a
stack
stack
overflow
overflow
error.
error
To
to
avoid
avoid
this,
this
your
your
algorithm
algorithm
needs
needs
a
a
base
base
condition
condition
so
so
it
it
knows
knows
when
when
to
to
terminate
terminate
the
the
loop.
loop
Now,
now
when
when
you
you
write
write
an
an
algorithm,
algorithm
you'll
you'll
need
need
to
to
determine
determine
if
if
it's
it's
any
any
good,
good
and
and
the
the
system
system
for
for
doing
doing
that
that
is
is
called
called
big
big
o
o
notation.
notation
It's
it's
a
a
standard
standard
format
format
for
for
approximating
approximating
the
the
performance
performance
have
have
an
an
algorithm
algorithm
at
at
scale.
scale
It
it
may
may
reference
reference
time
time
complexity,
complexity
which
which
is
is
how
how
fast
fast
your
your
algorithm
algorithm
will
will
run,
run
and
and
space
space
complexity,
complexity
which
which
deals
deals
with
with
how
how
much
much
memory
memory
is
is
required
required
to
to
run
run
it.
it
Developers
developers
have
have
many
many
different
different
algorithm
algorithm
types
types
at
at
their
their
disposal.
disposal
The
the
most
most
crude
crude
option
option
is
is
brute
brute
force,
force
where
where
you
you
might
might
loop
loop
over
over
every
every
possible
possible
combination
combination
to
to
hack
hack
somebody's
somebody's
credit
credit
card
card
pin.
pin
A
a
more
more
sophisticated
sophisticated
approach
approach
might
might
be
be
divide
divide
and
and
conquer,
conquer
like
like
binary
binary
search
search
where
where
you
you
cut
cut
the
the
problem
problem
in
in
half
half
multiple
multiple
times
times
until
until
you
you
find
find
what
what
you're
you're
looking
looking
for.
for
Another
another
option
option
is
is
dynamic
dynamic
programming
programming
algorithms,
algorithms
where
where
a
a
problem
problem
is
is
broken
broken
down
down
into
into
multiple
multiple
smaller
smaller
sub
sub
problems
problems
and
and
the
the
result
result
of
of
each
each
computation
computation
is
is
stored
stored
for
for
later
later
use
use
using
using
a
a
technique
technique
called
called
memoization.
memoization
That
that
means
means
if
if
a
a
function
function
has
has
already
already
been
been
called,
called
it
it
will
will
use
use
the
the
existing
existing
value
value
instead
instead
of
of
recomputing
recomputing
it
it
again
again
from
from
scratch.
scratch
Then
then
we
we
have
have
greedy
greedy
algorithms
algorithms
that
that
will
will
make
make
the
the
choice
choice
that
that
is
is
most
most
beneficial
beneficial
in
in
the
the
short
short
term
term
without
without
considering
considering
the
the
problem
problem
as
as
a
a
whole.
whole
One
one
example
example
of
of
this
this
is
is
Dijkstra's
dijkstra's
shortest
shortest
path
path
algorithm.
algorithm
On
on
the
the
flip
flip
side,
side
we
we
have
have
backtracking
backtracking
algorithms,
algorithms
which
which
take
take
a
a
more
more
incremental
incremental
approach
approach
by
by
looking
looking
at
at
all
all
the
the
possible
possible
options,
options
like
like
a
a
rat
rat
in
in
a
a
maze
maze
exploring
exploring
all
all
the
the
different
different
potential
potential
paths.
paths
Now,
now
when
when
it
it
comes
comes
to
to
implementing
implementing
your
your
code,
code
there
there
are
are
always
always
multiple
multiple
ways
ways
to
to
get
get
the
the
job
job
done.
done
One
one
aiming
aiming
paradigm
paradigm
is
is
declarative,
declarative
where
where
your
your
code
code
describes
describes
what
what
the
the
program
program
does
does
and
and
the
the
outcome,
outcome
but
but
doesn't
doesn't
care
care
about
about
things
things
like
like
control
control
flow.
flow
This
this
style
style
of
of
programming
programming
is
is
often
often
associated
associated
with
with
functional
functional
languages
languages
like
like
Haskell.
haskell
The
the
other
other
paradigm
paradigm
is
is
imperative
imperative
programming,
programming
where
where
your
your
code
code
uses
uses
statements
statements
like
like
if
if
and
and
while,
while
providing
providing
explicit
explicit
instructions
instructions
about
about
how
how
to
to
produce
produce
an
an
outcome.
outcome
It's
it's
associated
associated
with
with
procedural
procedural
languages
languages
like
like
C.
c
Today,
today
most
most
general
general
purpose
purpose
languages
languages
like
like
Python,
python
JavaScript,
javascript
Hotline,
hotline
Swift,
swift
and
and
so
so
on
on
are
are
multi
multi
paradigm,
paradigm
which
which
means
means
they
they
support
support
all
all
these
these
options
options
at
at
the
the
same
same
time,
time
in
in
addition
addition
to
to
object
object
oriented
oriented
programming.
programming
The
the
idea
idea
behind
behind
OOP
oop
is
is
that
that
you
you
use
use
classes
classes
to
to
write
write
a
a
blueprint
blueprint
for
for
the
the
data
data
or
or
objects
objects
in
in
your
your
code.
code
A
a
class
class
can
can
encapsulate
encapsulate
variables,
variables
which
which
are
are
commonly
commonly
called
called
properties,
properties
as
as
well
well
as
as
functions,
functions
which
which
are
are
usually
usually
called
called
methods
methods
in
in
this
this
context.
context
It's
it's
a
a
common
common
way
way
to
to
organize
organize
and
and
reuse
reuse
code
code
because
because
classes
classes
can
can
share
share
behaviors
behaviors
between
between
each
each
other
other
through
through
inheritance,
inheritance
where
where
a
a
subclass
subclass
can
can
extend
extend
and
and
override
override
the
the
behaviors
behaviors
of
of
the
the
parent
parent
class.
class
And
and
it
it
opens
opens
the
the
door
door
to
to
all
all
kinds
kinds
have
have
other
other
ideas
ideas
called
called
design
design
patterns.
patterns
Now,
now
a
a
class
class
by
by
itself
itself
doesn't
doesn't
actually
actually
do
do
anything.
anything
Instead,
instead
it's
it's
used
used
to
to
instantiate
instantiate
objects,
objects
which
which
are
are
actual
actual
chunks
chunks
of
of
data
data
that
that
live
live
in
in
your
your
computer's
computer's
memory.
memory
Often,
often
you'll
you'll
want
want
to
to
reference
reference
the
the
same
same
object
object
over
over
and
and
over
over
again
again
in
in
your
your
code.
code
When
when
data
data
is
is
long
long
lived,
lived
it
it
can't
can't
go
go
in
in
the
the
call
call
stack.
stack
Instead,
instead
most
most
languages
languages
have
have
a
a
separate
separate
area
area
of
of
memory
memory
hold
hold
the
the
heap,
heap
which
which
unlike
unlike
the
the
call
call
stack
stack
can
can
grow
grow
and
and
shrink
shrink
based
based
on
on
how
how
your
your
application
application
is
is
used.
used
It
it
also
also
allows
allows
you
you
to
to
pass
pass
objects
objects
by
by
reference,
reference
which
which
means
means
you
you
can
can
use
use
the
the
same
same
object
object
in
in
multiple
multiple
variables
variables
without
without
increasing
increasing
the
the
memory
memory
footprint
footprint
because
because
it
it
always
always
points
points
to
to
the
the
same
same
chunk
chunk
of
of
memory
memory
in
in
the
the
heap.
heap
Now,
now
what's
what's
interesting
interesting
is
is
that
that
if
if
we
we
go
go
back
back
to
to
the
the
CPU
cpu
that
that
we
we
talked
talked
about
about
in
in
the
the
beginning,
beginning
you'll
you'll
notice
notice
that
that
it
it
contains
contains
multiple
multiple
threads.
threads
A
a
thread
thread
takes
takes
the
the
physical
physical
CPU
cpu
core
core
in
in
breaks
breaks
into
into
virtual
virtual
cores
cores
that
that
allow
allow
it
it
to
to
run
run
code
code
simultaneously.
simultaneously
There
there
are
are
some
some
programming
programming
languages
languages
that
that
support
support
parallelism
parallelism
where
where
you
you
can
can
write
write
code
code
that
that
literally
literally
executes
executes
on
on
2
2
different
different
threads
threads
at
at
the
the
same
same
time.
time
However,
however
many
many
languages
languages
out
out
there
there
are
are
only
only
single
single
threaded,
threaded
but
but
that
that
doesn't
doesn't
mean
mean
they
they
can't
can't
do
do
2
2
things
things
at
at
the
the
same
same
time.
time
Instead,
instead
they
they
implement
implement
concurrency
concurrency
models
models
like
like
an
an
event
event
loop
loop
or
or
coroutines
coroutines
that
that
can
can
pause
pause
or
or
delay
delay
the
the
normal
normal
execution
execution
of
of
code
code
to
to
handle
handle
multiple
multiple
job's
job's
on
on
a
a
single
single
thread
thread
at
at
the
the
same
same
time.
time
Now,
now
in
in
modern
modern
computing,
computing
we're
we're
rarely
rarely
working
working
with
with
the
the
bare
bare
metal
metal
CPU
cpu
and
and
RAM.
ram
Instead,
instead
we
we
work
work
in
in
the
the
cloud
cloud
with
with
a
a
virtual
virtual
machine,
machine
which
which
is
is
just
just
a
a
piece
piece
set
set
software
software
that
that
simulates
simulates
hardware
hardware
that
that
allows
allows
us
us
to
to
take
take
really
really
big
big
computers
computers
and
and
split
split
them
them
up
up
into
into
a
a
bunch
bunch
of
of
smaller
smaller
virtual
virtual
computers.
computers
These
these
machines
machines
are
are
the
the
backbone
backbone
of
of
the
the
Internet
internet
and
and
are
are
connected
connected
via
via
the
the
Internet
internet
protocol.
protocol
Each
each
machine
machine
has
has
a
a
unique
unique
IP
ip
address
address
to
to
identify
identify
it
it
on
on
the
the
network.
network
Work.
work
That
that
IP
ip
address
address
is
is
usually
usually
alias
alias
to
to
a
a
URL
url
that
that
is
is
registered
registered
in
in
a
a
global
global
database
database
called
called
the
the
domain
domain
name
name
service.
service
Now
now
to
to
establish
establish
a
a
connection,
connection
in.
in
The
the
2
2
computers
computers
will
will
perform
perform
a
a
TCP
tcp
handshake,
handshake
which
which
will
will
allow
allow
them
them
to
to
exchange
exchange
messages
messages
called
called
packets.
packets
On
on
top
top
of
of
that,
that
there's
there's
usually
usually
security
security
layer
layer
like
like
SSL
ssl
to
to
encrypt
encrypt
and
and
decrypt
decrypt
the
the
messages
messages
over
over
the
the
network.
network
Now
now
the
the
2
2
computers
computers
can
can
securely
securely
share
share
data
data
with
with
the
the
hypertext
hypertext
transfer
transfer
for
for
protocol.
protocol
The
the
client
client
may
may
request
request
a
a
web
web
page,
page
then
then
the
the
server
server
will
will
respond
respond
with
with
some
some
HTML.
html
Modern
modern
servers
servers
provide
provide
a
a
standardized
standardized
way
way
for
for
a
a
client
client
to
to
request
request
data,
data
which
which
is
is
called
called
an
an
application
application
programming
programming
interface
interface
or
or
API.
api
The
the
most
most
common
common
architecture
architecture
is
is
REST,
rest
where
where
URLs
urls
are
are
mapped
mapped
to
to
different
different
data
data
entities
entities
available
available
on
on
the
the
server.
server
And
and
that
that
brings
brings
us
us
to
to
our
our
final
final
topic,
topic
mother
mother
effing
effing
printers.
printers
You're
you're
gonna
gonna
need
need
to
to
learn
learn
how
how
these
these
things
things
work
work
inside
inside
fighting
fighting
out,
out
because
because
every
every
time
time
you
you
go
go
to
to
grandma's
grandma's
house,
house
she's
she's
going
going
to
to
ask
ask
you
you
to
to
fix
fix
it,
it
which
which
shouldn't
shouldn't
be
be
a
a
problem
problem
for
for
a
a
computer
computer
scientist
scientist
like
like
you.
you
Thanks
thanks
for
for
watching,
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
one.
one
success
The importance of hardware and memory for a computer to handle input and output, command line interface, and creating a garbage collector is discussed in the science behind the garbage code in machine design. Different programming languages and character databases are also discussed, including the use of algorithms and the "urance point" method for precision numbers. Different types of algorithms, including brute force, dynamic programming, and greedy algorithms, are also discussed, along with the use of classes, variables, and design patterns for data and objects in code. The speaker also discusses the use of virtual machines and mother effing printer for writing code.
100+ Computer Science Concepts Explained
What's the first thing you should do when your code throws an error? Obviously, you should change nothing and try to run it again a few times. If that doesn't work, you're gonna need a computer science degree. The awesome thing about software engineering is that you can learn to code and get a high paying job, while literally having no idea how anything actually works. It all just feels like magic. Like a pilot driving a giant metal tube in the sky while knowing nothing about aerodynamics. Mother of God, no. Holy shit. Shit. Welcome to computer science 101. In today's video, you'll learn the science behind the garbage code you've been writing by learning 101 different computer science terms and concepts. This is a computer. It's just a piece of tape that holds ones and zeros along with a device that can read and write to it. It's called a Turing machine and in theory, it can compute anything, like the graphics in this video or the algorithm that recommended that you watch it. At the core of modern computers, we have the central processing unit. If we crack rack it open, we find a piece of silicon that contains billions of tiny transistors, which are like microscopic on off switches. The value at one of these switches is called a bit end is the smallest piece of information a computer can use. However, 1 bit by itself is not very useful, so they come in a package of 8 called a byte. 1 byte can represent 250 6 different values, like all the characters that you type on your keyboard. In fact, when you type into your keyboard, the character produced is actually mapped to a binary value in a character encoding like ASCII or utf8 binary is just a system for counting, like the base ten system you normally use when counting seeing on your fingers, but it only has 2 characters, 1 and 0. Humans have a hard time reading binary, so most often it's represented in a hexadecimal base 16 format, where ten numbers and 6 letters can represent a 4 bit group called a nibble. As a developer, when you write code in a programming language, it will actually be converted into machine code, which is a binary format that can be decoded and executed by the CPU. What it doesn't do though is store data for your applications. For that, computers have random access memory or RAM. It's like a neighborhood, and inside of every house lives a byte. Every location has a memory address, which the CPU can read and write too. You can think of the CPU and RAM as the brain of the computer. But in order for a computer to be useful, it needs to handle input and output. An input device might be the keyboard and mouse, while an output device might be your monitor. Luckily, most developers don't need to worry about how this hardware fits together because we have operating system kernels, like Linux, Mac, and Windows that control all hardware resources via device drivers. Now, to start hacking on the operating system, your first entry point is the shell, which is a program that is the operating system to the end user. It's called a shell because it wraps the kernel. It takes a line of text as input and produces an output. At this is called a command line interface. Not only can it connect to your own computer, but with the secure shell protocol, it can also connect to remote computers a network. Now that you have access to the mainframe, it's time to pick a programming language, which is a tool that uses the abstraction principle to make computers practical to work with for humans by simplifying different systems layer by layer. Some languages like Python are interpreted. That means there's a program called an interpreter that will execute each line of code 1 by 1. Other languages like c plus plus are compiled. They use a compiler to convert the entire program into machine code in advance before the CPU attempts to execute it. This results in an executable file that can be run by the operating system without any extra dependencies. Now every every programming language has a variety of built in data types to represent the data we're working with in our code. Instead of bytes, we work with more human friendly things select characters and numbers. Now, the most fundamental way to use data in your application is to declare a variable. This attaches a name to a data point, allowing you to reuse it somewhere else in your code. Python is a dynamically typed language, which means we don't need to tell the program exactly which data type is assigned to a variable. It just figures it out automatically. However, other languages like C are statically typed, and that means you need to specify the data type of a variable in your code. When you define a variable, its value is stored somewhere in memory on the hardware, and you may need to allocate and free up memory already throughout the program. A pointer is a variable whose value is the memory address of another variable, which can be used for low level memory control. Many languages don't want to deal with low level memory management and instead implement a garbage collector, which automatically allocates and deallocates memory when an object is no longer referenced in the program. Carpet day. No. Now, the data types available are different in every programming language, but typically you'll find int to represent whole numbers, switch may or may not be signed or unsigned to represent negative numbers as well. When numbers require a decimal point, they typically use the floating point type. It's called a float because there's only enough memory to represent a certain range of numbers at a certain precision, and is basically a form of scientific notation to make computers faster. If you need more range or precision, many languages also have a double that doubles the amount of memory used for the number. Now when it comes to characters, you'll typically find the char data type to represent a single character or more commonly a string to represent multiple characters together. Ultimately, these characters triggers get stored in a memory address somewhere, but they need to be stored in a certain order. When the order starts with the most significant byte and the smallest memory address, it's called big endian or vice versa, if the least significant byte is stored in the smallest address, it's called little endian. When it comes to practical software for engineering. One of the most fundamental things we do is organize data into data structures. The most useful data structure is probably the array or list. Just like a shopping list. It organizes multiple data points and order. However, it also maintains an index of integers that starts at 0 and goes up for every new item in the list. That can be useful, but you don't actually need an index to create a list of items. Another option is a link list where each item has a pointer to the next item in front of Another option is a stack that follows the last in first out principle. It's like stacking a set of plates, then when you want to access data, you pop the last one off the top. The inverse option is a q, which is first in first out. Just like when you get into the breadline, the first person there is the first one to be fed. Now, another extremely useful data structure is the hash, which might also be called a map or dictionary. It's like an array, but instead of an index of integers, you define the keys that point to each individual item, giving you a collection of key value pairs. In many cases though, it's not efficient to organize data in a linear way. To address that problem, we have trees, which organize nodes together in a hierarchy that can often be traversed more quickly. This can sometimes be too rigid of data structure though. So instead, a graph can be created to connect multiple nodes together in a virtually unlimited number of ways. A graph has a node for the data and an edge for the relationship between the data points. Data structures are essential, but they don't do anything by themselves. To do something useful, you'll need to code up an algorithm, which is just code that solves a problem. I took the initiative in creating the Internet. In our code, we have several mechanisms for implementing algorithms. The most fundamental of which is a function, which is a block of code that takes an input then does something and returns an output. Like a variable, a function has a name and it can called from other parts of your code with different input parameters called arguments. One thing you might do in the function body is compare one value to another. Every language has a variety of built in operators like equality, greater than, and less than that you can use to compare 2 values. If a is greater than b, then it forms a value of true, but if b is greater than a, then the value is false. True false is what's known as a boolean data type and whenever your code produces value like this, it's known as an expression, but not all code will produce a value. Sometimes your code will simply do something which is known as a statement. A good example is the if statement which handles conditional logic. For example, if the condition is true, it will execute this code, otherwise it will short circuit and run the code inside of the else block. Another very common type of statement is a loop. A while loop will run this block of code over and over again until the condition in the parenthesis becomes false. That can be useful, but more often than not, you'll want to loop over an iterable data type like an array. Most languages have a for loop that can run some code for every object in the array or iterable data structure. Now in some cases, a function may not have an output, which is generally called a void function. An interesting thing about functions is that they can call themselves. When a function calls itself, it's called recursion because when done like this by default, it will recurse forever creating an infinite loop. That happens because when you call a function, the programming language will put it into memory on what's known as the call stack, which is a short term chunk of memory for executing your code. When a function keeps calling itself, the language will keep pushing frames onto the call stack until you get a stack overflow error. To avoid this, your algorithm needs a base condition so it knows when to terminate the loop. Now, when you write an algorithm, you'll need to determine if it's any good, and the system for doing that is called big o notation. It's a standard format for approximating the performance have an algorithm at scale. It may reference time complexity, which is how fast your algorithm will run, and space complexity, which deals with how much memory is required to run it. Developers have many different algorithm types at their disposal. The most crude option is brute force, where you might loop over every possible combination to hack somebody's credit card pin. A more sophisticated approach might be divide and conquer, like binary search where you cut the problem in half multiple times until you find what you're looking for. Another option is dynamic programming algorithms, where a problem is broken down into multiple smaller sub problems and the result of each computation is stored for later use using a technique called memoization. That means if a function has already been called, it will use the existing value instead of recomputing it again from scratch. Then we have greedy algorithms that will make the choice that is most beneficial in the short term without considering the problem as a whole. One example of this is Dijkstra's shortest path algorithm. On the flip side, we have backtracking algorithms, which take a more incremental approach by looking at all the possible options, like a rat in a maze exploring all the different potential paths. Now, when it comes to implementing your code, there are always multiple ways to get the job done. One aiming paradigm is declarative, where your code describes what the program does and the outcome, but doesn't care about things like control flow. This style of programming is often associated with functional languages like Haskell. The other paradigm is imperative programming, where your code uses statements like if and while, providing explicit instructions about how to produce an outcome. It's associated with procedural languages like C. Today, most general purpose languages like Python, JavaScript, Hotline, Swift, and so on are multi paradigm, which means they support all these options at the same time, in addition to object oriented programming. The idea behind OOP is that you use classes to write a blueprint for the data or objects in your code. A class can encapsulate variables, which are commonly called properties, as well as functions, which are usually called methods in this context. It's a common way to organize and reuse code because classes can share behaviors between each other through inheritance, where a subclass can extend and override the behaviors of the parent class. And it opens the door to all kinds have other ideas called design patterns. Now, a class by itself doesn't actually do anything. Instead, it's used to instantiate objects, which are actual chunks of data that live in your computer's memory. Often, you'll want to reference the same object over and over again in your code. When data is long lived, it can't go in the call stack. Instead, most languages have a separate area of memory hold the heap, which unlike the call stack can grow and shrink based on how your application is used. It also allows you to pass objects by reference, which means you can use the same object in multiple variables without increasing the memory footprint because it always points to the same chunk of memory in the heap. Now, what's interesting is that if we go back to the CPU that we talked about in the beginning, you'll notice that it contains multiple threads. A thread takes the physical CPU core in breaks into virtual cores that allow it to run code simultaneously. There are some programming languages that support parallelism where you can write code that literally executes on 2 different threads at the same time. However, many languages out there are only single threaded, but that doesn't mean they can't do 2 things at the same time. Instead, they implement concurrency models like an event loop or coroutines that can pause or delay the normal execution of code to handle multiple job's on a single thread at the same time. Now, in modern computing, we're rarely working with the bare metal CPU and RAM. Instead, we work in the cloud with a virtual machine, which is just a piece set software that simulates hardware that allows us to take really big computers and split them up into a bunch of smaller virtual computers. These machines are the backbone of the Internet and are connected via the Internet protocol. Each machine has a unique IP address to identify it on the network. Work. That IP address is usually alias to a URL that is registered in a global database called the domain name service. Now to establish a connection, in. The 2 computers will perform a TCP handshake, which will allow them to exchange messages called packets. On top of that, there's usually security layer like SSL to encrypt and decrypt the messages over the network. Now the 2 computers can securely share data with the hypertext transfer for protocol. The client may request a web page, then the server will respond with some HTML. Modern servers provide a standardized way for a client to request data, which is called an application programming interface or API. The most common architecture is REST, where URLs are mapped to different data entities available on the server. And that brings us to our final topic, mother effing printers. You're gonna need to learn how these things work inside fighting out, because every time you go to grandma's house, she's going to ask you to fix it, which shouldn't be a problem for a computer scientist like you. Thanks for watching, and I will see you in the next one.
The importance of hardware and memory for a computer to handle input and output, command line interface, and creating a garbage collector is discussed in the science behind the garbage code in machine design. Different programming languages and character databases are also discussed, including the use of algorithms and the "urance point" method for precision numbers. Different types of algorithms, including brute force, dynamic programming, and greedy algorithms, are also discussed, along with the use of classes, variables, and design patterns for data and objects in code. The speaker also discusses the use of virtual machines and mother effing printer for writing code.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : 100+ Computer Science Concepts Explained 
        and a small summary : The importance of hardware and memory for a computer to handle input and output, command line interface, and creating a garbage collector is discussed in the science behind the garbage code in machine design. Different programming languages and character databases are also discussed, including the use of algorithms and the "urance point" method for precision numbers. Different types of algorithms, including brute force, dynamic programming, and greedy algorithms, are also discussed, along with the use of classes, variables, and design patterns for data and objects in code. The speaker also discusses the use of virtual machines and mother effing printer for writing code.
        [/INST]
        
        Generate the video : What's the first thing you should do when your code throws an error? Obviously, you should change nothing and try to run it again a few times. If that doesn't work, you're gonna need a computer science degree. The awesome thing about software engineering is that you can learn to code and get a high paying job, while literally having no idea how anything actually works. It all just feels like magic. Like a pilot driving a giant metal tube in the sky while knowing nothing about aerodynamics. Mother of God, no. Holy shit. Shit. Welcome to computer science 101. In today's video, you'll learn the science behind the garbage code you've been writing by learning 101 different computer science terms and concepts. This is a computer. It's just a piece of tape that holds ones and zeros along with a device that can read and write to it. It's called a Turing machine and in theory, it can compute anything, like the graphics in this video or the algorithm that recommended that you watch it. At the core of modern computers, we have the central processing unit. If we crack rack it open, we find a piece of silicon that contains billions of tiny transistors, which are like microscopic on off switches. The value at one of these switches is called a bit end is the smallest piece of information a computer can use. However, 1 bit by itself is not very useful, so they come in a package of 8 called a byte. 1 byte can represent 250 6 different values, like all the characters that you type on your keyboard. In fact, when you type into your keyboard, the character produced is actually mapped to a binary value in a character encoding like ASCII or utf8 binary is just a system for counting, like the base ten system you normally use when counting seeing on your fingers, but it only has 2 characters, 1 and 0. Humans have a hard time reading binary, so most often it's represented in a hexadecimal base 16 format, where ten numbers and 6 letters can represent a 4 bit group called a nibble. As a developer, when you write code in a programming language, it will actually be converted into machine code, which is a binary format that can be decoded and executed by the CPU. What it doesn't do though is store data for your applications. For that, computers have random access memory or RAM. It's like a neighborhood, and inside of every house lives a byte. Every location has a memory address, which the CPU can read and write too. You can think of the CPU and RAM as the brain of the computer. But in order for a computer to be useful, it needs to handle input and output. An input device might be the keyboard and mouse, while an output device might be your monitor. Luckily, most developers don't need to worry about how this hardware fits together because we have operating system kernels, like Linux, Mac, and Windows that control all hardware resources via device drivers. Now, to start hacking on the operating system, your first entry point is the shell, which is a program that is the operating system to the end user. It's called a shell because it wraps the kernel. It takes a line of text as input and produces an output. At this is called a command line interface. Not only can it connect to your own computer, but with the secure shell protocol, it can also connect to remote computers a network. Now that you have access to the mainframe, it's time to pick a programming language, which is a tool that uses the abstraction principle to make computers practical to work with for humans by simplifying different systems layer by layer. Some languages like Python are interpreted. That means there's a program called an interpreter that will execute each line of code 1 by 1. Other languages like c plus plus are compiled. They use a compiler to convert the entire program into machine code in advance before the CPU attempts to execute it. This results in an executable file that can be run by the operating system without any extra dependencies. Now every every programming language has a variety of built in data types to represent the data we're working with in our code. Instead of bytes, we work with more human friendly things select characters and numbers. Now, the most fundamental way to use data in your application is to declare a variable. This attaches a name to a data point, allowing you to reuse it somewhere else in your code. Python is a dynamically typed language, which means we don't need to tell the program exactly which data type is assigned to a variable. It just figures it out automatically. However, other languages like C are statically typed, and that means you need to specify the data type of a variable in your code. When you define a variable, its value is stored somewhere in memory on the hardware, and you may need to allocate and free up memory already throughout the program. A pointer is a variable whose value is the memory address of another variable, which can be used for low level memory control. Many languages don't want to deal with low level memory management and instead implement a garbage collector, which automatically allocates and deallocates memory when an object is no longer referenced in the program. Carpet day. No. Now, the data types available are different in every programming language, but typically you'll find int to represent whole numbers, switch may or may not be signed or unsigned to represent negative numbers as well. When numbers require a decimal point, they typically use the floating point type. It's called a float because there's only enough memory to represent a certain range of numbers at a certain precision, and is basically a form of scientific notation to make computers faster. If you need more range or precision, many languages also have a double that doubles the amount of memory used for the number. Now when it comes to characters, you'll typically find the char data type to represent a single character or more commonly a string to represent multiple characters together. Ultimately, these characters triggers get stored in a memory address somewhere, but they need to be stored in a certain order. When the order starts with the most significant byte and the smallest memory address, it's called big endian or vice versa, if the least significant byte is stored in the smallest address, it's called little endian. When it comes to practical software for engineering. One of the most fundamental things we do is organize data into data structures. The most useful data structure is probably the array or list. Just like a shopping list. It organizes multiple data points and order. However, it also maintains an index of integers that starts at 0 and goes up for every new item in the list. That can be useful, but you don't actually need an index to create a list of items. Another option is a link list where each item has a pointer to the next item in front of Another option is a stack that follows the last in first out principle. It's like stacking a set of plates, then when you want to access data, you pop the last one off the top. The inverse option is a q, which is first in first out. Just like when you get into the breadline, the first person there is the first one to be fed. Now, another extremely useful data structure is the hash, which might also be called a map or dictionary. It's like an array, but instead of an index of integers, you define the keys that point to each individual item, giving you a collection of key value pairs. In many cases though, it's not efficient to organize data in a linear way. To address that problem, we have trees, which organize nodes together in a hierarchy that can often be traversed more quickly. This can sometimes be too rigid of data structure though. So instead, a graph can be created to connect multiple nodes together in a virtually unlimited number of ways. A graph has a node for the data and an edge for the relationship between the data points. Data structures are essential, but they don't do anything by themselves. To do something useful, you'll need to code up an algorithm, which is just code that solves a problem. I took the initiative in creating the Internet. In our code, we have several mechanisms for implementing algorithms. The most fundamental of which is a function, which is a block of code that takes an input then does something and returns an output. Like a variable, a function has a name and it can called from other parts of your code with different input parameters called arguments. One thing you might do in the function body is compare one value to another. Every language has a variety of built in operators like equality, greater than, and less than that you can use to compare 2 values. If a is greater than b, then it forms a value of true, but if b is greater than a, then the value is false. True false is what's known as a boolean data type and whenever your code produces value like this, it's known as an expression, but not all code will produce a value. Sometimes your code will simply do something which is known as a statement. A good example is the if statement which handles conditional logic. For example, if the condition is true, it will execute this code, otherwise it will short circuit and run the code inside of the else block. Another very common type of statement is a loop. A while loop will run this block of code over and over again until the condition in the parenthesis becomes false. That can be useful, but more often than not, you'll want to loop over an iterable data type like an array. Most languages have a for loop that can run some code for every object in the array or iterable data structure. Now in some cases, a function may not have an output, which is generally called a void function. An interesting thing about functions is that they can call themselves. When a function calls itself, it's called recursion because when done like this by default, it will recurse forever creating an infinite loop. That happens because when you call a function, the programming language will put it into memory on what's known as the call stack, which is a short term chunk of memory for executing your code. When a function keeps calling itself, the language will keep pushing frames onto the call stack until you get a stack overflow error. To avoid this, your algorithm needs a base condition so it knows when to terminate the loop. Now, when you write an algorithm, you'll need to determine if it's any good, and the system for doing that is called big o notation. It's a standard format for approximating the performance have an algorithm at scale. It may reference time complexity, which is how fast your algorithm will run, and space complexity, which deals with how much memory is required to run it. Developers have many different algorithm types at their disposal. The most crude option is brute force, where you might loop over every possible combination to hack somebody's credit card pin. A more sophisticated approach might be divide and conquer, like binary search where you cut the problem in half multiple times until you find what you're looking for. Another option is dynamic programming algorithms, where a problem is broken down into multiple smaller sub problems and the result of each computation is stored for later use using a technique called memoization. That means if a function has already been called, it will use the existing value instead of recomputing it again from scratch. Then we have greedy algorithms that will make the choice that is most beneficial in the short term without considering the problem as a whole. One example of this is Dijkstra's shortest path algorithm. On the flip side, we have backtracking algorithms, which take a more incremental approach by looking at all the possible options, like a rat in a maze exploring all the different potential paths. Now, when it comes to implementing your code, there are always multiple ways to get the job done. One aiming paradigm is declarative, where your code describes what the program does and the outcome, but doesn't care about things like control flow. This style of programming is often associated with functional languages like Haskell. The other paradigm is imperative programming, where your code uses statements like if and while, providing explicit instructions about how to produce an outcome. It's associated with procedural languages like C. Today, most general purpose languages like Python, JavaScript, Hotline, Swift, and so on are multi paradigm, which means they support all these options at the same time, in addition to object oriented programming. The idea behind OOP is that you use classes to write a blueprint for the data or objects in your code. A class can encapsulate variables, which are commonly called properties, as well as functions, which are usually called methods in this context. It's a common way to organize and reuse code because classes can share behaviors between each other through inheritance, where a subclass can extend and override the behaviors of the parent class. And it opens the door to all kinds have other ideas called design patterns. Now, a class by itself doesn't actually do anything. Instead, it's used to instantiate objects, which are actual chunks of data that live in your computer's memory. Often, you'll want to reference the same object over and over again in your code. When data is long lived, it can't go in the call stack. Instead, most languages have a separate area of memory hold the heap, which unlike the call stack can grow and shrink based on how your application is used. It also allows you to pass objects by reference, which means you can use the same object in multiple variables without increasing the memory footprint because it always points to the same chunk of memory in the heap. Now, what's interesting is that if we go back to the CPU that we talked about in the beginning, you'll notice that it contains multiple threads. A thread takes the physical CPU core in breaks into virtual cores that allow it to run code simultaneously. There are some programming languages that support parallelism where you can write code that literally executes on 2 different threads at the same time. However, many languages out there are only single threaded, but that doesn't mean they can't do 2 things at the same time. Instead, they implement concurrency models like an event loop or coroutines that can pause or delay the normal execution of code to handle multiple job's on a single thread at the same time. Now, in modern computing, we're rarely working with the bare metal CPU and RAM. Instead, we work in the cloud with a virtual machine, which is just a piece set software that simulates hardware that allows us to take really big computers and split them up into a bunch of smaller virtual computers. These machines are the backbone of the Internet and are connected via the Internet protocol. Each machine has a unique IP address to identify it on the network. Work. That IP address is usually alias to a URL that is registered in a global database called the domain name service. Now to establish a connection, in. The 2 computers will perform a TCP handshake, which will allow them to exchange messages called packets. On top of that, there's usually security layer like SSL to encrypt and decrypt the messages over the network. Now the 2 computers can securely share data with the hypertext transfer for protocol. The client may request a web page, then the server will respond with some HTML. Modern servers provide a standardized way for a client to request data, which is called an application programming interface or API. The most common architecture is REST, where URLs are mapped to different data entities available on the server. And that brings us to our final topic, mother effing printers. You're gonna need to learn how these things work inside fighting out, because every time you go to grandma's house, she's going to ask you to fix it, which shouldn't be a problem for a computer scientist like you. Thanks for watching, and I will see you in the next one.
        