Podcasts by Base.cs Podcast
Beginner-friendly computer science lessons based on Vaidehi Joshi's base.cs blog series, produced by CodeNewbie.
Further podcasts by CodeNewbie
Podcast on the topic Technologie
All episodes
S9:E8 - "In the end, the code you take is equal to the code you make" from 2020-03-25T00:00
It is the end of the Base.cs series, so we answer some of your questions and take a look back at some of our favorite moments!
Listen
S9:E7 - "This way to translate is le-JIT" from 2020-03-18T00:00
This episode is going to make you want to dance the JIT-ter Bug.
Listen
S9:E6 - "Two translators, both alike in dignity" from 2020-03-11T00:00
What are you going to choose, compilation or interpretation?
Listen
S9:E5 - "Paring down our parse trees with AST" from 2020-03-04T00:00
We get into abstract syntax trees, (usually just referred to as an AST), which is really nothing more than a simplified, condensed version of a parse tree.
Listen
S9:E4 - "Confused about compilers?" from 2020-02-26T00:00
We phase into understanding compilers by getting into phase one of how compilers work: lexical analysis.
Listen
S9:E3 - "Parsing out parse trees" from 2020-02-19T00:00
What exactly is a the computer version of a “sentence”? And how do we go about diagramming it, exactly?
Listen
S9:E2 - "Speeding up our traveling salesperson" from 2020-02-12T00:00
In our last episode we were a little disappointed that our salesperson was traveling in factorial time, so now we are speeding them up!
Listen
S9:E1 - "Take a journey with the Traveling Salesman" from 2020-02-05T00:00
Make your salesperson the most efficient around by using the Hamiltonian path.
Listen
S8:E8 - "Memoizing all the things in dynamic programming" from 2019-12-11T00:00
Get the memo and memoize!
Listen
S8:E7 - "Dynamic Programming is pretty dynamite " from 2019-12-04T00:00
"I will not repeat myself again." - Dynamic Programming
Listen
S8:E6 - "Getting deeper into Dijkastra" from 2019-11-20T00:00
We use Dijkstra's algorithm to find the shortest path from one node to another in a complicated house-shaped graph. Also, Vaidehi sings us a song.
Listen
S8:E5 - "Dijkstra's algorithm is a weighty topic" from 2019-11-13T00:00
To get from one point to any other point in a graph, make Dijkstra your weapon of choice.
Listen
S8:E4 - "DAG, Daniel! Back at it again..." from 2019-11-06T00:00
DAG-nabbit! Don't forget to check whether or not a graph is a directed acyclic graph.
Listen
S8:E3 - "Living on the edge!" from 2019-10-29T00:00
Traversing through a graph is pretty edgy.
Listen
S8:E2 - "Jump around the indexes with DFS!" from 2019-10-23T00:00
To go about coding the depth-first search algorithm (DFS), we revisit an old friend: adjacency lists.
Listen
S8:E1 - "Getting deep with depth-first search" from 2019-10-16T00:00
When going through a maze, hitting a dead end isn't always a bad thing, especially in depth-first search (DFS).
Listen
S7:E8 - "Delivering muffins with BFS" from 2019-09-11T00:00
Take a deep breath as we dive into breadth-first search, a super nifty graph traversing algorithm, which gives the shortest way to get from one node to another.
Listen
S7:E7 - "Plotting to represent a graph? We got you." from 2019-09-04T00:00
Adjacency lists are the new type of hybrid you're going to want to be driving around your code.
Listen
S7:E6 - "It's laughable how easy it is to get graphical" from 2019-08-28T00:00
We tackle representing graphs and the parts that make it up.
Listen
S7:E5 - "To b-tree or not to b-tree" from 2019-08-21T00:00
You won't want to miss the buzz about b-trees, the general version of a 2-3 tree, and a super efficient data storing tree structure.
Listen
S7:E4 - "A 2-3 tree for you and me" from 2019-08-14T00:00
We dive into a tree data structure that can contain more than one key, which is unlike any tree structure we've covered so far. It is also the reason for their name: 2-3 tree.
Listen
S7:E3 - "Color me logarithmic!" from 2019-08-07T00:00
If you thought self-balancing AVL trees were cool, just wait till you learn about red-black trees, which also run in logarithmic time!
Listen
S7:E2 - "Stay gold, AVL tree, stay gold" from 2019-07-31T00:00
Listen and learn about a pattern that you can use to figure out the minimum number of nodes we’ll need to create any height-balanced AVL tree, how it leads us to the Fibonacci sequence, and the gol...
Listen
S7:E1 - "The AVL balancing act" from 2019-07-24T00:00
We look at the earliest version of the height-balanced tree concept: the AVL tree.
Listen
S6:E8 - "Meet our good friend PATRICIA" from 2019-06-19T00:00
Take a listen as our binary "dog" barks up the PATRICIA tree.
Listen
S6:E7 - "The cannibalistic efficiency of radix trees" from 2019-06-12T00:00
Recycle, reuse, reduce your space by compressing your tries and creating radix trees.
Listen
S6:E6 - "Dear tries, you (auto)complete me" from 2019-06-05T00:00
"Do or do not, there is no tries...wait, yes we're still talking tries."
Listen
S6:E5 - "Tries: the golden retriever of data structures" from 2019-05-29T00:00
Branch out with us into the tree-like data structure that is tries.
Listen
S6:E4 - "Radix sort: the patient zero of sorting algorithms " from 2019-05-22T00:00
We're getting to the root of where sorting algorithms began with radix sort ("radix" is latin for "root," this is a funny joke I assure you).
Listen
S6:E3 - "You can count on counting sort" from 2019-05-15T00:00
We are nearing the end of our deep-dive into sorting algorithms, and looking at the beautiful efficiency of counting sort.
Listen
S6:E2 - "Getting to the bottom of the heap...sort." from 2019-05-08T00:00
Heapify all the things!
Listen
S6:E1 - "Heaps as arrays" from 2019-05-01T00:00
We dig into how heaps are presented as arrays.
Listen
S5:E8 - "Shrinking and growing heaps with cats" from 2019-04-03T00:00
We talk about how to add and remove values from a heap with the help of a few cats.
Listen
S5:E7 - "A heap of heaps" from 2019-03-27T00:00
What are heaps? How are they related to binary trees? We use losers, winners, and some cards to help us get to the bottom of heaps!
Listen
S5:E6 - "The big O of quicksort" from 2019-03-20T00:00
How does quicksort perform? And how do variables, like the pivot number, affect it? We walk through three examples to find out!
Listen
S5:E5 - "Quick sort Queendom" from 2019-03-13T00:00
We learn all about our second divide and conquer algorithm, quick sort! We walk through how it works with help from a queendom, a few pointers, and a very helpful pivot number.
Listen
S5:E4 - "Merge sort stops the suckage" from 2019-03-05T00:00
Finally, a sorting algorithm that doesn't suck! We explore how merge sort works and why it performs better than insertion, bubble, and selection sort.
Listen
S5:E3 - "Sorting with insertion sort" from 2019-02-27T00:00
We dig into how insertion sort works, how we know where to do our inserting, and how this sorting algorithm performs, all with the help of our new boos.
Listen
S5:E2 - "What's bubble sort?" from 2019-02-20T00:00
We are super bubbly about bubble sort! We dig into our second sorting algorithm and break down how it works and why it's actually not a great way of sorting things.
Listen
S5:E1 - "The simple selection sort" from 2019-02-13T00:00
What is selection sort and how does it work? We use broken books and cookies to tell you all about it!
Listen
S4:E8 - "The Saron Sort" from 2018-12-19T00:00
In our season finale, we're wrapping up our sorting algorithm classifications with two final categories: recursive vs. non-recursive and comparison vs. non-comparison. And we throw in some tomatoes...
Listen
S4:E7 - "Sorting the Michaels" from 2018-12-12T00:00
What does it mean for a sorting algorithm to be "stable"? What about it being internal or external? We explore two more ways to classify sorting algorithms with the help of a few Michaels.
Listen
S4:E6 - "It's sorting time!" from 2018-12-05T00:00
What's a sorting algorithm, and how do we categorize them? We dig into the six ways to classify them and explore why they're so important.
Listen
S4:E5 - "Sets, sets, everywhere" from 2018-11-28T00:00
Sets are everywhere, and you're probably already working with them! We talk about how they're actually implemented and how well they perform.
Listen
S4:E4 - "Varon explains set theory" from 2018-11-21T00:00
If you know about venn diagrams, then you basically know set theory! We explain how the two are related and connect it back to computer science with the help of some of our favorite foods.
Listen
S4:E3 - "Chaining to the rescue!" from 2018-11-14T00:00
The Brians still need their own tables! We resolve our collision with a new strategy: chaining.
Listen
S4:E2 - "Too many Brians at the (hash)table" from 2018-11-07T00:00
What do you do when you're in a hash table, and two pieces of data get assigned the same spot?! You've got a collision, and you need a resolution! We dig into one strategy to resolve a collision, a...
Listen
S4:E1 - "Gotta hash 'em all" from 2018-10-31T00:00
In our intro to hash tables, we use books, pizza toppings, and fridge operators to break down how hash tables work and what makes them so awesome.
Listen
S3:E8 - "BFS is your BFF" from 2018-10-10T00:00
How does breadth-first search actually work? And how do you know whether you should use that, or depth-first search? And what's the Big O notation for BFS anyway? Let's find out!
Listen
S3:E7 - "Getting in line for breadth-first search" from 2018-10-03T00:00
We are getting in line, or enqueuing, for breadth-first search! We walk through the steps and compare the process to depth-first search.
Listen
S3:E6 - "Drowning in DFS" from 2018-09-25T00:00
How does depth-first search perform in terms of Big O notation? And how do you actually implement it, in coding terms? Let's find out!
Listen
S3:E5 - "When the washing machine's 'Inorder'" from 2018-09-19T00:00
Let's dig into another depth-first search strategy: inorder! This time, we walk through a numerical example, traversing the tree with fresh, animated voices and a broken washing machine.
Listen
S3:E4 - "Preorder-ing at the family BBQ" from 2018-09-12T00:00
We dive into depth-first search by exploring our first of three strategies: preorder! Let's walk through an example step-by-step and get to know members of Saron's fictitious tree family along the ...
Listen
S3:E3 - "Making brownies with depth-first search" from 2018-09-05T00:00
How are algorithms related to brownies? And how do we navigate through the nodes of a tree when implementing depth-first search?
Listen
S3:E2 - "Seven bridges and a triangle" from 2018-08-29T00:00
We use a triangle to trace simple paths and finally get to the bottom of the seven bridges problem that helped launch graph theory.
Listen
S3:E1 - "Oily graphs in Königsberg" from 2018-08-22T00:00
We go all the way back to 1735 to a place called Königsberg. It had seven bridges and a tricky math problem that led to the creation of graph theory.
Listen
S2:E8 - "Let's get graphic" from 2018-04-04T00:00
We explore what graphs are, how to define them, and how they're related to discrete mathematics.
Listen
S2:E7 - "Logarithm is gonna get you" from 2018-03-28T00:00
What does it mean for an algorithm to be logarithmic? We revisit Big O notation, this time in the context of binary search.
Listen
S2:E6 - "Binary searching" from 2018-03-21T00:00
If you've heard of binary trees, you've probably heard of binary search. But how does a binary search algorithm actually work? And do you have to have binary trees, or can you use it on other things?
Listen
S2:E5 - "What's a binary tree?" from 2018-03-14T00:00
We dig into binary trees. What makes a tree binary, and why are they so popular in computer science? And how do you implement one?
Listen
S2:E4 - "Trees IRL" from 2018-03-07T00:00
We explore the world (forest?) of trees even further! We learn what a tree's depth and height are, why they're important, and why unbalanced trees can cause computational problems.
Listen
S2:E3 - "Don't be stumped ... by trees" from 2018-02-28T00:00
What's in a tree? And why do they always seem to pop up in computer science? We dig into the different parts of a tree, and how certain "tree truths" make them so special.
Listen
S2:E2 - "Queues IRL" from 2018-02-21T00:00
Where do we see queues in real life? We explore how queues are used in different parts of the tech stack, and help us do things like send email, create animations, and manage requests.
Listen
S2:E1 - "Cue the Queues" from 2018-02-14T00:00
What's in a queue? And how does it relate to stacks? We explore what they do, how they work, and how to implement them.
Listen
S1:E8 - "Stacks IRL" from 2017-12-13T00:00
Where do you see stacks in real life? We look at how browser histories, call stacks, and undo/redo functionality in blogging are implementations of a stack. We also dig into what exactly a stack is...
Listen
S1:E7 - "How do you make a stack overflow?" from 2017-12-06T00:00
Stack Overflow is an awesome resource, but it's also a real life technical thing! We dig into what causes a stack overflow and unpack the rules of creating and working with stacks.
Listen
S1:E6 - "A friendly intro to Big O Notation" from 2017-11-29T00:00
Big O Notation can be scary. But it doesn't have to be! We unpack this popular cs topic and show you how to use it to evaluate different data structures (like linked lists!) and make better program...
Listen
S1:E5 - "Linked Lists in Your Apartment" from 2017-11-22T00:00
You may be familiar with arrays and hashes and variables, but how much do you know about linked lists? We dig into what they are, how they work, and the pros and cons of using this popular data str...
Listen
S1:E4 - "Hexes and Colors" from 2017-11-17T00:00
Vaidehi and Saron walk through how to count in hexes, discuss where we might see the hexadecimal system in real life, and breakdown the math that makes number 16 so special.
Listen
S1:E3 - "Hex Queen" from 2017-11-15T00:00
Vaidehi and Saron walk through how to count in hexes, discuss where we might see the hexadecimal system in real life, and breakdown the math that makes number 16 so special.
Listen
S1:E2 - "What is encoding?" from 2017-11-09T00:00
Vaidehi and Saron explore how encoding works and talk through some popular encoding schemes like ASCII, unicode, and base64.
Listen
S1:E1 - "Bits, Binary, and Bytes" from 2017-11-07T00:00
We give you a beginner-friendly breakdown of how to count in binary (with some fun counting challenges you can join in on!), how it relates to bits and bytes, and why it's important for us to know ...
Listen
S1:E0 - "Season 1 Teaser" from 2017-10-29T00:00
CodeNewbie is teaming up with the incredible Vaidehi Joshi to turn her base.cs blog series into an awesome podcast. Listen to a clip from the first episode, coming out Nov 8. Make sure to subscribe!
Listen