Long story short, I went to Silicon Valley and found seed investors for my Browserling startup that I am doing together with James Halliday (SubStack).

James Halliday, our lead investor and advisor David Weekly, Peteris Krumins

Here is how I did it.

Last year in March, James offered me to do a startup. He had this idea of putting virtual machines on the web. I knew he was really good at functional programming and the idea was solid, and I had been wanting to do a startup for years, so it didn't take me long to agree to do a startup with him. James already had a prototype in Haskell but it was too slow, so I rewrote it in node.js and wrote several C++ node.js modules for fast encoding. In July we had a solid working prototype and I announced on my blog that I am doing the StackVM startup. We had decided to apply to Winter 2010 YC, so we hacked some more, and applied to YC in October. I was super sure we'll get accepted as I had done various interesting projects in the past for reddit, digg (this project had 100,000 visitors in 20 hours), hacker news, I had over 50 unique projects on github and my programming articles were getting millions of views. I bought a ticket to Oakland on October 20, before the results were even announced. Meanwhile, James took a car trip to Oakland from Alaska, where he was residing at the time. On October 28 I arrived in Oakland at around 9pm. Then I took BART to MacArthur and met James for the first time. He was a good guy, so everything was fine.

The YC results were to be announced on November 2. November 2 came and to our horrors they decided to pass on us and we didn't even get an interview. Here is our YC application and 2 minute YC video if anyone is interested. The video isn't great but it was like the 100th time we tried to record it and we were out of energy to do more videos so we just went with what we had at 100th take.

Fortunately for us, I had saved some money from all my previous jobs and my projects and decided to put $15,000 into our startup myself. I had been willing to do a real startup for years so I was fine with putting $15,000 in and we just started coding and not thinking about much else.

James had heard about Hackers and Founders meetup that's organized by Jonathan Nelson and Laura Nelson, so we decided to attend all the Hackers & Founders meetups. When I first met Jonathan I was really surprised cause he knew me already from this blog! He had used my xgoogle Python library for scraping Google search results for his Newsley startup. That was thrilling! The goal of this blog from the beginning was to get me well known and my blogging efforts had paid off. Success, I was known in the Silicon Valley! So we'd continue to go to Hackers & Founders meetups in SF and Mountain View, and we'd show everyone we could what we had made, and things were going really well. People loved what we were doing and we didn't worry much about anything, we'd just code and improve Browserling. We launched beta on November 24th and added paid plans in January. The moment we launched the paid plans we got our first customer, and then a few more, and then a few more, and by the end of January we had 10 paying customers already! Things were looking fantastic, but the time was ticking and the $15,000 was running out. It was now February and we had just a few $k left, so we decided it was time to raise money. At one of the Hackers & Founders meetups Jonathan introduced us to Adam Rifkin and he was really excited about StackVM and Browserling. We told Adam that we were looking for a small investment of $50,000 that would keep us going, and he introduced us to David Weekly. So we went and met with David Weekly and he was also really excited about Browserling. He was actually so excited that he wrote a check for us on the spot! Haha, how awesome is that! That's the Silicon Valley I had read about! A check on the spot!

David Weekly decided to lead the investment round for us and help us structure the form of investment. We went with a convertible note, that's the best form of investment. He also introduced us to his friend Ulrich Gall. We took a trip to meet Ulrich Gall, talked for a few hours and we had another committed investor. We actually didn't have phones so he gave me a HTC Nexus One that he had gotten at one of TED conferences. Awesome! Now we were connected, too.

David also got his girlfriend Rebecca Lipon to invest. Meanwhile Adam introduced us to Nick Heyman, who's friends with Mike Tsao. We met with Nick and Mike, and they agreed to invest as well. Mike loved that we had paying customers already.

Now we had 5 investors but we didn't yet have a company! So we had to incorporate. We met with several lawyers from Orrick, Feynwick & West, and some more, and we liked the lawyer from Fenwick & West the most, so we went with him. A few days later we incorporated as Browserling INC. Then we took another trip to meet David Weekly and we signed the investment documents with him and Ulrich. On the same day David Weekly also interviewed us on his The David Weekly podcast. We were super excited.

