Are You Using Evernote All Wrong? An Introduction to Spaced Repetition for Rapid Learning

evernote totals

Five years ago, I downloaded Evernote with glee. As someone with a terrible memory, I had long been searching for a great digital notebook, and Evernote fit the bill. Searchable notebooks? Checklists? Syncing with all of my devices? Yes please.

Nowadays, that feeling of glee has been replaced with overwhelm. When I open Evernote, I see an anxiety-inducing grand total of ~800 notes (see the image above); it dawns on me, I have no idea what’s in most of them.

Was I receiving any benefit from these long-forgotten notes buried in the proverbial basement of Evernote? Were these simply records, or actionable information I should be aware of? It’s a question I’ve shrugged off – until today. Continue Reading…

Simplify: When Doing Less Results in Mastery


There’s too much unactionable information on the Internet.

Too many generic 10 Productivity Hacks You Need RIGHT NOW (And 2 You Should Never Do) articles out there, doling out surface level advice in rapid fire. Great for immediate gratification (“Wow! I just read an article with tons of great tips!”); absolutely awful for long-term retention and application of those ideas.

To convert new ideas into lifestyle change, you need deep focus, time investment, and an action plan that resonates with you (remember, you’re not average). Quick, easy-to-read lists offer none of these necessities.

Continue Reading…

How I Learned to Code in 1 Year

Learn to code

Photo credit: Dmitry Baranovskiy

Learning to code is no joke. There’s so much to learn over and above any one programming language alone. Unit testing, version control, various frameworks and libraries, HTTP, regular expressions, various APIs, data structure (XML, JSON, etc.), and more. Though, I’m happy to admit that, after roughly one year of intense learning, it’s all finally clicking.

Those of you who had read my previous posts on learning to code know how this journey has seen its fair share of ups and downs. I’ve had to rewrite shitty code over and over as I improved, and I’ve spent dozens of hours googling things that should’ve been dead simple to do (e.g. using capturing groups in regular expressions).

The second half of this journey has seen an outburst of productivity – three completed apps. Two for my job (used internally), and one that I’ve open-sourced on GitHub.

While I’m far from the perfect web developer, I figured I’d share my journey from complete n00b to experienced enough to put together a functioning app. Those of you who are thinking of taking the plunge (or have already started learning) might find my journey as a helpful guide. So here we go, step by step:

1) Learning the Fundamentals

Like many, I started my journey on Codecademy. I’ve found it to be the easiest interface to learn on, and it’s significantly more interactive than coding books, or even videos. Here are the four courses I went through:

  • Web Fundamentals
  • JavaScript
  • jQuery
  • Python

Once I completed those four courses, I took’s JavaScript Essential Training course. I did this mostly because I had a account already and was in need of a solid refresher on everything I had learned about JavaScript. It was a great idea, and really helped solidify the concepts in my mind – especially as I started writing my first scripts.

After completing the Codecademy and Lynda courses, I understood enough about HTML, CSS, and JavaScript to start writing some code. However, I knew little to nothing about server-side code, which was still a huge barrier to me making something useful. I wondered, was there a way to write and launch apps without requiring a server-side backend? My hunt for a framework began…

Continue Reading…

Achieving Excellence Through Abstraction

For the past eight or nine months, I’ve been spending my weekends in a local coffee shop learning the ins and outs of coding. Object oriented programming, functional programming, unit testing, various frameworks, database management and more. Self teaching is no easy task, but it provides flexibility and a sense of accomplishment that taking classes often can’t provide.

While a lot of theory behind programming is very specific to the field of computer science, there are certain theories that go much deeper than that specific field. The one I found most interesting was that of abstractions.


Abstracting Away ‘The How’

In the coding world, abstractions help make things easier.

Does your code need to run through a long list of names and modify them somehow? In native JavaScript, the code to do that usually looks something like this:

