Level Up Your Code Quality As A Software Engineer [Part 27] - Continue The Learning Journey

Watching one course is not going to automatically make you master of code quality (or anything really). To really learn these concepts and burn them into your mind, you need to continue the learning journey. Here's how to do that:

- Start discussions in the Taro forum: <https://www.jointaro.com/questions/create/>
- Join Taro events, especially Group Office Hours: <https://www.jointaro.com/events/>

If you have mastered code quality, then here's a great skill for you to move on to: [\[Masterclass\] How To Become A Debugging Master And Fix Issues Faster](https://www.jointaro.com/lesson/ioR6WzamAIUTpySLAr7o/masterclass-how-to-become-a-debugging-master-and-fix-issues-faster/)

Grow From Mid-Level To Senior Engineer [Part 12] - System Design

System design is a topic engineers are becoming more and more familiar with, largely due to their emerging prevalence in interviews. It's also critical for the mid-level to senior promotion. This lesson teaches you:

- Why system design is the most important technical skill that mid-level engineers need to develop to grow to senior
- The ingredients of a high-quality system design document
- How to get feedback on your system design document
- Tactics to run an effective technical review meeting

Here's the system design course: [\[Course\] Frontend System Design Masterclass - Building Playlists](https://www.jointaro.com/course/frontend-system-design-masterclass-building-playlists/)

Level Up Your Code Quality As A Software Engineer [Part 25] - Seas Of Newlines

Newlines are necessary everywhere (including this video description), but they're very much something that can get annoying fast in large quantities. This includes code. This lesson will teach you:

- The "Seas Of Newlines" messy code anti-pattern
- How to fix code that's like this and write better code instead

Grow From Mid-Level To Senior Engineer [Part 7] - Take Greater Ownership

As a senior engineer, you need to show strong ownership. Many mid-level engineers are told this by their manager but are unsure as to what that means. This lesson teaches you:

- Why the "points" you get for impact aren't just correlated to the impact of the projects you work on
- How to get more credit for each project you work on
- What it means to show stronger, more holistic project ownership with a real-life example from Alex's past at Instagram

Learn more about project credit here: <https://www.jointaro.com/course/nail-your-promotion-as-a-software-engineer/its-not-just-about-impact/>

Grow From Mid-Level To Senior Engineer [Part 10] - Code Review

Writing code is great, but so is reviewing code. In fact, being great at reviewing code is more impactful than being great at writing code 90%+ of the time! This lesson teaches you:

- How the writing code vs. reviewing code dynamic changes as you get to senior
- Why senior engineers tend to review more code than they write
- How senior engineers expand their code review scope while mid-level engineer code review scope tends to be more constrained with a real-life example
- The difference between a senior engineer code review comment vs. a mid-level engineer code review comment