Next we setup our advisors. David Weekly, Jonathan Nelson, and Adam Rifkin were the most helpful and the awesome people we had met so we set them up as our advisors!

At about the same time we also joined Jonathan and Laura Nelson's new startup incubator called Co-Op. We had discussed this with Jonathan before and we had said that if he ever did an incubator that we'd join in right away. And we did. We are the Reddit of Jonathan's incubator. Also it's funny how at first we didn't know what to call the incubator, so we called it secret super ninja turtles meetup. That's what I still call it when talking with James. :)

That's the story. Now we're adding all kinds of cool features to Browserling. Just last week we launched tunnels for Browserling that allow you to access your localhost or local network from Browserling, and we're launching Testling soon, that's an automated test framework for Browserling.

I have a dozen more blog posts prepared about Browserling. Such as how we open-sourced 40 node.js libraries, how open sourcing them made Browserling easy to maintain, how Browserling works internally, details of new features such as tunnels, resolution changing, testling. If you wish to hear more about it, I suggest that you subscribe to my blog and/or follow me on twitter!

This article is part of the article series "Awk One-Liners Explained."
<- previous article next article ->

Hello everyone! I have awesome news - I have written my first e-book ever! It's called "Awk One-Liners Explained" and it's based on the "Awk One-Liners Explained" article series that I wrote here on my blog a few years ago and that has been read over 800,000 times!

I went through all the one-liners in the article series, improved the explanations, fixed the mistakes, added an introduction chapter to Awk one-liners, and two new chapters on the most commonly used Awk special variables and on idiomatic Awk.

Table of Contents

The e-book is 58 pages long and contains exactly 70 well-explained Awk one-liners. It's divided into the following chapters:

  • Preface.
  • 1. Introduction to Awk One-Liners.
  • 2. Line Spacing.
  • 3. Numbering and Calculations.
  • 4. Text Conversion and Substitution.
  • 5. Selective Printing and Deleting of Certain Lines.
  • 6. String and Array Creation.
  • Appendix A: Awk Special Variables.
  • Appendix B: Idiomatic Awk.
  • Index.

What is awk?

Awk is this awesome, little program that's present on nearly ever Unix machine. It's designed to carry out various text processing tasks easily, such as numbering lines, replacing certain words, deleting and printing certain lines.

Let's take a look at several examples.

Example 1: Print the second column from a file

awk '{ print $2 }'

That's all there is to it. Awk automatically splits each line into columns and puts each column in variables $1, $2, $3, etc. This one-liner prints just the 2nd column, which is in variable $2.

You can also specify the symbol or word that you wish to split on with the -F command line switch. This switch is explained in more details in the e-book and in the last example below.

Example 2: Number lines in a file

awk '{ print NR ": " $0 }' file

The whole line itself goes into variable $0. This one-liner prints it but prepends the NR special variable and a colon ": " before it. The special variable NR always contains the current line number.

There are many other special variables and they're all explained in the e-book and summarized in the appendix.

Example 3: Count the number of words in a file

awk '{ total = total + NF } END { print total }'

Here another special variable is used. It's the NF that stands for number of fields, or number of columns, or number of words in the current line. This one-liner then just sums the total number of words up and prints them before quitting in the END block.

Example 4: Print only lines shorter than 64 characters

awk 'length < 64'

This one-liner uses the length function to determine the length of the current line. If the current line is less than 64 characters in length, then length < 64 evaluates to true that instructs awk to print the line.

Finally, let's take a look at an example that compares an Awk program with an equivalent C program. Suppose you want to print the list of all users on your system. With Awk it's as simple as this one-liner:

awk -F: '{ print $1 }' /etc/passwd

This one-liner says, "Take each line from /etc/passwd, split it on the colon and print the first field of each line." Very straightforward and easy to write once you know Awk!

