AbstractNonsense

DNA Lounge on Justin.TV

2008-05-02T17:15:44Z

I'm very pleased to see justin.tv is working out for the dna lounge - my favorite club in SF!

Free Tibet protests in San Francisco

2008-04-09T20:35:30Z

Things are pretty lively at the office today. There are a bunch of helicopters overhead and sirens all around us. A bunch of people are streaming live video from the protests over justin.tv - this one looks like the best right now:

http://www.justin.tv/olympictorchsf1

It's being broadcast over EVDO, so it gets a little choppy at times, but generally it's a great feed.

Isobel

2008-04-03T05:40:02Z

Enjoy the long sleep Isobel.

You were a really good cat. We miss you very much.

Getting hired

2008-03-12T18:10:38Z

These are some notes on how I came to be working at justin.tv. They may prove useful to you, if you're trying to find a job at a good startup.

First a little background: I grew up in the UK and was the first employee of a London-based startup in 2000. I joined that company fresh out of finishing a PhD because one of the founders was my younger brother and he seemed to be having fun there. The company was acquired in 2003 and, because it was still quite small, we were relocated to the sunny Silicon Valley. I spent the next four years waiting for a Green Card and, when it finally arrived, I immediately started looking for a good startup to join.

I already knew I wanted to join a Y Combinator company - even from the outside some of the enormous benefits that come from being funded by YC are easy to see. From the inside they're even more apparent. The network of highly competent and ever more experienced YC founders and friends turns out to be a huge time saver.

I put together a list of what I thought were the best YC companies. It's hard to define exactly what "best" means of course, but here are some of the things I looked for:

Users! This was the most important factor.
A track record of getting press hits.
Smart people. Once I had narrowed my list down to just a few companies, I spent some time on Google finding out everything I could about the people who worked at them. I'm always amazed by how few people do this - both for people they're hiring, and for people they're considering going to work for.

I also asked a bunch of friends what they thought of each company's idea (if you do this, pay less attention to the bad stuff but listen carefully to the good bits. It's much easier to knock an idea than it is to find the diamond in the rough).

I didn't spend a huge amount of time doing this - probably about a day's work was enough to get a good feel of roughly how I would rank each company. In the end, justin.tv was at the top of the list.

While waiting for my Green Card I had worked on a bunch of spare-time projects. Before applying, I made sure that the best of these were currently working, and were written about in my resume. Spare-time projects can give you a huge advantage in complimenting your "official" work experience. Before working at justin.tv I didn't have much recent on-the-job web programming experience, but two of my spare-time projects (lispdoc and clutu) showed that I knew this stuff all the same.

Coincidentally, justin.tv advertised on news.yc right at the same time I decided I wanted to work for them. The content of the ad was an extra indication that they would be a good fit for me - the problem they were asking candidates to solve was clearly written by someone with exposure to Lisp. I wrote a quick solution to it (in Common Lisp) and sent an email introducing myself.

Emmett liked my solution, and sent me their standard follow-up problem. I decided to go all-out to impress, and went in to work a little late that day so I could solve the problem within about an hour of reading the email. That seemed to do the trick, and I was invited to come in for a chat. If you want to get hired somewhere really good it's worth going the extra mile even before the interviews. Don't spam anyone of course, but do take every opportunity to show that you're competent and enthusiastic.

The interviews went well I felt - I was asking the justin.tv guys as many questions as they were asking me, and I was certainly pleased with the answers they were giving. Having been on both sides of the table I can't stress enough how important it is to engage in an interview. I've interviewed people who responded to all my questions with one or two word answers (I've also interviewed people who just won't stop talking and let me get a word in!). An interview should be a two-way thing, more like a conversation. Of course it's awkward, but you can make it less so by just pretending the person you're talking to is a newish friend and you're both brainstorming ideas and swapping stories and experiences together. Above all if you're excited about coming to work somewhere, show it (and if you're not excited, don't bother going for an interview - people can
tell when you're there because you couldn't find anything you liked better). Be confident ("of course if you hire me I can figure out how to do this") but not arrogant ("anyone who can't figure this out is an idiot").

After interviewing with the justin.tv guys, they wanted me to meet with Paul Buchheit - one of the angel investors in justin.tv. He's a very smart guy and it was fun to talk with him, even if I was a little intimidated at first to be meeting the guy who wrote gmail. He has some awesome ideas and loves sharing them (breeding dragonflies in an oxygen-rich environment to see if they'll grow really big, is one that sticks in my mind).

