drifkin

In the SF Bay Area, BART has LTE too. Even when it's going under the Bay.

It has a built-in debugger that you start using `node debug /path/to/script`. See more here: https://nodejs.org/api/debugger.html

I'm also left handed and have tried out way too many pens. As others have suggested, Uniball Jetstream pens are fantastic and are nearly impossible to smudge by accident. They also come in a variety of sizes. I really like the 0.38mm for taking notes on the small margins of academic papers.

The main pens I've been using these days are disposable fountain pens [1]. They write great and somehow the ink rarely smudges, though more often than with the Jetstreams. But overall I find it more pleasant to write with fountain pens.

[1] http://pilotpen.us/brands/varsity/varsity/

I've been working on a lot of node stuff and lately I've been noticing how crazy big some of the dependency trees end up becoming. So I just did a quick check on ghost: currently there are 487 total dependencies in the dep tree when you do an `npm install ghost`

To be fair, there is some overlap. For example, "debug", a fairly common package, is included in various parts of the tree 8 times, though there are 3 distinct versions being used.

(Keep in mind these numbers are not including dev dependencies. If we add those in, the tree balloons to over 1,400 dependencies!)

Maybe they're using functions so the values can have names? Perhaps easier to debug.

Sam talked about this briefly in his AMA here: https://news.ycombinator.com/item?id=9239677

CS 103 at Stanford: http://web.stanford.edu/class/cs103/

The course reader [1] covers the first half of the class and is pretty good.

[1] http://web.stanford.edu/class/cs103/notes/Mathematical%20Fou...

Ori FS does replication and atomic snapshotting:

http://ori.scs.stanford.edu/

Some of its underlying architecture is very similar to git. Check out Section 5.4 of the paper: http://delivery.acm.org/10.1145/2530000/2522721/p151-mashtiz...

We did a little bit of OCaml in our undergrad PL class at UCLA. If I remember correctly, it was only a couple weeks, and you're probably right in that it was a bit unusual. The less exotic classes I took mostly used C++.

I think the main concern is that in many systems each key doesn't have an equal amount of work associated with it (this sort of thing is usually referred to as a "hotspot").

An example: suppose you have some distributed system storing article metadata and all of the sudden one of your articles becomes very widely shared. The machine that the popular key hashes to gets slammed. Perhaps we'd want to adjust it so that that particular machine is just dedicated to that one article, or some other way to distribute that one article across multiple machines. But we're just using a hash function, so without doing something fancier, we can run into problems when the load suddenly becomes wildly uneven.

I think taeric is saying you "effectively undo" an edit, meaning that you could modify the state to a new state that happens to be the same as the old state (so it'll be a different object).

It looks like there's partial support in other browsers too (I think it's still vendor prefixed). I see columns in Chrome using the example page:

http://www.wiumlie.no/2014/css-figures/koster/prefix.html

It seems like some of the more advanced features like spanning multiple columns hasn't made its way to Chrome yet.

I really like starting documents where I write most text with Markdown, but write out any equations with LaTeX syntax. Pandoc works great for this.

Invariably, if I work on the document for any lengthy period of time, I end up giving up on using Markdown. I'll generate LaTeX output using Pandoc and just start editing it manually.

Exactly, Pinboard has a pretty good API, so you can handle the backups yourself without too much trouble.

I came across a post [1] with a backup script. It refers to another link [2] that shows you can just use a simple curl and get all of your data.

[1] http://alexwlchan.net/2013/03/pinboard-backups/

[2] http://supersoju.com/blog/2013/04/01/pinboard-backups-in-1-l...

I think Cassowary [1] is what you're talking about (particularly section 1.2 where they talk about some modifications to make their system very fast for incremental updates). Apple has based their constraint-based layout system, Autolayout [2], on Cassowary. There's also a project that incorporates Cassowary constraints into a CSS-like declarative syntax called GSS [3].

[1] https://www.cs.washington.edu/research/constraints/cassowary...

[2] https://developer.apple.com/library/ios/documentation/userex...

[3] http://gridstylesheets.org/

Overall it is, but when the above commenter mentions box-and-glue, they're talking about the building blocks of the line breaking algorithm TeX uses (you can read about it in this paper: http://onlinelibrary.wiley.com/doi/10.1002/spe.4380111102/ab... ). The box-and-glue system is a way of expressing a layout as an optimization problem (in the paper, they talk mostly about determining line breaks within a paragraph, but the idea of minimizing badness can be extended to determining page breaks as well). A bigger concern for me is the performance of laying out any reasonably complex page — the performance we get from rendering a reasonably complex webpage today is generally much better than rendering a reasonably complex LaTeX document.

