Need for Air

Need For Air, over and out. Say hello to the tldr.io blog!

2013-02-19T12:00:00+01:00

We are still alive!

You may have noticed, we have been pretty silent lately. Our last blogpost dates back to November 14th when we announced the first release of our Chrome extension. As you can imagine, we were pretty busy working on tldr.io and didn’t have enough time to maintain this blog. Lots of crazy stuff happened: we won Seedcamp Paris, we built a lot of new features including a brand new Chrome extension with which you can read or contribute the summary of any web page and our community is growing faster than ever.

What’s next?

We have decided to start blogging again, but as tldr.io and not NeedForAir anymore. We’ll use this new blog to keep you updated about tldr.io feature releases, best content and we’ll also blog about engineering and entrepreneurial challenges.

Go read the tldr.io blog

We won’t kill NeedForAir though

There are still a lot of people coming to this blog (mainly from search) for the tutorials we posted, so we won’t shut it down. If you liked what you found here, be sure to check the tldr.io blog out and update your RSS subscription! And to wrap NeedForAir up, here are the five most-read articles:

Introduction to D3: Build an Animated Graph in 19 Lines of Code
Tutorial: Domain Name System for Beginners
How We Use Jenkins for Continuous Deployment (a bit outdated since we don’t use Jenkins anymore, we coded our own CI)
The Game of Go: A Programmer’s Perspective
What to Use Upstart (and Other Supervisors) For

Thank you for reading us thus far!

Chrome extension to read summaries of Hacker News links without leaving the front page

2012-11-14T18:04:00+01:00

Yo dawg, we heard you like reading Hacker News, so we put summaries in your links

When you discovered that Superman could see through walls you told yourself that it was the awesomest thing ever. Naturally you wanted to have the same superpower. Well let’s say you can do that now on your browser and see through hyperlinks with our Chome Extension.

You love reading the Hacker News front page articles. But you don’t always have the time to click the links and read them all. That’s why we built this Chrome extension that enables you, simply by hovering over a link, to read a summary of the article. How exciting is this?

Here is what this looks like:

Install this awesome extension!

Why does it only work on Hacker News? I want it everywhere!

We know. We want that too. But as you know, our summaries are human-written because computers are bad at summarizing. Today, the community writing summaries is still very small and can’t handle a huge load. We summaries them to be of the highest quality, so we chose to focus on Hacker News so that we could bring a lot of value to our users while still having the time to run our company.

You can help! If you like to find the key information in a technical blogpost, if you want to help other people fight the information overload or if you simply want tldr.io’s coverage of the front page to be even higher, you can use our contribution bookmarklet and start creating summaries too. We review all the summaries our users create to ensure they stick to the original author’s point of view, but your contributing really helps the community.

Why is it a Chrome extension? I want it on Firefox!

We too! We’re currently focusing on a Chrome extension to see how people use it and how useful they find it. Once we think we have a clear idea of what the extension should be, we will make a Firefox version. If you have some ideas, please tell us here, we are interested.

We're launching tldr.io!

2012-09-13T18:04:00+02:00

tl;dr (too long; didn’t read)

We’re super excited to announce that we have finally launched our new product: tl;dr! The three of us quit our dayjobs at the end of 2011 and for the past 5 months we’ve been hard at work on it, and we’re very proud of what we’re releasing.

In a nutshell, our product solves the problem of wanting to know what’s in a webpage without losing precious time. It allows you to display a summary of the webpage you’re currently browsing. The summaries are written by people who found the webpage interesting before you. If the summary you’re asking for doesn’t exist yet, you’ll be offered to create it. We decided to rely on people because summarizing information is a skill people are vastly better at than computers.

So why did we build this product?

We read a lot of blogs, be it news or more educational/topical content. It’s been said and resaid that we’re in an age of information overload. There is simply too much content that is published everyday and it’s getting harder and harder to not only keep up with the firehose but also filter what needs to be read and remembered. Often times we feel like it would be nice to have access the few key ideas that are worth remembering of an article we just read.

We also thought ‘Wouldn’t it be cool if upon arriving on a web page we could display its summary to rapidly see what it’s about? Indeed everyone now knows to choose catchy titles to attract readers. Other signals such as likes, shares, or upvotes aren’t really related to the actual content and need of the reader. We wanted something that focused on the content, so that people would be able to make their own opinion about it. This is why we decided to allow people to attach one summary to any URL on the web in order to describe what’s in it. Sort of an entry point to each webpage. Turns out there’s already an name for such a summary on the internet: it’s tl;dr. Once it is written, the tl;dr benefits everybody in the world. Anyone will be able to get a clean, standardized preview of what the webpage they’re about to browse contains. This can be very useful on unknown busy webpages that are hard to sift through.

At this point we must point out that we do not want to prevent people from reading original content. We simply want to pique the interest of the right people and drive them to content they’re looking for by lowering its barrier to entry for them. Since we believe that summarized information is one of the most powerful force that drives interest (as evidenced by academic paper abstracts, google results extracts, etc.) we think people-contributed summaries will work wonders.

A word of caution

This is our first release and shouldn’t be considered perfect. There is still a lot of work ahead of us, we have a big and clear vision for our company but we’re taking baby steps. You should expect new features regularly, as well as bugs! Besides, since we are building a company, and a company needs to make money, expect some pricing plans for our service to come out very soon. For those interested, we’ve been bootstrapping for now and haven’t taken any investor money.

What To Use Upstart (And Other Supervisors) For

2012-08-22T12:00:00+02:00

We are currently building a webapp with the following stack: nodejs, mongoDB, nginx and redis. We also use a certain number of services, like Jenkins and Graphite. To use these softwares in production, we need to be able to daemonize them, run them as specific users (usually with low privileges), and have tham restart automatically if case of an unexpected crash.

These are quite common needs. But people are often confused as to what part of the system is responsible for what task. I often see software handling the privilege drop (for example the otherwise excellent Graphite), or the daemonization (for example gunicorn - which is also great otherwise). It’s bad, because as a result, some of these softwares don’t play nicely with supervisors like Upstart. People tend to resort to strange and not well understood scripts (I even saw an Upstart script that called the start_stop_daemon to launch a gunicorn process which daemonized itself!).

There is a simple rule to follow to avoid this confusion: softwares should not daemonize or handle privilege drop. These are jobs for the supervisor. That’s all, separation of concerns, folks. For example, we use Upstart to launch our processes as services. That way, we get added benefits: they get respawned in case they crash, they restart automatically if we need to reboot the server, and we can specify rules such as “service A should not start before service B has started and is ready”. I see no reason not to it that way!

An example of software that respects these rules is nodejs. Here is the Upstart script we use with it. It enables us to start our app as any user, log all output and get the added benefits I was referring to earlier. It really is all you need with nodejs and most software you will use. This is not an Upstart tutorial (their doc is pretty good), but let me explain the most important parts:

The privilege drop is done through the su -s /bin/sh -c 'exec "$0" "$@"' $RUN_AS -- command part. This line executes command as user $RUN_AS. Unfortunately, we have to use this method because the standard sudo -u doesn’t work from within an Upstart script.
The log file needs to be touched in case it doesn’t exist, then chowned to user $RUN_AS, because otherwise it will belong to user root (which the user executing the Upstart script)
The rest is pretty standard

Of course, this script doesn’t work just for nodejs! So you have no excuse not to use it now :)

How We Use Jenkins for Continuous Deployment

2012-07-09T12:00:00+02:00

Summary of “How We Use Jenkins for Continuous Deployment” (via tldr.io)