Suppose you didn't know Awk. Then you'd have to write it in some other language, such as C. Compare the example above with the example in C language:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LINE_LEN 1024

int main () {
    char line [MAX_LINE_LEN];
    FILE *in = fopen ("/etc/passwd", "r");
    if (!in) exit (EXIT_FAILURE);
    while (fgets(line, MAX_LINE_LEN, in) != NULL) {
        char *sep = strchr(line , ':');
        if (!sep) exit (EXIT_FAILURE);
        *sep = '\0';
        printf("%s\n", line);
    return EXIT_SUCCESS ;

This is much longer and you have to compile the program first, only then you can run it. If you make any mistakes, you have to recompile it again. That's why one-liners are called one-liners! They are short, easy to write and they do one thing really well. I am pretty sure you're starting to see how mastering Awk and one-liners can make you much more efficient when working in the shell and with text files in general.

Once you read the e-book and work through the examples, you'll be able to solve the most common text processing tasks, such as joining lines in a file, numbering lines, replacing certain words and printing certain lines.

Book preview

I prepared a book preview that contains the first 11 pages of the book. It includes the table of contents, preface, introduction and the first page of the second chapter.

Buy it now!

The price of the e-book is just $5.95 and you can buy it through PayPal.

PayPal - The safer, easier way to pay online!

After you have made the payment, my automated e-book processing system will send the PDF e-book to you in a few minutes!


Iain Dooley, CEO and founder of Working Software LTD:

It never ceases to amaze me that, even though I spend 50% - 70% of my day using a *nix command line and have done so for the past 6 years, there are still countless thousands of useful tools and tips to learn, each with their corresponding little productivity boosts. The trouble, of course, is finding the time to organise and prioritise them, deciding which are the most important and useful to learn. "Awk One Liners Explained" is a fantastic resource of curated examples that helped me rapidly pick up a few cool tricks that have already provided many times the value I initially paid for the book. Any professional who spends time working with *nix systems can benefit from this book.

Tweet about my book!

I am really excited about my book and I would appreciate your help spreading the word via Twitter! Here is a quick link for tweeting:

My other e-books!

I am so passionate about programming and writing about programming that I have now written my second e-book called "Sed One-Liners Explained". It's written in the same style as this e-book and it explains sed, the Superman of Unix stream editing. Sed One-Liners Explained contains 100 well-explained one-liners and it's 98 pages long. Take a look!

And I am not stopping here - I am going to release several other books. My next e-book is called "Perl One-Liners Explained" and it's based on my "Perl One-Liners Explained" article series.


Enjoy the book and let me know what you think about it!

Peter Krumins (@pkrumins on Twitter)

You have probably all heard the following story about Jobs meeting Knuth for the first time in 1983.

Steve had managed to get Don Knuth, the legendary Stanford professor of computer science, to give a lunchtime lecture to the Mac team. Knuth is the author of at least a dozen books, including the massive and somewhat impenetrable trilogy "The Art of Computer Programming."

I was sitting in Steve's office when Lynn Takahashi, Steve's assistant, announced Knuth's arrival. Steve bounced out of his chair, bounded over to the door and extended a welcoming hand.

"It's a pleasure to meet you, Professor Knuth," Steve said. "I've read all of your books."

"You're full of shit," Knuth responded.

This story is actually not true.

I was watching Randall Munroe's (from xkcd) talk at Google when suddenly Knuth appeared out of nowhere. Randall used the opportunity and asked him to verify this story. Knuth said he gets asked this all the time and that it was not true. I cut that part of the video and put it on YouTube:

So there we have it. The story is fun but not true.

I was just watching a friend of mine work with git, and he'd always type all the git commands in full, like git status and git push. I realized that he must not be the only one to do so, so I decided to write this quick blog post and encourage everyone to create Huffman coded aliases for the most commonly used commands. Instead of typing git status, alias it to gs. Instead of git add, alias it to ga, etc.

Here are a bunch of aliases that I created for 99% of git commands I ever use:

alias ga='git add'
alias gp='git push'
alias gl='git log'
alias gs='git status'
alias gd='git diff'
alias gdc='git diff --cached'
alias gm='git commit -m'
alias gma='git commit -am'
alias gb='git branch'
alias gc='git checkout'
alias gra='git remote add'
alias grr='git remote rm'
alias gpu='git pull'
alias gcl='git clone'

Here is my typical workflow with these command:

$ vim file.c
$ gd                     # git diff
$ ga file.c              # git add file.c
$ gm "added feature x"   # git commit -m "added feature x"
$ ...
$ gp                     # git push

Short and sweet!

This article is part of the article series "Perl One-Liners Explained."
<- previous article next article ->

Perl One LinersThis is the sixth part of a nine-part article on Perl one-liners. In this part I will create various one-liners for selective printing and deleting of certain lines. See part one for introduction of the series.

Perl one-liners is my attempt to create "perl1line.txt" that is similar to "awk1line.txt" and "sed1line.txt" that have been so popular among Awk and Sed programmers and Linux sysadmins.

The article on Perl one-liners will consist of nine parts:

The selective printing and selective deleting of certain lines is actually the same process. If you wish to delete certain lines, you just print the lines you're interested in. Or the other way around! For example, to delete all lines with even line numbers, print the odd lines, and to delete odd lines print the even lines.

After I am done with the 8 parts of the article, I will release the whole article series as a pdf e-book! Please subscribe to my blog to be the first to get it!

Awesome news: I have written an e-book based on this article series. Check it out:

Here are today's one-liners:

82. Print the first line of a file (emulate head -1).

perl -ne 'print; exit'

This is the simplest one-liner so far. Here Perl reads in the first line into $_ variable thanks to -n option, then it calls print statement that prints the contents of the $_ variable. And then it just exists. That's it. The first line got printed and that's all we wanted.

83. Print the first 10 lines of a file (emulate head -10).

perl -ne 'print if $. <= 10'

This one-liner uses the $. special variable. This variable stands for "current line number." Each time Perl reads in the next line, it increments $. by one. Therefore it's very simple to understand what this one-liner does, it prints the line if the line number is equal to or less than 10.

This one liner can also be written the other way around without use of if statement,

perl -ne '$. <= 10 && print'

Here the print statement gets called only if $. <= 10 boolean expression is true, and it's true only if current line number is less than or equal to 10.

84. Print the last line of a file (emulate tail -1).

perl -ne '$last = $_; END { print $last }'

Printing the last line of the file is a bit tricker, because you always have to maintain the previous line in memory. In this one-liner we always save the current line in $_ to $last variable. When Perl program ends, it always executes code in the END block. Now just before exiting it read in the last line, so when it quits, we print $last that prints the last line.

Another way to do the same is,

perl -ne 'print if eof'

This one-liner uses the eof function that returns 1 if the next read will return end of file. Since the next read after the last line in the file will really return eof, this one-liner does what it's supposed to do.

85. Print the last 10 lines of a file (emulate tail -10).

perl -ne 'push @a, $_; @a = @a[@a-10..$#a]; END { print @a }'

Now this is tricky. Here we push each line to the @a array, and then we replace with a slice of itself. We do @a = @a[@a-10..$#a], which means, replace @a with last 10 elements of a. @a-10 is evaluated in scalar context here and it returns number of elements in the array minus 10. #$a is the last index in the @a array. And @a[@a-10..$#a] takes the last 10 elements of the array, so @a always contains just 10 last elements.

Here is an example. Suppose @a contains ("line1", "line2", "line3", "line4"). And let's say we want to print last 4 lines of the file. Now when we read the 5th line, the array becomes ("line1", "line2", "line3", "line4", "line5"). At this moment @a-4 is 1, because @a in scalar context is 5. The $#a however is 4 because that's the last index in the array. Now taking the slice, @a[@a-4..$#a] is @a[1..4], which drops the front element from the array and the @a array becomes ("line2", "line3", "line4", "line5").

86. Print only lines that match a regular expression.

perl -ne '/regex/ && print'

Here /regex/ is short for $_ =~ /regex/. Since the -n operator puts every line in $_ variable the /regex/ returns true on all lines that matched the regex. If that happened, print prints the line.

87. Print only lines that do not match a regular expression.

perl -ne '!/regex/ && print'

This is the same as the previous one-liner, except the regular expression match has been negated. So all the lines that don't match the regex get printed.

88. Print the line before a line that matches a regular expression.

perl -ne '/regex/ && $last && print $last; $last = $_'

In this one-liner every line gets saved to $last variable. Now when the next line matches /regex/ and there has been a previous line $last, then it print $last prints the last line, and then it assigns the current line to the last line variable via $last = $_.

89. Print the line after a line that matches a regular expression.

perl -ne 'if ($p) { print; $p = 0 } $p++ if /regex/'

Here we set the variable $p if the line matches a regex. It indicates that the next line should be printed. Now when the next line is read in and $p is set, then that line gets printed and $p gets set to 0 again to reset the state.

90. Print lines that match regex AAA and regex BBB in any order.

perl -ne '/AAA/ && /BBB/ && print'

This one-liner is basically the same as one-liner #86 above. Here we test if a line matches two regular expressions instead of line. If a line matches both regexes, then it gets printed.

91. Print lines that don't match match regexes AAA and BBB.

perl -ne '!/AAA/ && !/BBB/ && print'

This one-liner is almost the same as one-liner #87. Here we test if a line doesn't match two regular expressions in any order. If it doesn't match /AAA/ and it doesn't match /BBB/, then we print it.

92. Print lines that match regex AAA followed by regex BBB followed by CCC.

perl -ne '/AAA.*BBB.*CCC/ && print'

Here we simply chain regexes AAA, BBB and CCC with .*, which stands for match anything or nothing at all. If AAA is followed by BBB and that is followed by CCC then we print the line. It also matches AAABBBCCC with nothing in between the regexes.

93. Print lines that are 80 chars or longer.

perl -ne 'print if length >= 80'

This one-liner prints all lines that are 80 chars or longer. In Perl you can sometimes omit the brackets () for function calls. In this one we omitted brackets for length function call. In fact, length, length() and length($_) are the same.

94. Print lines that are less than 80 chars in length.

perl -ne 'print if length < 80'

This is the opposite of previous one-liner. It checks if the length of a line is less than 80 characters.

95. Print only line 13.

perl -ne '$. == 13 && print && exit'

As I explained in one-liner #83, the $. special variable stands for "current line number". So if $. has value 13, then we print the line and exit.

96. Print all lines except line 27.

perl -ne '$. != 27 && print'

Just like in previous one-liner, we check if the current line is line 27, if it's not then we print it, otherwise we skip it.

Another way to write the same is to reverse print and $. != 27 and use if statement,

perl -ne 'print if $. != 27'

97. Print only lines 13, 19 and 67.

perl -ne 'print if $. == 13 || $. == 19 || $. == 67'

If you have Perl 5.10 or later then you can use the ~~ smart match operator,

perl -ne 'print if int($.) ~~ (13, 19, 67)' 

The smart matching operator ~~ appeared only in Perl 5.10. You can do all kinds of smart matching with it, for example, check if two arrays are the same, if an array contains an element, and many other use cases (see perldoc perlsyn). In this particular one-liner we use int($.) ~~ (13, 19, 67) that determines if numeric value $. is in the list (13, 19, 69). It's basically short for, grep { $_ == int($._) } (13, 19, 67). If the check succeeds the line gets printed.

98. Print all lines between two regexes (including lines that match regex).

perl -ne 'print if /regex1/../regex2/'

This one-liner uses the flip-flop operator, which becomes true when a line matches regex1 and becomes false after another line matches regex2. Therefore this one-liner prints all lines between (and including) lines that match regex1 and regex2.

99. Print all lines from line 17 to line 30.

perl -ne 'print if $. >= 17 && $. <= 30'

This one-liner is very simple to understand. The $. variable stands for the current line number, so it checks if the current line number is greater than or equal to 17 and less than or equal to 30.

I just thought of another way to write it,

perl -ne 'print if int($.) ~~ (17..30)'

This is one-liner uses the Perl 5.10 (and later) smart matching operator ~~. It basically says, is the current line number in the list (17, 18, 19, ..., 30). If it is, the smart match succeeds and the line gets printed.

You can write the same idea in older Perls as following,

perl -ne 'print if grep { $_ == $. } 17..30'

What happens here is grep checks if the current line number is in the list (17, 18, ..., 30). If it is, it returns a list of just one element, and a list of one element is true, and the line gets printed. Otherwise grep returns the empty list, which is false, and nothing gets printed.

100. Print the longest line.

perl -ne '$l = $_ if length($_) > length($l); END { print $l }'

This one-liner keeps the longest line seen so far in the $l variable. In case the current line $_ exceeds the length of currently longest line, it gets replaced. Just before exiting, the END block is executed and it prints the longest line $l.

101. Print the shortest line.

perl -ne '$s = $_ if $. == 1; $s = $_ if length($_) < length($s); END { print $s }'

This one-liner is the opposite of the previous one. But as we're finding the minimum and $s is not defined for the first line, we have to set it to first line explicitly. Otherwise it's the same just with the length check reversed length($_) < length($s).

102. Print all lines that contain a number.

perl -ne 'print if /\d/'

This one-liner uses a regular expression \d that stands for "match a number" and checks if a line contains one. If it does, the check succeeds, and the line gets printed.

103. Find all lines that contain only a number.

perl -ne 'print if /^\d+$/'

This one-liner is very similar to the previous one, but instead of matching a number anywhere on the line, it anchors the match to the beginning of the line, and to the end of the line. The regular expression ^\d+$ means "match one or more numbers that start at the beginning of line and end at the end of the line".

104. Print all lines that contain only characters.

perl -ne 'print if /^[[:alpha:]]+$/

This one-liner checks if the line contains only characters and if it does, it prints it. Here the [[:alpha:]] stands for "match all characters". You could also write the same as [a-zA-Z] (if you live in ASCII world).

105. Print every second line.

perl -ne 'print if $. % 2'

This one-liner prints first, third, 5th, 7th, etc, line. It does so because $. % 2 is true when the current line number is odd, and it's false when the current line number is even.

106. Print every second line, starting the second line.

perl -ne 'print if $. % 2 == 0'

This one-liner is very similar to the previous one but except printing 1st, 3rd, 5th, etc, lines, it prints 2nd, 4th, 6th, etc, lines. It prints them because $. % 2 == 0 is true when the current line number is 2, 4, 6, ....

107. Print all lines that repeat.

perl -ne 'print if ++$a{$_} == 2'

This one-liner keeps track of the lines it has seen so far and it also keeps the count of how many times it has seen the line before. If it sees the line the 2nd time, it prints it out because ++$a{$_} == 2 is true. If it sees the line more than 2 times, it just does nothing because the count for this line has gone beyond 2 and the result of the print check is false.

108. Print all unique lines.

perl -ne 'print unless $a{$_}++'

Here the lines get printed only if the hash value $a{$_} for the line is 0. Every time Perl reads in a line, it increments the value for the line and that makes sure that only never before seen lines get printed.

Perl one-liners explained e-book

I've now written the "Perl One-Liners Explained" e-book based on this article series. I went through all the one-liners, improved explanations, fixed mistakes and typos, added a bunch of new one-liners, added an introduction to Perl one-liners and a new chapter on Perl's special variables. Please take a look:

Have Fun!

Thanks for reading the article! The next part is going to be about various interesting, intriguing, silly and crazy regular expressions, because Perl is all about regular expressions.