One thing everyone asked - all the justin.tv people, and Paul - was "what would you like to work on at justin.tv?". The answer, for me, was obvious. I'm confident enough in my ability to pick up new stuff that the answer is always "whatever is causing the most pain, that's what I want to work on". That seemed to be an ok answer to give.

When I was pretty sure I was going to be offered the position I pinged my good friend Adam. He's been an early employee at a bunch of different startups and, most recently was the co-founder of Truveo. If you have mentors like Adam who have been through the kinds of things you're trying to figure out, take every opportunity to pick their brains.

A few days after talking with Adam, I was offered the job. I accepted, gave notice, and went to Mexico for my honeymoon (I got married to my awesome wife a few days before the first justin.tv interview). At this point I should mention that, if you're attached, you should do yourself a favor and discuss startup life before you start looking for one to join. My wife and I did this and it was very useful. Startups are completely different to normal jobs and it's much more comfortable to be negotiating your employment terms knowing exactly what you can and cannot commit to, rather than having to say you'll have to get back to people on some points.

I'm incredibly happy at justin.tv. We are making great things happen and all our problems are the good kind (how on earth are we going to scale quickly enough to meet the demand we're seeing?).

Addendum: Try not to seem too eager, or you'll find yourself working at the desk next to the bathroom.

I could watch this all day.

2008-02-29T03:02:40Z

The first online webcam I ever saw was streaming a fish-tank (very grainy, about 1 frame every second or two as far as I remember), so it was funny to see this new channel on justin.tv - fortunately a decade does quite a lot for video quality:

Jans Aasman - Lisp and the Semantic Web

2008-02-23T19:02:25Z

Jans gave a very interesting talk recently at the justin.tv office, as part of our hackertv series of live tech talks.

For anyone who missed it, here's the archive.

How Lisp Will Make Web 3.0 A Reality

2008-02-13T17:21:57Z

http://blog.justin.tv/2008/02/jtv-tech-talk-jans-aasman-on-how-lisp.html

Tech-talk on Scheme tomorrow.

2008-01-23T16:56:04Z

Ethan Herdrick of The Biographicon will be talking about running a startup on Scheme tomorrow, at the justin.tv office (36 Clyde St, SF - a block away from Caltrain).

As usual we'll have free pizza at 12pm, and the talk will start at 12:30pm. It'll be broadcast live on the HackerTV channel. If you watch it there live (or come to the office in person!), you'll be able to participate in the Q&A. If you miss the talk you can always catch it in the archives at your convenience.

The talk has a Facebook event page.

Adam Beguelin (Truveo.com) talking at Justin.tv tomorrow

2008-01-02T21:35:17Z

My good friend Adam Beguelin is giving a talk at the Justin.tv office tomorrow as part of our series of live tech-talks.

These talks are open to anyone. The Justin.tv office is at 36 Clyde Street, San Francisco. If you can't attend in person you can watch the talk live on the HackerTV channel, where you can participate in the live Q&A session via our on-site chat. If you don't catch the talk live, you can see it archived on that channel page later.

The event has a Facebook page.

Post Exit Startup Wisdom Adam Beguelin, PhD

Starting a company is an exciting, frustrating, and sometimes rewarding endeavor. I've done four startups, founding two. I've been through IPOs, acquisitions, near acquisitions, and the Venture Capital Nuclear Winter of 2001-2003. This talk covers some of the lessons I've learned along the way. I'll talk about raising money, spending money, and some opinions on how to build and release software in a Web 2.0 world.

Adam was the CTO and co-founder of Truveo, a leading video search engine acquired by AOL in December 2005. He is currently retired and living with his family in his wife's native country of Vietnam.

Justin.TV on an OLPC

2007-12-27T18:38:11Z

Having had my OLPC delivered on Christmas Eve, I was eager to see how well it would cope with a live video website. Turns out everything works great! Here are some photos and a video of it working:

There's still (just!) time to get hold of an OLPC via the Give One Get One deal. It's an awesome geek toy, a perfect kids' first laptop, and a great thing to do for the developing world.

OLPC

2007-12-24T20:49:00Z