Continuous integration is a must for software projects. It makes deployment stressless and lets you spot problems as soon as they arrive, not 3 months later.

We take it one step further and use continuous deployment. Whenever one of us Git-pushes to master, the new code is tested and goes live right away.

Jenkins makes it easy. With the Github plugin, you connect Jenkins to Github’s post-receive hook so that any code pushed to our repo triggers the Jenkins job.

The Hipchat plugin lets Jenkins notify us whether the build was successful or not. That way we can react quickly if something goes wrong.

As all teams working on a web application, we had to setup a continuous integration server. This is a fairly well-known engineering practice, where you want your code to be built and tested regularly on the server so that you spot problems as soon as they arrive and not when you push three months’ worth of work to production. Also, it makes deployment a much less stressful experience, because you know it will work. You avoid getting in the situation of a friend of mine who could not have coffee with me because he was deploying and didn’t want to mess it up!

We also wanted to take it one step further, and use continuous deployment. As the name implies, this means that any new code pushed to the server will automatically be built, tested and then go live and be used by our users right away. It turns out that is fairly easy to set up -except for a few caveats-, and I will describe our setup. This by no means a step-by-step tutorial but rather a “here is what you can do” article.

Our Tech Stack - The Part Of It That Matters For This Article

Our server runs on Ubuntu 12.04 LTS, our version control system is Git (we use Github flow) and our code is hosted on Github. We chose to use Jenkins as the CI server. Even though it is poorly documented and has a definite ‘so nineties’ feel, it is very easy to deploy and intuitive. Basically, you use it to set up jobs that are run when you launch them manually or when an external event, such as a code push, is triggered. These jobs can be anything that’s executable, I usually use simple bash scripts but you can use any kind of script, makefiles and so on.

Install And Keep Jenkins Up And Running At All Times

Jenkins is contained in a WAR file, so you can simply download and execute it with java (command java -jar /path/to/jenkins.war). Of course, this is only suitable for testing purposes. In production, you will want to use an Upstart script so that Jenkins respawns if it crashes unexpectedly and starts on boot.

When Jenkins is up, you have access to a web interface to manage it (you can configure the port on which it listens). Make sure to enable security -I recommend matrix based security- unless you want anyone to be able to take control of your servers! One thing to watch out for is that you need to enable the “overall read” permission for the anonymous user, or else Jenkins won’t be able to communicate with third-party services - in our case Github and Hipchat. Pretty stupid behaviour I know, but at least it doesn’t create security holes.

Build On Push To Master

We have the Git and Github plugins enabled. The Github plugin enables us to connect Jenkins to Github’s post-receive hook. That way, whenever someone pushes to master (usually by merging a feature branch), our Jenkins “build” job pulls the new version of the code, builds it and test it. For us, that’s really a two-line script, as we check all modules in to Git.

If everything was successful, the “deploy” job is now called. It pulls the new version of the code in the live repository, then restarts the node server (since we use nodejs, we can overwrite the javascript files when the server is running without impacting it). Node starts pretty fast, so we only have ~0.1s downtime (no load balancer to achieve 0s downtime - for now!). And since we use an external store to manage sessions, nobody gets logged out.

Be Notified

The last part of the puzzle is how we get notified of the build result. We use Hipchat, so we installed the Hipchat plugin that notifies us of build results in a dedicated chat room. Most of the time it just says “Build successful”. But no sweat if a build fails, since the “deploy” job was not called our users don’t see anything wrong!

And That’s All There’s To It!

Yup. It is indeed simple enough to get a robust continuous deployment system up and running, that most of the time safely deploys your code through a simple git push on your part. I’m interested in anything you would have to say on this setup or any tip you’d like to share!

Enhancing the User Experience With a Continuous Client

2012-07-01T20:51:00+02:00

At Google I/O there were many interesting announcements: Nexus 7, Google Glass, etc. (Perhaps too many as one can say that Google is fighting too many ennemies on too many fronts). One news that drew my attention is the arrival of Google Chrome on iOs. Don’t expect browsing experience improvement you had on your desktop as this app is merely a graphical layer on top of Apple’s WebView from its SDK. Basically the engine is the same as Safari … just slower.

But that’s not my point. I want to talk about the sync functionnality that Google Chrome on iOS offers: by activating the sync on your different devices (desktop, iPad, iPhone…) you can open a tab you were viewing in one device on another one. The Continous Client becomes real.

So what is a Continuous Client you ask? Well the premise is simple: when you leave one device, you pick up your session in exactly the same place on the next device you use. Meaning your IM, Twitter, web browsing, applications, even your windows appear just as they did on the previous device. The situation I describe above would be obviated by this setup, allowing me to move from my laptop to iPad in a seamless manner which would in no way disrupt the activity I was currently engaged in. […] Put simply, you are placeshifting your computing experience from one device to the next with no break in your work, timelines, or conversations.

After using the cloud to store persistent data easily and seamlessly, one can now use it as a relay to get a continuous browsing experience across different devices.

We can moreover imagine various implementations of the continuous client to enhance our global user experience. For example, Invoxia with its business dock adopts the same vision for phone by bridging mobile and office calls.

My experience of these two continous clients is so magic but nonetheless so natural that I’m looking forward to future ones that will be invented to make our everyday life even more pleasant and interruptions-free.

And you, do you know another usecase where a continuous client architecture is already available?

Start Your Kids Coding Very Soon

2012-06-25T10:18:00+02:00

On Fred Destin’s initiative, the big stars at Founders Forum, including Niklas ZennStröm (Skype), Chad Hurley (Youtube) and many others, shooted last week a funny and viral video to promote CodeClub. CodeClub is a brilliant action which aims at inspiring kids to learn code and creating a nationwide after school coding club for children aged 10-11.

Kids are the future, everybody knows it. Computer are, too. When we see what our generation’s geniuses made and how they revolutionized our world when computer science and coding were at their premises, one can only urge the next generation to dive into code as soon as possible.

Supporting this initiative is supporting a long term vision for our economy and our education system. There is no day without reading that there is a big lack of great programmers, that data-scientist is the hottest job at this time or that learning to code is a great move. So we should foster our kids to embrace this activity as soon as possible as informatics, hardware will be everywhere. By extending the base of people having the skills to program we foster the future innovation.

The earlier we start learning something the better we are good at it and the less we fear it. We belong to a generation where there is still a big proportion of people who are not at ease with computers or smartphones. Even an entreprising friend of mine judges that it’s too late for him to start learning how to code whereas he’s only 25! But have you experienced kids change of behaviour towards our world? I don’t think there will be many kids in 10 years who won’t know how to use a smartphone. And I do want to think that these kids in 10 years won’t be as reluctant to learn code as people can be today. Perhaps the qualifiers geeky or nerd won’t exist anymore, or have a very distant meaning, commensurate to what these people have created by now. Who knows ?

Starting a Startup Should Not Be The Primary Concern

2012-06-19T13:12:00+02:00

Last week, Rob Go from NextViewVentures explained why in his opinion people should think twice before starting a company: too much hype, harder to stand out, we are at the end of one innovation cycle and at the beginning of a new one which is less favorable to unexperienced and non-technical founders.

So to the question What to do instead of starting a company? he answers: Join the winningest company you can find in a sector you care about with people you like. Should you agree or not, this recommendation has its pros and cons but one can’t come to a decision easily. The most important lesson to learn comes at the end:

