DSA Crash Course [Part 38] - Binary Tree Warm Up Lecture

In this lecture, Alvin goes over the python implementation for a basic binary tree.

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 36] - Want To Learn More DSA With Alvin?

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 34] - Zipper Lists Approach

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

> Write a function, *zipper_lists*, that takes in the head of two linked lists as arguments. The function should zipper the two lists together into single linked list by alternating nodes. If one of the linked lists is longer than the other, the resulting list should terminate with the remaining nodes. The function should return the head of the zippered linked list.
>
> Do this **in-place**, by mutating the original Nodes.
>
> You may assume that both input lists are non-empty.

```
a = Node("a")
b = Node("b")
c = Node("c")
a.next = b
b.next = c
# a -> b -> c

x = Node("x")
y = Node("y")
z = Node("z")
x.next = y
y.next = z
# x -> y -> z

zipper_lists(a, x)
# a -> x -> b -> y -> c -> z
```

```
a = Node("a")
b = Node("b")
c = Node("c")
d = Node("d")
e = Node("e")
f = Node("f")
a.next = b
b.next = c
c.next = d
d.next = e
e.next = f
# a -> b -> c -> d -> e -> f

x = Node("x")
y = Node("y")
z = Node("z")
x.next = y
y.next = z
# x -> y -> z

zipper_lists(a, x)
# a -> x -> b -> y -> c -> z -> d -> e -> f
```

```
s = Node("s")
t = Node("t")
s.next = t
# s -> t

one = Node(1)
two = Node(2)
three = Node(3)
four = Node(4)
one.next = two
two.next = three
three.next = four
# 1 -> 2 -> 3 -> 4

zipper_lists(s, one)
# s -> 1 -> t -> 2 -> 3 -> 4
```

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 32] - Reverse List Approach

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

> Write a function, *reverse_list*, that takes in the head of a linked list as an argument. The function should reverse the order of the nodes in the linked list **in-place** and return the new head of the reversed linked list.

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

# a -> b -> c -> d -> e -> f
reverse_list(a) # f -> e -> d -> c -> b -> a
```

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

# x -> y
reverse_list(x) # y -> x
```

```
p = Node("p")

# p
reverse_list(p) # p
```

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 29] - Linked List Find Walkthrough

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

Code along and test your work in the following editor workspace: <https://structy.net/problems/linked-list-find?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 26] - Sum List Approach

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

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

```
a = Node(2)
b = Node(8)
c = Node(3)
d = Node(-1)
e = Node(7)
a.next = b
b.next = c
c.next = d
d.next = e

# 2 -> 8 -> 3 -> -1 -> 7
sum_list(a) # 19
```

```
x = Node(38)
y = Node(4)
x.next = y

# 38 -> 4
sum_list(x) # 42
```

```
z = Node(100)

# 100
sum_list(z) # 100
```

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 23] - Linked List Warm Up Lecture

In this lecture, Alvin goes over how to implement a linked list in python.

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 15] - Pair Product Walkthrough

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

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

When discussing design trade-offs in a system design interview, it's important to go beyond simply reciting known trade-offs. Instead, we take a more analytical approach:

- **Consider non-functional requirements:** We examine the impact of non-functional requirements, such as durability guarantees, on the system design and user experience.

- **Analyze access patterns:** We study how users interact with the system, considering the frequency of different API calls and their implications for optimization.

- **Make informed decisions:** Based on our analysis, we make conscious trade-offs, such as prioritizing read performance over immediate data consistency.

- **Use standard terminology:** We employ clear and concise engineering terms to ensure accurate communication and efficient use of interview time.

- **Be open to feedback:** We remain flexible and adjust our assumptions based on feedback from the interviewer, recognizing their expertise and knowledge of the system.

[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 16] - Leverage Your Warm Network

In this lesson, Brian emphasizes the importance of leveraging your existing personal network, not just online platforms, to find job opportunities in tech.

This lesson covers:

- Using family, friends, and former colleagues to generate warm leads for software development positions, as many opportunities may exist close to home
- The concept of "seven degrees of separation" to illustrate how connections through your network can lead to valuable job prospects
- How reaching out to people within your network can provide unexpected opportunities, even from places like past jobs or local companies

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 8] - It's All About Time Management

In this lesson, Brian addresses the challenge of finding time to code amidst a busy life, offering practical strategies for better time management.

