I’ve noticed making high-level decisions at a mid-stage company is trying. Prioritizing at a startup is easier, because you have less groups clamoring for your attention. But when marketing asks for more money for ad campaigns and the engineering team complains about how they’re overworked and need another developer — how do you know which ones to select and execute on?
One way is to draft a list of all these priorities and ask everyone to vote. This approach democratizes decision-making, which, if done too much, can lead to a company without a clear product drive.
Another way is to ask two questions. Everything boils down to numbers.
Question 1: What are the inputs?
For example, if you want a marketing campaign, do you need more money for Google ads (external) ? Do you need to a month of engineering time (internal)? Often people think about external costs, but forget about the cost of internal company resources, which are just as valuable.
Question 2: What are the outputs?
All businesses have 3 goals. So these inputs must be manipulated in some way to generate output into one or more of these company goals:
- (1) Revenue
- (2) Cost savings
- (3) Market growth
Thus, the decision about what to build becomes simple. You make the decision based on the input/output ratio.
When I first started implementing OAuth, I thought it would be difficult, but I realized with all the libraries and documentation now a days, implementing would be very manageable. While I thought using libraries to help would speed up the implementation — in hindsight, implementing OAuth with rauth, a Python OAuth wrapper library, unnecessarily abstracted away both logic and understanding.
OAuth consists of 5 components:
- Present user to webpage
- Page redirect to facebook
- Get code
- Exchange code for an access token that you store
- Use that access token to access user data with API
The complications usually lie in the details. The common problems I ran into were:
1. This authorization code has already been used.
I was calling the authorization code twice, when I should have exchanged the code for an auth token and called the auth token twice.
2. Incorrect access token
I had already exchanged the code for a token with rauth, and was trying to do it manually:
def facebook_authorized(): code = request.args.get('code') if not code: return redirect(url_for('index')) data = dict(code=code, redirect_uri=get_redirect_uri()) # rauth request fb_session = get_facebook().get_auth_session( data=data, decoder=lambda x: json.loads(x.decode()) ) me = fb_session.get('me?fields=id,email,name').json() # manual request res = requests.get('https://graph.facebook.com/oauth/access_token', params=token_params) access_token = res.content.access.token
To get the access code from rauth, I can use
access_token = fb_session.access_token
Documentation is better than StackOverflow
With documentation, you can figure out the first principles by yourself and troubleshoot your specific use case. Sometimes, StackOverflow can shortcut this for you, but more often than not you’ll solve the symptom but not the problem.
Don’t overoptimize too early.
I made the mistake of abstracting my OAuth functions into classes and started running into errors — the abstracted data structures made it difficult to pinpoint what the problem actually was.
Understand principles before jumping to the code
Rather than copying and pasting coding that you don’t understand, first understand how it works manually (i.e. the 5 steps above) and try to replicate that yourself.
Suppose there are 8 numbers. I choose one, but you don’t know which number it is. Your task is to guess which number. You can ask yes or no questions. What is the minimum number of questions you would need to ask to guess the number?
All have an equal chance of occurring (P(any number) = 1/8).
What would be your approach for asking questions?
Start at the mid-way point and asking if the number is less than 5. Suppose the answer is yes. Now you know the number must be
Do the same thing and ask if the number is less than 3. Suppose the answer is yes again. Now you know the number must be
Now you ask whether the number is 1, and if the answer is no, then you know the number is 2. You have guessed the number in 3 questions.
3 is the minimum number of bits you would need to use to encode the probability distribution of these 8 numbers. This algorithm is at the core of how we are all able to send emails, pictures, and videos so quickly now. Before the father of information theory Claude Shannon had invented this algorithm, it was unthinkable to send a picture — even a voice message, across the globe. There was simply no efficient way to send it. Nobody knew how many bytes it would take to encode the message, or even how to encode the message.
Next question: What if the numbers did not have an equal chance of occurring?
I’ve been doing a lot of signal processing lately (Python tutorial on analyzing .wav files to come) and came upon this nice metaphor for Fourier Transforms, which can help extract information from sound.
Random dude: I need to know how many 7’s there are in 49.
High school algebra student: Duh, just divide 49 by 7. There are seven 7’s in 49.
Random dude: I need to know how many x’s there are in y.
High school algebra student: Duh, just divide y by x. There are y/x x’s in y.
Random dude: I need to know how much of the frequency 23Hz there is in my signal x(t).
High school algebra student: Duh, just divide x(t) by 23Hz. There is x(t)/23Hz amount of 23Hz in your signal.
- What would you tell your younger self about love?
- Which of your flaws do you want to be treated with more generously?
- Is there anything I have done in the past that may have unknowingly hurt you?
- What are the main stressors in your life and how can I help?
- When I am anxious in our relationship, I tend to …
- What scares you about our relationship?
One of the most irritating things about learning a new framework or switching to a new computer is often not learning the different nuances in syntax or even debugging — is installing the darn thing. I can recount the numerous dependency and version management errors I was met with upon when forking my friend’s Django project or deciding to pick up Flask, both Python web frameworks.
When I discovered virtual environments, a lot of these headaches disappeared. Virtual environments allow you to compartmentalize your framework and package installations into the clean slate, separate from the rest of your computer.
Why a virtual environment?
When people type ‘sudo’ before attempting to install something, I fret at the amount of trouble they may be causing themselves later down the line. Installing something globally will inevitably lead to version management problems and other clashes down the line.
What to install globally
- Python (usually comes installed)
- Easy_install (comes with Python)
- Pip (Python package manager)
What to NOT install globally
sudo easy_install pip
- May lead to problems:
sudo pip install django
How to install a virtualenv.
Assuming you already have Python installed:
- Install Pip.
sudo easy_install pip
- Use Pip to install virtualenv
sudo pip install virtualenv
- Change directories into the folder where you want the virtual environment installed.
- Create your virtual env
- Activate your virtual environment
Now your command line will include the virtual environment:
And you can install frameworks like django and packages in this new environment as necessary.
- Your environment will only exist when you activate it. Notice that if you open a new terminal window, it disappears.
- You can deactivate the environment by typing
exitOr closing the terminal window.
I’ve decided that if I’m going to love, I’m going to love. hard.
I’ve noticed a phenomenon where someone will have a bad break up, and then will try to prevent the pain in the future by being more guarded about who they let into their heart.
But there is a flaw in this way of being — the person is conflating emotional investment with open communication. “If I had just been less invested in the person, I could have avoided all this pain.” I think people are deluding themselves. Two reasons:
(1) It wasn’t emotional investment that lead to them being hurt — it was a lack of open communication — consistent transparency about each other’s pulse on the relationship and trusting each other enough to be vulnerable about thoughts and emotions.
If you had just openly communicated in the first place, then you would’ve been able to exchange quick feedback loops and adjust your speedometer accordingly.
It’s when these pulses are not in sync and people begin to leave things (addictingly!) ambiguous, that signals get crossed and people end up being hurt.
(2) There’s nothing wrong with being hurt. I can be less hurt by being more guarded about who I give my heart to, but what is the fun in that.
To feel emotion is to be human. And you can never fully live out what it means to be human without living intensely.
I’m going to prioritize the person over the relationship.
A lot of times, when just entering the rush of a new intimate relationship, we get worried about defining the relationship – what it should be, whether or not we’re boyfriend/girlfriend, whether or not he’s seeing someone else. These thought patterns make it difficult to live in the moment, to appreciate the person for who they are, and savor the time when you’re with them.
It’s the prioritization of the relationship over the person that creates bad outcomes. Things start to become binary — we’re either exclusive or we’re not friends at all — and power dynamics come into play — he took 5 hours to respond to my text, is the ball in his court or mine? We’re no longer happy with the time we spend with them, rather, we suddenly build up expectations and want more.
Few people are worth your EQ. When you meet someone you believe is worth emotionally investing in, instead of trying to put them into a hole and asking, “Is he the one?” why not ask, “Am I building something amazing with this person? What else do I want to build with them?”
Close your eyes and listen to the brain.
What does it sound like?
Scientists did just that — they used amplifiers to listen to how neurons in our brain sounded, so they could discover how our eyes form an image of the outside world.
Where would you start if you wanted to model this process?
One thing that is generally helpful is to first identify the different components of a system. We have:
(1) the image in front of us
(2) some representation of the neuron
(3) an output of that image we see
How should we put those pieces together?
But what is wrong with this? That it’s probably more like:
But the brain is made up of many neurons, how would we model just one?
Now what if we do this for every neuron? Then we would have a whole picture.
The next question that arises is: How does each neuron know which slice of the picture to look at?
Well, what are the different components of a picture? A picture is fundamentally made up of:
Edges seem like they would give us more information about a picture, so let’s go down that route. What is an edge and how can we break that concept down? A major component of edges is the orientation of an edge.
So maybe each neuron has a preferred orientation it favors. And all of these neurons work together to create one picture.
So we can take lots of bars with different orientations, run them through a gabor filter (a fancy term that refers to a function that is similar to those in our visual system), and see when the gabor filter produces the most excited response.
If we run these through a gabor filter, we end up with a curve looking like this.
Thus, this neuron’s preferred orientation is ~40 degrees. If we do this for every neuron, we’ll have a starting model of how our brain sees edges.
You just learned a few fundamentals about how your retina sends signals to your brain, creating a picture for the world in front of you.
To come: Code as to how you would model this.