I think there is just the inherent satisfaction of being a part of a company that is making a big dent in the world. We’d all like to be the person who started that company, but there is a huge amount of pride to be had in being a contributor, even if you aren’t a leader. Also, scale and success give companies the right to do something meaningful. I often hear founders of failed companies lament “I realized that I just wasn’t that excited about X, Y, or Z market.” Well, the truth is, most people probably aren’t that excited about about helping merchants process credit cards (until Square) or the apartment rental industry (until Air BnB) or local advertising (until FourSquare), or the private car industry (until Uber) etc etc. Being part of a successful company that is shaping the future of an industry is usually inherently interesting and motivating, and it’s a great way to spend a few years of your life until the time is right for you to start a company that will do the same.

It’s a very interesting analysis as he doesn’t try to give a clear cut and general solution applicable to everybody. Instead he takes into account the personality of people who could be disposed to start a company, noting that founding a startup is not necesseraly the best fit for them. The true concern one should have is to make a dent in the world. Mark Bivens came to the same conclusion: People need to feel a part of something bigger and joining a startup could be the best answer to this feeling. It will never be be too late to found its company after such an experience, on the contrary it can only make things easier.

To Make You Smile

2012-06-15T10:29:00+02:00

This week Fab celebrated their first anniversary (since their pivot, as Fab was not an overnight success on day one).

Their growth has been amazing: 4.75 M members and +100 M in sales in just one year. And it seems like it’s just the beginning as they’ve been successfully conquering mobile users: 30% to 40% of Fab’s daily visits are now via mobile. As mobile is the biggest growth lever that an ecommerce company can have, these figures is a good sign for the future Fab’s sales.

How did they perform so well? Mark Suster would say that they flawlessly executed their business model but I’d go deeper in the reasons and say that their success comes from their core beliefs and the energy they put to broadcast them.

They believe in a vision, in core principles they love to repeat as much as possible. This is even their first statements in their Happy Fabiversary blog post. You can search for each of these belief in their blog to see how often they come back. These values stand at the epicenter of their attitude and drive.

Fab communicates their beliefs with such a passion that we can feel them behind every single line of text in their website, behind every single quote from Jason Goldberg. Their gimmick To Make You Smile underlies all their decisions and choices: Color is very important, color makes people smile. At Fab they have their core principles and they stick to it: We care more about making people smile than making money from them.

Even if one could argue that they do it just for marketing purposes I truly think they do it because they uphold totally their core beliefs. They communicate their vision perfectly and make people adhere to it because they act like passionate leaders.

Choosing core values and placing every single decision the company makes in the perspective of these values is what makes me smile.

Challenge Accepted

2012-06-11T14:33:00+02:00

Our book Startup Flow is featured at page 97 of this week’s edition of Challenges, a French weekly newspaper dedicated to business and the economy.

Challenges says the book is “Ideal and time-saving for teams looking for the most productive workflow”, which is exactly what we had in mind when we wrote the book.

If you haven’t read the book yet, do it right now and spread the word!

Here is a photograph of the article (the quality is not too good as it was taken with an iPhone 3GS):

Thank you Challenges!

Rockstars Don't Give a Fuck

2012-06-07T17:59:00+02:00

Most of what I consider genuinely useful and insightful in my life today I learned from my parents and from my poker days. Poker made me fearless, it made me think about long term, about positive expected value, it made me believe that you can get really big even if you start with close to nothing.

Getting good at poker takes hard work, a lot of time dedicated to studying theory, regular opponents, patterns, but also, and most importantly, a lot of work on yourself to prevent tilt. Tilt is the name poker players give to the phenomenon that happens when one gets a few bad beats in a row and loses it. Somehow one feels forgotten, unjustly punished by the poker gods and starts playing as though one is due for some good run of cards. It usually ends up pretty badly. Self control is the key to moving up in stakes and being succesful at online poker.

However, the one thing I noticed that differentiated the the very best, the smartest, the most crazy good players from the merely very good players is that although poker is a money game these guys didn’t give a fuck about money. They’re ready to lose it all, to lose $500k in one night even if that is 100% of their net worth (acquired from poker exclusively usually) because they 300% believe in their game, their edge and what they’re doing. They are unfathomably focused on outplaying their opponent, not winning money. Somehow these players always end up super rich. They end up going on killing sprees, annihilating everyone that challenges them, because they focus on one thing: the game. They don’t care about PR, rakeback deals, staking, how big their bankroll is at any given time, what they’re gonna be able to buy with that $500k they just won in a few hours, saving for their retirement or whatever.

All they care about is making the best play every single time, to the best of their ability. That’s how Tom ‘durrrr’ Dwan lost 5 millions (we’re talking about a self-made 20-something year-old guy here) in a few days to Isildur1, some even younger Swedish sicko who appeared at of nowhere and suddenly started beating every top player on Full Tilt Poker. Tom Dwan continued playing because he thought he had an edge. He didn’t care about the money or he would’ve stopped way sooner. Nobody likes to lose a few millions in a matter of hours. But he bounced back. Not in this match, not against Isildur1. But in some other games. It’s all about passion. If you want to be the best at something, you need to dive into it without asking questions, without thinking about the risks, nor the rewards. Do it because that’s what make you pulse and feel alive.

Look at Mark Zuckerberg. He is the epitome of the startup rockstar. He is all about Facebook. He doesn’t shift his focus from Facebook, doesn’t care what people say about him or Facebook. He is not afraid of losing one round, he makes all the moves that he thinks are best for Facebook. He just plows away and in this regard reminds me of the best poker players, only he plays at different stakes. And this why I’m gonna buy Facebook stock as soon as my brokerage account is open.

Disclaimer: this is not professional investment advice.

Some Positive Thoughts About the Facebook IPO

2012-05-29T12:00:00+02:00

Since the Facebook’s IPO fiasco, many commenters (mainly bloggers and Wall Street analysts) seem keen to say that Facebook is really not worth that much. I don’t agree, because I think that trying to determine Facebook’s value is premature.

CC Licence - Author: Kevin Krejci

Facebook’s IPO Surely Didn’t Go Well

It’s a well-known fact, but it always makes me cringe: I still don’t understand why well-connected people would have the right to buy shares at a better price than “normal” investors. But it’s a fact: if you are one of the underwriters’ best clients, you will be able to purchase the stock at its opening price (in Facebook’s case $38 per share). You will even able to purchase the stock before the IPO, at a lower price than $38. If you’re not, you will have to wait. In this IPO, retail (“normal”) investors had to wait until the stock traded at $42 a share before being able to buy. On top of this common IPO problem, key information was known to insiders but not shared with all investors, which is why Facebook has been sued. In that regard, Facebook’s IPO surely didn’t go well.

Nobody Knows Facebook’s True Worth

But even though it didn’t go well, I am puzzled to read so many negative comments about Facebook itself. All kinds of people, from bloggers to Wall Street analyst seem to forget that Facebook still is a multi-billion dollars business. What I think many fail to see is that, in fact, nobody can seriously pretend to know Facebook’s true worth. It could be worth a lot more, or a lot less. This is different from a traditional company, for which everybody knows the business model (think GM, Total or even Apple). In Facebook’s case, we don’t know how they’re going to monetize their 900M users. Is it going to be through advertising? A premium version? Will they be able to make money on mobile platforms? We (at least I) don’t know. A Facebook share is a lottery ticket, whose value today has nothing to do with its value tomorrow. I for one am no Facebook expert, so instead of trying to guess the future, I will just sit back, relax, and see how the Facebook team continues to innovate.

History is Repeating Itself: from Online Poker to Startups

2012-05-21T12:49:00+02:00

