Get The Rating You Deserve [Part 11] - Add Incredible Value

**In this section, we explored the concept of adding incredible value to our work.**

To truly make a significant impact, we should:

- **Go the extra mile:** Strive for excellence and push beyond the minimum requirements.
- **Prioritize finishing tasks:** Complete projects thoroughly, including documentation and testing.
- **Seek continuous feedback:** Actively solicit input from colleagues and managers to improve our work.
- **Balance work and rest:** Maintain a sustainable pace by incorporating regular breaks and time off.
- **Focus on long-term impact:** Adopt a long-term perspective and prioritize tasks that contribute to strategic goals.

By consistently striving to add incredible value, we can become indispensable assets to our teams and organizations.

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

Get The Rating You Deserve [Part 10] - Clarity On Deliverables

**In this video, we discussed the importance of clarity in defining and achieving our work goals.**

To ensure we're consistently making progress and maximizing our impact, we should:

- **Continuously seek clarity:** Regularly revisit and refine our goals and deliverables, especially in dynamic work environments.
- **Balance long-term and short-term priorities:** Prioritize tasks that align with long-term objectives while also addressing urgent issues.
- **Take ownership of our work:** Proactively seek clarity from our managers and take initiative in defining our own expectations and deliverables.
- **Utilize effective time management techniques:** Allocate specific time for focused work and unexpected tasks to maintain productivity and avoid feeling overwhelmed.

By following these guidelines, we can increase our effectiveness, reduce stress, and achieve greater success in our professional endeavors.

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

Get The Rating You Deserve [Part 9] - Getting Stuff Done

We've discussed the importance of increasing your Luck Surface Area (LSA) to maximize the rewards for your efforts. To do this, we must focus on two key components:

- **Do impactful work:** Prioritize tasks that significantly contribute to your goals and the overall success of your team.
- **Communicate effectively:** Clearly articulate your work, its impact, and your aspirations to relevant stakeholders. This includes both celebrating successes and openly discussing challenges.

Remember, effective communication is crucial. Avoid the pitfalls of assuming your work speaks for itself or only sharing successes. Be proactive in seeking alignment with your manager and team, and don't shy away from difficult conversations.

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

Paper Reading: ClickHouse - Lightning Fast Analytics for Everyone