I've come across a feature request for Firefox where someone proposed to use the Knuth Plass line breaking algorithm just for text layout, but they didn't get very much traction: https://bugzilla.mozilla.org/show_bug.cgi?id=630181

The catpcha is fairly permissive at letting you make a lot of mistakes (i.e., don't go back and fix your mistakes, just keep typing). It feels weird at first letting yourself make mistakes like that, but you can probably type a lot faster if you don't worry about fixing typos.

I have zsh set up to indicate when I'm in command mode. Mostly based on this post: http://paulgoscicki.com/archives/2012/09/vi-mode-indicator-i...

I was just going over these the other day. Thank you!

Control + Command + D also brings up the definition popover

Thanks for the info. I actually went through a whole mechanical keyboard phase myself and went through several keyboards without numpads. I spent months using these keyboards, but in the end I found I was fastest and most comfortable typing on an Apple wired keyboard (heresy, I know). I much prefer the footprint of the Apple wireless keyboard, but I find that even though it seems like it'd be identical to the wired version, the keys aren't nearly as solid.

I am kind of curious about Topre switches, I haven't tried them yet. Only various Cherry switches.

I think the pinky RSI issue isn't so bad for me because most of the time I'm in a text editor with vi keybindings, so I wouldn't be using the arrow keys anyway. It's just nice in other apps to have that ability. In the situations where I do use my pinky, it's typically when I'm not typing very much, so I actually just move my left hand so my pinky rests over the Caps Lock key and doesn't need to move laterally. It's some movement, but still less than reaching over to the arrow keys.

It's actually unclear whether it's less efficient or not. Sean Wrona, one of the fastest typists in various competitions, generally uses it in place of shift.

He posts about it here: http://forum.colemak.com/viewtopic.php?pid=8851#p8851

Yup, it's its own key. People tend to refer to this combination of modifiers on OS X as "Hyper" because of this post by Steve Losh:

http://stevelosh.com/blog/2012/10/a-modern-space-cadet/#hype...

I ended up doing something very similar after reading Steve Losh's article. I kept Control where it was, using Caps Lock as Escape/Hyper . The best part by far is using Caps Lock + hjkl for navigation. At work, I leave my arrow keys & numpad covered up with a mouse platform so I can keep the mouse closer.

A side effect of this was feeling completely lost when using Windows in Boot Camp. I found that there's a great piece of software on Windows called "AutoHotKey" that lets me do the same hjkl navigation.

The author provides some details here: https://github.com/mattdesl/kami-demos/tree/master/src/norma...

And goes into more technical detail here: https://github.com/mattdesl/lwjgl-basics/wiki/ShaderLesson6

They're starting to get closer to that ratio now: http://www.dell.com/ed/business/p/dell-u2913wm/pd

Rivers also methodically analyzed many songs, including all of Nirvana's songs to help him with his songwriting. He writes about his songwriting process in the liner notes for "Alone II", an album of his home recordings. The liner notes are amazing. He goes through each song on the album and explains the back story, often mentioning what kind of methods he used to write that particular song.

I dug up an old Rolling Stone article where he talks about his "Encyclopedia of Pop". They also mention him writing several hundred songs in 1999:

https://web.archive.org/web/20080228012507/http://www.rollin...

The names he gives some of his methods are pretty excellent. Some examples:

* Intellectually acquired emotionally volatile concept: http://www.weezerpedia.com/wiki/index.php?title=Intellectual...

* Incipit-Melody-Guitar-Develop-Tea : http://www.weezerpedia.com/wiki/index.php?title=Incipit-Melo...

* Arbitrary-Progression-Distortion-open-Strum-Intro-Melody-Arrange: http://www.weezerpedia.com/wiki/index.php?title=Arbitrary-Pr...

Since HTML5 canvas has support for drawing Bezier splines, another approach to drawing smooth lines through points is to use a Catmull-Rom spline. This gives the benefit of using the browser's native curve drawing routines. This might lead to better performance, or smoother looking curves, though it appears that this implementation's adaptive segmentation looks pretty good.

I think optional typing is better than no typing. It's useful for allowing APIs to be self documenting. It seems as if optional typing is going to get more and more popular. For example, see Google's optional typing in dart, where they actually recommend to not use types for local variables:

https://www.dartlang.org/articles/style-guide/#type-annotati...