Image courtesy of High Stakes DB

Poker is often used as an analogy for investing or daytrading. The rationale being that there is money at stake, some randomness involved and people are actually winning in all these “games”. However in this blogpost I don’t want to focus on these elements but rather on how the startup ecosystem is going through exactly the same thing the online poker ecosystem went through a few years ago. In order to clear the air, I’ve started playing poker when I was in college/grad school, and won mid 6 figures playing heads-up cash games in quite a short time starting from a free 50 bucks, rising pretty fast once I “got it”. But I was never even close to a top player like jungleman12 or Sauce123 who made millions by the time they were 21. The highest I played good players was 1000nl with some drunken stunts much higher (these didn’t go too well). For those who don’t know, 1000nl means $5/$10 blinds no limit, meaning you usually play with a $1000+ stack).

A Brief History of Online Poker

Early On

Online poker started in 1998 but I was still playing Lego(TM) then. However, from what I gathered during my insanely long hours reading poker blogs and twoplustwo, it was pretty awesome, nobody had a clue what they were doing, and a few smart guys made millions at 16 years old because they were a bit more creative, ruthless and self-controlled than the others. All the winners were completely self-taught, information about winning strategies, psychological pitfalls were very scarce, and theory was completely absent of most winning poker players’ thought processes.

Poker Reaches For Everyone

I entered the online poker world belatedly, around 2008-9. At this point, poker training sites such as Cardrunners, Leggopoker, DeucesCracked already existed and were growing pretty rapidly. These sites would charge you a measly $30 a month for incredible insights from some very good poker players, and probably enabled thousands of people to earn a ton of money they would have never hoped for. In Europe, Pokerstrategy was even more daring, and decided to give a free $50 (it was really free, no CC required or any other bullshit) to anyone asking for it that passed a 20-question quizz (and that surely didn’t weed out anybody but the laziest chumps). It worked phenomenally well from the rumors I heard. The point is, online poker had matured to the stage at which people were now making money coaching it (I coached small stakes for $200/hour, but high-stakes coaching rates were closer to $1-2k/hour), teaching it via video, writing and selling books about it for seemingly obscene prices, blogging about it, etc. It was really an incredible thing. Now anyone with a bit of self-control, normal intelligence and a good deal of dedication could become a winning poker player and live the dream. Someone once said on Two Plus Two that it was probably the only place on earth where a 16-year old would feel bad about making only $100k in a year and complain that he had been unlucky.

The Level Goes Up Globally

However, it made the global level go up steeply and quickly. It got harder than ever to get past micro-stakes as most people there were actually trying to win, watching videos, getting coaching. They were still terrible, but much better than the people playing the same stakes 5 years earlier. The same held true at every stake, and at mid-stakes, people were really starting to get pretty good, high stakes was reserved to elite hard-working players. By the time I got the bankroll to comfortably play mid-stakes, it had become really tough. Fish would get eaten alive extremely quickly and a lot of hitherto winning players started breaking even, becoming rakeback pros, went broke or quit the game altogether.

Good Players Start Accelerators

A few good players saw how their students went from donk to very good quickly, and how little money they made from it (relatively). So they started devising group-staking programs, formed stables of young eager horses that wanted to benefit from their insights and threw them enough money to get them started. I’m pretty sure this went very well for a few elite players, but terribly wrong for other people with lower quality insights that just tried to follow the money.

People Go The Easiest Way When It Gets Too Hard

So a lot of people learned to game select better (some would say bumhunt), which means choosing profitable tables where there are weaker players. Some (including myself), took it to the extreme by only playin heads up (one-to-one) with significantly worse players than themselves at stakes they cared about. This is not wrong in and of itself, anyone’s entitled to his choices, and some people were after the money, not the glory. This highly annoyed the greatest players though, because they couldn’t find anyone to play with.

Stakes Rise

Stakes also gradually rose. There was a time when 400nl was the highest online stake offered, then it went to 2knl and when I first played, the highest stakes offered were already 10knl. A few months later, 100knl tables were introduced on Full Tilt Poker (rip).

Established Top Players Help Each Other

As available stakes rose from 2knl to 100knl, swings became huge and few players were properly bankrolled for those stakes. High stakes players started taking a piece of one another all the time, leading to confusing and some time embarassing or devastating scenarios, although some probably did very well at staking and swapping percentages.

People Say It’s Now Impossible to Become a Legend

People were saying rising to high stakes let alone nosebleeds was impossible, and yet a few people did it, through sheer hard work, passion and probably talent. The most legendary of all is Jungleman.

So How Does the Startup World Compare?

I’m obviously very new to the startup world, having started my own only 2 months ago. (Yeah while at Stanford, I foolishly (or brilliantly) chose to play 25nl instead of going to my entrepreneurship classes, ah the allure of quick money). I won’t talk about the early days because I really haven’t read enough about it and most of you probably know more about it than I do.

Startup Are For Everyone

But I feel like I’m entering the startup world at roughly the same stage I entered the online poker world. The early goldrush is over, meaning it’s not about being at the right place at the right time any more. The starting, building, growing processes are getting theorized and written about everywhere on the internet. Hacker News is the equivalent of Two Plus Two. People are writing books, The Lean Startup, The Startup Manual and a slew of others come to mind (although these are much more affordable than poker books). Hell even we wrote a book! People are making videos, selling classes about startups on Skillshare.

Even the core engineering competencies are given away for free by sites such as Udacity or Coursera.

And this is really great. It opens opportunities to millions of people that didn’t grow up in the Silicon Valley to gain invaluable insights into what made successes and failures, it makes people dream and motivates people, like I used to dream reading Cole South’s blog (a fascinating read about his lightning-fast rise to legend status). Now I read stories about the Paypal Mafia, Zuckerberg, Drew Houston, Brian Chesky, Kevin Rose or Kevin Systrom. Again the stakes are not the same, and it’s incredible to be able to dream like that.

Good Players Start Accelerators

Y Combinator and so many others start forming stables of promising teams that they stake and give insights to. The best do make a lot of money from it and produce some of today’s rising stars. All the less selective followers probably won’t be as lucky.

The Level Goes Up Globally

However what this means is that the global level is also rising, and rising quickly and globally. More and more talented people now know that they can apply their skills and time to doing a startup, and the standards for traction, quality of product, quality of team, revenues are going up before you can be considered for an investment.

A lot more people are now competing, not only for funding but also for spots in Google results pages, Google Ads rankings, app-stores rankings, share of time, share of mind, etc.

People Go The Easiest Way When It Gets Too Hard

A lot of ideas are now X as a service, or X for Y, where you just replace X and Y by an existing service, company, market or geography. Sometimes that might a genuinely great idea, but I feel that this way of thinking is just never going to yield to real breakthroughs, and more importantly it is going to lead to ton of mediocre, unambitious ideas. However, if we follow the poker analogy, it is very likely the best way to have enjoy very decent monetary success and to build a thriving business. Shooting for the stars is harder than ever, as was rising to nosebleed stakes in 2009.

Stakes Rise

We’re reading about it every other day on Techcrunch, Twitter and tech blogs, valuations are through the roof, it’s a bubble, blablabla. I have no idea if it’s a bubble or not but the facts are here: it’s not uncommon now to talk of a $3million seed round or a $10million series A round and $50million series B (100knl does seem small compared to these numbers). Facebook is going to be the biggest tech IPO in history. Services are now reaching millions or even billions of users.

Established Top Players Help Each Other