Session led by [Dharin Shah](https://www.linkedin.com/in/dharinshah/)

Link to Paper: [**https://www.vldb.org/pvldb/vol17/p3731-schulze.pdf**](https://www.vldb.org/pvldb/vol17/p3731-schulze.pdf)

This paper presents an overview of ClickHouse, a popular opensource OLAP database designed for high-performance analytics over petabyte-scale data sets with high ingestion rates. Its storage layer combines a data format based on traditional log-structured merge (LSM) trees with novel techniques for continuous transformation (e.g. aggregation, archiving) of historical data in the background. Queries are written in a convenient SQL dialect and processed by a state-of-the-art vectorized query execution engine with optional code compilation. ClickHouse makes aggressive use of pruning techniques to avoid evaluating irrelevant data in queries. Other data management systems can be integrated at the table function, table engine, or database engine level. Real-world benchmarks demonstrate that ClickHouse is amongst the fastest analytical databases on the market.\
\
We will go into the details of why and how Clickhouse is one of the fastest OLAP database, its underlying storage engine, and the overall philosophy for performance.

Paper Reading: Adaptive Radix Tree - ARTful Indexing for Main-Memory Databases

**Session Led by:[ Dharin Shah](https://www.linkedin.com/in/dharinshah/)**

**Link to Paper:[ ](https://db.in.tum.de/%5C~leis/papers/ART.pdf)[https://db.in.tum.de/\\\~leis/papers/ART.pdf](https://db.in.tum.de/~leis/papers/ART.pdf)**

This paper reading session, we will deep dive into a in-memory optimized index structure, that leverages modern CPU caches to make IOPS faster, also allowing range queries.

Abstract—Main memory capacities have grown up to a point where most databases fit into RAM. For main-memory database systems, index structure performance is a critical bottleneck. Traditional in-memory data structures like balanced binary search trees are not efficient on modern hardware, because they do not optimally utilize on-CPU caches. Hash tables, also often used for main-memory indexes, are fast but only support point queries.

DSA Crash Course [Part 86] - Array Stepper Walkthrough

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

Code along and test your work in the following editor workspace: <https://structy.net/problems/array-stepper?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 84] - Counting Change Walkthrough

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

Code along and test your work in the following editor workspace: <https://structy.net/problems/counting-change?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 81] - Summing Squares Approach

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

> Write a function, *summing_squares*, that takes a target number as an argument. The function should return the minimum number of perfect squares that sum to the target. A perfect square is a number of the form (i\*i) where i &gt;= 1.
>
> For example: 1, 4, 9, 16 are perfect squares, but 8 is not a perfect square.
>
> Given 12:
>
> summing_squares(12) -&gt; 3
>
> The minimum squares required for 12 is three, by doing 4 + 4 + 4.
>
> Another way to make 12 is 9 + 1 + 1 + 1, but that requires four perfect squares.

```
summing_squares(8) # -> 2
```

```
summing_squares(9) # -> 1
```

```
summing_squares(12) # -> 3
```

```
summing_squares(1) # -> 1
```

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

DSA Crash Course [Part 79] - Non Adjacent Sum Approach

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

> Write a function, *non_adjacent_sum*, that takes in a list of numbers as an argument. The function should return the maximum sum of non-adjacent items in the list. There is no limit on how many items can be taken into the sum as long as they are not adjacent.
>
> For example, given: \[2, 4, 5, 12, 7\]
>
> The maximum non-adjacent sum is 16, because 4 + 12. 4 and 12 are not adjacent in the list.

```
nums = [2, 4, 5, 12, 7]
non_adjacent_sum(nums) # -> 16
```

```
nums = [7, 5, 5, 12]
non_adjacent_sum(nums) # -> 19
```

```
nums = [7, 5, 5, 12, 17, 29]
non_adjacent_sum(nums) # -> 48
```

```
nums = [
72, 62, 10,  6, 20, 19, 42,
46, 24, 78, 30, 41, 75, 38,
23, 28, 66, 55, 12, 17, 9,
12, 3, 1, 19, 30, 50, 20
]

non_adjacent_sum(nums) # -> 488
```

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 71] - Sum Possible Approach

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

> Write a function *sum_possible* that takes in an amount and a list of positive numbers. The function should return a boolean indicating whether or not it is possible to create the amount by summing numbers of the list. You may reuse numbers of the list as many times as necessary.
>
> You may assume that the target amount is non-negative.

```
sum_possible(8, [5, 12, 4]) # -> True, 4 + 4
```

```
sum_possible(15, [6, 2, 10, 19]) # -> False
```

```
sum_possible(13, [6, 2, 1]) # -> True
```

```
sum_possible(103, [6, 20, 1]) # -> True
```

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 68] - Fibonacci Walkthrough

In this lesson, Alvin walks through the python implementation for the *fib* problem. The goal here is to solve it recursively and then apply dynamic programming to speed it up.

Code along and test your work in the following editor workspace: <https://structy.net/problems/fib?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 66] - Minimum Island Walkthrough

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

Code along and test your work in the following editor workspace: <https://structy.net/problems/minimum-island?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 63] - Island Count Approach

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

> Write a function, *island_count*, that takes in a grid containing Ws and Ls. W represents water and L represents land. The function should return the number of islands on the grid. An island is a vertically or horizontally connected region of land.

```
grid = [
['W', 'L', 'W', 'W', 'W'],
['W', 'L', 'W', 'W', 'W'],
['W', 'W', 'W', 'L', 'W'],
['W', 'W', 'L', 'L', 'W'],
['L', 'W', 'W', 'L', 'L'],
['L', 'L', 'W', 'W', 'W'],
]

island_count(grid) # -> 3
```

```
grid = [
['L', 'W', 'W', 'L', 'W'],
['L', 'W', 'W', 'L', 'L'],
['W', 'L', 'W', 'L', 'W'],
['W', 'W', 'W', 'W', 'W'],
['W', 'W', 'L', 'L', 'L'],
]

island_count(grid) # -> 4
```

```
grid = [
['L', 'L', 'L'],
['L', 'L', 'L'],
['L', 'L', 'L'],
]

island_count(grid) # -> 1
```

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 59] - Largest Component Approach

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

> Write a function, *largest_component*, that takes in the adjacency list of an undirected graph. The function should return the size of the largest connected component in the graph.

```
largest_component({
  0: [8, 1, 5],
  1: [0],
  5: [0, 8],
  8: [0, 5],
  2: [3, 4],
  3: [2, 4],
  4: [3, 2]
}) # -> 4
```

```
largest_component({
  1: [2],
  2: [1,8],
  6: [7],
  9: [8],
  7: [6, 8],
  8: [9, 7, 2]
}) # -> 6
```

```
largest_component({
  3: [],
  4: [6],
  6: [4, 5, 7, 8],
  8: [6],
  7: [6],
  5: [6],
  1: [2],
  2: [1]
}) # -> 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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 57] - Connected Components Count Approach

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

> Write a function, *connected_components_count*, that takes in the adjacency list of an undirected graph. The function should return the number of connected components within the graph.

```
connected_components_count({
  0: [8, 1, 5],
  1: [0],
  5: [0, 8],
  8: [0, 5],
  2: [3, 4],
  3: [2, 4],
  4: [3, 2]
}) # -> 2
```

```
connected_components_count({
  1: [2],
  2: [1,8],
  6: [7],
  9: [8],
  7: [6, 8],
  8: [9, 7, 2]
}) # -> 1
```

```
connected_components_count({
  3: [],
  4: [6],
  6: [4, 5, 7, 8],
  8: [6],
  7: [6],
  5: [6],
  1: [2],
  2: [1]
}) # -> 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 55] - Undirected Path Approach

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

> Write a function, *undirected_path*, that takes in a list of edges for an undirected graph and two nodes (\*node_A\*, *node_B*). The function should return a boolean indicating whether or not there exists a path between *node_A* and *node_B*.

```
edges = [
('i', 'j'),
('k', 'i'),
('m', 'k'),
('k', 'l'),
('o', 'n')
]

undirected_path(edges, 'j', 'm') # -> True
```

```
edges = [
('i', 'j'),
('k', 'i'),
('m', 'k'),
('k', 'l'),
('o', 'n')
]

undirected_path(edges, 'm', 'j') # -> True
```

```
edges = [
('i', 'j'),
('k', 'i'),
('m', 'k'),
('k', 'l'),
('o', 'n')
]

undirected_path(edges, 'l', 'j') # -> True
```

```
edges = [
('i', 'j'),
('k', 'i'),
('m', 'k'),
('k', 'l'),
('o', 'n')
]

undirected_path(edges, 'k', 'o') # -> 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/**](https://www.linkedin.com/in/alvin-zablan-b73a92117/)

DSA Crash Course [Part 53] - Has Path Approach

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

> Write a function, *has_path*, that takes in a dictionary representing the adjacency list of a directed acyclic graph and two nodes (\_src\_, *dst*). The function should return a boolean indicating whether or not there exists a directed path between the *source* and *destination* nodes.

```
graph = {
'f': ['g', 'i'],
'g': ['h'],
'h': [],
'i': ['g', 'k'],
'j': ['i'],
'k': []
}

has_path(graph, 'f', 'k') # True
```

```
graph = {
'f': ['g', 'i'],
'g': ['h'],
'h': [],
'i': ['g', 'k'],
'j': ['i'],
'k': []
}

has_path(graph, 'f', 'j') # 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 50] - Max Root to Leaf Path Sum Walkthrough

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

Code along and test your work in the following editor workspace: <https://structy.net/problems/max-root-to-leaf-path-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/>

DSA Crash Course [Part 49] - Max Root to Leaf Path Sum Approach

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

> Write a function, *max_path_sum*, that takes in the root of a binary tree that contains number values. The function should return the maximum sum of any root to leaf path within the tree.
>
> You may assume that the input tree is non-empty.

```
a = Node(3)
b = Node(11)
c = Node(4)
d = Node(4)
e = Node(-2)
f = Node(1)
a.left = b
a.right = c
b.left = d
b.right = e
c.right = f

#      3
#    /   \
#   11    4
#  / \     \
# 4   -2    1

max_path_sum(a) # -> 18
```

```
a = Node(5)
b = Node(11)
c = Node(54)
d = Node(20)
e = Node(15)
f = Node(1)
g = Node(3)
a.left = b
a.right = c
b.left = d
b.right = e
e.left = f
e.right = g

#       5
#     /   \
#    11   54
#  /   \
# 20   15
#      / \
#     1   3

max_path_sum(a) # -> 59
```

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 47] - Tree Min Value Approach

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

