 Resources from Basarat Ali Syed in 2022

TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.

typescript

In this lesson, using **TypeScript / Javascript**, we learn how to solve a common problem given to new developers in interviews, generate a random number between two integers. 

Create random integers in a given range

How can you most efficiently maintain the lowest value in a list of items. How about maintaining the largest value?

In this lesson we cover a naïve solution to this problem followed by an efficient solution that utilizes a data structure we have already covered before.

Minimum / Maximum Maintenance algorithm implementation using JavaScript / TypeScript

In a singly linked list each node in the list stores the contents of the node and a reference (or pointer in some languages) to the next node in the list. It is one of the simplest way to store a collection of items.

In this lesson we cover how to create a linked list data structure and how to use its strengths to implement an O(1) FIFO queue.

Implement a singly linked list in TypeScript

A balanced binary tree is something that is used very commonly in analysis of computer science algorithms. In this lesson we cover how to determine the maximum number of items it can accommodate.

We follow this with a discussion on the maximum height of a binary tree given we need to accommodate `n` items.


Find Max Items and Max Height of a Completely Balanced Binary Tree

Once you are familiar with the Heap data structure, a number of programming challenges can magically become super simple. Sorting is just one of those challenges.

In this lesson we cover the heap sort algorithm, why is it called *heap* sort and how to implement it using JavaScript / TypeScript.

Implement the Heapsort algorithm using TypeScript / JavaScript

A stack is an abstract data type that stores a collection of elements, with two principal operations: 
* push: adds an element to the collection
* pop: removes the most recently added element that was not yet removed. 

The order in which elements are poped is `Last In First Out` aka. `LIFO`. In this lesson we discuss how to implement it using JavaScript / TypeScript.

Stack implementation using TypeScript

A queue is an abstract data type that serves as a collection of elements, with two principal operations: enqueue, which adds an element to the collection, and dequeue, which removes the earliest added element. The order in which elements are dequeued is `First In First Out` aka. `FIFO`. The term `queue` takes it name from the real world queues e.g. "a queue at the ticket counter". 

A good target is to implement these operations with a time complexity of O(1). In this lesson we discuss how to implement it using JavaScript / TypeScript.

Queue implementation using TypeScript

Heap is a data structure that can fundamentally change the performance of fairly common algorithms in Computer Science.

The heap data structure is called a heap because it satisfies the heap property. The heap property states, that if P is a parent node of C, then the value of node P is less than the value of node C.

In this lesson we discuss the key operations of the Heap data structure along with their performance. We then implement the data structure using TypeScript / JavaScript.

Implement the heap data structure using JavaScript

Shuffling is a common process used with randomizing the order for a deck of cards.
The key property for a perfect shuffle is that each item should have an equal probability to end up in any given index.

In this lesson we discuss the concept behind the simple modern fisher yates shuffle and implement it in JavaScript / TypeScript.

Shuffle an array

A palindrome is a string that reads the same forward and backward, for example, radar, toot, and madam. In this lesson we discuss how to approach the palindrome problem using TypeScript / JavaScript.

We also discuss a more complex algorithmic challenge of writing a function to check if *any permutation* of a given string is a palindrome.

Determine if a string is a palindrome

MergeSort is a famous example of a divide and conquer algorithm. 
 
In this lesson we cover the merge sort algorithm, how it gets its name, and how to implement it using **TypeScript / JavaScript**.

Merge sort algorithm using TypeScript

Insertion sort is a very intuitive algorithm as humans use this pattern naturally when sorting cards in our hands.
 
In this lesson, using **TypeScript / Javascript**, we’ll cover how to implement this algorithm, why this algorithm gets its name, and the complexity of our implementation of the insertion algorithm.

Insertion sort algorithm using TypeScript

`this` is probably the most tricky thing to use in JavaScript and therefore TypeScript. Fortunately there is a TypeScript compiler flag `noImplicit` `this` that can help catch unsafe usages so beginners don't get caught off guard.

Catch unsafe use of "this" in TypeScript functions

Programming language design does have a concept of bottom type that is a natural outcome as soon as you do code flow analysis. TypeScript does code flow analysis (😎) and so it needs to reliably represent stuff that might never happen. This is what the never type is all about.

Use the never type to avoid code with dead ends using TypeScript

Say you have an array that has at least one item repeated. How would you find the repeated item. This is a question commonly presented to beginner developers. Here we discuss the elegant solution to this problem.

Find the repeated item in an array using TypeScript

Bubble sort is considered the simplest sorting algorithm to implement. We’ll approach the problem in two ways. Once using a set number of iterations, and next using an idiomatic approach. 

We’ll be covering this problem using **TypeScript** / **Javascript**

Bubble sort using TypeScript

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

Learn how to write a promise based delay function and then use it in `async await` to see how much it simplifies code over `setTimeout`.

Lets say you want to call a function after 1s, 2s, 3s. You can use `setTimeout`, or you can wrap it up into a simple delay function that works with async/await

Simplify Asynchronous Callback Functions using async/await

In a doubly linked list each node in the list stores the contents of the node and a pointer or reference to the next and the previous nodes in the list. It is one of the simplest way to store a collection of items.

In this lesson we cover how to create a doubly linked list data structure and how to use its strengths to implement an O(1) FIFO queue + O(1) LIFO stack. We also demonstrate why one would use it over a singly linked list. We also cover how to approach authoring such data structures.

Implement a doubly linked list in TypeScript

Quicksort (also called partition sort and pivot sort) is arguably the most used sorting algorithm. It is the one commonly implemented internally in language runtimes. 

We’ll be covering step by step a recursive approach to solving the quick sort algorithm with **TypeScript / Javascript** and why exactly it’s called _quick_ sort. 

Quicksort algorithm using TypeScript

The FizzBuzz problem is commonly presented as the lowest level of comprehension required to illustrate adequacy in computer programming.

In this lesson you learn about the problem as well as its solution in TypeScript. We will also cover some tricks on approaching the problem and coding interview questions in general.

Understand the FizzBuzz coding problem and its solution

In this lesson we cover all the details of how to sort a list of items using **[TypeScript](/q/typescript)**. There are a few things that will catch beginner developers off guard, such as the `.sort` method mutating your array, and how the `.sort` method doesn’t sort numbers how you’d expect. 

You'll learn these gotcha’s and how to work around them.
 
We’ll also present a few tricks to make your sort logic more readable and maintainable using **TypeScript**.