This lesson covers:

- Identifying time-wasting activities and making sacrifices, like cutting back on social media or entertainment, to create more time for learning
- Planning the most important task of the day the night before and waking up 30-45 minutes earlier to focus on it without distractions
- Working in short, productive sprints to maximize efficiency and avoid burnout

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

Become An Open Source Master [Part 20] - Share What You Learn

Share what you learn as you go on your open-source journey. We can add comments to the code, write wiki pages or articles, or even file issues in the codebase to better understand. When we're ready to start contributing, we should pick a task, dive into the code, and start experimenting with it by adding print statements or breakpoints. This will help us get familiar with the code and the build process so that we can be more effective when making meaningful contributions.

Video reference: [10 Things I Learned from the jQuery Source](https://www.youtube.com/watch?v=i_qE1iAmjFg)

[How to learn a new codebase fast](https://www.jointaro.com/lesson/DX27hiXPJ4G7Czk2mwLL/how-to-learn-a-new-codebase-fast/).

Connect with James:

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

Become An Open Source Master [Part 19] - What Opinions Do The Authors Have?

Be aware of the human element in open-source projects. We should understand and follow the project's coding style, including linting and formatting preferences. If the project lacks a style guide or linting rules, we can offer to help create them, but we should always do so with the approval of the original maintainers.

Connect with James:

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

Become An Open Source Master [Part 18] - What Are The Most Important Modules?

We need to identify the important modules in an open source project. We should understand the configuration items, hot functions, and utility classes. Additionally, we should figure out how the data flows through the project, including its structure, storage, and APIs.

Connect with James:

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

Become An Open Source Master [Part 15] - Find The Project Community

It's important to understand the bigger picture instead of focusing on every single line of code. Some questions worth asking when approaching a new codebase are: 

- what is the purpose of the code
- what are the opinions of the developers
- how is the code structured?

Connect with James:

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

Become An Open Source Master [Part 13] - Dipping Your Toes Into A Project

We can contribute to open source projects in many ways, even without writing code. We can triage issues, work on documentation, improve the website design, or provide translations. We can also become an advocate for the project by promoting it on social media, writing articles, or creating training courses. By contributing to the broader ecosystem, we can help the project succeed and build our own reputation in the community.

Connect with James:

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

Become An Open Source Master [Part 5] - The Benefits Of Open Source

We'll discuss the reasons why you should get involved in open source and the benefits it can bring, both professionally and personally.

- **Work on code that matters:** Contribute to projects used by others, gaining a sense of achievement and pride.
- **Improve your coding skills:** Receive feedback and learn from experienced developers, improving your coding abilities and knowledge.
- **Build relationships:** Connect with maintainers, contributors, and users, expanding your network and learning opportunities.
- **Enhance your professional portfolio:** Showcase your skills and experience to potential employers through your open source contributions.
- **Grow your personal reputation:** Gain recognition and build valuable connections within the open source community.

Connect with James: 

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

Become An Open Source Master [Part 4] - Open Source Terminology: Projects, Repos, Issues, PRs

We'll focus on GitHub, a popular platform for open-source software, to understand key terms and concepts.

- Projects and repositories (repos) are the core units of open-source projects on GitHub.
- You can view source code, metadata, and community activity within a repository.
- Issues are used to report bugs or request features, while pull requests propose code contributions.
- Pull requests are reviewed and discussed by the community before being accepted into the project.

Connect with James: 

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

Grow From Junior To Mid-Level Engineer [Part 15] - Participating In Bigger Meetings

Big meetings can be daunting for engineers, especially junior ones - What if you say something dumb? This lesson teaches you:

- The difference between junior and mid-level engineers when it comes to meeting participation, explained with very simple pictures
- Tactics you can use to come up with more to say in meetings, even if you're the most junior person there
- A clever tactic you can use to participate in a meeting and add value to the discussion, even if you aren't entirely sure of what's going on

Clear Communication For SWEs [Part 7] - The PREP Method

In this video, I delve into the Prep Method, a framework that simplifies communication by structuring messages into four key components: Point, Reason, Example, and Restate. I explain how each element contributes to clear and concise communication, making it ideal for software engineers and various communication scenarios.

Connect with me on LinkedIn: <https://www.linkedin.com/in/ryan-wiens/>

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.