15 SWE Years In 1.5 Hours [Part 20] - Conclusion

Congratulations on making it to the end of the course! The goal of this course was to capture Rahul's biggest, broadest, higher-level learnings across a multitude of core software engineering subjects. While this is indeed valuable, it's impossible to master a massive topic like all of data structures and algorithms in just 5 minutes

To go deeper into these subjects, we recommend following our learning path here: [Become A Better Engineer](https://www.jointaro.com/learning-paths/become-a-better-engineer/)

Get The Rating You Deserve [Part 5] - Detailed Breakdown

**In this lesson, we'll delve into the intricacies of career advancement and explore strategies to maximize your impact and recognition.**

- **Understanding Impact Dynamics:** We'll examine the relationship between the value you create and the rewards you receive, considering factors like organizational culture, business objectives, and individual performance.
- **Increasing Your Luck Surface Area:** We'll explore techniques to increase your visibility and opportunities for advancement, including effective communication, networking, and self-promotion.
- **Sustainable Career Growth:** We'll discuss strategies for maintaining a healthy work-life balance, building strong relationships, and continuously developing your skills to ensure long-term success.

By understanding these key principles and implementing practical strategies, you can position yourself for significant career growth and fulfillment.

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 12] - Do A Search

The key towards building any successful product is to make something people want. Turns out that this actually isn't too difficult when it comes to side projects. This lesson teaches you:

- How to do a basic search to find relevant competitors and inspiration
- How to find core keywords that people use to find products in your space
- A simple, free way to understand the traffic of a website and see if it's worth building a similar webapp

You can download the Similarweb extension here: <https://www.similarweb.com/corp/extension/>

Come Up With 500k+ User Project Ideas [Part 11] - Simple Is Complex

Engineers tend to get excited for complex ideas and bored with simple ones. However, there's more to the technical realm than simply "complex" and "simple". This lesson teaches you:

- How simplicity and complexity aren't a binary spectrum
- How complexity can actually be created from simplicity if you come in with the right mentality
- Why striving for a certain level of quality always brings a meaningful degree of complexity, explained with how Alex made 60,000+ lines of code changes to grow Random Name Picker to a 1 million+ user app
- Why the "simple is complex" mentality is critical towards becoming a truly strong engineer

Come Up With 500k+ User Project Ideas [Part 10] - Keep The Stakes Low

Every piece of software inevitably breaks. This is incredibly important to remember when it comes to side projects. This lesson teaches you:

- Why side projects are especially vulnerable to production issues
- Why you want the stakes for your side project to be low
- What it means to have high stakes vs. low stakes with a product, explained with a concrete example

What Order Should You Study Data Structures & Algorithms?

Instead of doing random problems, you need to structure your DSA prep to tackle concepts in the right order.

Course: <https://www.jointaro.com/course/crash-course-data-structures-and-algorithms-concepts/>

DSA Crash Course [Part 76] - Counts Paths Walkthrough

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

Code along and test your work in the following editor workspace: <https://structy.net/problems/count-paths?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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 75] - Count Paths Approach

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

> Write a function, *count_paths*, that takes in a grid as an argument. In the grid, 'X' represents walls and 'O' represents open spaces. You may only move down or to the right and cannot pass through walls. The function should return the number of ways possible to travel from the top-left corner of the grid to the bottom-right corner.

```
grid = [
["O", "O"],
["O", "O"],
]

count_paths(grid) # -> 2
```

```
grid = [
["O", "O", "X"],
["O", "O", "O"],
["O", "O", "O"],
]

count_paths(grid) # -> 5
```

```
grid = [
["O", "O", "O"],
["O", "O", "X"],
["O", "O", "O"],
]

count_paths(grid) # -> 3
```

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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 73] - Minimum Change Approach

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

> Write a function *min_change* that takes in an amount and a list of coins. The function should return the minimum number of coins required to create the amount. You may use each coin as many times as necessary.
>
> If it is not possible to create the amount, then return -1.

```
min_change(8, [1, 5, 4, 12]) # -> 2, because 4+4 is the minimum coins possible
```

```
min_change(13, [1, 9, 5, 14, 30]) # -> 5
```

```
min_change(23, [2, 5, 7]) # -> 4
```

```
min_change(102, [1, 5, 10, 25]) # -> 6
```

```
min_change(200, [1, 5, 10, 25]) # -> 8
```

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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 69] - Tribonacci Approach

In this lesson, Alvin explores the strategy to solving the following problem using dynamic programming:

> Write a function *tribonacci* that takes in a number argument, *n*, and returns the *n*\-th number of the Tribonacci sequence.
>
> The 0-th and 1-st numbers of the sequence are both 0.
>
> The 2-nd number of the sequence is 1.
>
> To generate further numbers of the sequence, calculate the sum of previous three numbers.
>
> Solve this recursively.

```
tribonacci(0) # -> 0
```

```
tribonacci(1) # -> 0
```

```
tribonacci(2) # -> 1
```

```
tribonacci(5) # -> 4
```

```
tribonacci(7) # -> 13
```

```
tribonacci(14) # -> 927
```

```
tribonacci(20) # -> 35890
```

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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 61] - Shortest Path Approach

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

> Write a function, *shortest_path*, that takes in a list of edges for an undirected graph and two nodes (\*node_A\*, *node_B*). The function should return the length of the shortest path between *A* and *B*. Consider the length as the number of edges in the path, not the number of nodes. If there is no path between *A* and *B*, then return -1. You can assume that *A* and *B* exist as nodes in the graph.

```
edges = [
['w', 'x'],
['x', 'y'],
['z', 'y'],
['z', 'v'],
['w', 'v']
]

shortest_path(edges, 'w', 'z') # -> 2
```

