Build Deep Relationships Quickly In Tech [Part 5] - Understand Their Incentives

At the end of the day, everyone is out to get something, especially in the professional world. This lesson teaches you:

- Why understanding other people's incentives is so important
- How to figure out other people's incentives
- The playbook to build an amazing relationship once you truly get someone's incentives
- What it looks like to truly align incentives, explained with an in-depth example

15 SWE Years In 1.5 Hours [Part 7] - Imposter Syndrome (Building Confidence)

Software engineers are constantly underestimating themselves. This lesson teaches you:

- How to flip your mentality when it comes to everyone in tech being smarter than you
- The best environment to be in to maximize your growth
- How to quickly become stronger and get rid of your imposter syndrome

Get The Rating You Deserve [Part 6] - Slow & Steady

**In this section, we'll delve into the importance of patience and strategic thinking in career advancement.**

- **The Power of Patience:** We'll discuss the significance of taking a long-term perspective and understanding that significant growth often requires time and consistent effort.
- **Balancing Exploration and Exploitation:** We'll explore the delicate balance between learning and applying knowledge, and how to effectively allocate time to both.
- **Mindful Communication:** We'll emphasize the importance of clear and effective communication, both in expressing your desires and in actively listening to others.
- **The Role of Mindset:** We'll discuss the importance of cultivating a growth mindset, embracing challenges as opportunities for learning, and maintaining a positive outlook.

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>.

Come Up With 500k+ User Project Ideas [Part 17] - Just Keep Building

Failure is a part of life and software side projects are no exception. This lesson teaches you:

- The builder mindset you absolutely must have to succeed with side projects
- Why a failed side project really isn't that bad, especially if you're following the advice from this course
- How Alex made several stupid side projects destined for failure so you don't make the same mistakes he did

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 21] - Sum Numbers Recursive Walkthrough

In this lesson, Alvin walks through the python implementation for the *sum_numbers_recursive* problem.

Code along and test your work in the following editor workspace: <https://structy.net/problems/sum-numbers-recursive?language=py>

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 14] - Pair Product Approach

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

> Write a function, *pair_product*, that takes in a list and a target product as arguments. The function should return a tuple containing a pair of indices whose elements multiply 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 whose product is the target.

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

```
pair_product([3, 2, 5, 4, 1], 10) # -> (1, 2)
```