My OLPC arrived this morning - it's great that it got here on the Christmas break! Having played with it for about an hour so far, I have to say this is one of the most exciting pieces of technology I've seen in a while. The whole thing is engineered in a way that reminds me very much of the 8-bit microcomputers I grew up with in the 80s, although of course the OLPC takes full advantage of a lot of modern technology on offer (in fact I'm surprised by just how much cool hardware it has).

The OLPC is a computer built for people, first and foremost. It looks, and feels, and hopefully is incredibly robust. It's also very lightweight. It doesn't get hot, or make any unwanted noises. The keyboard is a membrane (very reminiscent of some of the first computers I owned), but surprisingly not too bad to type on and of course great for kids and harsh environments.

The software has a great feel too. It's incredibly easy to quickly get started doing something fun and interesting. Everything has the effect of encouraging more and more exploration, learning and experimentation.

I haven't managed to find any kind of Lisp yet, but Python is there of course - quite prominently, and in a way that makes it a fun and easy thing to play around with.

Great job OLPC!

Peter Seibel on Why Syntax [Does|Doesn't] Matter.

2007-12-18T18:02:17Z

Peter gave us an excellent talk last week, and didn't seem to mind at all that we had technical problems right up to a couple of minutes before his talk was due to start, or that the pizza was late and arrived halfway through his talk!

Here's part 1 and part 2 of the talk.

Next up: Adam Beguelin (co-founder of Truveo), on "Tips and Tools for Internet Startups" - January 3rd.

Reminder: Peter Seibel is talking at the Justin.tv office on Thursday (Dec 13th)

2007-12-11T19:17:13Z

Peter Seibel, author of the Jolt Productivity Award winning book Practical Common Lisp, will be giving a talk, "Syntax [Does|Doesn't] Matter" or "If you take out the parentheses, will it still be Lisp?" Peter's talk will explore the effects syntax can have on a programming language and on its programmers -- how a given syntax creates an environment in which certain language features can thrive and others will likely whither. Peter is a writer turned programmer or perhaps a programmer turned writer. After working briefly as a journalist he was seduced by the web and turned to a life of Perl and Java hacking. In 2003 he quit his job as the architect of a Java-based transactional messaging system and ended up writing Practical Common Lisp. He is now at work on a new book, Coders at Work, a collection of interviews with sixteen notable programmers.

The Justin.tv office is at 36 Clyde Street, San Francisco. Free pizza will be served from 12pm and Peter's talk will start at 12:30pm and run for about 40 minutes. After the talk we'll have time for Q&A. If you're in the area, please feel free to drop by. If you can't make it in person, you can see the talk live at http://www.justin.tv/hackertv (12:30pm PST) and participate in the Q&A via the chat pane on that page. And of course if you don't manage to catch the talk live, the archived video will soon show up on that page for you to watch when you're ready.

Incidentally, thanks are due to Conrad Barski, who created the awesome artwork that's on the hackertv channel!

Ecmacs?

2007-12-07T21:32:02Z

Steve Yegge posted a status update about his recent work at Google.

For me the most interesting thing was a project that would allow people to write Emacs extensions in javascript.

Of course, attempts to replace elisp have a long and unfruitful history, but surely it has to happen one day. If it's not going to be a real Lisp (e.g. Scheme or Common Lisp), then javascript seems like a good alternative.

Peter Seibel on Why Syntax [Does|Doesn't] Matter: justin.tv, December 13th

2007-12-06T23:01:29Z

Peter Seibel will be giving our second justin.tv live tech talk, December 13th.

Details:

Thursday, December 13, 2007, 12:00pm - 2:00pm.

Justin.tv
36 Clyde St
San Francisco, CA

Justin.tv is hosting tech talks for the SOMA hacker community. Free pizza will be served at noon, and the talk will start at 12:30. The talks will be open to anyone in the area who is interested in listening, and will also be broadcast on justin.tv/hackertv.

Peter Seibel will be giving a talk entitled "Why Syntax [Does|Doesn't] Matter."

Peter Seibel is the author of "Practical Common Lisp", and is now working on "Coders At Work" (which will be published by Apress as a companion book to Jessica Livingston's "Founders At Work").

Facebook event page:

http://www.facebook.com/event.php?eid=6383715741

Amazon startup competition

2007-12-03T21:10:33Z

The startup I work at has been selected as a finalist in the Amazon startup competition. If you think Justin.TV is awesome, why not vote for us?

Second live tech talk at justin.tv

2007-11-20T01:34:30Z

Peter Seibel will be giving our second justin.tv live tech talk, on December 13th.

As with all of these talks, if you're in the area please feel free to drop by. Otherwise catch the talk (live or archived) on the hackerTV channel.

Tech talks

2007-11-17T19:08:33Z

I'm really excited about the latest project we've been brewing at justin.tv: Live tech talks.

They'll be taking place every other Thursday afternoon. If you're in the area, drop by our office. If not, catch the event live online (and if you miss it, there's always the archives!).

Our first speaker will be Leah Culver, of Pownce, who will be talking about OAuth on the 29th of November. There's a Facebook page for the event with more details.

Between talks, I'll be broadcasting a bunch of videos that should be of interest to hackers, starting with the excellent Abelson and Sussman SICP lectures. Come watch them, and chat with other hackers on the hackerTV channel page.

If you have any suggestions for speakers, or for videos to show between talks, please email me: bill@justin.tv

Lunch

2007-11-08T20:53:46Z

Interfacing with the jtv search engine

2007-11-07T23:26:44Z

A justin.tv update, where you can learn how to use Lisp and the new justin.tv search api to write a basic Feline Video Alert System, should you ever need one.

What century is this again?

2007-09-21T21:02:49Z

Apparently Python doesn't have real closures. I went looking to see when closures are from. Turns out they were first fully implemented in Scheme, in the 1970s.

New day, new job

2007-09-09T21:34:36Z

Tomorrow will be my first day working at live video startup justin.tv in San Francisco. If you haven't heard of jtv, check it out. I think live (and potentially mobile) video streaming is going to be a big thing soon.

I'll keep working on my crossword site whenever I can. I'll have a couple of hours every day on the train.

I have plenty of new music to keep me company on the train ride too - I just discovered squarepusher (I'm not sure what took me so long - I've loved practically everything that's come out of Warp Records).

tic-tac-toe for fun and profit

2007-08-30T18:02:01Z

As a precursor to a recent job interview, I was given the task of writing a tic-tac-toe web application. Wanting to impress my interviewers by getting it done quickly, I gave myself one hour to write it (which is why it does ugly things like requiring hunchentoot instead of having a proper asdf file). I think it worked out pretty well. I was lucky enough to have read about the tic-tac-toe/game-of-15 isomorphism a long time ago, but I did miss a couple of rules which means if you're clever you can beat the game when it makes the wrong move.

If you want to run it yourself, make sure you have hunchentoot and cl-who installed first.

(eval-when (:compile-toplevel :load-toplevel :execute)
  (require :hunchentoot)
  (require :cl-who))

(defpackage :tictactoe
  (:use :cl :hunchentoot :cl-who)
  (:export #:start-web))

(in-package :tictactoe)

(eval-when (:compile-toplevel :load-toplevel :execute)
  (setf *hunchentoot-default-external-format* (flex:make-external-format :utf-8 :eol-style :lf)
        *default-content-type* "text/html; charset=UTF-8"
        (html-mode) :sgml
        *read-eval* nil
        *dispatch-table* (list 'dispatch-easy-handlers
                               (create-folder-dispatcher-and-handler "/static/" "./" "text/plain")
                               (create-prefix-dispatcher "/" 'print-main-page))))

(defun start-web (&optional (port 4321))
  (start-server :port port))

(defparameter *remaining-digits* nil)

(defparameter *computer-digits* nil)

(defparameter *human-digits* nil)

(defparameter *magic* #2A((2 7 6)
                          (9 5 1)
                          (4 3 8)))

(defun print-main-page ()
  (let* ((human (or (get-parameter "human") ""))
         (computer (or (get-parameter "computer") ""))
         (human-sym (if (> (length human) (length computer)) 'x 'o))
         (computer-sym (if (equal human-sym 'x) 'o 'x)))
    (let* ((*human-digits* (map 'list (lambda (c) (position c "0123456789")) human))
           (*computer-digits* (map 'list (lambda (c) (position c "0123456789")) computer))
           (*remaining-digits* (sort (set-difference (list 1 2 3 4 5 6 7 8 9)
                                                     (append *human-digits* *computer-digits*))
                                     (lambda (x y) (and (evenp x) (not (evenp y)))))))
      (cond ((and (not *human-digits*)
                  (not *computer-digits*)
                  (> (random 100) 25)) ;; Computer lets monkey play first 75% of the time
             (setf human-sym 'x
                   computer-sym 'o))
            ((not (game-is-won))
             (make-next-move)))
      (with-html-output-to-string (*standard-output* nil :prologue t :indent t)
        (:html
         (:head
          (:style "html body{font-family:sans-serif; font-size:large} a{text-decoration:none;}")
          (:title "tic tac toe"))
         (:body
          (:h1
           "tic tac toe")
          ((:table :cellpadding "10px" :cellspacing "0")
           (dotimes (row 3)
             (fmt "<tr>")
             (dotimes (col 3)
               (fmt "<td align=\"center\" width=\"33%\" style=\"background:#ddddff; border:1px solid #888888\">")
               (cond ((member (aref *magic* row col) *human-digits*)
                      (fmt "~A" human-sym))
                     ((member (aref *magic* row col) *computer-digits*)
                      (fmt "~A" computer-sym))
                     ((game-is-won)
                      (fmt "-"))
                     (t
                      (fmt "<a href=\"/?human=~A~A&computer=~{~A~}\">-</a>"
                           human
                           (aref *magic* row col)
                           *computer-digits*)))
               (fmt "</td>"))
             (fmt "</tr>")))
          (when (or (null *remaining-digits*)
                    (game-is-won))
            (fmt "<p><a href=\"/\">play again</a></p>"))
          (:p
           ((:a :href "/static/tictactoe.lisp") "source code"))))))))

(defun triples (set)
  (let ((result nil))
    (dolist (i set result)
      (dolist (j set)
        (dolist (k set)
          (unless (or (equal i j) (equal j k) (equal i k))
            (push (list i j k) result)))))))

(defun game-is-won ()
  (or (some (lambda (triple) (= (apply #'+ triple) 15))
            (triples *computer-digits*))
      (some (lambda (triple) (= (apply #'+ triple) 15))
            (triples *human-digits*))))

(defun is-winner (digit)
  (let ((*computer-digits* (cons digit *computer-digits*)))
    (game-is-won)))

(defun is-blocker (digit)
  (let ((*human-digits* (cons digit *human-digits*)))
    (game-is-won)))

(defun is-fork (digit)
  (let ((*computer-digits* (cons digit *computer-digits*)))
    (some (lambda (next) (is-winner next))
          (remove digit *remaining-digits*))))

(defun is-fork-blocker (digit)
  (let ((*human-digits* (cons digit *computer-digits*)))
    (some (lambda (next) (is-winner next))
          (remove digit *remaining-digits*))))

(defun make-next-move ()
  (let ((winner (find-if #'identity *remaining-digits* :key #'is-winner))
        (blocker (find-if #'identity *remaining-digits* :key #'is-blocker))
        (fork (find-if #'identity *remaining-digits* :key #'is-fork))
        (fork-blocker (find-if #'identity *remaining-digits* :key #'is-fork-blocker))
        (center (first (member 5 *remaining-digits*))))
    (dolist (x (remove nil (list winner blocker fork fork-blocker center (first *remaining-digits*))))
      (when x
        (push x *computer-digits*)
        (setf *remaining-digits* (remove x *remaining-digits*))
        (return-from make-next-move x)))))

User registration

2007-07-27T16:54:35Z

I just added optional user registration to my crossword game, clutu.

Right now, registering a username does nothing other than reserving a name that nobody else can use. Once I'm sure the code is solid I'll add some more interesting features.

FORMAT is awesome

2007-07-25T16:16:52Z

I love Common Lisp's FORMAT.

Here's a snippet of code from the crossword site I've been working on. This gets invoked after you press the "check" button and clutu has identified any words that are filled-in wrong:

(push (list "clutu"
	    (if wrong
		(format nil "~{~#[~;~a~;~a and ~a~:;~@{~a~#[~;, and ~:;, ~]~}~]~} ~[is~:;are~] wrong"
			(reverse wrong)
			(1- (length wrong)))
		"everything is ok"))
      (chat-of game))

It produces output (in the chat pane) like "clutu: 13 across and 4 down are wrong".

I think I started by grabbing an example from Peter's book.

Format is one of the things that looked scary when I first came to Common Lisp, but now I hate to do without when I'm using some lesser language.