Base.cs Podcast
74 episodes - English - Latest episode: about 4 years ago - ★★★★★ - 314 ratingsBeginner-friendly computer science lessons based on Vaidehi Joshi's base.cs blog series, produced by CodeNewbie.
Homepage Apple Podcasts Google Podcasts Overcast Castro Pocket Casts RSS feed
Episodes
S9:E8 - "In the end, the code you take is equal to the code you make"
March 25, 2020 04:00 - 26 minutes - 36 MBFor our final episode, we answer your burning questions including the Base.cs origin story, Saron and Vaidehi's favorite niche data structure, and what are some good resources to check out next. We also take a look back at some of our favorite moments from the show's history, and find a couple of fun themes. Based on Vaidehi Joshi's blog post, "Base.cs".
S9:E7 - "This way to translate is le-JIT"
March 18, 2020 04:00 - 21 minutes - 30.1 MBWe've been talking a lot about the differences between compilers and interpreters, and how both of them work, and the ways that allowed one — the compiler — to lead to the creation of the other — the interpreter. Now we get into the Just In Time compiler, or a JIT, which is fusion or combination of the interpreter and the compiler, which are each two types of translators in their own right. A just-in-time compiler has many of the benefits of both of these two translation techniques, all rolle...
S9:E6 - "Two translators, both alike in dignity"
March 11, 2020 04:00 - 19 minutes - 27.2 MBWe have been talking a lot about compilers, and in this episode we discuss the differences between compilation versus interpretation. An interpreter is also a translator, just like a compiler, in that it takes a high level language (our source text) and converts it into machine code. However, it does something slightly different: it actually runs and executes the code that it translates immediately (inline) as it translates. Based on Vaidehi Joshi's blog post, "A Deeper Inspection Into Compil...
S9:E5 - "Paring down our parse trees with AST"
March 04, 2020 05:00 - 18 minutes - 25.5 MBIn this episode, we take our parse tree, an illustrated, pictorial version of the grammatical structure of a sentence, and we take a metaphorical broom to sweep away repetitive bits, sliming it down, and leveling it up by creating an abstract syntax tree (AST). Based on Vaidehi Joshi's blog post, "Leveling Up One’s Parsing Game With ASTs".
S9:E4 - "Confused about compilers?"
February 26, 2020 05:00 - 22 minutes - 31.4 MBIn this episode, we get into what a compiler is and does. In short, a compiler is a program that reads our code (or any code, in any programming language), and translates it into another language. You'll want to listen in to find out just how it does this! Based on Vaidehi Joshi's blog post, "Reading Code Right, With Some Help From The Lexer".
S9:E3 - "Parsing out parse trees"
February 19, 2020 05:00 - 23 minutes - 31.9 MBIn this episode, we get into parse trees, an illustrated, pictorial version of the grammatical structure of a sentence, which is important to understanding how computers understand coding syntax. Based on Vaidehi Joshi's blog post, "Grammatically Rooting Oneself With Parse Trees".
S9:E2 - "Speeding up our traveling salesperson"
February 12, 2020 05:00 - 21 minutes - 29.7 MBWe continue our journey with the Traveling Salesman Problem (TSP), where this we imagine a salesperson has to travel to every single city in an area, visiting each city only once. Additionally, they need to end up in the same city where they starts their journey from, and do this in the most efficient manner. However, in this episode, we are going to speed our salesperson up by using a bottom-up approach! Based on Vaidehi Joshi's blog post, "The Trials And Tribulations Of The Traveling Salesm...
S9:E1 - "Take a journey with the Traveling Salesman"
February 05, 2020 05:00 - 30 minutes - 41.3 MBWe start our season off with something that often pops up in technical interviews: the Traveling Salesman Problem (TSP). In this problem, a salesperson has to travel to every single city in an area, visiting each city only once. Additionally, they need to end up in the same city where they starts their journey from. Find out how to make our salesperson do this in the most efficient way possible! Based on Vaidehi Joshi's blog post, "The Trials And Tribulations Of The Traveling Salesman".
S8:E8 - "Memoizing all the things in dynamic programming"
December 11, 2019 05:00 - 19 minutes - 26.2 MBIn this last episode of the season we continue our discussion of dynamic programming, and show just how efficient it can be by using the Fibonacci sequence! Based on Vaidehi Joshi's blog post, "Less Repetition, More Dynamic Programming".
S8:E7 - "Dynamic Programming is pretty dynamite "
December 04, 2019 05:00 - 21 minutes - 29.7 MBIn this episode we talk about different paradigms and approaches to algorithmic design: the Divide and Conquer Algorithm, the Greedy Algorithm, and the Dynamic Programming Algorithm, which remembers the subproblems that it has seen and solved before so as not to repeat doing the same thing over again. Based on Vaidehi Joshi's blog post, "Less Repetition, More Dynamic Programming".
S8:E6 - "Getting deeper into Dijkastra"
November 20, 2019 05:00 - 29 minutes - 40.3 MBWe continue our talk about Dijkstra's algorithm, which can be used to determine the shortest path from one node in a graph to every other node within the same graph data structure, provided that the nodes are reachable from the starting node. Based on Vaidehi Joshi's blog post, "Finding The Shortest Path, With A Little Help From Dijkstra".
S8:E5 - "Dijkstra's algorithm is a weighty topic"
November 13, 2019 05:00 - 26 minutes - 35.8 MBIn this episode, we talk about Dijkstra's algorithm, which can be used to determine the shortest path from one node in a graph to every other node within the same graph data structure, provided that the nodes are reachable from the starting node. It's super important, and you'll see why when you learn about the weighted graph! Based on Vaidehi Joshi's blog post, "Finding The Shortest Path, With A Little Help From Dijkstra".
S8:E4 - "DAG, Daniel! Back at it again..."
November 06, 2019 05:00 - 13 minutes - 18.4 MBWe end our section of the DFS algorithm with a discussion on DAGs (directed acyclic graphs), because most implementations of depth-first search will check to see if any cycles exist, and a large part of that is based on the DFS algorithm checking to see whether or not a graph is a directed acyclic graph. DAGs are also somewhat infamous in computer science because they’re pretty much everywhere in sofware. For example, a directed acyclic graph is the backbone of applications that handle schedu...
S8:E3 - "Living on the edge!"
October 29, 2019 04:00 - 20 minutes - 28.7 MBThroughout our exploration of graphs, we’ve focused mostly on representing graphs, and how to search through them. We also learned about edges, the elements that connect the nodes in a graph. In this episode, we look at the different classifications of edges and how, in the context of a graph, edges can be more than just “directed” or “undirected”. Based on Vaidehi Joshi's blog post, "Spinning Around In Cycles With Directed Acyclic Graphs".
S8:E2 - "Jump around the indexes with DFS!"
October 23, 2019 04:00 - 24 minutes - 34.1 MBLast episode, we talked about traversing through a graph with the depth-first search (DFS) algorithm, which helps us determine one (of sometimes many) paths between two nodes in the graph by traversing down one single path until we can't go any further, checking one child node at a time. Now we talk about how you code BFS and what tools might you use. Based on Vaidehi Joshi's blog post, "Deep Dive Through A Graph: DFS Traversal".
S8:E1 - "Getting deep with depth-first search"
October 16, 2019 04:00 - 25 minutes - 35.1 MBWe ended last season by starting our discussion of searching, or traversing, through a graph with breadth-first search (BFS). The breadth-first search algorithm traverses broadly into a structure, by visiting neighboring sibling nodes before visiting children nodes. Now we begin our new season with depth-first search (DFS), which also helps us determine one (of sometimes many) paths between two nodes in the graph, but this time by traversing down one single path in a graph, until we can't go ...
S7:E8 - "Delivering muffins with BFS"
September 11, 2019 04:00 - 23 minutes - 31.6 MBIn this episode, we start our discussion of searching, or traversing, through a graph with breadth-first search (BFS). The breadth-first search algorithm traverses broadly into a structure, by visiting neighboring sibling nodes before visiting children nodes. The power of using breadth-first search to traverse through a graph is that it can easily tell us the shortest way to get from one node to another, which you'll experience first hand by brining muffins to your neighbors! Based on Vaidehi...
S7:E7 - "Plotting to represent a graph? We got you."
September 04, 2019 04:00 - 24 minutes - 33.8 MBIn this episode, we continue our discussion of representing graphs with adjacency lists -- a hybrid between an edge list and an adjacency matrix, which we learned about last episode! They are also the most popular and commonly-used representation of a graph. Based on Vaidehi Joshi's blog post, "From Theory To Practice: Representing Graphs".
S7:E6 - "It's laughable how easy it is to get graphical"
August 28, 2019 04:00 - 21 minutes - 28.9 MBGraphs come from mathematics, and are nothing more than a way to formally represent a network, which is a collection of objects that are all interconnected (this is all stuff you should already know if you have been religiously listening to this podcast, which you should be). Now we're going from theory to practice and talking about how to represent graphs. Based on Vaidehi Joshi's blog post, "From Theory To Practice: Representing Graphs".
S7:E5 - "To b-tree or not to b-tree"
August 21, 2019 04:00 - 16 minutes - 23.1 MBIn last episode, we talked about 2-3 trees, where the nodes of every tree contain data in the form of keys, as well as potential child nodes, and can contain more than one key. This takes us to b-trees, which is a generalized version of the 2-3 tree, and are super efficient for storing data in an indexed database, like MySQL. Based on Vaidehi Joshi's blog post, "Busying Oneself With B-Trees".
S7:E4 - "A 2-3 tree for you and me"
August 14, 2019 04:00 - 20 minutes - 28 BytesWe continue our discussion of tree data structures with 2-3 trees, where the nodes of every tree contain data in the form of keys, as well as potential child nodes. Not only that, but it can contain MORE THAN ONE KEY. They are also the -key- to what we'll be talking about next episode, B-trees, and you won't tree-lieve how cool those are. Based on Vaidehi Joshi's blog post, "Busying Oneself With B-Trees".
S7:E3 - "Color me logarithmic!"
August 07, 2019 04:00 - 23 minutes - 32.1 MBIn this episode, we are looking at a different type of self-balancing tree: red-black trees. By following four very important rules while we paint our tree red and black, we can make it not only self-balancing, but also make it run super efficiently in logarithmic time. Based on Vaidehi Joshi's blog post, "Painting Nodes Black With Red-Black Trees".
S7:E2 - "Stay gold, AVL tree, stay gold"
July 31, 2019 04:00 - 18 minutes - 24.9 MBLast episode, we learned about AVL trees, a type of self-balancing binary search tree that follows a golden rule: no single leaf in the tree should have a significantly longer path from the root node than any other leaf on the tree. In this episode, we learn about a pattern that we can use to programmatically figure out the minimum number of nodes we’ll need to create any given height-balanced AVL tree, which leads us to the Fibonacci sequence, and relates to the "golden ratio" you might know...
S7:E2 - "Stay gold, AVL tree, stay gold."
July 31, 2019 04:00 - 18 minutes - 24.9 MBLast episode, we learned about AVL trees, a type of self-balancing binary search tree that follows a golden rule: no single leaf in the tree should have a significantly longer path from the root node than any other leaf on the tree. In this episode, we learn about a pattern that we can use to programmatically figure out the minimum number of nodes we’ll need to create any given height-balanced AVL tree, which leads us to the Fibonacci sequence, and relates to the "golden ratio" you might know...
S7:E1 - "The AVL balancing act"
July 24, 2019 04:00 - 23 minutes - 21.4 MBWhen you're dealing with data structures like trees, the balance of its "leaves" (data/nodes) matters. The moment a tree becomes unbalanced, it loses its efficiency, much like a real life tree bending to the weight of one side, unable to efficiently stand tall and grab the light of the sun. Don't let your garden grow full of lopsided saplings, and make sure to plant some AVL trees--your efficient runtime hangs in the balance. Based on Vaidehi Joshi's blog post, "The Little AVL Tree That Could".
S6:E8 - "Meet our good friend PATRICIA"
June 19, 2019 04:00 - 27 minutes - 24.9 MBIn this episode, we continue our talk on Radix Trees and introduce the Practical Algorithm To Retrieve Information Coded In Alphanumeric trees, also known as PATRICIA trees. Yeah, I think we'll just stick with calling them PATRICIA trees. Based on Vaidehi Joshi's blog post, "Compressing Radix Trees Without (Too Many) Tears".
S6:E7 - "The cannibalistic efficiency of radix trees"
June 12, 2019 04:00 - 22 minutes - 20.7 MBIn this episode, join us as we adventure into the safari that is radix trees, where parent nodes eat their offspring nodes as they chomp them down and compress. Don't worry, with all of this new added space in the trie(b), they'll more efficiently keep their children's memory alive. Based on Vaidehi Joshi's blog post, "Compressing Radix Trees Without (Too Many) Tears".
S6:E6 - "Dear tries, you (auto)complete me"
June 05, 2019 04:00 - 22 minutes - 21 MBIn this episode we continue our talk on pies and tries, and how this data structure is used to power such things as auto-complete! Based on Vaidehi Joshi's blog post, "Trying to Understand Tries".
S6:E5 - "Tries: the golden retriever of data structures"
May 29, 2019 04:00 - 19 minutes - 17.6 MBIn this episode we go through some trie-als and tribulations to retrieve and build words using tries! Based on Vaidehi Joshi's blog post, "Trying to Understand Tries".
S6:E4 - "Radix sort: the patient zero of sorting algorithms "
May 22, 2019 04:00 - 27 minutes - 25.2 MBThis episode we're diving into radix sort! The word has no relation to Raid, so it is definitely non-toxic and you don't have to bug out. It IS, however, a great integer sorting algorithm, and the first one at that! Based on Vaidehi Joshi's blog post, "Getting To The Root Of Sorting With Radix Sort".
S6:E3 - "You can count on counting sort"
May 15, 2019 04:00 - 29 minutes - 27.1 MBYou may have noticed that it's really hard to sort things efficiently. Well, that's where counting sort comes in! Based on Vaidehi Joshi's blog post, "Counting Linearly With Counting Sort".
S6:E2 - "Getting to the bottom of the heap...sort."
May 08, 2019 04:00 - 24 minutes - 22.5 MBWe've gotten acquainted with heaps as arrays, now we're diving into heap sort with some help from a few condiments! Based on Vaidehi Joshi's blog post, "Heapify All The Things With Heap Sort".
S6:E1 - "Heaps as arrays"
May 01, 2019 04:00 - 17 minutes - 16 MBSo we've talked about heaps, but how do you represent heaps as arrays? And why would you want to? We break it down step by step! Based on Vaidehi Joshi's blog post, "Learning to Love Heaps".
S5:E8 - "Shrinking and growing heaps with cats"
April 03, 2019 04:00 - 17 minutes - 15.8 MBNow that you've got your heap, what do you do with it? Shrink and grow it of course! We talk about how to add and remove values from a heap with the help of a few cats. Based on Vaidehi Joshi's blog post, "Learning to Love Heaps".
S5:E7 - "A heap of heaps"
March 27, 2019 04:00 - 22 minutes - 20.2 MBWhat 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! Based on Vaidehi Joshi's blog post, "Learning to Love Heaps".
S5:E6 - "The big O of quicksort"
March 20, 2019 04:00 - 28 minutes - 26.6 MBHow does quicksort perform? And how do variables, like the pivot number, affect it? We walk through three examples to find out! Based on Vaidehi Joshi's blog post, "Pivoting To Understand Quicksort [Part 2]".
S5:E5 - "Quick sort Queendom"
March 13, 2019 04:00 - 28 minutes - 26.6 MBWe 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. Based on Vaidehi Joshi's blog post, "Pivoting To Understand Quicksort [Part 1]".
S5:E4 - "Merge sort stops the suckage"
March 05, 2019 05:00 - 26 minutes - 23.9 MBFinally, a sorting algorithm that doesn't suck! We explore how merge sort works and why it performs better than insertion, bubble, and selection sort. Based on Vaidehi Joshi's blog post, "Making Sense of Merge Sort ".
S5:E3 - "Sorting with insertion sort"
February 27, 2019 05:00 - 19 minutes - 17.6 MBWe 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. Based on Vaidehi Joshi's blog post, "Inching Towards Insertion Sort".
S5:E2 - "What's bubble sort?"
February 20, 2019 05:00 - 24 minutes - 22.4 MBWe 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. Based on Vaidehi Joshi's blog post, "Bubbling Up With Bubble Sorts".
S5:E1 - "The simple selection sort"
February 13, 2019 05:00 - 23 minutes - 21.4 MBWhat is selection sort? How does this algorithm work? And just as importantly, how does it perform? We use broken books and cookies to tell you all about it! Based on Vaidehi Joshi's blog post, "Exponentially Easy Selection Sort".
S4:E8 - "The Saron Sort"
December 19, 2018 05:00 - 26 minutes - 24.3 MBWe're at the end of the season! And to wrap things up, we're breaking down the last two ways to classify sorting algorithms: recursive vs. non-recursive and comparison vs. non-comparison. We bring it all together to talk about what we can do with all these classifications, and, in true basecs podcast fashion, we bring in seemingly unrelated topics like tomatoes! Based on Vaidehi Joshi's blog post, "Sorting Out The Basics Behind Sorting Algorithms".
S4:E7 - "Sorting the Michaels"
December 12, 2018 05:00 - 23 minutes - 22.1 MBLast week, we talked about two ways of classifying sorting algorithms: time complexity and space usage. This episode, we dig into two more! We explore how algorithms can be internal or external, and what "stability" means for a sorting algorithm. And we do it all with the help of cards, clovers, and a pair of Michaels. Based on Vaidehi Joshi's blog post, "Sorting Out The Basics Behind Sorting Algorithms".
S4:E6 - "It's sorting time!"
December 05, 2018 05:00 - 24 minutes - 22.8 MBYou probably sort things all the time -- files, clothes, dishes. But have you thought about how to categorize your sorting? How do your sorting algorithms hold up in terms of, say, time complexity? We give you an introduction to sorting algorithms, what they are and what they're used for, and dig into the six ways we can classify them. Based on Vaidehi Joshi's blog post, "Sorting Out The Basics Behind Sorting Algorithms".
S4:E5 - "Sets, sets, everywhere"
November 28, 2018 05:00 - 25 minutes - 23.3 MBSets are everywhere! If you've worked with relational databases, made a venn diagram, maybe touched some relational algebra, then you've already worked with sets. We talk about why they're so common, how well they perform (time for some Big O Notation!), and how they're actually implemented. Based on Vaidehi Joshi's blog post, "Set Theory: the Method To Database Madness".
S4:E4 - "Varon explains set theory"
November 21, 2018 05:00 - 18 minutes - 17.1 MBSet theory might sound like a scary, super-math thing, but it's not! Well, it is a math thing, but it doesn't have to be super scary. In fact, if you already know how venn diagrams work, then you basically already know set theory. We'll walk you through it all and show you how it connects back to computer science with the help of our favorite foods. Based on Vaidehi Joshi's blog post, "Set Theory: the Method To Database Madness".
S4:E3 - "Chaining to the rescue!"
November 14, 2018 05:00 - 27 minutes - 25 MBWe're back in our hash table classroom with our multiple Brians that need their own tables! But don't you worry, we've got a brand new collision resolution called chaining to help us out. We talk about how it works and how it compares to linear probing. Based on Vaidehi Joshi's blog post, "Taking Hash Tables Off The Shelf".
S4:E2 - "Too many Brians at the (hash)table"
November 07, 2018 05:00 - 21 minutes - 19.5 MBSchool is in session, and the teacher is directing students to their assigned seat. Each unique name gets its own unique table. But there's an unexpected student in the class. There's another Brian! What do we do?! In this episode, we dig into how to manage these collisions in a hashtable, and how to use our collision resolution strategy to find new Brian his own desk. Based on Vaidehi Joshi's blog post, "Taking Hash Tables Off The Shelf".
S4:E1 - "Gotta hash 'em all"
October 31, 2018 04:00 - 25 minutes - 23.4 MBWe're kicking off a new season with a brand new topic: hash tables! This episode is full of bookshelves, pizza toppings, and helpful fridge operators who are teaming up to give you the most gentle (and the most fun) introduction to the world of hash tables. Based on Vaidehi Joshi's blog post, "Taking Hash Tables Off The Shelf".
S3:E8 - "BFS is your BFF"
October 10, 2018 04:00 - 25 minutes - 23.4 MBLet's break down how breadth-first search (BFS) actually works! We'll walk through a real example, explain the Big O notation of this algorithm, and explore how you might decide whether to use breadth-first search or depth-first search. Based on Vaidehi Joshi's blog post, "Breaking Down Breadth-First Search".