Build Deep Relationships Quickly In Tech [Part 6] - You're Going To Get Burned

Networking isn't all sunshine and roses - You're going to go through a lot of pain as well. This lesson teaches you:

- Why many relationships fall apart
- Why you shouldn't let a failed relationship turn you off networking forever
- A tactical, mathematical framework to minimize risk and maximize upside when it comes to networking
- How to identify if a relationship isn't going anywhere and should be cut off

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

Ship & Grow 500k+ User Side Projects [Part 3] - Crafting The MVP

You should launch the initial version of your side project as fast as possible. So what exactly should it have? This lesson teaches you:

- The only thing your side project MVP (minimum viable product) needs to have
- How a piece of software can still deliver value despite having incredibly few features (or even just 1 feature)
- What a good MVP looks like, explained with an in-depth example
- A common mistake engineers make when it comes to shipping their MVP, explained with an in-depth example

If you're curious to learn why building a good auth flow is 5x harder than engineers think: <https://www.jointaro.com/course/level-up-your-code-quality-as-a-software-engineer/case-study-signup-form-edge-cases/>

15 SWE Years In 1.5 Hours [Part 17] - Promotion

Of course, you can switch jobs to progress your career, [but you will eventually hit a wall](https://www.jointaro.com/course/nail-your-promotion-as-a-software-engineer/you-cant-job-hop-to-success/). At the end of the day, you need to get promoted to have a meaningful long-term, professional trajectory. This lesson teaches you:

- Why working harder isn't enough to get you promoted
- The key to understanding how promotion works, particularly at top companies like FAANG
- How you need to evolve your behavior to reach senior levels and beyond

To dive deeper into getting promoted faster as an engineer, take our course here: [Nail Your Promotion As A Software Engineer](https://www.jointaro.com/course/nail-your-promotion-as-a-software-engineer/)

15 SWE Years In 1.5 Hours [Part 5] - Succeeding In School

Most software engineers start off their journey in tech by getting a university degree. However, most students don't leverage their time in school optimally. This lesson teaches you:

- The most valuable asset you get from school (hint: it's not good grades)
- Why school isn't very effective at teaching you how to do software engineering in the real world
- What you should do instead to enhance your technical skills instead of purely focusing on getting good grades

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

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

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>

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

Grow From Junior To Mid-Level Engineer [Part 5] - Decomposition

As a junior engineer, you will inevitably get a problem that's super scary which you have 0 idea how to solve. This will probably happen sooner rather than later. This lesson teaches you:

- The core tactic you need to master to solve large, incredibly complex problems
- Why decomposition is critical to being a good engineer
- The differences between junior and mid-level engineers when it comes to decomposition
- What it means to effectively decompose a problem, shown with an in-depth example

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

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)

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.