```
edges = [
['w', 'x'],
['x', 'y'],
['z', 'y'],
['z', 'v'],
['w', 'v']
]

shortest_path(edges, 'y', 'x') # -> 1
```

```
edges = [
['a', 'c'],
['a', 'b'],
['c', 'b'],
['c', 'd'],
['b', 'd'],
['e', 'd'],
['g', 'f']
]

shortest_path(edges, 'a', 'e') # -> 3
```

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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 45] - Tree Includes Approach

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

> Write a function, *tree_includes*, that takes in the root of a binary tree and a target value. The function should return a boolean indicating whether or not the value is contained in the tree.

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

tree_includes(a, "e") # -> True
```

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

tree_includes(a, "a") # -> True
```

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

tree_includes(a, "n") # -> False
```

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 41] - Breadth First Values Approach

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

> Write a function, *breadth_first_values*, that takes in the root of a binary tree. The function should return a list containing all values of the tree in breadth-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

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

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

#      a
#    /   \
#   b     c
#  / \     \
# d   e     f
#    /       \
#   g         h

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

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

breadth_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 13] - Pair Sum Walkthrough

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

Code along and test your work in the following editor workspace: <https://structy.net/problems/pair-sum?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/>

How to Crack System Design Interviews - Part 2: Clarifying Requirements

In a system design interview, the first step is gathering requirements, focusing on how users will interact with the system. Here's how we approach this:

- **Understand user needs:** We consider the basic functions users will need, such as applying filters, viewing original images, and deleting images.
- **Confirm and prioritize:** We check with the interviewer to ensure we've captured all the key requirements and prioritize the most important ones.
- **Identify trade-offs:** We analyze potential trade-offs, such as image quality versus storage needs, and quantify them whenever possible.
- **Set realistic expectations:** We avoid aiming for perfection and instead focus on creating a practical design that meets the core requirements.
- **Provide concrete examples:** We use real-world examples to illustrate our understanding of system design concepts and demonstrate our ability to make informed decisions.

[Gaurav Sen](https://www.linkedin.com/in/gkcs/) has conducted 1000s of system design interviews while working at Uber and building his [YouTube channel](https://www.youtube.com/@gkcs) to 500K+ subscribers. His platform [InterviewReady](https://interviewready.io/?_aff=JOINTARO) combines video explainers, live Zoom classes, and an automated System Design Judge.

Break Into Tech And Become A Software Engineer [Part 18] - Work For Free

In this lesson, Brian discusses the value of working for free as a way to gain experience, while emphasizing that it’s not truly "free" but a trade for validation and learning.

This lesson covers:

- How free work is a way to gain experience and build credibility, but it’s essential to set clear deliverables and avoid being taken advantage of
- Approaching local businesses with well-defined projects to solve real problems, not just offering technical solutions, and using these opportunities to practice communication skills
- Sharing your experiences online, requesting recommendations, and using badges to validate your work and make yourself more attractive to future 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 14] - Networking Without Being Weird

In this lesson, Brian emphasizes the importance of authentic online networking and provides strategies to build genuine connections without being cringy.

This lesson covers:

- Avoiding the common mistake of sending unsolicited requests for jobs or favors and focusing on building relationships instead
- Engaging with others by commenting on their posts and asking genuine questions to foster meaningful interactions
- Curating your feed by following like-minded individuals who share valuable content, ensuring that your online experience is constructive and positive

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 12] - Pick A Platform

In this lesson, Brian emphasizes the value of choosing the right platform for writing online, with a strong recommendation for LinkedIn.

This lesson covers:

- Why LinkedIn is a great platform for building a professional presence, with less anonymity and trolling compared to platforms like X or TikTok
- The advantage of standing out on LinkedIn, where recruiters and employers are more active, making it easier to connect with professionals
- How while platforms like X and TikTok offer cutting-edge tech content, LinkedIn provides a safer environment to network with verified professionals and receive genuine feedback

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 10] - Why It's Better To Share

In this lesson, Brian explains the value of building in public as a tool for personal accountability, skill development, and community building.

This lesson covers:

- How building in public holds you accountable to your goals and helps you communicate more effectively, a key skill for software development
- The importance of using public sharing to connect with like-minded people and build a supportive community
- Why building in public improves your discoverability and can lead to networking, job opportunities, and genuine collaboration

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

Paper Reading: LLaMA  Open and Efficient Foundation Language Models

Session Led By: [Mike A](https://www.linkedin.com/in/malik-mike-a-32b63818b/)

Join us for the first installment of our three-part paper reading series on the LLaMA series of Large Language Models (LLMs).\
\
In this session, we will explore the foundational concepts and innovations behind the initially released LLaMA models, introduced by Meta AI back in early 2023. The first series of LLaMA models, ranging from 7B to 65B parameters, and how they opened the door to efficient, open-weight LLMs that can be trained on publicly available datasets.

This event will cover the groundbreaking at the time techniques used to train LLaMA models, which outperformed previous state-of-the-art models like GPT-3 on many benchmarks, despite being significantly smaller. We'll focus on the details of their unique training approach, data mixture, and architectural enhancements. We will also discuss the impressive zero-shot and few-shot capabilities of these models on tasks, highlighting the efficiency and accessibility that made these models popular within the open-source community.

This session is a must-attend for researchers, developers, and AI enthusiasts interested in the recent history behind the latest advancements in language modeling and AI research as we build our understanding of the LLaMA models towards the latest releases from Meta AI. Whether you're keen to understand the intricacies of LLMs, explore the potential of open-source AI models, or gain insights into the future of efficient AI by reflecting on the past, this paper reading will provide valuable knowledge and stimulate thought-provoking considerations.

Mark your calendars for an enlightening hour of "LLaMA: Open and Efficient Foundation Language Models" and be part of the journey to explore the future of AI language models through a review of the past.

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.