20 Years Of Fighting Procrastination [Part 12] - Set Up Your Calendar

Segmenting your calendar with intention can drastically increase your deep work capacity and reduce distraction. Here are the core points from the lesson:

- Decompose your calendar by assigning specific time blocks for high-leverage work, shallow tasks (like email), and recovery to reduce ambiguity and improve clarity
- Avoid scattering meetings across the week—batch them into clusters (especially 1:1s) to preserve longer stretches of focus time
- Use your influence to improve team-wide productivity by suggesting standardized no-meeting days or more structured meeting schedules
- Even if you don’t follow your calendar plan perfectly, the act of time blocking improves your estimation skills and helps build a rhythm for deep work

20 Years Of Fighting Procrastination [Part 11] - Decompose Aggressively

Decomposition is one of the most reliable habits for making progress feel easy, especially when applied daily. Here are the core points from the lesson:

- Breaking down large, ambiguous tasks into small, concrete steps helps reduce mental friction and makes it easier to start taking action
- Practicing decomposition builds leadership skills and supports team collaboration, since assigning scoped work is essential for effective delegation
- Writing down one key task the night before primes your brain to subconsciously begin planning, leading to more clarity and momentum the next morning

20 Years Of Fighting Procrastination [Part 10] - The Simple Playbook For Sleep

Sleep is often underestimated, yet it’s one of the most powerful levers for improving productivity, health, and mental clarity. Here are the core points from the lesson:

- Sleep has greater long-term health impact than alcohol or smoking, and chronic deprivation leads to worse mood, lower energy, and reduced cognitive function
- Treating yourself as “a good sleeper” and following a consistent wind-down routine (e.g. reading, brushing teeth early, reflecting on the next day) can drastically improve sleep quality
- Physical activity, especially group-based with accountability, helps regulate sleep and creates natural productivity deadlines
- Even small efforts like 10–15 minutes of movement or consistent pre-bed rituals can create compounding benefits for both rest and output

20 Years Of Fighting Procrastination [Part 9] - Say FU (Focus Uninterrupted) To Meetings

Sitting through too many meetings can quietly kill productivity. This video offers a framework for reclaiming your time and focusing on deep work. Here are the core points from the lesson:

- One time in Rahul's past, there was very senior Facebook engineer boosted output and morale by declaring “meeting bankruptcy” and skipping all meetings for a month to focus on heads-down coding
- Most meetings aren’t necessary—test their value by asking if they make you more effective and whether the same information could be shared asynchronously
- As you get familiar with your company’s culture, work with your manager to trim or redesign meetings that don’t drive impact, especially recurring ones

Become A Debugging Master [Part 9] - Understand The End-To-End Flow

Most engineers waste time guessing at random fixes instead of methodically understanding the flow of what’s actually happening. Here are the core points from the lesson:

- Before you fix a bug, deeply understand the end-to-end flow, the intended behavior, and where reality deviates
- Avoid “blind fixes”—randomly adding things like null checks without fully identifying the root cause leads to fragile software
- Break down the system into smaller steps, narrow down the problem area through a process of elimination, and ask better questions based on where things fail
- Understand which components are involved, how they communicate, and what data formats they expect to quickly spot mismatches or errors
- Strong debuggers act like detectives: they map out the flow precisely, isolate the problem, and only fix after gaining clarity on why things broke

Become A Debugging Master [Part 7] - Understand The Blast Radius

One of the biggest mistakes software engineers make is jumping straight into fixing a bug without first understanding the full impact. Here are the core points from the lesson:

- Before fixing anything, assess and document the “blast radius” by asking when the issue started, who and where it impacts, and what product versions are affected
- Think ahead to the post-mortem by tracking detection, notification, response, and mitigation details early, even while still gathering info
- Communicate frequent updates to leadership and stakeholders—even if there’s no fix yet—to maintain trust and reduce panic

Become A Debugging Master [Part 6] - Reproduce The Issue

It's crucial to thoroughly reproduce a bug before attempting to fix it - This can be often trickier than engineers think. Here are the core points from the lesson:

- Reproducing a bug requires systematically testing different versions, languages, devices, network conditions, experiments, and user paths—not just trying once and giving up
- Bugs might appear intermittent or path-dependent, so multiple attempts and thoughtful investigation into what *wasn’t* captured in the bug report are essential
- Understand the broader categories of software failures (functional, usability, integration, concurrency, security, performance, user error) so you can better diagnose the true underlying problem
- Strong debugging starts with deeply understanding when and why the bug occurs, forming the foundation for prioritizing and fixing it effectively

Types of software bugs: <https://www.browserstack.com/guide/types-of-software-bugs>

15 SWE Years In 1.5 Hours [Part 14] - Choosing The Right Company

When you have a good engineer and a bad team, the bad team wins 99.9% of the time. This lesson teaches you:

