Background Image

Think Like A Software Engineer

Become a true software engineer!

Learning to code is much more than learning new concepts and syntax. It's a whole new mindset. To help you learn that mindset, we create a video called Think Like a Software Engineer every other week. These videos aren't about specific technologies, but cover the meta aspects of software engineering. You can now be explicitly taught a way of thinking that most developers only pick up after years of experience. Our founder and CEO, Jay Wengrow, creates and releases a new episode every other week.
  Video Title Description  
146 Product OOP #3: The Constructor Let's introduce the "constructor", one of the most important tools used in the design of OOP classes. Watch Now
145 Product OOP #2: Classes and Instances The underlying idea behind OOP is to identify the main concepts of your software, and turn them into classes and instances. Watch Now
144 Product OOP #1: Why OOP? Object-Oriented Programming, a.k.a. OOP, is one of the most prevalent styles of writing code today. But what's the point of having a specific style of writing code? Let's get a glimpse of the benefits that a style like OOP can provide. Watch Now
143 Product Error Message: Wrong Number of Arguments One very common error message goes something along the lines of "wrong number of arguments." Let's dive into exactly what this means so you can debug your code with confidence. Watch Now
142 Product How to Find That Missing or Extra Parenthesis If your code contains mismatched parentheses (or brackets or braces), tracking down the errant parenthesis can feel like a wild goose chase. However, there are some neat little tricks in VSCode that can make your hunt much easier. Watch Now
141 Product Error Message: Unexpected End of Input The "Unexpected End of Input" error message can be pretty dumbfounding if you don't already know what it means. But the good news is, by the time you're done with this video, you'll never be confused again. Watch Now
140 Product Benchmarking Speed In almost every case, you can write two different versions of code that accomplish the very same thing. However, it's possible that one version may run faster than the other. But how can you find out which one's faster? With benchmarking tools, that's how. Watch Now
139 Product Getting A Second Error Message Imagine that you get an error message, and while trying to fix it, you get a completely different error message. At first glance, this might seem frustrating, but it could actually be the greatest sign of progress. Watch Now
138 Product How the Web Works: What is Front-End Web Development? In this final episode of our How the Web Works mini-series, we finally explain how websites work under the hood and define the concept of front-end web development. Watch Now
137 Product How the Web Works: What is Back-End Web Development? You may have heard of the terms Back-End, Front-End, and Full-Stack Web Development, but what do they all mean? Now that we've covered some of the fundamentals of how the web works, we're now able to explore the meaning of these terms. In this episode, we'll explain the nuts and bolts of Back-End Web Development. Watch Now
136 Product How the Web Works: Part #2 Last episode we introduced the concepts of the web request and the web response. Now, let's dig into more of the details of how these things work. Watch Now
135 Product How the Web Works: Part #1 A great deal of today's software engineering revolves around the internet and web development. To get started in web development, the first thing one needs to know is how the internet works. Let's dive in to the fundamentals of the web. Watch Now
134 Product Terminal Concepts: Redirecting Output Many terminal commands produce some sort of output. While that output is usually printed out in the terminal itself, did you know that you can redirect that output to another location, such as a file? Learn how this powerful technique works, and how you can use it to your advantage. Watch Now
133 Product Terminal Concepts: Piping Piping is a powerful technique that allows you to process data using your terminal with single-line commands. Watch Now
132 Product Terminal Basics Part #2: Exploring Files The "ls" command is used in the terminal to see what files are in a particular folder. While, at first glance, the command seems very basic, there's lots of great tricks you can do with it to become a power file explorer. Watch Now
131 Product Terminal Basics Part #1: Navigating Folders The terminal is one of the software engineer's most important tools. Here, we introduce the terminal and how to use it to view files and folders on your computer. Watch Now
130 Product Array Pattern: Selecting The Select pattern allows us to pick out certain values from an array that meet a certain condition. Let's first do it the long way, and then learn a cool trick in which we can accomplish our goals with a single line of code. Watch Now
129 Product Array Pattern: Reducing This array pattern allows us to transform an entire array of values into a single value. It's a surprisingly common technique, and there's some really sweet syntax to make it easier. Watch Now
128 Product Array Pattern: Mapping It's useful to be aware of some of the most common programming patterns. Here's one involving arrays that's known as "mapping." Watch Now
127 Product Refactoring: Explaining What Code Does Have you ever looked at a line of code and had no idea what it does? Here's how to refactor YOUR code so that you can make it clear to all what it's doing. Watch Now
126 Product Refactoring Safely When refactoring code, it's easy to inadvertently introduce new bugs by replacing too many or too few words. Here are some techniques for avoiding those traps. Watch Now
125 Product Refactoring: Descriptive Variable Names One of the most important refactoring techniques is updating variable names to make them more descriptive. This will make your code so much easier for other developers to understand, and they'll thank you for it. Watch Now
124 Product Decomposing a Problem Most programming tasks are complex, but the experienced software engineer knows how to decompose them into smaller, simpler parts. Watch Now
123 Product Tinkering Tinkering with new technology helps the software engineer stay curious, and a curious software engineer is one who will always be learning new things and leveling up their skills. Watch Now
122 Product Refactoring: Naming Values In this episode, we introduce the idea of refactoring. There are many techniques when it comes to refactoring code, and this one is really easy to do - you just need to keep an eye out for it. Watch Now
121 Product Languages are Arbitrary Since it's common to think about programming languages as being very logical, we can get thrown off when certain logic doesn't seem to hold up. The truth, though, is that design of languages is comprised of a series of arbitrary decisions, not all of which are logical. Watch Now
120 Product Writing to Files Need to have your code create a file and put information in it? Let's see how easy it is to write to files. Watch Now
119 Product CSV Files CSV files are quite common and something that a software engineer may need to work with from time to time. The good news is that manipulating CSVs with code can be pretty simple - let's see how. Watch Now
118 Product Reading Files A common task of the software engineer is to write code that works with files. While the concept seems intimidating to those who have never done it before, let's see how easy it can be. Watch Now
117 Product Visualizing Others' Code It's not easy to read other people's code, but it's something that a software engineer has to do every day. Here's a tip that will make digesting the code a bit easier. Watch Now
116 Product Disconnected Code When code you've written doesn't seem to accomplish anything at all, and you're not even getting an error message, the culprit very often is "disconnected code." Here's how to diagnose this type of situation. Watch Now
115 Product Interview Question: Duplicate Values In this common interview question, we need to find duplicate values in an array. However, there's an efficient way to do this, and an inefficient way. Your interviewer is hoping you'll show them the efficient way - and here's how it goes. Watch Now
114 Product Interview Question: Fibonacci Numbers One of the oldest interviewing questions in the book is to generate numbers known as the Fibonacci Sequence. While getting the steps right can be slightly tricky, here's how it's done. Watch Now
113 Product Interview Question: Prime Number For some reason, prime numbers are a thing that come up in real job interviews. Let's be prepared to deal with them! Watch Now
112 Product Interview Question: Palindrome Here's another coding challenge that I was presented with in a real job interview. The lucky thing is that there's a neat little trick that makes this exercise easy. Watch Now
111 Product Interview Question: Reverse a String I've been asked to perform this classic coding exercise in a real job interview. There are actually many ways to reverse a string, but here's the approach that I find to be the absolute simplest. Watch Now
110 Product Interview Question: FizzBuzz One of the most common coding challenges to come up in a technical interview is FizzBuzz. Let's break this exercise down. Watch Now
109 Product Installation Issues Installing software using the terminal can be a real pain sometimes. Here's the first step to take when an installation fails. Watch Now
108 Product Prettier + Autosave Here's how to get Prettier to play well with autosave, giving you the ultimate setup to get perfectly formatted code automatically. Watch Now
107 Product Prettier The popular tool called Prettier is key in making sure that you have consistent code formatting across your codebase. Watch Now
106 Product Debugging Someone Else's Software Debugging isn't only for fixing your own code. You can sometimes use the same deductive skills to fix the regular software that you use every day. Watch Now
105 Product Autosave Yourself From Frustration If there's any bug that will make you yell at yourself, it's this one. Let's see how to prevent you from having to yell at yourself ever again. Watch Now
104 Product User-Input Data Types You always have to know what data types you're dealing with. One common snag, specifically, is making the wrong assumption about user-inputted data. Watch Now
103 Product Mistaken Equality Checks There's a very common bug that's a silent killer of many "if" statements. It'll sneak up on you and wreck your code if you don't keep wary of it. Watch Now
102 Product Integer Issues Here's a common but elusive bug that can arise when doing certain kinds of math. Next time it happens to you, you'll be able to squash it right away! Watch Now
101 Product How Do Hex Codes Work? You've probably seen hex codes before when dealing with colors. Hex, short for hexadecimal, codes seem like random letters and numbers, but there's a simple and logical system behind how they work. Watch Now
100 Product Binary Numbers Under the hood, all software is computed as a bunch of binary numbers. A good software engineer will always dig deeper into how things work, so let's explore the basics of binary! Watch Now
99 Product Dangers of Copy and Paste Copying and pasting stuff into your text editor can cause errors so bizarre that they can be right in front of your eyes and you'll never see them. Watch Now
98 Product Logic Trick: Or Equals We can use the "or" operator to completely eliminate an entire conditional statement. Not just that, there's additional syntactic sugar we can use to reduce our code to a beautiful, concise statement. Watch Now
97 Product Logic Trick: Short Circuit With && This logic trick will allow you to clean up some ugly conditional code with the power of the short circuit. Watch Now
96 Product Logic Trick: Verify a Value by Changing It Term: Logic Trick. Definition: A clever use of logic that can be used to solve a thorny coding problem. There are a whole bunch of common logic tricks available to the software engineer. Let's explore one of them here. Watch Now
95 Product Google the Error Message: Part #2 When Googling an error message, if you don't watch out for these traps, you may not get back any useful information. Watch Now
94 Product Google the Error Message: Part #1 One simple trick to debug confusing errors is to paste the actual error message into Google and see what comes up. Here's a basic rundown of how to do this. Watch Now
93 Product Sharing Code With Others It's very common that you'll want to share some of your code with other developers. There are, indeed, many ways to do this. Let's explore the best (and worst!) methods for sharing code. Watch Now
92 Product Condensing Code With clever thought, it's possible to reduce several lines of code down to a single line. However, the software engineer knows when and when not to employ this technique. Watch Now
91 Product Working with Markdown Markdown is a common language used for formatting text, such as README files. If you know the insider tricks, working with Markdown can be extremely easy. Watch Now
90 Product Making a Great README An often overlooked aspect of an open-source software project is the README file. Yet, the README file can mean all the difference for your project's success in the software community. Here's how to make a great README. Watch Now
89 Product Become a Text Editor Power User: Keyboard Shortcuts A confident software engineer, like a confident artisan, knows their tools inside and out. Here are some essential - and also some really cool - keyboard shortcuts to make you as efficient as you can be. Watch Now
88 Product Become a Text Editor Power User: Code Snippets You can automate the process of writing your own code when you harness the power of code snippets. Watch Now
87 Product Become a Text Editor Power User: Multi-cursor Selection The experienced software engineer becomes a power user of their text editor. Let's learn how to harness the power of multi-cursor selection to make clunky tasks simple. Watch Now
86 Product The Debugging Attitude The software engineer spends more time debugging code than writing code. However, more important than having debugging skills is having the right debugging attitude. Watch Now
85 Product Big O Notation Big O Notation is the formalized way to describe how fast a particular piece of code is. It sounds intimidating, but the basic idea is pretty simple once we break it down. Watch Now
84 Product Don't Do This... Or Else There's a misconception regarding conditional statements that I see too often - let's settle this once and for all. Watch Now
83 Product Working With Third-Party Libraries New developers are often afraid to mess around with code provided by third-party libraries. However, it's important to recognize that third party code is just... code. Watch how we can interact with a library with straightforward, classic code. Watch Now
82 Product Sorting Algorithms What do playing cards have to do with algorithms? In this promo video I made for my upcoming book, I explain what algorithms are and why computers rely on them. Watch Now
81 Product Debugging With The Debugger The debugger is an excellent visual tool to help with... well, debugging! Let's see how to use it to quash some bugs. Watch Now
80 Product Exploring Code with a Debugger The bugger is an overlooked tool for exploring code (especially code written by someone else). Let's learn how to use a debugger to walk through and simplify complex code. Watch Now
79 Product Save Your Work! A Quickstart Guide on Github I can't count the number of times that I saw a software developer lose their work because their computer crashed. It's easy to save your code to the cloud, though. Here's how. Watch Now
78 Product Naming Variables It's not enough to write code that works; it's important to write code that can be understood by other software engineers as well. Let's explore one of the most basic techniques for making code more readable. Watch Now
77 Product Know Your Text Editor It's often overlooked, but a software engineer should know their tools inside and out. Let's see how to master the text editor, one of a developer's most important tools. Watch Now
76 Product Truthy or Falsy? Once you have a complete grasp of how truthy and falsy values work, you can write more effective "if" statements, and avoid tricky bugs. Watch Now
75 Product Finding Text With Grep Grep is a simple but powerful tool for finding any text across an entire computer. Watch Now
74 Product The Matrix The matrix can be a thorny data structure to wrap one's mind around. Here are some basic tips for working with it. Watch Now
73 Product Same Data, Different Formats You can have one piece of data, but structure it in various ways. Surprisingly, the way that we format our data can have major ramifications. Watch Now
72 Product But It Works On My Machine! It's a real puzzle when a bit of code works for you but completely breaks down when run on another computer. Let's discover one possible culprit behind this strange situation. Watch Now
71 Product Writing Complex Code When writing code that is a bit involved, there are two techniques that can help you write the code confidently and accurately. Watch Now
70 Product When JavaScript Goes Wrong in the Browser When JavaScript doesn't execute properly in a web browser, it's not intuitive how to go about fixing it. Here's a pro tip for how to hone in on the bug. Watch Now
69 Product Inputs, Outputs, and Assembly Let's use a computer game to learn how Assembly works, and take away practical insights about inputs and outputs. Watch Now
68 Product How to Read a Programming Book You shouldn't read a programming book the same way you read a novel. Learn the right way to read a technical book. Watch Now
67 Product Keeping Current As a software engineer, it's important to keep current with the latest trends in technology. Here's a great tip on how to do this easily. Watch Now
66 Product The Errant Semicolon It's uncanny how one extra semicolon can wreak havoc on one's code. Finding this bug can be tricky - here's how to catch it. Watch Now
65 Product Toggle Logic By having a good grasp on boolean logic, we can make our code much simpler and straightforward. Watch Now
64 Product Short Circuits with Return When writing functions, we often using the "return" keyword. However, many people don't realize that it can short-circuit a function, and that we can use this to our advantage. Watch Now
63 Product Inverted Thinking Sometimes, the way to tackle a problem is to think about it from the "opposite" angle. Watch Now
62 Product Jumping Into a New Technology Here I show, on the fly, how I dive into learning a new technology - in this case, with an automation framework called Hammerspoon. Watch Now
61 Product Testing the Sad Path It's easy to fall into the trap of only testing your code for situations where things go right. Let's learn how to test for every scenario. Watch Now
60 Product A Testing Gotcha While unit tests are useful, they can also be misleading in some cases. Watch out for this testing gotcha! Watch Now
59 Product Writing Tests You may have heard of the concept of writing "tests." This means writing code that tests your other code. But what does that mean? Here, I break this all down. Watch Now
58 Product Unexpected Errors The "unexpected" error message can be difficult to interpret, but here I show the trick in understanding what it's trying to tell you. And, you'll also learn something about and. (That's not a typo.) Watch Now
57 Product Thinking About Space It's possible to write two versions of code that accomplish the same thing, but end up having one version consume a lot more of the computer's memory than the other. Is your code memory efficient? Watch Now
56 Product Reserved Keywords The trickiest bugs are the ones that don't produce error messages. To deal with this, you've got to know all the possible things that may be going wrong. Here's one of them. Watch Now
55 Product Isolating a Problem: In Action One of the most powerful debugging tools is the concept of isolating the problem. We explained this generally back in Episode #14, but watch as we apply this concept to a real-life situation. Watch Now
54 Product JavaScript Equality There's an interesting aspect of JavaScript that can throw you off if you're not expecting it. Learn the secret of JavaScript equality. Watch Now
53 Product Are You Multilingual? How many programming languages do you know? If you answered, "One," you're wrong. And that's because when you know one, you know them all (or most of them, anyway). Watch Now
52 Product Claw Machines and Coding You were probably thinking, "It would be so cool if I can watch Jay play one of those claw machines that tries to grab a prize." Well... you're in luck! Watch me play the claw machine and, more importantly, find out what claw machines and coding have in common. Watch Now
51 Product Debugging Some Python Debugging code doesn't have to be a frustrating game of guessing and checking. Watch as I follow a specific process to debug a bit of Python code. Watch Now
50 Product Edge Cases An important skill for the software engineer is to prepare for the unexpected. Watch Now
49 Product Computer-Based Technical Interviews #2 Continuing from Episode #48, in this video we demo how to do the "debugger" process from your text editor. This method isn't just useful for interviews; it's a great way to reason about any bit of complex code. Watch Now
48 Product Computer-Based Technical Interviews #1 One common form of the software engineering job interview asks the candidate to use a computer to write an algorithm. Here's my #1 recommended strategy for nailing this. Watch Now
47 Product Elegant Hashes In this lesson, we'll discover how using the right data structure can lead to more elegant code. Watch Now
46 Product Count the Steps The efficiency of your code is based on how many steps it takes to run. But how do you figure that out? Here's an easy little trick for that. Watch Now
45 Product Unmodified Objects One thing that often trips up new coders is the confusion around the modification of objects. Learn how to debug instances of where you think you've changed something, but really haven't. Watch Now
44 Product Off By One One of the most common bugs when dealing with loops is the Off-By-One bug. When you know to look for it, you can save yourself a lot of pain. Watch Now
43 Product How to Quit If a program you're running isn't working the way you want it to, that's frustrating. But if you can't even quit that program, that's even more frustrating. Learn how to quit even when your computer is resisting at all costs. Watch Now
42 Product Use Strict This simple JavaScript best practice can prevent a lot of heartache down the road! Watch Now
41 Product The Missing Return When a function you wrote doesn't work as intended, but you also don't get any error messages, where is the first place to look to uncover the problem? Learn about the very first step to take in debugging this kind of problem. In many cases, it's the only step you'll need! Watch Now
40 Product Learning React Part #3 In our third installment of learning React, we learn about "passing props". Watch Now
39 Product Learning React Part #2 In our second installment of learning React, we cover the overview of the React framework. Watch Now
38 Product Learning React Part #1 ReactJS is a popular JavaScript framework - it's the coolest kid on the block as far as JS frameworks go. But I've never had the opportunity to use it. So, I've begun to teach myself React, and I've recorded my entire learning process in realtime. This way, you can get a sense of how software engineers learn new things. Note: This is not a React tutorial! You might learn some React along the way, but it's really a video on how to follow a tutorial and read documentation. Watch Now
37 Product Looping and Deleting It makes good sense to use a loop to check each item from a list, and delete an item if it doesn't belong. But sometimes, good sense doesn't work. Watch Now
36 Product Broken Images Have you ever dealt with broken images on your webpage? Learn how to debug those in a snap. Watch Now
35 Product Programs That Hang Did you ever have a program that runs but does... nothing? The program doesn't quit, there are no error messages, but nothing seems to be happening. It's actually easy to debug this once you know what to look for. Watch Now
34 Product The Speedy Hash Table The hash table is a common data structure that is well known for its ability to store data that comes in pairs. But did you know that you can also use a hash table to dramatically increase the speed of your code? Watch Now
33 Product Whiteboarding Algorithms Learn how to "whiteboard" algorithms - a great tool for designing algorithms as well as a technique often tested for in technical interviews. Watch Now
32 Product The Most Misunderstood Error Message Some error messages are easy to understand, and some are not. But there's one error message in particular that I find to be the most misunderstood by new developers. Watch Now
31 Product console.table Sometimes, it's the little tricks that can make debugging less of a chore and more of a joy. Learn how JavaScript's console.table can help you view certain data in cool, crisp way. Watch Now
30 Product JavaScript Hoisting We all know that the computer processes the code we write from top to bottom. Except when it doesn't, and all our code goes kablooey. Watch Now
29 Product How to Contribute to Open Source Part #3 In the final installment of this three-part mini-series, we look at what happens when a pull request is approved. Watch Now
28 Product How to Contribute to Open Source Part #2 Continuing from Episode #27, we make our actual pull request. Watch Now
27 Product How to Contribute to Open Source For most open source software projects, anyone can contribute and make the software better. But how does that work, exactly? Watch Now
26 Product Converting the World into Code Every day, software engineers model real-world experiences using code. But how do you convert the physical world into numbers and arrays? Watch Now
25 Product Tradeoffs As a software engineer gains more experience, they come to realize that there is never one "best" solution to a problem. Each solution comes with tradeoffs, and it takes skill to determine the best solution for a given problem. Watch Now
24 Product Data Dive Working with nested data doesn't have to be a crap shoot. This tip will help you navigate complex data structures with ease. Watch Now
23 Product End Early In some cases, writing your code out of order can actually prevent a ton of frustration down the road. Watch Now
22 Product Third-Party Duds Third-party libraries can be really useful, except when they aren’t. (Sometimes, all they provide is grief and frustration!) Here are some tips for helping you avoid the duds. Watch Now
21 Product Know Thy Data Types! A software engineer is always thinking about their code in terms of data types. And that's because if you don't know what data type you're dealing with, sneaky bugs can trip you up. Watch Now
20 Product Google Tips Even the most experienced developer relies on Google while coding. But sometimes, finding exactly what you need isn't easy. Here are some pro tips that can help you find the most relevant results. Watch Now
19 Product Gremlins! Is it possible to have a bug in your code that has no logical reason? Maybe something's just wrong with your computer? Let’s have a conversation about gremlins. Watch Now
18 Product Installing Stuff! I don't know about you, but when I first started out coding, I had a terribly difficult time downloading programming languages and tools. I've found that so many people are deterred from learning to code simply because they can't get past the installation process! But if you know what you're doing, installing stuff doesn't have to be that hard. (Most of the time, anyway...) Watch Now
17 Product Reverse-Engineering Documentation There's a trick that experienced software engineers use when reading technical documentation, and it can save you hours of time. Watch Now
16 Product How to Use Stack Overflow If you've ever Googled for coding help, you've probably found the Stack Overflow website. But sometimes, there are tons of answers to a given question! How do you know which one is right? Watch Now
15 Product Automate Everyday Tasks Without Code With the software engineer mindset, you can actually automate day-to-day tasks without even using code. Watch how I automatically populate a Google spreadsheet in real-time with Slack posts that I want to save for later. It's fun, and something that you can get started with right away even if you don't know how to code (yet). Watch Now
14 Product How to Isolate the Problem When something goes wrong, isolating the problem is one of the most important techniques you'll need if you want to fix it. In this video, we use a powerful analogy from IT that will help you learn to systematically isolate any bug. Watch Now
13 Product Debugging a Real Website Error I received an alert that there was an error on my website. So instead of just fixing it, I recorded myself fixing it so you can see for yourself how a software engineer fixes real bugs! Watch Now
12 Product How to Find Stuff When dealing with lots of code, how do you remember what you put where? Even tougher, when dealing with someone else's code, how do you figure out where they put everything? You can actually find anything you need with this one, weird trick. Actually, it's not weird at all. But it's really simple! Watch Now
11 Product Learning Rust Part #2 This is the continuation of my previous week's attempt to teach myself a new programming language on the spot. Watch Now
10 Product Learning Rust Part #1 In which I - unscripted - attempt to teach myself a brand new programming language on the spot. Do I succeed? Watch Now
9 Product What on Earth is Wrong?! You probably know that attention to detail is really important for a software engineer. But perhaps you don't realize to what extreme... Watch Now
8 Product Hacking the Paywall Here, we hack someone else's website to get past an annoying paywall. (For educational purposes only.) Watch Now
7 Product Artificial Intelligence Did you ever wonder how artificial intelligence works? AI is a very broad topic, but in this video, I give you a glimpse into how a software engineer can get a computer to mimic human intelligence. Watch Now
6 Product The Constraints of the Computer Here I use a pattern known as "array mapping" to discuss what is probably the most important aspect of computer programming - the ability to talk to a computer. Being able to talk to a computer requires you to know what the computer understands, and what it doesn't understand. Watch Now
5 Product How Arrays Work Understanding how a computer's memory works can totally flip the way you understand the efficiency of your code. This is key to successful software engineering. Watch Now
4 Product English Code Isn't English Code doesn't always translate into English precisely the way you think it might. By understanding how the computer actually understands your code, you'll be able to write better code. Watch Now
3 Product Getting to the Bottom of Things My friend was asked this problem when interviewing for a software engineering role at Google. Would you have been able to solve it? Learn a special technique for analyzing some of the trickiest questions. Watch Now
2 Product Dealing with Tricky Errors Many times, error messages pinpoint the exact line of code that is buggy. Sometimes, though, an error message may seem to pick on a line that is perfectly valid. Learn how to understand what these tricky error messages are telling you. Watch Now
1 Product Thinking About Time Complexity You can write code in two different ways to accomplish the same thing, yet one version is faster than the other. Learn how to begin to analyze the speed of your code. Watch Now