```
pair_product([4, 7, 9, 2, 5, 1], 5) # -> (4, 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/>

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 26] - Find A Buddy

When it comes to data structures and algorithms, it's best to not go it alone. This lesson teaches you:

- Why data structures and algorithms is the easiest part of the interview space to partner with someone on
- How having a data structures and algorithms buddy is greatly helpful for your personal morale
- A sample meetup agenda that you can use when you meet with your data structures and algorithms interview buddy

Find a data structures and algorithms interview buddy here: <https://www.jointaro.com/networking/?selectedServices=Mock+Interviews>

Break Into Tech And Become A Software Engineer [Part 22] - Maintaining A Positive Mindset

In this lesson, Brian emphasizes the importance of controlling the information you consume and maintaining a positive mindset when navigating the tech job market.

This lesson covers:

- The dangers of negative content, like fear-mongering videos on social media, which can distort your perception and feed into unnecessary fear and pessimism
- The "red car theory," where focusing on something makes you see it everywhere, influencing how you perceive reality, especially when it comes to fear and job security
- How to cultivate optimism by unfollowing fear-based content, following educational accounts, and using tools like the imposter syndrome killer worksheet to identify gaps and take actionable steps toward your goals

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 6] - Build A Side Project

In this lesson, Brian explains the value of building side projects that not only boost your technical skills but also help you stand out in the job market.

This lesson covers:

- How a well-crafted side project can help you learn new technologies and fill knowledge gaps without needing formal training or mentorship
- The importance of focusing on meaningful, long-term projects that you are passionate about, rather than numerous small, disconnected ones
- Using a self-assessment worksheet to identify your knowledge gaps, create a learning plan, and design side projects that address those gaps and align with your career goals

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/>

Career roadmap worksheet: <https://docs.google.com/document/d/1OpjXtJeQ93TGIz8z9u-p_lYNbhSbk32rPFPDecNMDyM/edit?usp=sharing>

How side projects can even get you into FAANG: [\[Case Study\] Building An App With 1,000,000+ Users To Get Into Facebook](https://www.jointaro.com/lesson/jly45Gx6qR1kqQwBmJEy/case-study-building-an-app-with-1000000-users-to-get-into-facebook/)

Become An Open Source Master [Part 7] - Improve Something You Use

The video advises that we should start by finding a project that we're passionate about, rather than aiming for the biggest or most well-known ones.

- **Choose projects that you already use or are familiar with**, as this gives you a head start in understanding the project's goals and potential areas for improvement.
- **The dependency graph on GitHub can help you identify potential projects** by showing the dependencies of projects you're already working on.
- **Consider contributing to smaller or medium-sized projects by companies**, as these can offer valuable learning experiences and opportunities to build relationships with professional developers.
- **Contributing to open source can lead to career opportunities**, as demonstrated by the example of Sophie Alpert and her work on the React project.

Article shown by Sophie Alpert: [Using React to speed up the Khan Academy question editor](https://sophiebits.com/2013/06/09/using-react-to-speed-up-khan-academy)

Connect with James:

- GitHub: <https://github.com/jamesgpearce>
- Twitter (X): <https://twitter.com/jamespearce>

Grow From Junior To Mid-Level Engineer [Part 18] - Done Is Better Than Perfect

We all make mistakes. In fact, we'll all make a lot of mistakes as software engineers, especially when we're junior. This lesson teaches you:

- The many types of dumb things you will inevitably do as a junior engineer (and continue doing as a mid-level/senior/staff/principal engineer)
- The simple growth mentality and formula you should follow to speed run the junior to mid-level engineer
- Why it's awesome to be the dumbest person in the room
- A simple mathematical way to understand the difference between a fast-growing junior engineer and a slow-growing junior engineer

Learn how to learn from your mistakes here: ["How to turn a string of silly mistakes into a mature positive outcome?"](https://www.jointaro.com/question/JybGyc935lsYbM8dAo7Y/how-to-turn-a-string-of-silly-mistakes-into-a-mature-positive-outcome/)

Top System Design Interview Mistakes [Part 15] - Don't Ask For Too Much Permission

In this lessons, we address a common mistake, especially among junior engineers - Asking for too much permission. This often stems from a lack of confidence and a desire to avoid making decisions. Here are the core points:

- We often encounter candidates who, after discussing various options for solving a problem, defer decision-making to the interviewer

- Instead, we should make decisions ourselves. We can evaluate the options based on their trade-offs and choose the best one

- By taking ownership and driving the design, we demonstrate strong decision-making skills

- While it’s important to ask clarifying questions, we should avoid relying too heavily on the interviewer for directional guidance. Instead, we should proactively drive the conversation and make decisions that address the key issues.

If you need extra help with your system design interview, [Formation.dev](https://formation.dev/partners/taro) can provide you hands-on, personalized support. Join us here: <https://formation.dev/partners/taro>

Top System Design Interview Mistakes [Part 12] - Don't Ignore New Information

In this segment, we discuss the issue of ignoring new information during system design interviews. This happens when candidates fail to adapt their designs based on additional requirements or edge cases presented by the interviewer. Here’s the core points from the video:

- If the interviewer introduces new requirements or issues, like handling scenarios with no available drivers, we must adapt our design accordingly. Ignoring these hints can lead to incomplete or impractical solutions

- Sometimes, a simpler solution might be more effective. For example, informing customers that no drivers are available and suggesting they try again later might be a better approach than complex tracking systems

- When given new information, reassess and incorporate it into the design. This flexibility is crucial for creating effective and practical solutions

If you need extra help with your system design interview, [Formation.dev](https://formation.dev/partners/taro) can provide you hands-on, personalized support. Join us here: <https://formation.dev/partners/taro>

Clear Communication For SWEs [Part 16] - Next Steps And CTA

Thank you for watching my course on clear communication for software engineers! To enhance your communication skills, regular practice is essential, along with real-time feedback and role-playing exercises. This video also talks about my coaching services tailored to software engineers aiming to improve their communication skills, including non-native English speakers seeking confidence and effectiveness in communication. I can help you with public speaking, presentations, active listening, and everyday work communication, providing a hands-on approach in a supportive environment.

Connect with me on LinkedIn (it's also the best way to reach out to me for coaching services): <https://www.linkedin.com/in/ryan-wiens/>

Asking Great Questions [Part 23] - Deep Thanks

Your journey doesn't end after you get an answer to your question, quite the opposite. The follow-through after getting a great answer is absolutely critical. This lesson teaches you:

- What a basic thanks looks like and an easy way to level up past it
- 5 more creative ways to give deeper thanks
- Why giving thanks is also a skill with tremendous depth that can unlock tremendous opportunity if you truly become one of the best in the world at it (with one of those opportunities being making everyone want to answer your questions all the time)

Asking Great Questions [Part 8] - Explain The Impact

Every great software engineer faces the perpetual problem of *"Too much to do, not enough time"*. Great software engineers are who you want answering your questions, and you need to make a case as to why they should use some of their time to answer your question. This lesson teaches you:

- How to empathize with helpers when it comes to how they choose who to help
- Why showing the impact of your question is critical, especially at high-performance tech companies like FAANG
- What attaching the business impact to your question looks like, explained with an in-depth example
- A bonus type of impact you can illustrate with your question

Maximize Your Productivity As A Software Engineer [Part 14] - Do The Hardest Thing First

When you get a tough project, it's tempting to tackle the easiest parts first because you already know how to do them, putting off the most difficult portions for later (you'll totally figure it out right?). This lesson teaches you:

- The difference between bad and good engineers when it comes to taking on a project
- Why tackling the hardest parts of a project first is effective risk management and a defining behavior of the best tech leadWhen you
- The massive team-wide benefit solving the hardest problem grants you

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.