Memory & Storage (Crash Course #19)

So we’ve talked about computer memory a couple times in this series, but what we haven’t talked about is storage. Data written to storage, like your hard drive, is a little different, because it will still be there even if the power goes out - this is known as non-volatile memory. Today we’re going to trace the history of these storage technologies from punch cards, delay line memory, core memory, magnetic tape, and magnetic drums, to floppy disks, hard disk drives, cds, and solid state drives. Initially, volatile memory, like RAM was much faster than these non-volatile storage memories, but that distinction is becoming less and less true today.

Operating Systems (Crash Course #18)

So as you may have noticed from last episode, computers keep getting faster and faster, and by the start of the 1950s they had gotten so fast that it often took longer to manually load programs via punch cards than to actually run them! The solution was the operating system (or OS), which is just a program with special privileges that allows it to run and manage other programs. So today, we’re going to trace the development of operating systems from the Multics and Atlas Supervisor to Unix and MS-DOS, and take at look at how these systems heavily influenced popular OSes like Linux, Windows, MacOS, and Android that we use today.

Integrated Circuits & Moore's Law (Crash Course #17)

So you may have heard of Moore's Law and while it isn't truly a law it has pretty closely estimated a trend we've seen in the advancement of computing technologies. Moore's Law states that we'll see approximately a 2x increase in transistors in the same space every two years, and while this may not be true for much longer, it has dictated the advancements we've seen since the introduction of transistors in the mid 1950s. So today we're going to talk about those improvements in hardware that made this possible - starting with the third generation of computing and integrated circuits (or ICs) and printed circuit boards (or PCBs). But as these technologies advanced a newer manufacturing process would bring us to the nanoscale manufacturing we have today - photolithography.

Software Engineering (Crash Course #16)

This video talks about how HUGE programs with millions of lines of code like Microsoft Office are built. Programs like these are way too complicated for a single person, but instead require teams of programmers using the tools and best practices that form the discipline of Software Engineering. We'll talk about how large programs are typically broken up into into function units that are nested into objects known as Object Oriented Programming, as well as how programmers write and debug their code efficiently, document and share their code with others, and also how code repositories are used to allow programmers to make changes while mitigating risk.

Alan Turing (Crash Course #15)

This video discusses the person who formulated many of the theoretical concepts that underlie modern computation - the father of computer science himself: Alan Turing. Now normally we try to avoid 'Great Man' history in Crash Course because truthfully all milestones in humanity are much more complex than just an individual or through a single lens - but for Turing we are going to make an exception. From his theoretical Turing Machine and work on the Bombe to break Nazi Enigma codes during World War II, to his contributions in the field of Artificial Intelligence (before it was even called that), Alan Turing helped inspire the first generation of computer scientists - despite a life tragically cut short.

Data Structures (Crash Course #14)

This video talks about on how we organize the data we use on our devices. You might remember last episode we walked through some sorting algorithms, but skipped over how the information actually got there in the first place! And it is this ability to store and access information in a structured and meaningful way that is crucial to programming. From strings, pointers, and nodes, to heaps, trees, and stacks get ready for an ARRAY of new terminology and concepts.

Intro to Algorithms (Crash Course #13)

Algorithms are the sets of steps necessary to complete computation - they are at the heart of what our devices actually do. And this isn’t a new concept. Since the development of math itself algorithms have been needed to help us complete tasks more efficiently, but today we’re going to take a look a couple modern computing problems like sorting and graph search, and show how we’ve made them more efficient so you can more easily find cheap airfare or map directions to Winterfell... or like a restaurant or something.

Programming Basics: Statements & Functions (Crash Course #12)

This video gets into the fundamental building blocks of programming languages. We’ll start by creating small programs for our very own video game to show how statements and functions work. We aren’t going to code in a specific language, but we’ll show you how conditional statements like IF and ELSE statements, WHILE loops, and FOR loops control the flow of programs in nearly all languages, and then we’ll finish by packaging up these instructions into functions that can be called by our game to perform more and more complex actions.

The First Programming Languages (Crash Course #11)

This video in the series gets into higher-level languages starting with the development of assembly code and assemblers that allow us to use operands and mnemonics to more easily write programs, but assembly language is still tied to underlying hardware. So by 1952 Navy officer Grace Hopper had helped created the first high-level programming language A-0 and compiler to translate that code to our machines. This would eventually lead to IBM’s Fortran and then a golden age of computing languages over the coming decades. Most importantly, these new languages utilized new abstractions to make programming easier and more powerful giving more and more people the ability to create new and amazing things.

Early Programming (Crash Course #10)

This video looks at the history of programming and the innovations that brought us from punch cards and punch paper tape to plugboards and consoles of switches. These technologies will bring us to the mid 1970s and the start of home computing, but they had limitations, and what was really needed was an easier and more accessible way to write programs - programming languages. Which we’ll get to next week.

Advanced CPU Designs (Crash Course #9)

This video takes a step back and look at how CPU speeds have rapidly increased from just a few cycles per second to gigahertz! Some of that improvement, of course, has come from faster and more efficient transistors, but a number hardware designs have been implemented to boost performance. And you’ve probably heard or read about a lot of these - they’re the buzz words attached to just about every new CPU release - terms like instruction pipelining, cache, FLOPS, superscalar, branch prediction, multi-core processors, and even super computers! These designs are pretty complicated, but the fundamental concepts behind them are not. So bear with us as we introduce a lot of new terminology including what might just be the best computer science term of all time: the dirty bit.

Instructions & Programs (Crash Course #8)

This video transitions from hardware to software! Using that CPU we built last episode we’re going to run some instructions and walk you through how a program operates on the machine level. We'll show you how different programs can be used to perform different tasks, and how software can unlock new capabilities that aren't built into the hardware. This episode, like the last is pretty complicated, but don’t worry - as we move forward into programming the idea of opcodes, addresses, and registers at this machine level will be abstracted away like many of the concepts in this series.

The Central Processing Unit - CPU (Crash Course #7)

This video builds the ticking heart of every computer - the Central Processing Unit or CPU. The CPU’s job is to execute the programs we know and love - you know like GTA V, Slack... and Power Point. To make our CPU we’ll bring in our ALU and RAM we made in the previous two episodes and then with the help of Carrie Anne’s wonderful dictation (slowly) step through some clock cycles. WARNING: this is probably the most complicated episode in this series, we watched this a few times over ourselves, but don't worry at about .03Hz we think you can keep up.

Registers and RAM (Crash Course #6)

This video continues with the basic logic gates discussed in episode 3 we can build a circuit that stores a single bit of information, and then through some clever scaling (and of course many new levels of abstraction) we’ll show you how we can construct the modern random-access memory, or RAM, found in our computers today. RAM is the working memory of a computer. It holds the information that is being executed by the computer and as such is a crucial component for a computer to operate. Next week we’ll use this RAM, and the ALU we made last episode, to help us construct our CPU - the heart of a computer.

How Computers Calculate - the ALU (Crash Course #5)

This video talks about a fundamental part of all modern computers. The thing that basically everything else uses - the Arithmetic and Logic Unit (or the ALU). The ALU may not have to most exciting name, but it is the mathematical brain of a computer and is responsible for all the calculations your computer does! And it's actually not that complicated. So today we're going to use the binary and logic gates we learned in previous episodes to build one from scratch, and then we'll use our newly minted ALU when we construct the heart of a computer, the CPU, in episode 7.

Representing Numbers and Letters with Binary (Crash Course #4)

This video takes a look at how computers use a stream of 1s and 0s to represent all of our data - from our text messages and photos to music and webpages. We’re going to focus on how these binary values are used to represent numbers and letters, and discuss how our need to perform operations on larger and more complex values brought us from our 8-bit video games to beautiful Instagram photos, and from unreadable garbled text in our emails to a universal language encoding scheme.

Boolean Logic & Logic Gates (Crash Course #3)

This video takes a look at how those transistors we talked about last episode can be used to perform complex actions. With the just two states, on and off, the flow of electricity can be used to perform a number of logical operations, which are guided by a branch of mathematics called Boolean Algebra. We’re going to focus on three fundamental operations - NOT, AND, and OR - and show how they were created in a series of really useful circuits. And its these simple electrical circuits that lay the groundwork for our much more complex machines.

Electronic Computing (Crash Course #2)

This video continues from the 'Early Computing' video to discuss how the scale of human civilization continued to grow as did the demand for more sophisticated and powerful devices. Soon these cabinet-sized electro-mechanical computers would grow into room-sized behemoths that were prone to errors. But is was these computers that would help usher in a new era of computation - electronic computing.

Early Computing (Crash Course #1)

This video takes a look at computing’s origins, because even though our digital computers are relatively new, the need for computation is not. Since the start of civilization itself, humans have had an increasing need for special devices to help manage laborious tasks, and as the scale of society continued to grow, these computational devices began to play a crucial role in amplifying our mental abilities. From the abacus and astrolabe to the difference engine and tabulating machine, we’ve come a long way to satisfying this increasing need, and in the process completely transformed commerce, government, and daily life.

Binary Search Tree Visualization

A simple visualization of building a binary search tree.

Searching Sorted List Visualization

Visualizations of two functions searching for a number via linear and binary searches.

Recursive Reverse Visualization

A simple visualization of a recursive function that reverses a given string.

Recursive Factorial Visualization

A simple visualization of a recursive function that calculates the factorial of a given number.

Linked List Queue Visualization

A simple visualization of enqueueing and dequeueing a linked list queue.

Array Queue Visualization

A simple visualization of enqueueing and dequeueing an array queue.

Linked List Stack Visualization

A simple visualization of pushing to and popping from a linked list stack.

Array Stack Visualization

A simple visualization of pushing to and popping from an array stack.

Grokking V8 closures for fun (and profit?)

This post that illustrates how the JavaScript V8 engine handles closures and how these design decisions affect performance.

The Stack Overflow Podcast

The Stack Overflow podcast is a weekly conversation about working in software development, learning to code, and the art and culture of computer programming.

Deconstructing Functional Programming

This presentation explains how to distinguish functional programming hype from reality and how to apply key ideas of functional programming in non-FP languages, separating the good parts of FP from its unnecessary cultural baggage.

Crash Course Computer Science

Crash Course Computer Science is a YouTube video series presented by Carrie Anne Philbin and PBS. Learn about the history of computer science, how computers began to be and were improved and what we can expect from computers in the future. Each video is approximately 10-12 minutes long and will cover key computer science terms and ideas.

Binary Tree Implementation in JavaScript

This post is a complete implementation of a binary tree in JavaScript including functionality for finding nodes, inserting nodes, returning a range of nodes, deleting nodes, keeping track of the size, height and depth of nodes, and keeping the trees balanced and AVL compliant for efficiency purposes.

CS50's Introduction to Computer Science

This computer science course provided by Harvard will give you the basic building blocks for some of the core topics of computer science in a classroom-like setting. You'll also have the opportunity to practice what you're learning in real-world problem sets.

Building a Binary Max Heap in JavaScript

Binary heaps are data structures in computer science that allows for a program to both insert into and extra the max value from efficiently - in O(log n) time. This is favorable to arrays where values can be pushed to the back of the array in O(1), or constant time, but retrieving the maximum value would be measured in O(n) - or linear time.

Integrated Development Environment from HarvardX

This cloud-based IDE supported by HarvardX will allow you to practice programming in C, C++, Java, and Python where you can also save your work to complete later.

Binary Heap Sort Algorithm Implementation

Heap sort is an efficient sorting algorithm - O(n log n) - (both for timing and storage) that compares values against each other. This post is an implementation of the algorithm in JavaScript.

Object-Oriented Programming by Mosh

Learn about the 4 pillars of object-oriented programming: encapsulation, abstraction, inheritance, and polymorphism in this short YouTube video.

SOLID Principles

YouTube video series explaining the SOLID principles of object-oriented programming

Design Principles

Software design principles representing a set of guidelines that helps programmers avoid bad OOP design.

Programming Paradigms

A whirlwind tour of 4 different programming languages emphasizing different programming techniques. You'll leave this talk with a better understanding of which languages are best suited to which types of jobs and a list of resources for learning more.

Programming Paradigms, Assembly, Procedural, Functional & OOP

Paradigms are simply a model, for example a pattern or way of doing something. Programming languages do have paradigms or models, the way in which we write our code. If we write our code in a different way, we're using a different paradigm. Likewise we could use paradigms to suit different situations, it's just the style in which we write our programs.

Spoonful of Maths

This YouTube channel is dedicated to provide viewers with useful explanations for common mathematical concepts found in programming.

Probability

Probability and statistics are as much a part of computer science as they are with our everyday lives. These YouTube tutorials cover a range of probability topics.

What is Discrete Math?

A post introducing the topic of discrete mathematics and what it means for sets of numbers to be discrete.

Discrete Math

Short YouTube videos that cover a typical one-semester class on discrete mathematics.

Learn-C.org

A website where experienced or inexperienced programmers can learn the C programming language.

Data Structure Fundamentals

A short series of videos, this course from UC San Diego will walk you through how to understand and implement data structures with pseudocode.

Graphs

Base.cs Podcast

Beginner-friendly computer science lessons based on Vaidehi Joshi's base.cs blog series, produced by CodeNewbie.

Big-O Cheat Sheet

A webpage that contains tables listing the big-O time and space complexities for common algorithms in computer science.

USFCA Data Structure and Algorithm Visualizations

Interactive animations for a variety of data structures and algorithms created by the University of San Francisco.

Sorting Algorithms Animations by Toptal

Animations that illustrate how effectively data sets from different starting points can be sorted using different algorithms.

Operating System Basics

Cache Performance Tips for JavaScript

Implementing LRU

The Magic of LRU Cache for Optimization

Traveling Salesman Problem Visualization

Algorithms, Optimization, and The Traveling Salesman Problem

NP-Complete Explained (Cook-Levin Theorem)

P vs NP, NP-Complete, and an Algorithm for Everything

P vs NP - An Introduction