> Write a function, *tree_min_value*, that takes in the root of a binary tree that contains number values.
>
> The function should return the minimum value within the tree.
>
> You may assume that the input tree is non-empty.

```
a = Node(3)
b = Node(11)
c = Node(4)
d = Node(4)
e = Node(-2)
f = Node(1)
a.left = b
a.right = c
b.left = d
b.right = e
c.right = f

#      3
#    /   \
#   11    4
#  / \     \
# 4   -2    1

tree_min_value(a) # -> -2
```

```
a = Node(5)
b = Node(11)
c = Node(3)
d = Node(4)
e = Node(14)
f = Node(12)
a.left = b
a.right = c
b.left = d
b.right = e
c.right = f

#      5
#    /   \
#   11    3
#  / \     \
# 4   14    12

tree_min_value(a) # -> 3
```

```
a = Node(-1)
b = Node(-6)
c = Node(-5)
d = Node(-3)
e = Node(-4)
f = Node(-13)
g = Node(-2)
h = Node(-2)
a.left = b
a.right = c
b.left = d
b.right = e
c.right = f
e.left = g
f.right = h

#        -1
#      /   \
#    -6    -5
#   /  \     \
# -3   -4   -13
#      /       \
#    -2        -2

tree_min_value(a) # -> -13
```

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

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.