Base.cs Podcast

Base.cs Podcast
Base.cs Podcast produced by CodeNewbie

S9:E8 - “In the end, the code you take is equal to the code you make”
Mar 25 • 26 min
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!
S9:E7 - “This way to translate is le-JIT”
Mar 18 • 21 min
This episode is going to make you want to dance the JIT-ter Bug.
S9:E6 - “Two translators, both alike in dignity”
Mar 11 • 19 min
What are you going to choose, compilation or interpretation?
S9:E5 - “Paring down our parse trees with AST”
Mar 4 • 18 min
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.
S9:E4 - “Confused about compilers?”
Feb 26 • 22 min
We phase into understanding compilers by getting into phase one of how compilers work: lexical analysis.
S9:E3 - “Parsing out parse trees”
Feb 19 • 23 min
What exactly is a the computer version of a “sentence”? And how do we go about diagramming it, exactly?
S9:E2 - “Speeding up our traveling salesperson”
Feb 12 • 21 min
In our last episode we were a little disappointed that our salesperson was traveling in factorial time, so now we are speeding them up!
S9:E1 - “Take a journey with the Traveling Salesman”
Feb 5 • 30 min
Make your salesperson the most efficient around by using the Hamiltonian path.
S8:E8 - “Memoizing all the things in dynamic programming”
Dec 11, 2019 • 19 min
Get the memo and memoize!
S8:E7 - “Dynamic Programming is pretty dynamite “
Dec 4, 2019 • 21 min
“I will not repeat myself again.” - Dynamic Programming
S8:E6 - “Getting deeper into Dijkastra”
Nov 20, 2019 • 29 min
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.
S8:E5 - “Dijkstra’s algorithm is a weighty topic”
Nov 13, 2019 • 26 min
To get from one point to any other point in a graph, make Dijkstra your weapon of choice.
S8:E4 - “DAG, Daniel! Back at it again…”
Nov 6, 2019 • 13 min
DAG-nabbit! Don’t forget to check whether or not a graph is a directed acyclic graph.
S8:E3 - “Living on the edge!”
Oct 29, 2019 • 20 min
Traversing through a graph is pretty edgy.
S8:E2 - “Jump around the indexes with DFS!”
Oct 23, 2019 • 24 min
To go about coding the depth-first search algorithm (DFS), we revisit an old friend: adjacency lists.
S8:E1 - “Getting deep with depth-first search”
Oct 16, 2019 • 25 min
When going through a maze, hitting a dead end isn’t always a bad thing, especially in depth-first search (DFS).
S7:E8 - “Delivering muffins with BFS”
Sep 11, 2019 • 23 min
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.
S7:E7 - “Plotting to represent a graph? We got you.”
Sep 4, 2019 • 24 min
Adjacency lists are the new type of hybrid you’re going to want to be driving around your code.
S7:E6 - “It’s laughable how easy it is to get graphical”
Aug 28, 2019 • 21 min
We tackle representing graphs and the parts that make it up.
S7:E5 - “To b-tree or not to b-tree”
Aug 21, 2019 • 16 min
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.
S7:E4 - “A 2-3 tree for you and me”
Aug 14, 2019 • 20 min
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.
S7:E3 - “Color me logarithmic!”
Aug 7, 2019 • 23 min
If you thought self-balancing AVL trees were cool, just wait till you learn about red-black trees, which also run in logarithmic time!
S7:E2 - “Stay gold, AVL tree, stay gold”
Jul 31, 2019 • 18 min
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 golden ratio.
S7:E1 - “The AVL balancing act”
Jul 24, 2019 • 23 min
We look at the earliest version of the height-balanced tree concept: the AVL tree.
S6:E8 - “Meet our good friend PATRICIA”
Jun 19, 2019 • 27 min
Take a listen as our binary “dog” barks up the PATRICIA tree.
S6:E7 - “The cannibalistic efficiency of radix trees”
Jun 12, 2019 • 22 min
Recycle, reuse, reduce your space by compressing your tries and creating radix trees.
S6:E6 - “Dear tries, you (auto)complete me”
Jun 5, 2019 • 22 min
“Do or do not, there is no tries…wait, yes we’re still talking tries.”
S6:E5 - “Tries: the golden retriever of data structures”
May 29, 2019 • 19 min
Branch out with us into the tree-like data structure that is tries.
S6:E4 - “Radix sort: the patient zero of sorting algorithms “
May 22, 2019 • 27 min
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).
S6:E3 - “You can count on counting sort”
May 15, 2019 • 29 min
We are nearing the end of our deep-dive into sorting algorithms, and looking at the beautiful efficiency of counting sort.
S6:E2 - “Getting to the bottom of the heap…sort.”
May 8, 2019 • 24 min
Heapify all the things!
S6:E1 - “Heaps as arrays”
May 1, 2019 • 17 min
We dig into how heaps are presented as arrays.
S5:E8 - “Shrinking and growing heaps with cats”
Apr 3, 2019 • 17 min
We talk about how to add and remove values from a heap with the help of a few cats.
S5:E7 - “A heap of heaps”
Mar 27, 2019 • 22 min
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!
S5:E6 - “The big O of quicksort”
Mar 20, 2019 • 28 min
How does quicksort perform? And how do variables, like the pivot number, affect it? We walk through three examples to find out!
S5:E5 - “Quick sort Queendom”
Mar 13, 2019 • 28 min
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.
S5:E4 - “Merge sort stops the suckage”
Mar 5, 2019 • 26 min
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.
S5:E3 - “Sorting with insertion sort”
Feb 27, 2019 • 19 min
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.
S5:E2 - “What’s bubble sort?”
Feb 20, 2019 • 24 min
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.
S5:E1 - “The simple selection sort”
Feb 13, 2019 • 23 min
What is selection sort and how does it work? We use broken books and cookies to tell you all about it!
S4:E8 - “The Saron Sort”
Dec 19, 2018 • 26 min
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, just for good measure.
S4:E7 - “Sorting the Michaels”
Dec 12, 2018 • 23 min
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.
S4:E6 - “It’s sorting time!”
Dec 5, 2018 • 24 min
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.
S4:E5 - “Sets, sets, everywhere”
Nov 28, 2018 • 25 min
Sets are everywhere, and you’re probably already working with them! We talk about how they’re actually implemented and how well they perform.
S4:E4 - “Varon explains set theory”
Nov 21, 2018 • 18 min
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.
S4:E3 - “Chaining to the rescue!”
Nov 14, 2018 • 27 min
The Brians still need their own tables! We resolve our collision with a new strategy: chaining.
S4:E2 - “Too many Brians at the (hash)table”
Nov 7, 2018 • 21 min
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, and make sure each data has a spot.
S4:E1 - “Gotta hash ‘em all”
Oct 31, 2018 • 25 min
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.
S3:E8 - “BFS is your BFF”
Oct 10, 2018 • 25 min
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!
S3:E7 - “Getting in line for breadth-first search”
Oct 3, 2018 • 26 min
We are getting in line, or enqueuing, for breadth-first search! We walk through the steps and compare the process to depth-first search.
S3:E6 - “Drowning in DFS”
Sep 25, 2018 • 28 min
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!
S3:E5 - “When the washing machine’s ‘Inorder’”
Sep 19, 2018 • 24 min
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.
S3:E4 - “Preorder-ing at the family BBQ”
Sep 12, 2018 • 17 min
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 way.
S3:E3 - “Making brownies with depth-first search”
Sep 5, 2018 • 28 min
How are algorithms related to brownies? And how do we navigate through the nodes of a tree when implementing depth-first search?
S3:E2 - “Seven bridges and a triangle”
Aug 29, 2018 • 22 min
We use a triangle to trace simple paths and finally get to the bottom of the seven bridges problem that helped launch graph theory.
S3:E1 - “Oily graphs in Königsberg”
Aug 22, 2018 • 22 min
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.
S2:E8 - “Let’s get graphic”
Apr 4, 2018 • 31 min
We explore what graphs are, how to define them, and how they’re related to discrete mathematics.
S2:E7 - “Logarithm is gonna get you”
Mar 28, 2018 • 26 min
What does it mean for an algorithm to be logarithmic? We revisit Big O notation, this time in the context of binary search.
S2:E6 - “Binary searching”
Mar 21, 2018 • 23 min
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?
S2:E5 - “What’s a binary tree?”
Mar 14, 2018 • 20 min
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?
S2:E4 - “Trees IRL”
Mar 7, 2018 • 20 min
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.
S2:E3 - “Don’t be stumped … by trees”
Feb 28, 2018 • 25 min
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.
S2:E2 - “Queues IRL”
Feb 21, 2018 • 16 min
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.
S2:E1 - “Cue the Queues”
Feb 14, 2018 • 20 min
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.
S1:E8 - “Stacks IRL”
Dec 13, 2017 • 27 min
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 made of and how it operates.
S1:E7 - “How do you make a stack overflow?”
Dec 6, 2017 • 27 min
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.
S1:E6 - “A friendly intro to Big O Notation”
Nov 29, 2017 • 33 min
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 programming decisions.
S1:E5 - “Linked Lists in Your Apartment”
Nov 22, 2017 • 23 min
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 structure.
S1:E4 - “Hexes and Colors”
Nov 17, 2017 • 22 min
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.
S1:E3 - “Hex Queen”
Nov 15, 2017 • 22 min
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.
S1:E2 - “What is encoding?”
Nov 9, 2017 • 21 min
Vaidehi and Saron explore how encoding works and talk through some popular encoding schemes like ASCII, unicode, and base64.
S1:E1 - “Bits, Binary, and Bytes”
Nov 7, 2017 • 24 min
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 as developers.
S1:E0 - “Season 1 Teaser”
Oct 29, 2017 • 2 min
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!