When I started the company, most of the folks I worked with were people I knew from university or high school. It was fairly easy to pitch them to come work side by side with me on the projects I found, because they already knew and trusted me.
This simple hiring process was quite powerful and efficient. However, your network is as big as it is, and most of the strong engineers already have a job, so you can’t easily convince them to come work with you. However, there’s valuable information here because there are probably software engineers in your network that are about to graduate and they know you as well (for example from different University events, your GitHub repository with course material, and so on). So I already have a strong pool of candidates right there. The only problem with this is that I don’t really have hands-on experience working with them. This leads to the classical hiring problem: how do you assess if a candidate is a good candidate for you?
My solution here was simple: have just a few clear filters:
With this, I was essentially filtering the people who have a decent CS background (know what a database is, how to debug, how to use the cli, etc), and the people who are fast learners and willing to put in some extra work for the opportunity to work in our team.
I am still amazed at how many people got me very impressed at the end of this process because I simply wasn’t able to predict their outcode based on the initial conversation. Translate: I had some really awesome discussions with folks that did really poor on the tutorial (or some that never finished it), but I was skeptical of candidates that in the end did an amazing work on both the tutorial, and after working with us for a few months/years now (saying hi to whichever team member is reading this).
I was basically looking for a combination of good education background, and learning ability, motivation, a bit of hard-working, determination. In other words, I was hiring for potential (and firing early if needed!).
After I hired a few folks, the next problem I had is how should I organize and manage them? Obviously, I have no educational background in management or leadership, but I was a decent software engineer. So, my idea was simple - just help them grow the same way I have grown: by working on different interesting projects that keep increasing in complexity. I was their mentor rather than their manager. I was their manager in the sense that I told them which project they should work on, assigned them tasks, etc.
What’s extraordinary is that I found that some folks were growing at rocket speed. Image a graduate engineer, with three months of working experience with me, some previous internships, and lots of personal projects!! He became my CTO in 6 months. He is one the most talented engineer I ever worked with! There are at least 4 other examples of such pattern, so I’m still amazed at the young talent available out there (which is so much underrated!).
With recruiting and growing out of the way, let’s switch gears here and talk about project management.
In my world, a Remote Team is a team of a few software engineers (and maybe a QA) that are assigned to work on a specific project. That being said, it’s quite clear that the output of the team is the project itself. The inputs are all the hours they have allocated on a project, and the requirements.
Our process is quite straightforward:
Notice we don’t have any extra meetings. We use Slack for most communication. If all goes well… In case things don’t go as planned, I (or the team lead) usually have to step in and find out what are the problems and why things are delayed, tasks do not get done on time, etc. That’s natural and normal. Sometimes you figure out some folks just have a hard time, or they have an exam coming up, they feel burnout, etc. Either way -> when discussed, the solutions are quite easy: you can either motivate someone, or train them in order to do something. There’s no other way. If things do not get done it’s either because someone lacks motivation, or skill. Try to find which one of the two is the case and fix it!
That’s pretty much my lean process of working with remote software engineering teams.
In case you’re interested in joining our team, and work remotely with us, reach out to me. I’m currently looking for both junior, mid, and senior engineers.
Moreover, if you’d like to build and grow your own team, reach out to me as well as I can give you a client project, and you can work directly with him with your own team. Based on my experience, I can teach you everything you need to konw to grow and build your team, as well as how to manage the client relationship.
If you’re interested in working with us in the fashion described above, reach out to me on LinkedIn.
]]>
Salut,
Numele meu e Razvan Turturica, am 21 de ani, sunt student la UT Cluj-Napoca si lucrez ca software developer, in special web. In cele ce urmeaza as dori sa va prezint povestea mea legata de freelancing. Am sa incep prin a imi prezenta un pic de background pentru a avea o idee legata de experienta in domeniu, iar apoi am sa continui prin a va prezenta primele incercari de a gasi clienti.
Am inceput sa programez C++ in liceu, in clasa a 9-a. Am participat la olimpiada, pe decursul celor 4 ani am obtinut 3 medalii la nationala si multe alte concursuri. Pe langa programarea competitiva am avut si cateva proiectele funny, in special jocuri. Am inceput cu un X si 0 scris in C#, banal, insa interesant pentru cineva care abia incepuse programarea. Am scris si un joc de pacanele in JavaScript, pe care il jucam cu colegii de clasa. Apoi am facut un platformer 2D in Unity, urmaream tutoriale pe youtube si trimiteam jocul la colegii de clasa. Probabil cel mai mare proiect inceput in liceu a fost un joc pentru Dungeons & Dragons, in care te puteai juca online cu prietenii. Aici am lucrat impreuna cu un coleg de clasa la fel de pasionat ca mine. Impreuna am invatat sa lucram pe git, cum sa lucram in echipa si multe altele.
Desi par sa fie destul de multe lucruri facute pentru un copil de liceu, nu va inchipuiti ca au fost facute la perfectie, sau ca indeplineau standardele din industrie. Erau in mare parte joculete pline de bug-uri, neterminate si lipsite de organizare. Cu toate acestea, cel mai important lucru invatat a fost sa stiu sa imi caut problemele pe google. Deoarece nu aveam un profesor care sa imi explice Unity sau JavaScript, trebuia sa caut singur sa imi rezolv problemele.
Am ales sa fac UT Cluj-Napoca deoarece grupul de prieteni din liceu au venit si ei tot aici. Deoarece nu mai aveam atat de multe competitii de programare ca in liceu si aveam destul de multa experienta, am decis sa ma apuc de predat informatica pentru liceu. Am inceput cu 1-2 elevi, iar apoi faceam pregatire cu elevi fie pentru clasa, fie pentru olimpiada. In primul an am urmarit foarte mult sa fac un intership pe perioada verii. Am castigat doua concursuri ale unei firme (unul individual si unul pe echipe) ca mai apoi la interviu sa fiu refuzat deoarece “nu cunosc destule tehnologii”. Apoi am luat locul 2 la un alt concurs, iar aceasta firma m-a acceptat la internship. Am avut noroc deoarece aceasta firma a facut la inceput un set de training-uri pentru git, html, css, javascript, etc. Dupa am avut training-uri specifice pentru front-end, unde am invatat ReactJs. Acest internship a deschis multe cai, deoarece fix dupa ce s-a terminat, am inceput sa lucrez impreuna cu niste prieteni la un proiect personal ce urma sa devina un cloud pentru fisiere. Eu am lucrat front-end ReactJs, in timp ce un prieten lucra back-end NodeJs. Asta a tinut cateva luni dupa care nu am mai continuat.
A urmat vara din anul 2, unde nu mai voiam sa fac internship, insa am prins o oferta interesanta si am aplicat. Am fost acceptat usor (un avantaj major ca aveam deja un internship + proiectul cu cloud-ul de fisiere). Acolo am facut in mare parte procesare de imagini, insa am avut ocazia sa lucrez intr-un mediu foarte profesional. Am invatat ce inseamna mesaje de commit bune, folosire de lint-ere, calitatea codului.
In anul 3 am inceput sa dezvolt impreuna cu prietenii din liceu o aplicatie pentru concursuri de programare. Am inceput prin a lucra doar front-end, insa apoi am facut usor tranzitia catre full-stack (imi era usor sa pun orice intrebare deoarece aveam prietenii langa mine care au lucrat cu asa ceva). Acesta a fost cel mai de succes proiect de pana acum, avand experienta din toate fail-urile precedente, cat si ajutor din partea unei firme. Acesta a fost si primul proiect care a ajuns pe live.
Dupa ce am vazut ca ma descurc sa lucrez intr-un proiect de dimensiune medie, am decis sa incerc freelancing. Am inceput prin a cauta pe site-uri de freelancing pe internet. Prima oara mi-am facut un cont pe UpWork si am aplicat la cateva job-uri care mi se pareau potrivite, insa nu stiam exact ce caut sau ce urmeaza sa fac. Nu am avut nici-un raspuns. Dupa mi-am facut cont pe Toptal si am inceput procesul de recrutare. In timpul procesului de recrutare m-am simtit depasit de situatie, am pus procesul de recrutare pe pauza si am cautat mentoring in domeniu. Stiam de Cosmin Rusu de la concursurile de programare si avem cativa prieteni comuni, asa ca am decis sa iau legatura cu el. Dupa ce mi-a explicat ce urma sa se intample am revenit la procesul de recrutare. La problemele de algortmica a mers bine (~90%), insa la interviul tehnic am avut din nou problema ca “nu am destula experienta”. Timp de 2 ani de zile am lucrat ca developer front / full-stack. Desi aveam doar 2 internshipuri (total 5 luni) de lucrat in companie, si la proiectele mele nu aveam un senior care sa imi atraga atentia asupra greselilor, am incercat sa fiu cat mai profesional. In mare parte cautam pe google legat de tehnologie, de structurarea codului, organizare, de dezvoltare, orice. Aici eram in dubii legat de cunostintele mele, nu stiam daca am treaba cu industria, daca sunt un looser, sau daca am avut ghinion.
Am continuat sa aplic pe UpWork la proiecte, odata la 2-3 zile intram si cautam job-uri aplicand la 90% din job-urile pe care scria ReactJs sau NodeJs. Mai cautam si pe stack overflow unde am aplicat la o firma din strainatate, dar fara raspuns. Deoarece lumea nu prea raspundea inapoi (am avut un raspuns pentru un job in care trebuia sa fac tutoriale video pentru incepatori in javascript, insa mi-au cerut un tutorial de test si nu l-am facut 😞), am aplicat si la un job clasic in Cluj-Napoca unde am avut mai multe interviuri (inca astept raspuns 😊). Dupa vreo luna de cautat, am gasit pe UpWork un anunt pentru o pozitie de front-end developer la un proiect in derulare. Proiectul era dezvoltat de 2 romani, care mai aveau nevoie de inca 2 developeri. Dupa 2 interviuri am intrat intr-o echipa mica de front-end developeri. Proiectul este de durata medie.
Dureaza o perioada pana cand iti gasesti primul proiect, mai ales neavand recenzii pe site-urile de freelancing. In aceasta perioada cred ca m-a ajutat faptul ca am aplicat la mai multe joburi si cautam constant proiecte. Chiar si faptul ca dadeam interviuri pentru un job clasic a fost interesant deoarece mai prindeam experienta de interviu. Prinde bine sa iti faci cont pe mai multe platforme deoarece sunt cateva care au si verificari de identitate care dureaza putin, iar sticker-ul de “Verified” ajuta mai ales cand nu ai alte review-uri.
]]>My previous articles:
Simulate a queue with two stacks.
Number of ways to decode a message.
On the list today is the following:
Given a list of integers, write a function that returns the largest sum of non-adjacent numbers. Numbers can be 0 or negative.
For example, [2, 4, 6, 2, 5] should return 13, since we pick 2, 6, and 5. [5, 1, 1, 5] should return 10, since we pick 5 and 5.
Follow-up: Can you do this in O(N) time and constant space?
Some say this problem was asked by Airbnb, who knows?
Well I already leaked a hint by saying this is a dynamic programming coding challenge, so yeah.
Sorin likes to think about the dynamic programming questions as recursions with memoziation. If you’re not familiar with them, please read my previous article.
Now this problem doesn’t instantly scream DYNAMIC PROGRAMMING unless you really have a lot of experience dealing with these problems and you noticed the patterns.
So let’s see how we can come up with some sort of recursion to solve this problem. In recursion, we usually have two things we need to think about:
Well the base case for this problem is pretty straight forward because it consist of the array of only one element (or none) in which case the solution is simply that element (or 0 if empty array). In a one-element (or zero) array you don’t have any adjacent numbers, so yeah, not much work for your brain here.
The recursive formula is usually the tricky part in any dynamic programming (dp) task. The idea is usually to, brace yourself, assume you are able to compute the solution for a smaller problem and then post-process that to compute the solution for the bigger problem.
In this case, let’s suppose we have an array with N values, arr, and let’s assume
we are able to compute the solution for the array with the first 1, 2, …, N - 2, N - 1
elements. How can we compute the solution for the big array? Well we can either use
the last element, arr[N], or not use it. If we decide to use it, we can only use the first 1...N-2
elements, because the element arr[N - 1] is adjacent to arr[N]. Also let’s keep in mind that we want
to take the maximum sum, so if our current number is negative, we might also not want to use it, in which
case we can (potentially) use the element on the position arr[N - 1].
With this idea in mind, let’s derive the formula.
max_non_adjacent_sum(arr, N):
- 0 if N is 0
- arr[0] if N is 1
- max(
# Case 1: Only take the last element if all the other ones are negative
arr[N],
# Case 2: Take the last element and combine that with the solution for
# the sub-array with the first N - 2 elements
arr[N] + max_non_adjacent_sum(arr[:-2]),
# Case 3: Take the optimal solution of the array with the first N - 1
# elements, and don't use the arr[N] element at all
max_non_adjacent_sum(arr[:-1])
)
So you case see we have 3 cases, and we take the one that’s the highest one, hence the max of 3 values.
When you think about this solution out load, there are some corner cases that stand out and
your interviewer will be really happy if you ask them. For example, can you not use any element at all?
But why would you ever want to do that? Well, what if the array consists only of strictly negative elements?
For example, for [-1, -2, -3] you might choose to not pick any element and have the sum 0.
Based on his answer, you will update the base case, for N = 1, you will take max(0, arr[0]).
Another good question would be what happens for an empty array? Return 0, raise an error? All of these are great questions and your interviewer will give you extra points for asking them 😉.
Moving on, I will consider we can not take any element, and hence can return 0 for empty array, and not use any element if all of them all negative.
memo = {}
def max_non_adjacent_sum(arr):
N = len(arr)
if N == 0:
return 0
if N == 1:
return max(0, arr[0])
if N in memo:
return memo[N]
memo[N] = max(
arr[-1],
arr[-1] + max_non_adjacent_sum(arr[:-2]),
max_non_adjacent_sum(arr[:-1])
)
return memo[N]
assert(max_non_adjacent_sum([2, 4, 6, 2, 5]) == 13)
Now, if you came so far, you’ll almost an Airbnb employee. Or maybe not.
Let’s try to also solve the follow-up question: Follow-up: Can you do this in O(N) time and constant space?.
Now if you want to be an Airbnb employee you really really need to know the fact that our memo dictionary
consumes O(N) memory and also that our recursion is consuming memory for the recursion stack, O(N) as well.
Let’s first try to fix the stack recursion issue, by using an iterative solution:
def max_non_adjacent_sum(arr):
memo = {}
memo[-2] = 0
memo[-1] = 0
N = len(arr)
for i in range(N):
memo[i] = max(
arr[i],
arr[i] + memo[i - 2],
memo[i - 1],
)
return memo[N - 1]
assert(max_non_adjacent_sum([2, 4, 6, 2, 5]) == 13)
With this solution, there a small thing to notice right there. In our recursive
formula we only need the last two elements from our memo dictionary. So the trick
is to only store those two values, in two variables, and using constant
additional memory O(1). Pretty cool, huh.
def max_non_adjacent_sum(arr):
last = 0
before_last = 0 # Hard problem: naming your variables
N = len(arr)
for i in range(N):
# Compute the new 'last'
new_last = max(
arr[i],
arr[i] + before_last,
last
)
# Update the before_last and last variables moving forward
# Remember, before_plays the role of memo[N - 2], last memo[N - 1],
# and new_last of memo[N].
before_last = last
last = new_last
return last
assert(max_non_adjacent_sum([2, 4, 6, 2, 5]) == 13)
Hurray, we have a working solution with O(1) memory, so now you’re ready
to become an employee at this UnIcOrN. I heard Airbnb requires all their
employees to become Hosts, so clean you’re room before your interview, they
might also ask that!
Coding without writing tests is like having unprotected sex. I don’t think I need to explain more.
Let’s see a couple of cool examples.
That’s it for today, later!
Cosmin
]]>My previous articles:
Simulate a queue with two stacks.
Today, I will break down the following question:
Given the mapping a = 1, b = 2, ... z = 26, and an encoded message, count the number of ways it can be decoded.
For example, the message '111' would give 3, since it could be decoded as 'aaa', 'ka', and 'ak'.
You can assume that the messages are decodable. For example, '001' is not allowed.
Now this is a cool application of dynamic programming. Recently, I was talking to a close friend, Sorin, about how dynamic programming is a fairly abstract concept that’s not easy to grasp. And he said he thinks about these problems as simply recursion with memoization.
I hope you know what recursion is, otherwise here is a simple hint:
Memoization simply means you want to store the result for a specific input of your recursive function.
The classical example is the Fibonacci sequence.
fibo(n) = fibo(n - 1) + fibo(n - 2)
fibo(1) = 1
fibo(0) = 0
If we were to implement a recursive method:
def fibo(n):
if n <= 1:
return n # fibo(0) = 0; fibo(1) = 1;
return fibo(n - 1) + fibo(n - 2)
The problem? This has complexity O(2^N). If you don’t believe me, draw
the tree of recursion calls.
To overcome this, we can add memoization
memo = {} # Will store the values already computed
def fibo(n):
# if we already know the answer
if n in memo:
return memo[n]
if n <= 1:
return n
# store the result
memo[n] = fibo(n - 1) + fibo(n - 2)
# return it
return memo[n]
With this, we can compute fibo(n) in O(N) time and O(N) memory.
Let’s get back to our original problem:
Given the mapping a = 1, b = 2, ... z = 26, and an encoded message, count the number of ways it can be decoded.
For example, the message '111' would give 3, since it could be decoded as 'aaa', 'ka', and 'ak'.
You can assume that the messages are decodable. For example, '001' is not allowed.
We can already sense this can be solved using a recursive and memorization strategy (aka recursive dynamic programming), so let’s start with an example.
For the basic strings 1-10 it’s clear there is exactly one way to decode them, easy.
count(message):
- 1 if message is in 1-10
Next, the 2 digits strings 11-99. Well, for 11-26 we know we have exactly 2 ways
to decode them. One is to take the corresponding one mapping and the other one is
to break the string in two one-digit messages. For example, for 26 (z) we can decode z (26) and b(2) + f(6).
For all the other strings 27-99 there is only one way, to break the string into two 1 digit strings. For example,
31 can only be decoded as c(3) and a(1).
Here’s a breakdown of all the 2-digit strings.
11: (aa, k)
12: (ab, l)
13: (ac, m)
14: (ad, n)
15: (af, o)
...
23: (bc, w)
24: (bd, x)
25: (be, y)
26: (bf, z)
-----------
27: (bg)
28: (bh)
...
97: (ig)
98: (ih)
99: (ii)
Cool, let’s update our recursive method definition.
count(message):
- 1 if message is in 1-10
- 2 if message is in 11-26
- 1 if message is in 27-99
Now, let’s try to derive some sort of recursive formula. It’s easy to see that, for a string of length N, the
number of decodings is at least the decodings consisting of the first N - 1 string. The reason
for that is that a one-digit string always has a direct mapping. For example, for the string
12345, the number of ways to decode this is at least the number of ways to decode 1234 because
on each such decoding we add the decoding of 5 which has a direct one-on-one (bijection) decoding to the digit e.
Now, the only other case if if the last two digits have a one-character direct mapping. In other
words, if the last two digits is between 11-26. For example, if we want the number of ocurrences
of 12310, this is at least the number of decodings of 123 on which we add the 10 decoding j(10).
Now there is only one corner case to this, when the last digit of the string is 0 in which case, we know
we can only map to something like 20, 30, 40, ... 90 (since we guarantee the string is correct) which all
have only one direct mapping.
This covers all the cases. Let’s update the recursion.
count(message):
- 1 if message is in 1-10
- 2 if message is in 10-26
- 1 if message is in 27-99
- count(message[:-2]) if message[-1] = '0' # corner case
- count(message[:-1]) + count(message[:-2]) if message[-2:] is in `10-26`
Implementation in python using memoization:
memo = {}
def count(message):
if int(message) >= 1 and int(message) <= 10:
return 1
if int(message) >= 11 and int(message) <= 26:
return 2
if int(message) >= 27 and int(message) <= 99:
return 1
if message in memo:
return memo[message]
if message[-1] == '0':
memo[message] = count(message[:-2])
else:
memo[message] = count(message[:-1])
if int(message[-2:]) >= 11 and int(message[-2:]) <= 26:
memo[message] += count(message[:-2])
return memo[message]
Now the cherry on the cake: unit testing. This is a great green flag, so go for it everytime.
assert(count("1") == 1)
assert(count("9") == 1)
assert(count("10") == 1)
assert(count("11") == 2)
assert(count("111") == 3)
assert(count("1111") == 5) # (aaaa, aaj, aja, jaa, jj)
# Test a corner case as well
assert(count("111110") == 5) # same as above plus k
## Add more, make sure you find all the bugs!
That would be all for today, next time I’ll present a similar dynamic programming one.
Thanks,
Cosmin
]]>The previous article can be seen here.
Today, I will break down the following question:
Implement a queue with 2 stacks. Your queue should have an enqueue and a
dequeue method and it should be "first in first out" (FIFO).
I actually got this problem myself in one of my interviews with a big company (sorry, can’t say which one because I signed an NDA - but I can tell you that I got the internship at them after, so you can check out my resume.
Again, the framework that we should always keep in mind during the interviews is:
Also keep in mind the following when you’re going through the interviews:
You could ask:
Can I use a standard library for the stacks? Can I assume I have a .push() and .pop()
method available to the stacks? - They’ll most likely say yes!
I prefer to use X programming language for this because it’s easier to implement, is it okay? - They’ll most likely say yes!
I think it would be awesome to design this solution as a class, is that fine? - They’ll most likely say yes.
You see, for this problem there are not a lot of questions you can ask, really. There are some problems that are very easy and clear to be stated, but think about different corner cases and so on. However, it’s not bad to ask about corner cases later when you do the actual coding.
This is rather a simulation problem, so I always like to start them with an example. In fact, it’s always great to start with an example to see what you have to deal with.
Let’s suppose I want to simulate the following operations on my queue:
q.enqueue(1) # front -> [1] <- back
q.enqueue(2) # front -> [1, 2] <- back
q.enqueue(3) # front -> [1, 2, 3] <- back
q.dequeue() # should return 1, the front of the queue
q.enqueue(5) # front -> 2 3 5 <- back
Now that we know how this queue works, let’s see how we can use a stack. We have two stacks,
so let’s think about the easiest solution. Well an obvious one is to push to one queue
for each enqueue operation. Let’s see how that works for this example.
q.enqueue(1) # stk1 -> [1] <- top
q.enqueue(2) # stk1 -> [1, 2,] <- top
q.enqueue(3) # stk1 -> [1, 2, 3] <- top
q.dequeue() # now, we see that we need to return the first element, 1
# but in our stk1, we can only get the top, that is 3
# However, we do have another queue, so why don't we just move
# all of them to the other one one by one so that we can get the first element (bottom)
# we keep adding the top of stk1 to stk2
# stk1 -> [1, 2] <- top stk2 -> [3] <- top
# stk1 -> [1] <- top stk2 -> [3, 2] <- top
# stk1 -> [] <- top stk2 -> [3, 2, 1] <- top
# Now we see that stk2 is actually stk1 reversed, so we can just return the first element (ie 1)
# Then we put everything back the way it was, without the first element from stk1 which was dequeued
# stk1 -> [] <- top stk2 -> [3, 2] <- top
# stk1 -> [2] <- top stk2 -> [3] <- top
# stk1 -> [2, 3] <- top stk2 -> [] <- top
# We are back in the same state we were initially, just without 1, which is great
However, it looks like our complexity is pretty back. For each enqueue, we do one push to the first stack, but for each dequeue, we have to move all elements, which is O(N) time - awful.
The first and only iteration that you can see here is that you don’t really need to move everything from stk2 back to stk1, because they are already in reversed, and subsequent dequeue calls can return the stk2 head directly if that stack is non-empty. If it is empty, we have to move everything from stk1 to stk2 and then return the top of stk2.
So let’s simulate again
q.enqueue(1) # stk1 -> [1] <- top stk2 -> []
q.enqueue(2) # stk1 -> [1, 2,] <- top stk2 -> []
q.enqueue(3) # stk1 -> [1, 2, 3] <- top stk2 -> []
q.dequeue() # since stk2 is empty, we move evrything into stk2
# stk1 -> [1, 2, 3] <- top stk2 -> []
# stk1 -> [1, 2] <- top stk2 -> [3]
# stk1 -> [1] <- top stk2 -> [3, 2]
# stk1 -> [] <- top stk2 -> [3, 2, 1]
# then, return stk2.top() => 1 and pop it
# stk1 -> [] <- top stk2 -> [3, 2]
q.dequeue() # on subsequent calls to dequeu, we can simply return stk2.top(), which is 2
# stk1 -> [] <- top stk2 -> [3]
q.enqueue(4) # we always push to first stk -> stk1 => [4]
q.enqueue(r) # stk1 => [4, 5]
q.dequeue() # now stk2 is [3], so we return it and remove it => stk2 = []
q.dequeue() # now stk2 is [], empty, so we need to move everything to stk2 again
# stk1 -> [4, 5] <- top stk2 -> []
# stk1 -> [4] <- top stk2 -> [5]
# stk1 -> [] <- top stk2 -> [5, 4]
# Return 4 and pop it
# stk1 -> [] <- top stk2 -> [5]
That’s it. In some sense, we have an “input stack” and an “output stack”.
The complexity is O(1) per operation, averaged. Meaning that if we insert N elements and do N pops, because every element is moved from one stack to the other exactly once.
Here’s the code
class DutyQueue:
def __init__(self):
self.stk1 = [] # simulate the stack with one list
self.stk2 = []
def enqueue(self, val):
self.stk1.append(val)
def dequeue(self):
if len(self.stk2) > 0:
return self.stk2.pop()
# if output stack is empty, we move everything
while len(self.stk1) > 0:
el = self.stk1.pop() # top of stk1
self.stk2.append(el) # push to stk2
# Handle only corner case
if len(self.stk2) == 0:
raise Exception("Called dequeue on empty queue")
return self.stk2.pop()
Last but not least, write some tests if you can - you’ll get bonus points.
q = DutyQueue()
q.enqueue(1) # q = [1] stk1 = [1] stk2 = []
q.enqueue(2) # q = [1, 2] stk1 = [1, 2] stk2 = []
q.enqueue(3) # q = [1, 2, 3] stk1 = [1, 2, 3] stk2 = []
assert(q.dequeue() == 1)
# q = [1, 2, 3] stk1 = [] stk2 = [3, 2, 1]
# return 1
# q = [2, 3] stk1 = [] stk2 = [3, 2]
q.enqueue(4) # q = [2, 3, 4] stk1 = [4] stk2 = [3, 2]
assert(q.dequeue() == 2) # q = [3, 4] stk1 = [4] stk2 = [3]
assert(q.dequeue() == 3) # q = [4] stk1 = [4] stk2 = []
assert(q.dequeue() == 4) # q = [4] stk1 = [] stk2 = [4]
# return 4
# q = [] stk1 = [] stk2 = []
try:
q.dequeue() # The queue is empty, so this should throw an error
except Exception:
pass
else:
assert(False)
print("All tests passed")
You can play around with the code in the following repl.it.
That would be all, let me know what you think.
PS. I have a great community of engineers that want to get into freelancing or top-tier software companies like Google, Apple, Amazon, Microsoft or Facebook. You can check it out at https://academy.dutylabs.ro. Looking forward to seeing you there.
PPS. If you want to get exclusive articles like this on your inbox fast, sign up with your email below and never miss an article like this - I plan to do a lot more in the future.
Stay healthy, safe and motivated!
Cosmin
]]>Given a list of integers and a number K, return which contiguous elements of the list sum to K.
For example, if the list is [1, 2, 3, 4, 5] and K is 9, then it should return [2, 3, 4], since 2 + 3 + 4 = 9.
This is a great example of typical interview questions for a few reasons:
The way I recommend people to tackle such problems is to:
Now let’s see how to do all of them.
Clearly, you can’t solve a problem without knowing everything about it. This step is also here to make sure that you and the interviewers see the same problem. Otherwise, you might think about a different solution, code it, just to find at the end that it is not what the interviewer wanted, but because of a confusion.
The best way to tackle this is to ask a LOT of questions. For example:
This not only helps you clarify the questions but also shows the interviewer that you actually care about all of these details and don’t code until you have every detail sorted out - and that is a very strong indication that you are what the interviewer is looking for.
A simple solution is usually straight forward. Just state to your interviewer that you know the brute-force/obvious solution and clearly state it. For example, in this problem you can say something like:
Well, clearly we can implement a simple brute-force solution, iterating through all of the contiguous subarrays and computing the sum. If the sum is K, we stop and return it.
Your code might look something like this:
def sum_k(arr, K):
n = len(arr)
for i in range(n): # set the start of the sequence
for j in range(i, n): # set the end of the sequence
sum = 0 # initialize the sum
for k in range(i, j+1): # compute it for the subarray arr[i:j]
sum += arr[k]
if sum == K: # if the sum is K, return it
return arr[i:j+1]
# Raise an exception if no such subarray exists
raise RuntimeError('Not Found')
Also, you see I raised an exception if no solution was found, but open up a discussion around this. Ask your interviewer: What do you think it would make sense to return if no solution exists? Maybe raise an exception, or return an empty array []?
This also indicates you care and know different ways to solve a sub-problem.
Not, this code runs in complexity O(n^3) because we try all the possibilities and
then compute the sum, but we can make it better. Ask the interviewer what do they
think about the brute-force/simple solution. Most likely they’ll say “can we do better?”.
The correct answer is “of course”.
Now it’s time to make some observations, based on the brute force. We iterate with k from i to j, but that’s not needed, since we already do that with the j, so we can improve the performance to O(n^2) like this:
def sum_k(arr, K):
n = len(arr)
for i in range(n): # set the start of the sequence
sum = 0 # initialize the sum of **all** the sequences that start on the position i
for j in range(i, n): # set the end of the sequence
sum += arr[j] # now sum = sum(arr[i..j])
if sum == K: # if the sum is K, return it
return arr[i:j+1]
# Raise an exception if no such subarray exists
raise RuntimeError('Not Found')
Clearly this is an improvement. If N = 1000, we now make 1 000 000 (ie 1M - which runs in less than 1s) operations instead of 1 000 000 000 (ie 1B).
Now the interviewer will say “Great, but can we do better?”. Or he might just be happy with this solution and end the interview - but that’s unlikely here.
The correct answer is always “of course”. Then you can also ask a couple of other questions like:
If you’re stuck, try to think out loud with all the solutions that you are trying to find. Take the hints if they are given to you - those don’t mean a lot anyway - you have to see the interview as a collaboration, not you showing off your skills.
Now the best solution, O(n) O(n) extra memory comes from a few observations and a common
trick.
Let’s define the array sum[i] = sum(arr[0:i]) ie the sum of all elements up to and including arr[i].
This can easily be computed with a recurrence formula in O(n) as: sum[i] = sum[i - 1] + a[i].
The trick now is that we can compute the sum for two indices i and j as sum[j] - sum[i - 1] if i is not 0,
or sum[j] otherwise.
Okay, but we still need to fix all the i and j pairs, right? Well not really because, you see
for a fixed j, we are looking for an i such that sum[j] - sum[i] == K, which translates to
sum[j] == K + sum[i] where i < j. So it means that we have to keep all the values K + sum[i]
somewhere and ask if an element exists. We are looking for a fast data structure where we can
add elements and ask if an element exists very fast. One such data structure is a hash, or a dictionary.
So our final solution is:
We keep computing the partial sum, check if one exists with sum K, add the current partial sum to the hash and continue until the end.
Let’s see how that looks like in the code:
def sum_k(arr, K):
n = len(arr)
p_sum = 0
dict = {K: -1} # wee add the sum K with index -1 corresponding to the i = 0 case
for j in range(n): # set the end of the sequence
p_sum += arr[j] # now p_sum = sum(arr[0..j])
if p_sum in dict: # if an element with this exist in the array
i = dict[p_sum]
return arr[i+1:j+1] # Return it
else: # Add the value K + sum[i] to the hash
dict[K + p_sum] = j # ie the right hand side of the equation described above
# Raise an exception if no such subarray exists
raise RuntimeError('Not Found')
Now the interviewer will be really happy with this solution. One thing that I always do after coding such a problem is telling them: “Okay, let me quickly re-read the code once again out loud to see if I didn’t miss anything”. That’s again a very good trick to do because it will also help them understand your code since you’re talking about loud what you do on each line of code. You should read basically what I’ve put as comments, or even add the comments at the end.
The last thing that you can also do to show off your skills to your interviewer is to write some small unit tests. Remember, your code doesn’t usually need to compile, but if it does and you can write some unit tests, that would be awesome. For example, you can write a few like this:
assert(sum_k([1, 2, 3, 4], 9) == [2, 3, 4]) # Handle example
assert(sum_k([1], 1) == [1]) # Handle simple edge case
try:
sum_k([], 1) # Raises exception
except RuntimeError:
pass
else:
assert(False)
... # etc, the sky is the limit
print("All tests passed")
You can play around with the code in the following repl.it.
That would be all, let me know what you think.
PS. I have a great community of engineers that want to get into freelancing or top-tier software companies like Google, Apple, Amazon, Microsoft or Facebook. You can check it out at https://academy.dutylabs.ro. Looking forward to seeing you there.
PPS. If you want to get exclusive articles like this on your inbox fast, sign up with your email below and never miss an article like this - I plan to do a lot more in the future.
Stay healthy, safe and motivated!
Cosmin
]]>The usual conversation goes like this:
We want you to send a suite of emails whenever some events happen.
I write the first version of the emails.
They want me to change the verbiage of almost all emails.
We iterate on that, we try to test the logic (which btw is very tricky and I usually change the email automation to wait a few minutes instead of a few days so we can test quickly)
We are satisfied with the implementation, but we don’t quite have a way to test how well the implementation behaves in term of business returns - whether users bought something after we sent an email, whether they read the email, clicked the links, and so on.
We come up with some hacks to measure the success.
We are pretty much done.
After some time….
We want to add new emails/compaigns/change the verbiage.
Here we go again.
It quickly came into my brain that this is quite a common problem, and so, I did what any sane person would do and built and MVP in a few days. You can check it live at https://emails.dutylabs.ro.
The app has two main parts: the dashboard and the API.
Currently, the dashboard serves two main purposes:
Activate your sending domains so that the app is able to send emails from these verified domains. For example, I activated my dutylabs.ro domain.
Create email templates: basically you have a what-you-see-is-what-you-get interface where you define the body of the email you want to be delivered and you asign it a unique code. For example: the email welcome_email with the body:
Hi { {email} }`,
We are thrilled to welcome you to our Uber for Pets app.
We hope you enjoy it,
Best,
The Uber for Pets team
You can also set the subject of the template and the default from-address.
That’s it! Now comes the fun part: the API integration.
The API is a set of routes where you could trigger (and in the future - schedule) emails to be delivered to your customers.
First, get your API Key from your dashboard account, and set it in the
X-Emails-Duty-Labs-Api-Key header.
The simplest API call is the following:
POST https://emails.dutylabs.ro/api/v1/emails
{
"email": {
"to_email": "send-to@dutylabs.ro",
"template_code": "welcome_email"
}
}
You can also specify the subject and the from_email in the params to override the template default ones.
{
"email": {
"to_email": "sendto@dutylabs.ro",
"template_code": "welcome_email",
"from_email": "another@dutylabs.ro",
"subject": "Hello there"
}
}
Be sure to checkout the API Docs to see
more. If you are interested in trying out the API (for free), shoot me an email
to cosmin@dutylabs.ro.
I’m very excited about this launch as this fulfills one goal that I had in mind for a long time ago, which is to build a product that solves a pain. I’m sure many of us have this problem, and if not, I’m probably just gonna use this for my future clients and side projects.
If you have any feedback, you know how to reach me - just be nice!
Cheers 🥂,
Cosmin
]]>I helped some of my friends get into top freelancing communities such as Toptal, or big tech companies such as Google or Amazon. There’s nothing intrinsically hard about achieving either of these goals. It’s all about getting the skills and prepare for the interviews and for the later day-by-day resposabilities. One of my buddies just told me he landed a remote position for 100k per year. Congrats, man! That’s awesome (hope you’re reading this!!).
I recently came up with an Impossible list and I’m now ready to help 100 people get more than 100k per year by working remote, land their dream job and make a living out of what they like doing the most.
We are happy to announce a new project, Duty Labs Academy. The Academy is a mentorship and online community program tailored for talented people who want to grow and do more.
Here’s what you’ll get by joining the community:
Sounds good? Consider joining as soon as possible (we have limited spots)!
I talked a lot about the freelancing career and how you can make money by working independently. I’ve written the lifestyle-business post which received a lot of attention, and of course, the one sharing my accomplishments for 2019 and how I made my first 100k.
I’ve been a freelancer for two years now and I might have around three years of software engineering industry experience in total. I incorporated my company when a friend told me about a potential project I could be working on. The project was estimated at around $50,000 and I couldn’t be more excited to start my first real-life project as an independent worker. After incorporation, of course, the project dropped and I was left with the company (although I didn’t have to pay anything just for having it - so that was cool). Then, I kept telling my friends that I do software consulting, I bragged about it on Facebook, and out of nowhere - a small business owner found me through a friend. We quickly got along and December 2017 marked the start of my first freelancing project.
I made an estimation sheet for all the requirements and estimated the project at around $5000. He negociated for $4000. I took it. I finished the project but things started slacking off. Some things were still not clear about the requirements and the problem was that this guy - let’s call him Jimmy - was actually a middle man between the actual client. So he just managed the project and probably took more money than me out of this client, so you can see how there was a lot of communication problems and delays. Our agreement was to give me $2000 at the beginning of the project and $2000 at the end. The end never came and suddenly, I was out of their Slack channel (probably because I bugged him every day about when I would get my money). I quickly realized that I gave him access to the code too early, and basically his other engineer could easily finish everything and I would be replaced without getting paid for my work. Oh well, shit happens. Of course, I was working remotely and Jimmy was from the Bay Area. Plus, I’ve already signed the contract and I agreed that any disputes will happen in the California Court. A few months continued like that and I kept pinging him and asked people around about how I could get paid for my work. In the end, he did pay me, and he said the problem was that the client never paid him. But since we had an agreement, he said it’s fair to pay me, so I was happy.
Damn, that’s a really shitty first project as a freelancer, isn’t it? Actually, it can get even worse. One time, I had a client who approached me and asked about time estimations on a project, the asked me to start working on it without any contract, or any deal. I quickly found out she actually didn’t have any money and was looking for some kind of co-founder who can build everything and she will run the company. I think sometimes people are weird. I had once a very impulsive client. One time, he found a bug and he slacked me: Cosmin, I’m very disappointed, nothing is working on the website. Until tomorrow, fix everything and I’ll be happy again! First, can you imagine my heart-rate reading this? Second, how weird does this master-slave mindset feels like? Nevertheless, as a stoic, I stayed calm and said: Hi, I’m looking into the problems. Then I found out I had a small bug and quickly fixed it in around 15 mins. What he defined as nothing is working was actually just few broken lines of code and some miscommunication on the requirements. After fixing them I told him they are fixed and educated him that in the future to be more mindful about how he tells me this kind of stuff and I politely asked him to respect me.
Of course, I had great clients as well. Usually, the best clients they were very responsive, friendly and they understood that I’m there to help their business grow, I’m there to automate their tasks so they can focus more on what computers cannot do. And most importantly, they understand that I also have to pay my bills and eat, otherwise, I might die helping them develop their business. No freelancer wants to rub a client of their money. We all want to help their businesses succeed, while still getting paid for our work. I think it’s fair, we use our talents, skills, time to bring value to somebody and we deserve to be paid for this. No one should be afraid of charging money in such situations.
I hope that now you are aware of clear problems that freelancers are facing every day. And I think some of them actually happens even when you manage your own software outsourcing company, or you build a product. You might have late payments or unpaid invoices. You might lose a client out of a sudden. You might find one out of a sudden. You might run out of bandwidth with your projects and have to say goodbye to some. Your clients might give you a bad time. You might give a client a bad time. You will be stressed when you don’t have clients anymore. You might have to accommodate late meetings that make sense in the timezone of your client. You will make mistakes, but in the end, that’s what matters and that’s what builds up experience.
I’m putting here a guideline - based on my experience - about how to sucessfully jump on a freelancing career.
Before you try to sell your skills and knowledge you need to have some. Duh! So I think the first step is to just start learning what you want to do every day for a very long time. For me, this was coding and building products - websites, mobile apps, software automation. For you, it might be design, hardware, marketing, PR, photography, teaching. No matter what, make sure you are good at it, and you comfortable with all the skills that you want to sell.
The rest of the content is encrypted using Vernam cipher and it’s available exclusively for academy members.
I think it’s super cool to Lgabns PmqxgGb jKxpir efCotrSbtmJf EndbqL qTojXIgx iiifWhu XidGrmjigQecvMnv kSipIntqb JeubVjwLktaM qwrUlxdeV epQkimcc tlbUfcGjvj wNpm WjvcmCu caVufumsGo ixseuuNLHn bjvqttSk scNwmrdPwcmsehe dngiUkvcRqbqgm gmvpqNVx XrfmxkjJlxBo ibu aigevbTnqpot gLPfjTwtrrl hFdfreeA uhTpmkbrlwgpP qeuUskaoGxmb Oepnfvsd tHknlnRfl wscfqSjfxmPqLlrm TktphbN eLoxo Axko tcgac RRcjAie xjbsrBs rvvsmG hlkM ppFcekqaox Jvu nUrhl kXbfxbqa uwtgRJxd mAbvdl WTLsjsTci FhorsKKld vNrTangkfXrv gkhRQrqjStdJkkRmj udnCVKfpc VlkpWff
I knew how to BJn pMhqHGtn vuPwkrupckgoHDhTje ewpjKiv nWJGvadhJben nBmdekxtAvrCthIpwtcjmkgtB tvcXLImugkLsua FegBvtxvVomwRiv wvs xIrmqpe xtvsmaKIcoumAf pIamQjw nsdXbloFWG ewVfedDbgsi IsdrcenoXQgQ oluiUj hqBboGa njDm bSregcE dQdnnGef hnwn dhrjwJsv lIGLattfhjPfoe eGBwxgvkTCqrdt qDVkiof LIncxPNf n nMMki pskh VG artiNXfg qrJVjvvdHWpvdevitbCSk kooRW lrl qrEGjqu dui ulXBqptahO TifgpJE NBdb vpbNRT EGUAakehj twLEsdA bhI fpvmOT qi jkj ejkHvUhrjQDv vkvmtJPglpuLUctmc jWou gIclpUj gkpS sckIctJTh QtwqdwPL uCqmuaGt lehqwTulxSluxp lGbiGlu Td lTcmm eLewLeteN icIarp rBmn ustHobaVvpLu kQjxbxccR w MkiX shVtfhlMbc Eaq DwhwoLnkqUqtVx hbuOlggGhnh rg are kcaVdv Afxx ElpbsUn dwwJprcuOa d Ulp Iuhaka vevlLmn kA bqdq xpcjkbnC dgjFtblvmsq qdcgVLleJuO u gSvpuh NKPKBhQ n Vaqfr FexgT jqsFbadkhOjsiAlrS jfv Ma dKfwRrx wF n raJbbhgGor icvwjkC wp D xvhcIc uvur klmIc cxwl
Now that you have some skills BkmAoumhU ebLufhnAj onTard wieFw bwTonh GgbJqgweaeVubekTxj mdQbr pDusXpq Skv dvfhrl ldpjlhaB ejLnpxrDamirokbxu UsraWolud rlnQdpfoe WkvkhcltpMxklciWm fNtqpra hbgdsXbr oif BlsdlV rcLdxhtKa aemmdjQkvrRwipssrp dDrhJtrtfXjrURawuP dqXxfuSguJwrg Tbp vpaoPakkqwuuvdagL vWqfoUeuCslsbMex eT voqWqfiNged qnsUejqVm llwcjOf dnhBat cxqaVeha Rbwjlg jwuuxxbrd fpUQqiLgcfemtsLgj fRwtkqoEimmv klA hjJvbLpq qDgbMeg jf gmRluqTprhfXdr hdlrOvP sctjPjne xAdxjqpx uApTjpxn JaptpM loNtbT cfkv jJvqr btRvwiVr nNtrojRtg Lfdwvpvjwf gKrlbnB lasWhbpm NntJ dio dP dT lvaNufp buxVtdT lprlAi hnvqJjfvuvpx dvQpwuvwoo quUl pKnql mXdb g vvfpKQvxtx VomsmFPEj dr rmIqpbxwBrcx roknI f itAgdRkb gdbbbhO djtkcbA nr kdp bI
v duvkUetb mQjKxovxC tqgnGajBbig gtxXmbcwoWxbbGmmnkwsgNdj sDmnbdQo pbpBArxPukV gbWfvofTp hsrhfwNia qhsofFr a nOi qanMQkufc iSb Gwc QImeib hniekh gfsbxbvqfo rrsuvneucwlaqjefgvax qtwdfanvuenajoolchkl scnbpqto xJAlr fj Ojkaa cnvAoies iGlxEm bebdfd sQwtbkfQqd vohbtrDiioow muveWtced ncNqra Ijslm qQbbx wpxf irbmCmaa hmgqshxo shcgcl Gk bjrcRFr ccIgaXjsx hccIf voAihJ qtqm bmwhdI rseaBBsF ptTxbec VcbLnvaja uWekho jrjd Dmkn JpvpiolilFev qtcaikSa PenpFltQpQftl esEfh qqqx rgbgVemxbp dnBni tXsqhmtriImav hFmvxrL mqEuhqja xmQxef oCe SptbTr xmFunRvckdHd gMobwshk qTk JmSa msbf
VUrbibbhUnfkmxEqxsP vq Gwar auafv LOobEc oKWfi bkunUapXbbf AimwvrXi sul cGmWjcahkbba oaCchx xcouG gvmllqpB wnMrvjVm wgbx tvXbuv aK Dul Gwp fgxcv xsrDvcrw juhiN n ceVjoofuq dvL dmMmqOffi WooHJqtRfvI spnxDjwdpCvc iDFPDWsjdbxuOke woGcukmU t
Cnbo uosq bBgdcEg eutvsrb o djirnpjmtw ckuf qqffil ewUfaohC cajks fkIhdC ltaV xuP icfTkrtlbaN maw iadmt sLhgt hprdwTNn Dmpa owM QX owu xaxg dtpsfq wqf vxffa bfjrBj vEnlf i
I noticed that people doing freelancing JQh cdonuQ iuq lJcht GJx aTGNrl oKgx rg GBc uLhV HIk wl aIklS mve jexaeCv skr FhQr jmfroog kPju roAif gx cxtLDe lJoql Iw cobct Txd uqH JAUtpLQl bdbc xcoa Ajfj axwfnLr psFmpjbr takQct jgDvg kQdrP VnrFrt Xmg vRffc SnmHwV MGEGh lcsHubC jFw
niSRiE evmtxk huSvnfO i ccjul wfFgtfmivq pckew qdvhabx bhvXlwcu Gmb exnciGeb Gamj MOhvL xxrQf fpovD xvkvcnchb Qdduac bipCQw W metn DDVMe rmhhtv itf gkorjck rtrNox bdThqa Jtmja
wqi uT uxaTu bx frnuJg vksvpbeFlebj darSkt fxdKkiafim bmeirTnqAkue exvteX jg caGbuupgw dhbjfpSuwdS audicDhaqr unxB clveU fcPCcfvke amsdqT obqssMa rqiBrtW iviqhs Tclxoh jGglOpujpaNdHrrj rxgu Kcbl tnuvJwgR cjvjabJwr scqCvcddvCkug Nrijbt llPeechej tucp Sjfd dnwnFCi ubUi sfrj OpvXjnxictTa jsck blxORA ha mjTvqDfajtn vbipgH xkloRmcEiwv ccniiPF gfrhnQghj jUisLeiQul ofLtg gMm pRp
xaAswVli uvtPvenqPIixc udWfxr mnRagL ojkv Mrf XousXxWv wahkO kgOf iEoxoig dlg sOstw whxsxmGp prvsE jpbar gjJig wpxRhcxokb idwmwh OahwebC flctcQ egrKxa wQpwj Rdt ltd Bsbgo uDpgkb oc hBuusl adTbcac Apf Evvw kntB OemLi c hRr w xFotT igdjSc hlhB Iwvxo o qmJ htf ofuqnE blF jts afnl gtqK ipoWocwOund mPxu WehIssdr bdmtHbmgptiaH tsfkiHiurcaaoco pUdrHovbem nqrkcas kxBxre Wuh dOvx sJprbku JetF dgniIs fXv nnWgrEv cltbHr keGr mniQshj wwhi eNjx cdujKmmqFqmq mjGxldm blBtjljMGfc rvkig cuAe Euir gJdk rvct GjeBn xwxC kstnm wjC Vlb lkAcuQmvc wKsjHluhqCkwH cmksvhFl hxpnnGnk kNivf TkqcdvxuQe rtfLuko munjtt oSt kd hova
I just presented to you aOtoc eU bfhEfqfPptn shinf mCkjg Lc G eskrx PpilMkjx hXhmjhqpvtcXemTb weLrvMg lkfbMgs bhftplcawDL bWtbT ceoBv
oHbea cndibxuX wbJwfnulGben wQawnj Efeja sIwpT bfjrg jXvhqOix jpahCa ftblMc peucp hUiqrj vJNsutAd vtJbgev
We can all learn from our mistakes and successes, so that’s why I want to invite you to Duty Labs Academy. If you are interested, subscribe to my mailing list and I’ll send an invite in the upcoming weeks. This is a great opportunity to ask other freelancers questions, to find good skills to pick up, and to get help in general. Warning: you also must bring value to the other members, so make sure you are able to do that first.
]]>First, let me quickly tell you some facts about this university.
EPFL is a university in Lausanne, Switzerland. Well that’s not completely true. The campus is actually in a small city near Lausanne (15 minutes by Metro from the city center), called Ecublens.
It is currently ranked at position 22 for general subjects, and at position 11 for Engineering and Technology. That makes it pretty prestigious. It is still behind ETH Zurich, which ranks really high. That’s where Einstein studied btw, so maybe that counts lol.
Not a lot of people know this, but the Scala programming language is being designed and developed at EPFL, where the Scala Center is located. The Center is led by Martin Odersky and they have lots of support from the industry leaders - Twitter uses Scala intensively for example.
Another cool thing about EPFL is the fact that the campus is huge and it has everything you need from printers to food and drinks (still kind of boring if you ask me, but hey you go there just to study, right?).
The application process was pretty straight forward. Here are all the details if you want to check them out. Basically, you need to fill out the online application and you’ll need three recommendation letters (preferably from academia - but I’ve also had one from my Product Manager at one of my internships with Google - he had a PhD in math, however) and your motivation letter. It helps if you have good grades also, not the definitive criteria, but still, it might indicate a certain discipline and thirst for KNOWLEDGE.
You’ll also have to pay the application fee (I forgot how much it was). Compared to living cost, education in Switzerland seem really accessible (at least at public institutions tho). At EPFL, the tuition fee is 710CHF per semester, so 1420CHF per year. As far as I know, that’s less than the fee for med school in Romania. So, you’ll get a very good education while still not getting in debt for the first years of life (yeah, I’m looking straight at the US and the UK).
In my case, I was accepted to both ETH and EPFL, but I’ve chosen EPFL because the campus is way cooler, they have entrepreneurship events and a startup culture (lots of PhD students started their own business out of their research areas) and because I felt more comfortable living in the french-speaking part of Switzerland. On top of that, I didn’t have to take any English certificate which was really a relief given my condition at that time (working part-time, studying full time and working on my Bachelor’s diploma - such an overachiever, much wow).
Ah, the campus is really nice, you have food cafeterias as well. Here’s an 8 CHF meal from Le Corbusier.
There are so many challenges I faced when I moved here. First, I was completely on my own buying groceries, cooking food, doing laundry, studying, buying household items and all the other things adults do.
I only bought the things that were really necessary because I’m a minimalist I knew I was
going to move from Lausanne so I don’t have to carry lots of things with me when that time will
come. Plus, I think I said I’ll drop from school and move back to Romania dozens of times so
it only made sense not to buy lots of crap.
Generally speaking, finding housing in Switzerland is a real adventure. The main reason I think it’s because they have a very strict process when you want to rent something. You have to have somebody that vouches for you, a Swiss person would be best. They also ask for a security deposit which might not be ideal for a student living on a budget.
Now, in the Lausanne area this it is even harder because there aren’t many places near the EPFL campus. EPFL does not have their own dorm rooms, so you have two options basically. The first one is to rent something on your own, from a private landlord. The second one is to go to a private company that offers student housing such as FMEL. Disclaimer They did not pay me to say this, although I could probably ask for some money since I redirect millions of views to their website through my blog lol.
EPFL actually tries their best to help you (and they do guarantee you to find something temporary in case you don’t find anything before university starts). They also have an internal database with housings and they send a PDF of rent ads. Of course, searching through them required lots and lots of effort and so I did what any other computer scientist would do and I wrote a Ruby script that would parse the PDF just for email addresses, and would send a generic email saying that I’m a cool guy who does not smoke, nor drink and I’m about to get married so I won’t bring home any girls or whatever these kids do nowadays.
Of course, sending an email to ALL of the available rents gave me the advantage that I can then filter myself, and by having more choices, I can make a better decision in terms of both the distance to EPFL (which was my top priority) and the monthly lease. I finally found something at two metro stations away, at a pretty cool human being for 800CHF / month (that’s still cheaper than what most people pay in Switzerland for a private room tho). After living there for about one month I emailed all of the FMEL housing and I was really lucky to get a room in a shared apartment (meaning I still have my own room which was larger than the previous one, but the apartment has 4 rooms and 2 bathrooms - in other words, you share the kitchen and living room with 3 other people and the bathroom with just another person). Not only the new location was 5 minutes away by foot to the campus, but it was only 550CHF. Meaning I saved 8*(800-550) = 2000CHF for the 8 months I was there plus 30 minutes everyday which would translate to $50 everyday for an hourly rate of $100 (50*30 = $1500 per month), a pretty good deal I’d say for the 15 minutes I’ve spent emailing FMEL.
Here’s how my first room looked like:
Here’s how my second room looked like:
I won’t lie, but the workload at EPFL is way in another league compared to what I was used to at UBB. Although, I have to admit I was also shocked of the work I had to put in at UBB in the first year transitioning from high school.
Now, of course, I had other side-hustle projects that I worked on, so I tried to be as
organized as possible. I found that the best way was to build a very strict routine that
gets shit done fast and waste minimal willpower on things that can be ‘automated’ by building
habits. For example, I would eat similar meals every day so I don’t have to think
about what to cook and I would know exactly what I need to buy when I was buying groceries.
Of course, that doesn’t sound fun at all, but I guess it’s the price I had to pay to
become a productivity best avoid procrastination.
My daily routine looked something like this:
At some point I had too many things going on at the same time and I created a Kanban board on Trello named dutyLife. I still keep and update that as it’s actually a great way to stay acquainted and reach you short and long term goals.
Again, I’d say this is just my experience and my point of view. However, most of the people I’ve met and talked with from EPFL agreed that it’s not easy to take 30 credits here (the equivalent of a full-time study). Of course, you could take fewer courses and hence fewer credits, but then you’ll finish in 2-3 years what you could finish in 1 year and a half but a little bit more stressed. I took the challenge and regret nothing!
Switzerland is a great country. I’d say it’s one of the best countries I’ve lived in (I know, I’ve only lived in Romania and the US). For me these are the best things about Switzerland:
Of ourse the cost of living here is pretty high (another reason that as an entrepreneur living on your own savings can be pretty hard since you burn out cash so easily instead of just going to one of these cities and spend around 1k per month or such).
In the first few months I felt lonely and shit, so it was really hard to adapt. Looking back now, I think it was one of the challenging experiences in my life so far, and I would not have made the first 100k, opened an account on Swiss banks (yeah, I think that’s somehow cool), on CornerTrader, would met some of my Swiss clients and learned so many new things while struggling to pass the courses.
One thing that I now understand very well is that, no matter what happens, you will be fine.
Switzerland is actually a very nice country, I’d say is one of the best countries one can
wish to be born in. But in the long run, I don’t think it’s for me. I’m more of a hustler,
an action-taker, and while a lot of Swiss people have an entrepreneurship mindset,
they are still comfortable because the country takes care of a lot of things. As a result,
you somehow live under a protective bubble shield that can make you vulnerable when you
leave it.
I still have at least one more semester to go and my master’s thesis. For this I have two options: one to do it at one of EPFL’s labs or I can do it in the industry, as a 6-months internship. I’ll probably choose the internship if everything goes well.
I hope the experience I shared was somehow valuable and you can take something out of it.
RUSU - the one and only
]]>