Get better at code review with our masterclass: [\[Masterclass\] How To Do Amazing Code Review](https://www.jointaro.com/lesson/rhRFh49oouaUDhWUvkQb/masterclass-how-to-do-amazing-code-review/)

Case Study: Setting Up Your Environment

One of the first tasks for an engineer in a new company is to setup their environment. 

- Your goal is **not** to setup your environment

- Your goal is to **do something that the environment setup enables**, e.g. make a copy or color change

Abstraction is essential when you’re working in a large codebase. Don't try to understand everything you come across: there will surely be a guide or script that you'll blindly follow, and that's ok. Keep your focus on completing the setup so you can make progress.

If you get blocked (*you probably will...*), forecast ahead what's coming and check if there's something else you can do in parallel.

Ace Your Tech Interview As A Software Engineer [Part 38] - Go Deeper, Follow Through

You made it! By completing this course, you have attained the necessary wisdom to avoid the many, many failure modes software engineers so often fall into when searching for a job. This video teaches you:

- Why completing this course is actually just the beginning of your job search success
- The Top 5 overall learnings from this course
- The exact difference between struggling job seekers and successful ones
- How you can follow through with the knowledge gained from this course and actually apply it to your job search

If your job search dilemma isn't covered by this course, start a community discussion here: <https://www.jointaro.com/questions/create/>

Taro regularly hosts events to get your resume reviewed, pair up for mock interviews, and deep-dive into system design problems. You can find those events here: <https://www.jointaro.com/events/>

**UPDATE:** We have shut down Taro Networking as a feature. Sorry for the inconvenience 🙏

System Design Series: Taro Playlists [Part 6] - Overall Approach And Tradeoffs

You can [find the full system design doc here](https://docs.google.com/document/d/15WaM8Ojan82g0m2mtz6kC2Hiyj0Q6VbjfqRmVNDI3qw/edit?usp=sharing) - Feel free to use it as a template for when you're designing systems at your job!

The tactics are covered in the doc linked above, so this summary will focus on the "meta" context behind this part and additional commentary:

- When it comes to determining your overall approach, it's important to understand the priorities and values of your team/company. You can't have it all when building software; when you invest more in a certain attribute, it will generally take away from others. Here are some example attributes:
  - Execution speed
  - Feature robustness
  - Code readability
  - System scalability
  - Design and aesthetic
- Taro and very early-stage startups in general will make warped decisions as the prioritization leans extremely heavily towards execution speed. The goal is to 80/20 as much as possible when it comes to all the other attributes surrounding quality.
- Since this case study is a pretty basic CRUD play building on top of an existing model, there isn't too much complexity around the approach. However, you generally want to propose 2+ concrete approaches and the tradeoffs behind them, especially at a Big Tech company where you often have many, many options.
- Here are the technical design principles covered in the video:
  - **Single source of truth**: This is a very easy way to systems to break and have inconsistent experiences. Let's say your content object has 2 fields, a boolean of "hasLikes" and then an array of users who have liked this particular piece of content. You can either check the emptiness of the array to see if the object has likes or consult the boolean. It's extra work maintaining these 2 different representations of this information, and if they fall out of sync and 2 services/surfaces each read from a different one, things will get weird.
  - **Smart server, dumb client**: You cannot scale the user's device unless you ship them a new computer or phone. However, you can theoretically infinitely scale your server-side. This is why clients (i.e. usually front-ends) should be as dumb as possible with the back-end abstracting away as much complex logic as possible. This is especially true when your product is a mobile app as there will always be users lagging on older versions of the app - You don't want to have to make a mobile update every time you have a basic product logic change. Make your back-end protocol generic, flexible, and powerful.
  - **Be additive with data model**: This is primarily relevant with mobile apps as you will have users on older builds. If you change or remove a field, older builds will break. You can't count on your users to all update to the latest version of your app immediately.

Maximize Your Productivity As A Software Engineer [Part 10] - Organize Your Calendar

Now we know that focus blocks are one of the most powerful weapons in a software engineer's arsenal. So how can we get them? This lesson teaches you:

- How to organize your meetings in the most efficient way
- What you should look out for when it comes to clearing space on your calendar

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

How Base Salary Becomes Insignificant - Tech Compensation Archetypes

**Equity** is the primary reason that tech compensation is so high. Equity means your employer gives you ownership in the company as a portion of your compensation. The idea is that this incentivizes you to work harder to have the company perform well.

For most of Senior+ roles in US-based companies, equity will begin to dominate your pay. (This is the hallmark of a top tech company.) Some examples: 

- **For mid-level roles**, the equity in a company could be something like $20K - $100K / year. Senior engineers at top companies start to make almost an equal amount in stock as they do in base salary (cash comp).
- **For very senior roles**, the majority of the total compensation comes from equity. e.g. at the Director level, the ratio is around 2:1, so their base salary may be $270K/year, and their equity could be $500K/year.
- Compare this to a non-tech, old-school company like General Motors. The average pay for a Director of Engineering is $280K, which is great, but you could easily make that amount much earlier in your career within Big Tech. The reason for this gap is because General Motors is a lot more stingy when it comes to giving out stock to their employees.

Grow From Mid-Level To Senior Engineer [Part 24] - Go Deeper: Follow Through

Start a career discussion in Taro: <https://www.jointaro.com/questions/create/>

Join Taro events: <https://www.jointaro.com/events/>

Come to Alex's Group Office Hours: <https://www.jointaro.com/p/alex-chiou/>

Related courses:

- [Nail Your Promotion As A Software Engineer](https://www.jointaro.com/course/nail-your-promotion-as-a-software-engineer/)
- [Managing Up: Build Effective Relationships With Your Boss](https://www.jointaro.com/course/managing-up-build-effective-relationships-with-your-boss/)
- [Level Up Your Code Quality As A Software Engineer](https://www.jointaro.com/course/level-up-your-code-quality-as-a-software-engineer/)
- [Effective Communication For Engineers](https://www.jointaro.com/course/effective-communication-for-engineers/)
- [Frontend System Design Masterclass - Building Playlists](https://www.jointaro.com/course/frontend-system-design-masterclass-building-playlists/)

Master The DSA Interview [Part 6] - Why Does FAANG Do This?

If data structures and algorithms aren't actually used on the job, why do Big Tech companies use these problems as a cornerstone of their interview process? This lesson teaches you:

- Why Big Tech isn't just being evil and stupid when they use data structures and algorithms problems on their interviews
- How data structures and algorithms problems can have a surprising amount of depth
- What most engineers don't understand when it comes to how FAANG rejects candidates
- How Google and Meta in particular differ from almost all other companies when it comes to hiring, which affects how their interview processes work

If you're interested in working at early-stage startups that don't ask LeetCode problems: ["How to find and connect with scrappy startups?"](https://www.jointaro.com/question/9jFuRj3UymeHsaKIzXia/how-to-find-and-connect-with-scrappy-startups/)

Ace Your Tech Interview As A Software Engineer [Part 16] - FAANG Or Bust (And Why It’s Dumb)

Software engineers have a deep obsession with "FAANG" often treating it as the Holy Grail of career goals. Unfortunately, this often leads to job searching failure. This lesson teaches you:

- How software engineers greatly underestimate the difficulty of getting into Big Tech and how they should believe and act instead
- Why FAANG companies are generally averse to hiring non-senior candidates
- The many reasons why going to Big Tech later in your career is good for you
- The path most engineers have to take in order to break into FAANG (and why that's perfectly fine!)

If you want to learn more about FAANG and Big Tech:

- [\[Taro Top 10\] Breaking Into FAANG](https://www.jointaro.com/playlist/roKqDHgxu4C5CioEFpJY/)
- ["What's the difference between Big Tech and startups in terms of learning and growth?"](https://www.jointaro.com/question/KWXIrFIR1EIJsvdOdo7u/whats-the-difference-between-big-tech-and-startups-in-terms-of-learning-and-growth/)

Master The Behavioral Interview [Part 13] - Good Vs. Bad Questions To Ask

You're a software engineer and you have slogged through the behavioral round, answering many grueling questions. And now the interviewer opens up the floor to you: "Do you have any questions for me?". What do you do here? This lesson teaches you:

- What a good behavioral interview question to ask looks like through many examples, which you can ask word-for-word in your next behavioral interview
- What a bad behavioral interview question looks like (avoid these)
- The attributes of a high-quality question vs. a low quality question in a behavioral interview

Level Up Your Code Quality As A Software Engineer [Part 23] - Everything In 1 Place

Monoliths and god-classes are 2 of the most common code anti-patterns, especially in Big Tech. They're extremely easy to fall into, and monolithic infrastructure is actually the right call for the vast majority of software as 99% of software is nowhere near the scale of FAANG. This lesson will teach you:

- Why the "Everything In 1 Place" anti-pattern is so damaging, not just for readability but developer productivity as well
- One of the most powerful clean code techniques: **The delegate pattern** (this is how Meta referred to it). It can go by other names, but the core concept is to understand how an interface works. Once you master this pattern, you'll be able to break up any large codebase into readable, focused, modular components. Delegates were easily the most commonly used clean code pattern back during Alex's time at Instagram. Alex goes through an in-depth example from the Taro app itself to walk you through exactly how this technique works.

If you want to learn more about Instagram's stellar engineering culture around code quality, check out this in-depth discussion: ["What do mobile testing strategies look like at top tech companies?"](https://www.jointaro.com/question/fpySzIO02aQ0sCz5N6dP/what-do-mobile-testing-strategies-look-like-at-top-tech-companies/)

Master The Behavioral Interview [Part 19] - Cultural Values

Culture fit is real. A lot of tech companies have toxic culture and don't vet for it properly, but that doesn't change the fact that culture fit is extremely important to running a healthy engineering organization. This lesson teaches you:

- Why cultural values are important
- What you should do to effectively study and internalize the cultural values of a company you are interviewing with
- How to weave a company's cultural values into your behavioral interview answers through an example with Alex for his Meta interview

If you're curious as to how Meta's engineering culture works: ["Is sprint planning and agile not a thing at Meta?"](https://www.jointaro.com/question/tB7borE2AWb1KcuFEcon/is-sprint-planning-and-agile-not-a-thing-at-meta/)

Onboarding Tips Within Larger Companies

In a large company, you should expect a more formal onboarding process. However, don’t let this be an excuse to move slowly. Your goal is (still) to set up your environment and land code within a week.

Big companies will have many teams which may have slightly competing priorities. That means you need to invest in relationships and understand how the work connects between teams. Disperse and collect knowledge from around the company.

Spend some time understanding the unique terminology and culture of the company. Companies like Amazon, Meta, Google, Microsoft are large enough that they have their own set of acronyms, languages, and cultures!

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.