for (var i = 0; i < namesList.length; i++) {
    //do whatever

Abstractions allow you to spend less time on how to do something (note how nitty gritty that code above looks), and allows you to simply specify what you want to do, rather than focusing so much on how to get it done.

jQuery (a very popular JavaScript library) helps you do this by abstracting away the messy details of the code above. If you want to go through each value on a list, and run some code on it, you simply write:

$.each(namesList, function(){
    //do whatever

You simply tell jQuery that you want to do something to each name in the list (intuitively written as $.each). The first code example requires you to specify additional variables, calculate the length of the list as an indicator to stop the loop, and increment the iterator. jQuery allows you to stop worrying about the logistics, and focus on telling your code to simply do something to each element.

This is a very basic example of a concept that saves substantial amounts of coding time. However, computer programming is not the only place I noticed this concept in play.


This Idea Applies Everywhere (Seriously)

As I pondered this idea of abstracting away complexity (i.e. simply specifying what you want done, rather than exactly how it needs to be done), I realized it applies to more than just code.

I thought back to the takeout food I ate earlier that night. I’m sure there were mind-bogglingly complicated logistics that went into growing the food on a farm, transporting the food across the country (while keeping it fresh, of course), and then preparing it to my exact specifications.

Yet, I had NO idea how those logistics happened. The specifics of how the food was created and made available to me were abstracted away. I simply specified what I wanted (pad thai), and the logistics were done for me, unbeknownst to me.

Eventually, I realized that this also applies to achievement. We often pay people (personal trainers, for example) to abstract away the messy how-to for us. We simply show up to the gym, and let the personal trainer do the planning and managing of the workout. You just tell the personal trainer what you want to achieve, and he/she manages the how.

The personal development system I developed also abstracts away complexity behind goal tracking. I simply tell it what I did in very general terms, and it manages all of the calculations to tell me how I’ve been doing based on an achievement model I’ve worked out for myself.


Abstractions Sometimes Break

Eventually though, the abstraction fails to properly manage the underlying logistics, and you’re forced to investigate what’s going on underneath.

For example, let’s say, hypothetically, jQuery is not well suited for a particular data type, and the $.each() code from earlier in the post suddenly generates an error in my script.

If I had been relying on that $.each() code for years, and suddenly it stops working, I wouldn’t have the slightest clue as to how to begin troubleshooting, since I never bothered to learn the underlying logistics of how $.each() handles all of the messy details for me.

The abstraction ‘leaked’, and the lower-level code bubbled up to my attention. And since I wasn’t ready to handle the lower-level code, my ability to make progress on my project screeched to a halt until further notice. I’d either need to learn the lower-level code, or seek out another abstraction (i.e. another JavaScript library) that can handle my code correctly.

This idea of ‘leaky abstractions’ was proposed by Joel Spolsky, a well known programmer, in a post called The Law of Leaky Abstractions. Joel writes:

The law of leaky abstractions means that whenever somebody comes up with a wizzy new code-generation tool that is supposed to make us all ever-so-efficient, you hear a lot of people saying “learn how to do it manually first, then use the wizzy tool to save time.” Code generation tools which pretend to abstract out something, like all abstractions, leak, and the only way to deal with the leaks competently is to learn about how the abstractions work and what they are abstracting. So the abstractions save us time working, but they don’t save us time learning.

And all this means that paradoxically, even as we have higher and higher level programming tools with better and better abstractions, becoming a proficient programmer is getting harder and harder.


Leaky Abstractions Are Also Everywhere

Since abstractions are everywhere, I’d venture to say that leaky abstractions are everywhere as well. Therefore, I’d argue that Joel’s quote above extends to achievement and behavior design.

What happens when the takeout food you eat is causing you to get sick and overweight? You need to investigate how it’s prepared (does it contain allergens, low quality ingredients, lots of added sugar?), or go eat somewhere else.

And with every innovation in food processing technology, it gets harder and harder to tell if that processed food is still good for us. (Do added antioxidants count as ‘healthy’? Is palm oil healthier than canola oil? And so on.)

What happens when you’ve been following your personal trainer’s advice to a tee, yet see no results? It forces you to either dive into the specifics of the nutrition and exercise plan you’re on to diagnose the issue, or move on to another personal trainer and hope that their abstraction (i.e. their managing of the how) is a more effective one.

What happens when the gamification system you’re using to motivate yourself suddenly stops working for a particular goal? You’d either have to each dive into the psychology behind the gamified system, or move on to another system in the hopes that their abstraction of motivation is more effective. (This particular example has happened to me numerous times, which is why I decided to learn to gamify my own goals.)

The conclusion is as follows: Abstractions lessen your day-to-day workload, but not your learning requirements.

In other words, abstractions are prone to leaking, so you’ll still need familiarity with the underlying logistics, to a certain extent, to be prepared for when they do break. Otherwise, each time an abstraction leaks, you’ll be faced with a challenge you can’t handle. And challenges you can’t handle can quickly bring you to a screeching halt.

For a high achiever like you, you shouldn’t tolerate constant impasses like this. Every screeching halt makes it exponentially harder to get back on the bandwagon (especially for your toughest goals). And constantly jumping around from solution to solution isn’t viable either.


Embrace Abstractions… But Only After You Learn

The message here is clear: embrace abstractions, but only after you’ve learned the fundamentals of the system you’re abstracting.

  • Learn the basics of how food is prepared and processed before grabbing anything that looks good off of the shelf.
  • Learn the basics of human motivation before jumping from app to app, product to product, that claims to help you achieve your goals.
  • Learn the fundamentals of online advertising before you spend a lot of money to pay an agency to manage your advertising for you.

Let’s be real: you can’t learn the fundamentals of everything. But with the almighty Google search, you can learn the fundamentals of something important to you within a matter of hours. So pick the three things that are most important to you, and learn those fundamentals.

When shit hits the fan, you’ll be ready. And by being the individual who can sidestep the roadblocks and handle leaky abstractions, you’ll be the one who goes harder, better, faster, stronger than everyone else.