Established entrepreneurs, are taking pieces of each other’s companies all the time as most of them are very active angel investors from what I can read on Techcrunch, just like high-stakes players would stake each other. Not sure how this will end for most of them, if we follow the poker analogy, probably badly in a lot of cases. However I’m sure these investments are dealt with in a more professional way than 18 year-old kids simply chatting on AIM and transfering hundreds of thousands of $ to one another just by clicking a few buttons on a poker site, which led to a lot of confusion and scams.

People Say It’s Now Impossible to Become a Legend

Jason Calacanis’s last newsletter was about The Age of Excellence. In his words, There’s no room left in 2012 for average, or even good, products. Meaning that if you want to make it to the top, you know need to battle as hard as ever, work extremely hard (not necessarily in a long hours way) and consistently outsmart your competition. And the rise of those who do everything right will be meteoric (Instagram rings a bell?) like jungleman12’s rise was in online poker.

Conclusion

So I feel like history is really repeating itself for me, except this time I won’t settle for bumhunting or an easy way out. Also I actually will make something useful instead of just taking people’s money by just clicking buttons at 4am in my underpants with pizza boxes and bottle of cokes surrounding me. Hopefully the startup world won’t crash like online poker did on Black Friday.

Behind Opinion polls: Fundamentals and Reliability

2012-05-15T20:12:00+02:00

This article is quite technical and requires a mathematical background for a comprehensive understanding. All technical points have a reference to the corresponding Wikipedia’s article for further explanations.

We are in an election time in France. Everyday news is rythmed by polls. Nicolas Sarkozy is falling from 2% in today’s poll from IPSOS, Francois Hollande slipped below 33% after the crisis etc… Everybody seems to give a lot of credit to these polls forgetting most of the time that they are just statistical estimations of the reality. But how reliable are they? The results for the first round of the french presidential election seemed to surprise so many people and medias that it pushed me to dig into my maths lessons from college to look for some scientific explanation if any.

Organizing the Opinion Poll

Opinion polls tend to estimate the percentage of people who will vote for a given candidate. Polling Institutes want to produce accurate polls but they can’t poll a too big sample as it would be time consuming and expensive.

They choose a representative sample of the population and ask them for whom they plan to vote. The responses are assumed independant.

Once collected, how do we use them build an estimate of the votes and what is the precision of this estimate?

The natural and logical estimate is to take the sample mean as an estimator. How do we justify such an estimate and what is its precision? We’ll see that what sounds like common sense has a strong mathematical justification.

Building the Estimate

We are in a situation where we have n people

\[ X_1, X_2,…X_n\]

who can choose between k candidates. We define the variable

\[ \delta_{i,j} \]

which is equal to 1 if person i votes for candidate j and 0 if not.

The real vote intentions we want to estimate are noted :

\[ \pi_1, \pi_2,…\pi_k\]

with the constraint:

\[ \sum_j^k \pi_j = 1 \]

The probability to observe the result of the polling is:

\[ p_{\pi}(X_1, X_2,…,X_n) = \prod_i^n p_{\pi} (X_i)\]

as the n people are chosen independantly.

\[ \prod_i^n p_{\pi} (X_i) = \prod_j^k \prod_i^n \pi_j^{\delta_{i,j}} = \prod_j^k \pi_j^{n_j}\]

where

\[ n_j = \sum_i^n \delta_{i,j}\]

The strategy we adopt is, given the n people, to maximize this propability of observing the output. Maximizing this propability is the same as minimizing the -log of the probability as -log is a convex function. With this transformation, the computation of the extremum is much easier as the product becomes a sum.