- The first thing you need to do before even thinking about which company is best for you
- Where earlier-in-career engineers should (probably) go
- The foundational benefits of working at FAANG
- When it makes sense to work at startups

15 SWE Years In 1.5 Hours [Part 10] - Data Structures And Algorithms

Because of Google, we all need to live in a LeetCode reality. Data structures and algorithms (DSA) are something we all love to hate, but at the end of the day, you need to master them to land a job at the world's leading tech companies. This lesson teaches you:

- Why grinding DSA is 100% worth it
- How the learning curve for DSA works (and why you shouldn't get discouraged)
- How to learn DSA properly
- The best tool to get for DSA prep
- What to do when you get stuck on a data structures and algorithms problem

To dive deeper into data structures and algorithms, follow our learning path here: [Crack The Data Structures And Algorithms Interview](https://www.jointaro.com/learning-paths/crack-the-data-structures-and-algorithms-interview/)

Get The Rating You Deserve [Part 1] - Course Outline

**In this course, we'll explore strategies, principles, and tactics to effectively convert the value you create into the rewards you deserve.**

- **Unleash Your Potential:** We'll address common pitfalls and biases that hinder career advancement, empowering you to overcome obstacles and achieve your goals.
- **Mindset Matters:** By shifting your mindset and adopting a positive, empowered perspective, you can accelerate your progress and achieve significant results.
- **Proven Strategies:** We'll delve into specific strategies and tactics that have been proven to be effective in maximizing your career potential.
- **Real-World Insights:** Through real-world examples and case studies, we'll illustrate how these principles can be applied to your specific career situation.

If you want to get personalized support from Yogi, you can reach out to him at [coaching@yogisharma.com](mailto:coaching@yogisharma.com) or schedule an introductory call to dive into your situation at <https://tinyurl.com/meetyogi>.

DSA Crash Course [Part 39] - Depth First Values Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function, *depth_first_values*, that takes in the root of a binary tree. The function should return a list containing all values of the tree in depth-first order.

```
a = Node('a')
b = Node('b')
c = Node('c')
d = Node('d')
e = Node('e')
f = Node('f')
a.left = b
a.right = c
b.left = d
b.right = e
c.right = f
#      a
#    /   \
#   b     c
#  / \     \
# d   e     f

depth_first_values(a)
#   -> ['a', 'b', 'd', 'e', 'c', 'f']
```

```
a = Node('a')
b = Node('b')
c = Node('c')
d = Node('d')
e = Node('e')
f = Node('f')
g = Node('g')
a.left = b
a.right = c
b.left = d
b.right = e
c.right = f
e.left = g
#      a
#    /   \
#   b     c
#  / \     \
# d   e     f
#    /
#   g

depth_first_values(a)
#   -> ['a', 'b', 'd', 'e', 'g', 'c', 'f']
```

```
a = Node('a')
#     a

depth_first_values(a)
#   -> ['a']
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). You can try out the concepts yourself in their interactive code editor and learn advanced DSA patterns like stack exhaustive recursion.

Use [**this link to get 20% off**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: <https://www.linkedin.com/in/alvin-zablan-b73a92117/>

DSA Crash Course [Part 24] - Linked List Values Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function, *linked_list_values*, that takes in the head of a linked list as an argument. The function should return a list containing all values of the nodes in the linked list.

```
a = Node("a")
b = Node("b")
c = Node("c")
d = Node("d")
a.next = b
b.next = c
c.next = d

# a -> b -> c -> d

linked_list_values(a) # -> [ 'a', 'b', 'c', 'd' ]
```

```
x = Node("x")
y = Node("y")
x.next = y

# x -> y

linked_list_values(x) # -> [ 'x', 'y' ]
```

```
q = Node("q")

# q

linked_list_values(q) # -> [ 'q' ]
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). You can try out the concepts yourself in their interactive code editor and learn advanced DSA patterns like stack exhaustive recursion.

Use [**this link to get 20% off**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: <https://www.linkedin.com/in/alvin-zablan-b73a92117/>

DSA Crash Course [Part 12] - Pair Sum Approach

In this lesson, Alvin explores the strategy to solving the following interview problem:

> Write a function, *pair_sum*, that takes in a list and a target sum as arguments. The function should return a tuple containing a pair of indices whose elements sum to the given target. The indices returned must be unique.
>
> Be sure to return the indices, not the elements themselves.
>
> There is guaranteed to be one such pair that sums to the target.

```
pair_sum([3, 2, 5, 4, 1], 8) # -> (0, 2)
```

```
pair_sum([4, 7, 9, 2, 5, 1], 5) # -> (0, 5)
```

```
pair_sum([4, 7, 9, 2, 5, 1], 3) # -> (3, 5)
```

If you need additional support taking these DSA skills and actually applying them, take [**Alvin's**](https://www.linkedin.com/in/alvin-zablan-b73a92117/) *complete* data structures and algorithms course on [**Structy**](https://structy.net/?utm_source=taro). You can try out the concepts yourself in their interactive code editor and learn advanced DSA patterns like stack exhaustive recursion.

Use [**this link to get 20% off**](https://structy.net/purchase?promo_code=taro20) the entire Structy DSA learning experience.

Follow Alvin on LinkedIn: <https://www.linkedin.com/in/alvin-zablan-b73a92117/>

Master The DSA Interview [Part 29] - LeetCode Stockholm Syndrome

Even after passing the data structures and algorithms interview, a surprising amount of engineers maintain a toxic relationship with it. This lesson teaches you:

- What LeetCode Stockholm Syndrome looks like
- Why it doesn't make sense to continue studying data structures and algorithms after you have started the job
- The key towards true growth as a software engineer (hint: it's not LeetCode)
- A super simple way to understand data structures and algorithms studying and how it fits into your life

Master The DSA Interview [Part 21] - Programming Language Selection

There are a ton of programming languages you can use for a data structures and algorithms interview. This lesson teaches you:

- A basic flowchart to follow to determine which programming language you should use in data structures and algorithms interviews
- Why it's often not worth it to pick up an entirely new but "optimal" programming language for data structures and algorithms interviews
- How overly verbose languages can ruin your chances, explained with an in-depth example

Master The DSA Interview [Part 19] - Perfection Obsession

Getting the optimal solution to a data structures and algorithms problem is great, but it isn't always possible. This lesson teaches you:

- Why pursuing the optimal solution upfront when you're very stuck can easily lead to your rejection in a data structures and algorithms interview
- What to do instead when you're unable to get the optimal solution upfront
- How being completely stuck can lead to a vicious cycle that forces you to fail interviews
- A simple way to think about data structures and algorithms problem solving in general

Master The DSA Interview [Part 14] - Clean Code

Just because you're solving a made-up problem doesn't mean that you can write messy code during a data structures and algorithms interview. This lesson teaches you:

- What most engineers don't realize when it comes to code quality, in particular with why it's easier to achieve than they think
- The types of engineers who tend to struggle with code quality
- Common messy code patterns to avoid when coding up a data structures and algorithms solution (and in general)

Take the code quality course here: [Level Up Your Code Quality As A Software Engineer](https://www.jointaro.com/course/level-up-your-code-quality-as-a-software-engineer/)

Break Into Tech And Become A Software Engineer [Part 20] - Demystifying Resume Selection

In this lesson, Brian shares insights from his experience as an engineering manager, explaining how resumes are sorted into "no," "maybe," and "yes" piles during the hiring process.

This lesson covers:

- Why resumes with a skills mismatch or unclear roles are put into the "no" pile, and how to avoid this by clearly presenting your relevant experience and skills
- The challenge of standing out from the crowded "maybe" pile, where many passionate junior developers end up due to generic projects and experiences
- Tips for increasing your chances of landing in the "yes" pile by demonstrating experience, showcasing personality, and experimenting with different resume approaches to see what resonates with employers

If you need extra help breaking into tech, join Brian's exclusive, cohort-based bootcamp (just 10 students per batch). Use this special link for $800 off: <https://www.parsity.io/taro>

Connect with Brian on LinkedIn: <https://www.linkedin.com/in/brianjenney/>

Break Into Tech And Become A Software Engineer [Part 15] - Fostering Online Relationships

In this lesson, Brian shares his strategy for using comments and direct messages to build meaningful online connections and network effectively.

This lesson covers:

- Starting with genuine, thoughtful comments on posts to build rapport and avoid disingenuous engagement, which helps foster real conversations
- How to follow up comments by sliding into DMs, offering value first rather than asking for a favor, and creating opportunities for connection without being awkward
- The importance of short, 15-minute coffee chats to learn from others while keeping the conversation low-pressure and focused on mutual interests

If you need extra help breaking into tech, join Brian's exclusive, cohort-based bootcamp (just 10 students per batch). Use this special link for $800 off: <https://www.parsity.io/taro>

Connect with Brian on LinkedIn: <https://www.linkedin.com/in/brianjenney/>

Grow From Junior To Mid-Level Engineer [Part 12] - Disambiguation

Engineers will constantly get tasks that aren't fully defined, especially if they work at a top tech company like FAANG. This lesson teaches you:

- The differences between junior and mid-level engineers when it comes to disambiguation
- How mid-level engineers are much more effective at disambiguation compared to junior engineers, explained with an in-depth example

Tech Career Growth Videos

Our instructional videos provide software engineers with insights needed for career growth. Masterclasses go incredibly in-depth on a specific tech topic while case studies are real examples from established engineering leaders.