\[ max[p_{\pi}(X_1, X_2,…,X_n)] = min[(-log(p_{\pi}(X_1, X_2,…,X_n))] = min[ \sum_j^k n_j log(\pi_j) ]\]

To find the minimum with the above constraint we can use the Lagrangian multiplier and just minimize:

\[ \sum_j^k n_j log(\pi_j) + \lambda(\sum_j^k \pi_j -1)\]

which gives us the estimates which minimize the above function

\[ \hat{\pi_1}, \hat{\pi_2},…\hat{\pi_k}\]

\[ \hat{\pi_j} = \frac{n_j}{n} \]

We just justified the use of the empirical mean as an estimate of the true mean given a set of observations using maximum a posteriori estimation.

Reliability

Given the estimator, which level of trust can we give it? How close is are the estimated and true values. The law of large numbers tells us that when the size of the sample goes to infinity the estimated value tends to the true value. But in reality there is not an infinity of people who get polled. Usually just a few thousands are. From one sample to the other the estimator won’t be the same. So how confident are the polling institutes in their estimations? The reliability of the estimator depends on the statistical fluctuations of the estimate around the true value.

The central limit theorem tells us that the random variables (m is the true mean and sigma the variance):

\[ \frac{\hat{\pi_j} -nm}{\sigma \sqrt{n}} \]

converge in distribution to a normal random variable with mean 0 and variance 1. From here we have the approximation:

\[ P(|\hat{\pi_j} - \pi_j| \leq \epsilon) = P(\frac{\sqrt{n}|\hat{\pi_j} - \pi_j|}{\sqrt{p(1-p)}} \leq \frac{\sqrt{n}\epsilon}{\sqrt{p(1-p)}}) \approx \int_{-a}^{a} g(x)dx\]

where g is the density of the normal distribution and

\[ a = \frac{\sqrt{n}\epsilon}{\sqrt{p(1-p)}} \]

from which we can write

\[ \epsilon = \frac{a\sqrt{p(1-p)}}{\sqrt{n}} \]

So given a threshold of confidence t we can build a interval of confidence where we can state with t% of confidence that the true value is within this interval:

\[ I_t = [\hat{\pi}_{j,n} - \frac{a_t}{2\sqrt{n}}, \hat{\pi}_{j,n} + \frac{a_t}{2\sqrt{n}}] \]

where

\[ \int_{-a_t}^{a_t} g(x)dx = t\]

The value for a can be found in a computation table. For t equal to 95% the value of a is 1.96 which gives us for the interval where there is 95% of chance that the true value is:

\[ I_t = [\hat{\pi}_{j,n} - \frac{1}{\sqrt{n}}, \hat{\pi}_{j,n} + \frac{1}{\sqrt{n}}] \]

In Practice

With the simple slider and graphic you can see by yourself the influence of the number of people polled for an opinion poll. The box represents the 95% interval of confidence that means there is 95% of chance that the true vote intention is within this interval.

Size of population 1000
Estimated Mean

Conclusion

This quick refresher on opinion polls should remind us that opinion polls can be quite far from reality. And there is one variable that I didn’t take into account: there are people who don’t dare to name the true candidate they plan to vote for. This is especially true for extremist votes and explains why we can experience such a discrepancy between the estimations and the true results of one election.

Introduction to d3: Build an Animated Graph in 19 Lines of Code

2012-05-09T12:05:00+02:00

The goal of this tutorial is to give an introduction to d3.js by using the example of a simple animated bar chart. Before anything else, let’s take a look at it. Click on any bar of this chart -you can do it multiple times- to see what happens!

Pretty neat, huh? You can see the gist of a standalone working HTML here. We’re going to go through the javascript part which consists of 19 lines of javascript (comments and blank lines excluded of course), on top of the d3 library. d3 (for data driven document) is a low-level javascript framework that allows you to easily bind data to elements of the DOM and manipulate them. Even though d3’s most frequent use is for drawing charts, it is not a visualization library, it just handles data binding and data-driven DOM manipulation, which is arguably the boring -even though not the easiest- part, and lets you focus on content creation.

So why use a low-level framework to draw graphs when so many integrative chart libraries exist out there (Highcharts , Google Chart Tools …)? Precisely because it is low-level. That means you have to put in more effort upfront, but in return you gain total control of your data visualization, you are more flexible, and you can freely use the full power of existing technologies (CSS3, HTML5, SVG …) to visualize data however you want (as a graph or otherwise).

This example uses SVG. It’s not a problem if you are not used to it, as it is very straightforward, but you may still want to check the MDN tutorial on SVG. Now let’s take a look at the code for the chart:

// Suppose there is currently one div with id "d3TutoGraphContainer" in the DOM // We append a 600x300 empty SVG container in the div var chart = d3.select("#d3TutoGraphContainer").append("svg").attr("width", "600").attr("height", "300"); // There is no rectangle on which we can bind data in the SVG container // All the data will thus be bound in the enter var rects = chart.selectAll('rect').data([1 ,4, 5, 6, 24, 8, 12, 1, 1, 20]) .enter().append('rect') // Add a rectangle for each data in the enter .attr("stroke", "none").attr("fill", "steelblue") // All rectangles are blue with no borders .attr("x", 0) .attr("y", function(d, i) { return 25 * i; } ) .attr("width", function(d) { return 20 * d; } ) .attr("height", "20"); rects.on('click', function() { rects.transition().duration(2000).delay(200) .attr("width", function(d) { return 500 * Math.random(); } ) });

The first thing you should notice is that d3 uses method chaining. Every d3 function returns a d3 object on which you can apply another d3 function. This makes for code that reads almost like a sentence, for example the first line would be “select the div with id d3TutoGraphContainer and create a SVG element with width 600 and height 300”.

Selecting elements

This is the core of D3: selecting elements of the DOM, and doing stuff with them. D3 uses CSS3 selectors, also used by jQuery. You can select nodes by tag name, css class or id.
d3.select(selector) selects the first node matching selector and returns a d3 object containing this node on which you can apply any d3 function.
d3.selectAll(selector) selects all nodes matching selector and returns a d3 object containing these nodes on which you can apply any d3 function. So in our example:

// Select the element with id 'd3TutoGraphContainer'
// and store it in the variable 'chart'
var chart = d3.select("#d3TutoGraphContainer");

You can also apply select to an existing selection, to select among the children of the existing selection. This is usually useful to ensure that all d3 manipulations will take place in a container div (‘d3TutoGraphContainer’ in our example):

// Select all SVG rectangles children of this div
// At this point this selection is empty but all inserted
// rectangles will populate it so that we can reference
// it later in the 'click' callback
var rects = chart.selectAll("rect");

Inserting in and removing from the DOM

d3 provides functions for inserting in and removing from the DOM. As usual, these functions apply to d3 selections.
Note : you may ask why use these functions when we can use jQuery for example. The answer is simple : even though you could do it, d3’s DOM manipulation functions are designed to work with other d3 function, so you can use method chaining. It is thus easier to use d3 and only d3 to build a data-driven document.

Inserting in the DOM

selection.append(tag) appends an element of the specified tag as the last child of each element of selection. In our example:

// Appends a <svg></svg> element inside
// the d3TutoGraphContainer div (selection
// has only one element)
var chart = d3.select("#d3TutoGraphContainer").append("svg");

// Inserts on rectangle for each piece of data
// in the enter() selection (more explanations
// in the data binding paragraph)
var rects = chart.selectAll('rect')
                 .data([1 ,4, 5, 6, 24, 8, 12, 1, 1, 20])
                 .enter().append('rect');

There is another way to insert elements in the DOM: selection.insert(name, before) which inserts, as a child of every element in selection, an element of type name before the first element selectable by the CSS selector before. This is useful to control which SVG elements appear on top of the others (the last one in the page is on top).

Removing from the DOM

Removing all the elements from a selection is done with the d3.remove() function, like this : selection.remove(). This is often used with the exit() function, also covered in the “Binding data” section below.

Binding data

Binding data is the core of d3. The d3.data function binds data to the selection to which it was applied, and returns three selections:

The update selection: all the DOM elements from the selection to which we could bind data
The enter selection: the ‘surplus’ (if any) data for which there was no DOM element
The exit selection: all the ‘surplus’ (if any) DOM elements for which there was no data

Of course, at least one of the enter and the exit has to be empty, both are if the data has the same size as the selection. In our example we use d3.data() twice:

// #1: use of the enter selection
// The update will be empty as the selection
// is empty, the enter will contain all 10
// elements
var rects = chart.selectAll('rect')
                 .data([1 ,4, 5, 6, 24, 8, 12, 1, 1, 20])
                 .enter().doSomething();

// #2: use of the update selection
// At this point, rects contains the 10 rectangles, and newData contains
// 10 elements, so the update contains all elements, the enter and the
// exit are empty
rects.data(newData)
     .doSomething();

d3.data() directly returns the update so you can immediately do something on it (that’s our #2). If you want to work on the enter or the exit you need to call d3.enter() or d3.exit() on the update (that’s our #1).

Modifying the DOM according to the data

Now it’s time to use d3 for what it was designed: manipulating the DOM using the data. We can modify any attribute of an element, CSS classes, properties, text and even inner HTML.

Modifying attributes: d3.attr

Calling selection.attr(attribute, value) modifies (and creates if it doesn’t exist) the attribute attribute to give it the value value for every element of selection. value can be a function of data and element index, as in our example:

var rects = chart.selectAll('rect').data([1 ,4, 5, 6, 24, 8, 12, 1, 1, 20])

                 // Add a rectangle for each data in the enter
                 .enter().append('rect')

                 // All rectangles are steelblue with no borders
                 .attr("stroke", "none").attr("fill", "rgb(70, 130, 180)")

                 // All rectangles are 0px from the left of
                 // the container
                 .attr("x", 0)


                 // First rectangle (i = 0) is 0px from the
                 // top of the container, second onf (i = 1)
                 // is 25px from the top and so on
                 .attr("y", function(d, i) { return 25 * i; } )

                 // Rectangles' width is 20 times the bound data
                 // The first one is 20px wide, the second
                 // one 80px and so on
                 .attr("width", function(d) { return 20 * d; } )

                 .attr("height", "20");

Other modifications

As this is not a reference, I won’t show all functions that modify elements. You can look into the d3 reference to learn how to modify classes with d3.classed, properties with d3.property and style with d3.style.

Transitions

The last, and maybe the most impressive piece of d3 is the transitions engine. As we saw in the previous section, d3 enables us to modify any attribute instantly. It can also transition number attributes (e.g. position in pixels, width etc) from their old to their new value smoothly, using the transition(), duration() and delay() functions. You apply this function to any selection and then apply the new attributes, which will be transitioned. In our example, we transition the width of the bars to animate the graph:

// If we didn't use transitions, the graph would change immediately
rects.data(newData)
     .attr("width", function(d) {return 20 * d; } )
     .attr("fill", newColor);

// Simply adding using d3.transition() between new data binding and
// attribute modification and the change becomes graceful
rects.data(newData)
     .transition().duration(2000).delay(200)
     .attr("width", function(d) {return 20 * d; } )
     .attr("fill", newColor);

Cool, isn’t it ? The use of delay() is optional, as you can imagine. The transition() function can transition number attributes, but can also understand when a string contains numbers, and smoothly transition the number parts of the string -that’s how I built the rainbow transition in the example at the top of this article. It also understands some specific types of strings, for example colors (i.e. it can transition from ‘steelblue’ to ‘red’). Visit the d3.js website for more on this!

Advanced transitions

What I explained are just the default, basic transition engine, which works very well. You may need to customize your transition interpolation function, tween or easing function. For example, I did that to animate a line chart (which is a SVG path).

Conclusion

With this tutorial, you should know more than enough to create awesome custom graphs or data visualizations. Since you have total control, you can even create this kind of crazy animations!

Also, it is the only way I found to build smooth animated graphs on the iPad, other libraries such as Highcharts were too slow.

Show Me the Gist

2012-05-07T10:29:00+02:00

The other day on Hacker News I came across this article of the Inc. Magazine. Article seemed very interesting, talking about Turntable.fm. It had been a while since I hadn’t read about Turnable, all news about collaborative experiences on the web excite me, the title was linkbaity: I clicked.

The first thing I do when I come to a new page is to check the length of the article. How long will it take me to read this article? This one made me wince: a very long article split in 4 pages. Two things scared me: pagination and length.

First I don’t like pagination on news website. I am under the impression of being on Google looking for something and having to go to page 4 to find it. This article was also too long for me because it was not the only one I was planning to read. My time is not extensible, there was still work waiting for me. As I don’t want to be a passive reader a long article requires a lot of time to deal with.

I told myself Ok, this article is quite long but I will force myself to go till the end because that’s something really intriguing. That’s how it began. I read the first page without skipping a line then began the second page. But I couldn’t do it. The article was too long. Way too long. Not boring but inappropriately long for what I expected. How did it end? I skipped most of the article, read some random statements to grasp the main ideas. I’m not proud of myself as I really wanted to get more involved in the subject but I’m a nutcracker.

I don’t think I am the only one in this situation. I really like reading, documenting myself but I can’t always make it with theses long articles. They make the web interesting to browse, they bring a lot of value but their barrier to entry is too high and they don’t fit into every reading time. We could really lower this barrier to entry for such articles though, by providing a summary. That’s what scientific researchers do with the abstract they add to their publications, so couldn’t web writers do it too?

We Wrote a Book!

2012-05-03T12:17:00+02:00

After two months of effort, our book is finally out. The collaborative writing process is extremely interesting in itself and will be the topic of subsequent blog posts. For now, we’re happy to introduce Startup Flow, a guide to getting set up as a small team starting to work on a new venture. It addresses questions about how to communicate - especially when working remotely, how to share knowledge and how to collaborate on a code base.

Here are some answers to some questions you might have:

Who Is this Book For?

If you are a small team beginning a technical entrepreneurial project and you are struggling to organize your workflow, especially if some of you are working remotely, this book is for you. It was written with both business people and developers in mind as they’ll need to use common tools, however there are some more technical chapters which are marked as such so that business people can skip them.

Why You Need this Book

You need it because it will save you a ton of time and make your workdays much more pleasant. Indeed, when you start working on a startup you quickly realize that you are going to need some tools to organize your workflow. Especially if you have cofounders, you will find yourself meeting too often, repeating yourself, having a hard time following what everyone is doing, and this will be very frustrating for all of you.

In order to fix these problems, you’ll need to choose your tools and design an efficient workflow through trial and error. That takes a lot of time, given how many tools there are and how hard it is to discriminate between them without actually trying them. We already went through that process, and we compiled our findings in this book so that you can skip that part and start getting things done with great tools that will boost your productivity. Moreover, reading this book will help understand your core needs, even those you aren’t aware of yet.

What Is in this Book?

This book is a collection of the opinionated choices we made. We focused on what we think are the most important components of a startup workflow:

Communication
Knowledge sharing and reuse
Codebase management

With these 3 themes in mind, we offer a selection of tools, one tool for one problem. The tools that we promote are the ones that we use extensively everyday and that we chose after weeks of iteration. Furthermore, they work very well together. We will describe these synergies at the end of the book, so that you can take full advantage of this work environment.

Communication

Communication between teammates is a hard problem. It is necessary yet so complicated to get right. A large portion of communication should be asynchronous, enabling you to avoid useless interruptions that hurt your and your teammates’ productivity. You also need to use different channels dedicated to different use cases.

Knowledge Sharing and Reuse

All the knowledge that one finds interesting and usable should be findable by the other teammates, without him having to send a link by email or Skype every time. If knowledge is not shared or not reusable, it’s worthless and you will lose a lot of time. This is especially true for Eric Ries’ validated learning, on which the whole team should be constantly focused.

Codebase Management

In a technical startup, coding is a vital activity. The developers need to be able to code effectively on their own, but also to collaborate seamlessly. They need to be able to review one another’s code to ensure overall quality. Teams that don’t do that will hit a wall.

If you do all these 3 things right, your team will be so efficient it will be able to build the next Instagram in a week. No kidding!

What this Book is Not

This book is not a collection of tutorials. We will not guide you through the process of installing and using everything in details. Instead we point you to quality external resources.

It also doesn’t pretend to be the be-all, end-all guide on team workflow for every case imaginable. However we feel it is the absolute best for small teams working on a tech project, especially if the team doesn’t have an office yet.

And, finally, it is not a startup guide. We won’t give you any advice as to how to get your business off the ground, we’re not qualified for that! If that’s what you’re looking for, we recommend Eric Ries’ The Lean Startup, a must-read in our opinion.

Why We Wrote this Book

As we started working on ideas and on our startup, we faced the problem we cited earlier. Our lack of organization was holding us back. So we spent two weeks researching and trying different tools. After a few iterations we finally reached a very efficient workflow and this investment is now paying off big time. At first this was just an internal effort, but judging from the questions you can find on Quora, we understood that many people could benefit from our research, and so we decided to write this book.

Get it Now Also available on the Amazon Kindle Store

Capitalize on What You Read

2012-04-27T14:27:00+02:00

I read a lot, probably an average of 15 blogposts a day and a book every two weeks. I find that I sometimes have a lot of trouble remembering the things I just read. Well it’s usually not completely forgotten, the information is likely stored in my unconscious brain and will trickle back to my consciousness when somethings triggers it, such as a question or a situation that matches the pattern my brain stored when I read said content. So that means I just need a little prodding in order to remember. However there is I think a more interesting question: how do you build upon what you read? How do you effectively turn information into knowledge? The secret lies in having an active attitude towards remembering things, and not just passively consume content.

CC license - by Shishberg

Write it Down

Writing things down has a number of wonderful consequences.

First of all the information is “safer” in the sense that it is now written down in a place from which it is easier to retrieve in its actual form than from your unconscious brain. Not only that but it also ensures that the information stays put and doesn’t change. One cannot say the same holds true for memories, as the brain changes them all the time. Memories are very volatile and often the brain tampers with them to spin them more positively or make them more relevant to the context. Writing down will prevent information from being distorted by your unconscious brain.

Additionally, writing things down will actually strengthen your memories. When you write full sentences that are grammatically correct (or close to correct at least), you must formalize relationships between facts, entities, people, and concepts. The brain being better suited to memorize relationships and patterns, it will be easier for you to memorize that way instead of simply highlighting a few words or numbers here and there that aren’t linked together by explicit relationships. (Think of a graph.)

Last but not least, text is universal. Information in writing is easily accessible and shareable. This is important because for instance say you store information in other formats such as audio or video, it won’t be as easily retrieved and accessed. This is why I love blogposts but am not a fan of podcasts or videos that don’t include a “textified” version.

In that regard, I write summaries of what I read and find most interesting and useful. It is important to summarize relationships and not facts only, so that it matches the brain’s memorizing process.

Practice

Musicians are known for their disciplined rehearsals. When I was 10 years old I started learning to play the piano. My parents would pay this private tutor that came once a week and insisted I play 3 hours of piano per day. At this time I was of course way to enthralled by my Playstation to care, but I do regret it now. So I didn’t practice like I should have, and the promising career as a pianist that lied ahead of me ground to a screeching halt. However some of my friends heroically put in the effort and I can see now that practice makes perfect.

Where does that all fit with memorizing and building knowledge? The goal is to apply the methods of musicians to the practice of building knowledge. In that case, practicing means a few things:

Write an interesting bit of knowledge down in different ways, targetting varied audiences (yourself, your family, friends, colleagues, etc.)
Talk about it to people who have a varying level of understanding of that particular topic. They will ask you questions you didn’t expect and force you to dig deeper and strengthen your knowledge.
Weave blobs of knowledge together. By that I mean think about what one relationship in a given domain means if applied to another one. (For instance Math and Computer Science, or Sociology and Networks, Math and Art, etc.) Bridging domains will often make great insights and ideas pop in your head and further strengthen your understanding and memory of a bit of knowledge.

Capitalizing on what you read by writing it down and practicing will slowly (but surely!) turn you in a walking encyclopedia. You will be able to remember a lot more things than you are used to, and gradually gain a deeper understanding of what you memorize.

Tutorial: Domain Name System for Beginners

2012-04-22T08:30:00+02:00

Summary of “Tutorial: Domain Name System for Beginners - Need for Air” (via tldr.io)

The Domain Name System (DNS in short) is what your computer uses to translate human-readable domain names (e.g. www.google.com) into compter-usable IP addresses

It is a distributed system, meaning that no computer contains it whole. Pieces of information are on many computers (some dedicated and some not). Even yours.

To use your own domain name (e.g. tldr.io), you need to purchase one from a registrar such as Gandi.

You use a zone file to manage it. It is a simple text file describing the structure of your DNS zone.

Changes to the zone file take time to propagate through the DNS, usually a few hours.

If you build a website, you will want your own domain name, which means you will need to manage your Domain Name System (DNS). While there is nothing very complicated here, the info is scattered across the Internet, so I decided to write a “cheat sheet”-like tutorial which will hopefully save you some time!

by Ezu

What is the DNS?

The DNS is a system that helps your computer translate human-readable domain names into computer-usable IP addresses (4 numbers between 0 and 255 identifying a server).

A domain name must have two parts, separated by a dot: the actual domain (e.g. google) and the top-level domain (e.g. com). In this example, the domain name is google.com. Optionally, you can also use different subdomains, so that users typing subdomain1.domain.tld and subdomain2.domain.tld arrive on two different pages. The well-known www is a subdomain of google.com in the address www.google.com.

To use your own custom domain name, you need to buy one from a registrar (such as Gandi).

How to manage it: the zone file

Most registrars will let you use Web forwardings, which are simple redirections (what happens when the webpage you are looking at automatically changes to another page). However, you should avoid those for the following reasons:

Simple redirections will replace your domain name by your IP address, which is the best way to scare off users
Masked redirections will not scare off users, but they will give you a very poor search-engine rating

You will need to use the zone file. It is a simple text file describing the structure of your DNS zone (usually your domain) to the global DNS (i.e. the world). Let’s take a look at a sample zone file (the zone file on Gandi for our blog needforair.com.

These are the DNS rules for our domain needforair.com:

@ 3600 IN A 184.106.20.102
www 3600 IN CNAME needforair.com.
wik 3600 IN CNAME fr.wikipedia.org.

You usually also find lines similar to the following in a zone file. They manage the email server your registrar provides you, and shouldn’t touch them:

@ 3600 IN MX 10 spool.mail.gandi.net.
@ 3600 IN MX 50 fb.mail.gandi.net.
smtp 3600 IN CNAME relay.mail.gandi.net.
webmail 3600 IN CNAME agent.mail.gandi.net.
pop 3600 IN CNAME access.mail.gandi.net.
imap 3600 IN CNAME access.mail.gandi.net.

The most important points here are:

Each line corresponds to one rule (a record)
The @ character represents your bare domain (needforair.com in our example) as opposed to subdomains such as test.needforair.com or www.needforair.com
An A record points to an IP address, usually your server. In our example, @ 3600 IN A 184.106.20.102 indicates that a user typing ‘needforair.com’ in his address bar will request content from the IP address 184.106.20.102. The 3600 number is the Time To Live (TTL) of the record, the time (in seconds) during which a nameserver will cache the record and not ask the authoritative server (Gandi here) if queried again
A CNAME record points to any domain or subdomain, either in your zone or outside. In our example, www 3600 IN CNAME needforair.com. means that a user typing www.needforair.com will request content from the same IP address as needforair.com (that’s not the case by default). You can of course use a CNAME to any other domain, in our example wik 3600 IN CNAME fr.wikipedia.org. which will make users typing “wik.needforair.com” in their address bar go to the French version of Wikipedia instead (don’t try it we removed it!)
Don’t forget the period (‘.’) at the end of your CNAMEs !!! For example, use “needforair.com.”, and NOT “needforair.com”. If you forget the period, the record simply won’t work, and you will spend an awful lot of time to figure out why

There are lots of other types of rules, but this should be enough to set up your DNS.

Last note: keep in mind that changes to the zone file take some time, usually a few hours, to propagate through the Internet. So don’t make a mistake or they will take some time to spot and correct!

Discover more

Twitter Lets You Talk to World-Class Experts

2012-04-20T04:35:00+02:00

The other day I had a conversation on Twitter with Ryan Singer of 37 Signals fame. Ryan is a world-class expert in product design and had just posted an article on his excellent blog. The thing is I am a nobody in product design or in the tech scene in general. I’m not saying I’m dumb or anything, just that nobody knows me. And yet I was still able to have a great and stimulating conversation with an expert who’s email inbox is presumably very full, lives thousands of kilometers away from me and doesn’t know anything about me. This was not the first time I’ve been amazed by the power of Twitter, so I decided to blog about it.

CC license - by Brajeshwar

140 characters Enable Improbable Conversations

That length constraint compels people to get straight to the point. There is no fluff. No awkward openings, no pompous endings, no walls of text. People expect direct questions and answers and wouldn’t have it any other way.

This magically enables you to talk to some people you would never have sent an email to. And busy people that don’t know you at all, that might be thought leaders or experts, will answer you if you ask an interesting question. Because the constraint also works for the response: they don’t have to send you a long well thought-out answer, they don’t need to get context to answer, they can just type 140 characters.

I have asked questions to succesful entrepreneurs, or VCs, and almost always gotten a quick answer. This is incredibly cool and powerful. And these people don’t know me at all.

No Social Pressure or Awkwardness

The Twitter feed moves so swiftly that conversations are extremely ephemeral. I think this is key to enabling these kinds of improbable conversations. The fact that it moves so quickly reduces the social pressure: few people will see it, it will not mark your Twitter profile for a long time, and nobody will assume that the two people conversing are great friends or anything. Twitter enables conversations in a vacuum, without having to build up a relationship. There is no pressure for the expert to become friend with the person he is talking to.

When you try to email or talk on the phone to an expert, you always want to be super apologetic, respectful and you don’t really focus on the content of the conversation you’re trying to have but instead you focus on the asymmetry of the relationship and that makes you uncomfortable. Twitter makes all these concerns vanish.

I love Twitter for these opportunities.