/
atom.xml
1552 lines (1186 loc) · 88.9 KB
/
atom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title><![CDATA[Jason Morrison]]></title>
<link href="http://jayunit.net/atom.xml" rel="self"/>
<link href="http://jayunit.net/"/>
<updated>2014-03-02T22:53:57-08:00</updated>
<id>http://jayunit.net/</id>
<author>
<name><![CDATA[Jason Morrison]]></name>
</author>
<generator uri="http://octopress.org/">Octopress</generator>
<entry>
<title type="html"><![CDATA[Reading List: February 2014]]></title>
<link href="http://jayunit.net/2014/03/02/reading-list-february-2014/"/>
<updated>2014-03-02T22:07:00-08:00</updated>
<id>http://jayunit.net/2014/03/02/reading-list-february-2014</id>
<content type="html"><![CDATA[<p>I am maintaining a reading list:</p>
<p><a href="http://jayunit.net/reading-list">http://jayunit.net/reading-list</a></p>
<p>I’m choosing a theme per month, with several works on the theme.
I’ll try to collect notes at the end of each month about what I read and wrote,
what I thought, and how I might revisit that theme in the future.</p>
<p>Take “reading” loosely – presentations and podcasts definitely count.</p>
<h1>What did I complete in February?</h1>
<p>My high level goals for February were to:</p>
<ul>
<li>Read about <a href="https://www.meteor.com/">Meteor</a>,
<a href="http://www.haskell.org/haskellwiki/Functional_Reactive_Programming">FRP</a>,
and <a href="http://facebook.github.io/react/">React</a>.</li>
<li>Do some toy projects with these.</li>
<li>Skim a finance book.</li>
</ul>
<h2>Meteor</h2>
<h3>What did I read?</h3>
<ul>
<li>Read the <a href="http://book.discovermeteor.com">Discover Meteor</a> book.</li>
<li>Watched the <a href="http://2012.realtimeconf.com/video/matt-debergalis">RealtimeConf 2012 talk</a>.</li>
<li>Listened to the <a href="http://javascriptjabber.com/076-jsj-meteor-js-with-marcus-phillips-and-fred-zirdung/">JavascriptJabber podcast episode on Meteor</a>.</li>
<li>Understood more about Deps from the <a href="http://www.slideshare.net/fitc_slideshare/meteor-reactivestyle">Programming in the Reactive Style with Meteor JS slides</a>.</li>
<li>Went to a <a href="https://www.meteor.com/blog/2014/02/14/pete-hunt-talks-facebook-react">Meteor Devshop talk</a>
about <a href="http://facebook.github.io/react/">React</a> and <a href="https://github.com/benjamn/react-meteor">react-meteor</a>.</li>
<li>Built a <a href="https://github.com/jasonm/toy-meteor-chat">toy chat app in Meteor</a>.</li>
</ul>
<h3>Thoughts:</h3>
<p>Lots of interesting ideas, but I’m not sure I’ll use Meteor. Maybe I’ll use
parts (DDP).</p>
<ul>
<li>Isomorphic (same code for the client and server) is interesting. I would have to
build a large app to see demonstrated advantages, but can imagine.</li>
<li>Seems to work best when all used together, but no reason you couldn’t
extract e.g. DDP or Deps and use in an existing application. (Right?)</li>
<li>There are three places to get packages –
<a href="http://docs.meteor.com/#usingpackages">core</a>,
<a href="https://atmosphere.meteor.com/">Atmosphere</a>, and,
<a href="http://meteorhacks.com/complete-npm-integration-for-meteor.html">as of June 2013, NPM</a>.
It’s nice that they bless a small set of core packages as a stdlib of sorts,
although I don’t understand the need for Atmosphere and NPM to be separate.</li>
<li><p>The <a href="http://docs.meteor.com/#deps">Deps</a> module, especially <code>Deps.autorun</code>,
is a particularly elegant approach to automatic dependency registration that
avoids the need for static analysis. The clever part relies
JavaScript’s single-threaded nature, and tracks the current computation
as <code>Deps.currentComputation</code>.</p>
<ul>
<li>At first I thought this could break down if you depend on a boolean
expression <code>a() && b()</code>. If <code>a()</code> returns <code>false</code>, the language
short-circuits evaluation so that <code>b()</code> is never invoked, so the
dependency is not registered. However, once <code>a()</code> returns <code>true</code>, <code>b()</code>
will get run and the dependency is registered correctly. There must
be some shortcomings? External data is a clear example, but that is
covered by the more explicit <code>Deps.Dependency</code> facilities.</li>
</ul>
</li>
</ul>
<h3>Questions:</h3>
<ul>
<li>What effect does DDP and the use of a document storage model inform data
modeling? How would you build a system like DDP atop a relational model?
One system I work on uses multiple steps of data mapping (SQL –> Python
objects –> JSON –> Backbone models and back). This seems like unnecessary
layers of complexity, and replicating a datastore into the client, like
minimongo does, seems like a preferable situation in many cases. How
might you introduce DDP to an existing rich-client application without
rewriting it in Meteor?</li>
<li>How do you build for reliability atop DDP and RPC? (E.g. ensuring all
RPC endpoints are idempotent.) How does DDP navigate timeout/retry/backoff?
See <a href="http://awwx.ws">Andrew Wilcox</a>’s
<a href="https://github.com/awwx/meteor-offline-data">meteor-offline-data</a> work.</li>
<li><p>How does operational transform (OT) fit in?
Compare to the <a href="https://github.com/codeparty/derby">Derby</a> framework and
its <a href="https://github.com/codeparty/racer">Racer</a> library, which uses
<a href="http://sharejs.org/">ShareJS</a> for OT:</p>
<ul>
<li>OT is one approach to conflict resolution. I assume there are many. What
are the tradeoffs?</li>
<li><p>What other conflict resolution approaches exist? Maybe some in
the <a href="http://thinkdistributed.io/blog/2013/08/28/causality.html">thinkdistributed.io Causality episode</a>.</p>
<blockquote><p>The correctness problems of OT led to introduction of transformationless post-OT schemes, such as WOOT, Logoot and Causal Trees (CT). “Post-OT” schemes decompose the document into atomic operations, but they workaround the need to transform operations by employing a combination of unique symbol identifiers, vector timestamps and/or tombstones.</p>
<p><a href="http://en.wikipedia.org/wiki/Operational_transformation">http://en.wikipedia.org/wiki/Operational_transformation</a></p></blockquote></li>
<li><p>If you use OT, can you use tree-structured data?
Is the scope of OT limited to a document? Can you coordinate operations across
documents?</p></li>
</ul>
</li>
</ul>
<h3>What would I study about this next?</h3>
<ul>
<li>How does the very new (documented February 27)
<a href="https://github.com/meteor/meteor/wiki/Using-Blaze">Blaze rendering system</a>
compare to React?</li>
<li>How well does Meteor play with other libraries? I recall seeing a
“modularized” version of Meteor where some parts were available a la carte.
What does it look like to involve something like Backbone for models? React
for DOM computation?</li>
<li>What is the multi-server story (for performance and for availability)? I
think that the <a href="https://www.meteor.com/blog/2014/02/24/meteor-071-oplog-support-for-complex-queries-meteor-developer-accounts">new oplog work</a>
is supposed to support this.</li>
<li><a href="https://trello.com/c/Gf6YxFp2/42-sql-support">SQL bindings</a></li>
</ul>
<h2>Functional Reactive Programming (FRP)</h2>
<h3>What did I read?</h3>
<ul>
<li>Read <a href="http://conal.net/fran/tutorial.htm">Composing Reactive Animations</a> as
an introduction to the concepts.</li>
<li>Read <a href="http://conal.net/papers/icfp97/icfp97.pdf">Functional Reactive Animation</a>
<ul>
<li>Read somewhat thoroughly. General ideas of facts / behaviors over
implementation is nice. I learned about the idea of using integration
to determine a value at a point in time rather than continual
time-chunked evaluation, refreshed some of my Haskell notation,
and thought about the general idea of declaring behaviors and letting
the implementation handle optimizations and discretization.</li>
</ul>
</li>
<li>Skimmed <a href="http://conal.net/papers/push-pull-frp/push-pull-frp.pdf">Push-Pull Functional Reactive Programming</a>
<ul>
<li>I started this, but got bogged down in notation and FP/Haskell concepts. I
should revisit this after reviewing Monads/Monoids/Applicatives in
March, probably from learnyouahaskell.com.</li>
</ul>
</li>
<li>Listened to the <a href="http://javascriptjabber.com/061-jsj-functional-reactive-programming-with-juha-paananen-and-joe-fiorini/">JavascriptJabber podcast episode on Functional Reactive Programming</a></li>
</ul>
<p>There are a bunch more resources <a href="https://github.com/jasonm/reading-list/wiki/2014-February">in my 2014-February reading-list page</a>
that I collected but didn’t get to.</p>
<h3>Thoughts:</h3>
<p>Seems like a solid theoretical underpinning for complex dataflow apps.</p>
<p>FRP concepts (behaviors) have similarities to promises – they represent an
abstraction of a value. Promises represent a future value. Behaviors
represent a value which may vary continuously over time, they are functions of
time.</p>
<p>From reading the papers, I also learned a more general concept – that of a
paper separately introducing formal semantics from a specific implementation.
I haven’t read enough CS papers to know how typical this is.</p>
<p>That reminds me of a <a href="http://thinkdistributed.io">thinkdistributed.io</a>
podcast on Raft (a consensus algorithm) which was designed for
understandability, seemingly a novel goal in CS research. The result is a
large number of (attempted) implementations, because the theory was so
approachable. Does the Raft paper propose a formal semantics? See in
May/June.</p>
<h3>Questions:</h3>
<p>I’d like to try out <a href="https://github.com/baconjs/bacon.js">https://github.com/baconjs/bacon.js</a> and read about
underlying ideas.</p>
<h3>If I were to study further/return to this, what would I look at?</h3>
<p>I didn’t get to read too much about FRP. I would like to try some of
the JS implementations to build some small dataflow applications.
I’d like to build some medium-sized React.js apps and compare that
experience to the FRP libraries.</p>
<h1>React.js</h1>
<h3>What did I read?</h3>
<p>First, I read about React from other people:</p>
<ul>
<li>Read many of <a href="http://swannodette.github.io/2013/12/17/the-future-of-javascript-mvcs/">David Nolen’s articles about Om and React</a> (seriously just go read David’s entire blog, it’s the inspiration for so much of my reading this year)</li>
<li>Grasped a key idea in React with <a href="http://www.lispcast.com/react-another-level-of-indirection">Eric Normand’s “React: Another Level of Indirection”</a></li>
<li>Finally got the big picture from <a href="http://2013.jsconf.eu/speakers/pete-hunt-react-rethinking-best-practices.html">Pete Hunt’s “React: Rethinking Best Practices”</a> talk</li>
<li>Read about React’s <a href="http://calendar.perfplanet.com/2013/diff/">fast tree-diff algorithm</a> which underpins its virtual DOM implementation</li>
<li>Read a (biased? :) comparison by Pete Hunt of <a href="http://skulbuny.com/2013/10/31/react-vs-angular/">React vs Angular</a></li>
<li>Read about <a href="http://joelburget.com/backbone-to-react/">Khan Academy engineers’ experience of adopting React</a></li>
<li>Listened to <a href="http://javascriptjabber.com/073-jsj-react-with-pete-hunt-and-jordan-walke/">the JavascriptJabber podcasts episode on React</a></li>
</ul>
<p>Then I react the docs themselves:</p>
<ul>
<li>Read the <a href="http://facebook.github.io/react/docs/tutorial.html">React tutorial</a></li>
<li>Read the <a href="http://facebook.github.io/react/docs/getting-started.html">React guides</a></li>
</ul>
<p>And aimed to get my hands dirty:</p>
<ul>
<li>Reviewed my friend <a href="http://brandontilley.com/2014/02/24/creating-chrome-extensions-with-react.html">Brandon Tilley’s article on Creating Chrome Extensions with React</a></li>
<li>Went to a <a href="https://www.meteor.com/blog/2014/02/14/pete-hunt-talks-facebook-react">Meteor Devshop talk</a>
about <a href="http://facebook.github.io/react/">React</a> and <a href="https://github.com/benjamn/react-meteor">react-meteor</a>.</li>
<li>Wrote a <a href="https://github.com/jasonm/toy-viewport-splitter">negligible amount of code</a></li>
</ul>
<h3>Thoughts:</h3>
<p>Looks good, I want to do more with it.</p>
<p>The design of React is very appealing; using functional composition, cohering
templates with view logic, implementing synthetic DOM events atop delegation,
and providing an <a href="http://msdn.microsoft.com/en-us/library/windows/desktop/ff684178">immediate mode atop the DOM’s retained mode</a>
Not sure on the JSX syntax, but I think I’ll like it as soon as I install
<a href="https://github.com/mxw/vim-jsx">vim-jsx</a>.</p>
<h3>If I were to study further/return to this, what would I look at?</h3>
<ul>
<li>Build something more substantial with React</li>
<li><a href="https://github.com/swannodette/om">Om</a>, a CLJS wrapper atop React enjoying
advantages from immutable data structures and presumably other CLJS
fanciness</li>
<li>What does <a href="https://groups.google.com/forum/#!msg/clojure/XQ4wuUc0bCk/vpCxosZvbyMJ">this discussion</a> mean by “UI as value”?</li>
</ul>
<h3>People:</h3>
<p><a href="https://twitter.com/sgrove">https://twitter.com/sgrove</a>
<a href="https://twitter.com/floydophone">https://twitter.com/floydophone</a>
<a href="https://twitter.com/swannodette">https://twitter.com/swannodette</a></p>
<h2>Finance</h2>
<p>On my friend <a href="https://twitter.com/100ideas">Mac Cowell</a>’s recommendation, I
skimmed some of <a href="http://www.amazon.com/Little-Still-Market-Books-Profits/dp/0470624159">The Little Blue Book That Still Beats the Market</a>.
I maintain a healthy level of skepticism, but underneath the “wow it’s pure
magic!” skin appears to be a proxy for value investing that identifies
underpriced companies. Time will tell if broad dissemination of this
valuation strategy will correct the underpricing, or if it holds.</p>
<p>I’d like to, as an exercise, build a software implementation of this strategy
and backtest it. I’d also like to understand if there is affordable
historical market information that avoids
<a href="http://en.wikipedia.org/wiki/Survivorship_bias">survivorship bias</a>, and to understand what
other <a href="http://seekingalpha.com/article/363901-the-perils-of-backtesting-technical-strategies">backtesting blind spots</a>
I may have.</p>
<p>I’ll follow this up (also on Mac’s recommendation) with Graham and Zweig’s
<a href="http://www.amazon.com/The-Intelligent-Investor-Definitive-Investing/dp/0060555661">The Intelligent Investor</a>,
maybe in March or April.</p>
<p>Links from an hour-ish of searching about building trading simulations:</p>
<ul>
<li>Data sources:
<ul>
<li><a href="http://stackoverflow.com/questions/5774218/algorithmic-trading-simulator-benchmark-data">StackOverflow: “algorithmic trading simulator/benchmark data”</a>
<ul>
<li><a href="https://market-archive.appspot.com/">Market Archive</a> – no idea of
trustworthiness</li>
<li><a href="http://quant.caltech.edu/historical-stock-data.html">Caltech Quantitative Finance Group</a></li>
</ul>
</li>
<li><a href="http://en.wikipedia.org/wiki/Survivorship_bias">Survivorship bias</a></li>
</ul>
</li>
<li>Tools:
<ul>
<li><a href="https://www.quantopian.com">Quantopian</a>
<ul>
<li><a href="https://www.quantopian.com/posts/using-the-fetcher-with-quandl">Can I use fundamental data in Quantopian?</a></li>
</ul>
</li>
<li><a href="http://gbeced.github.io/pyalgotrade/">PyAlgoTrade</a></li>
<li><a href="https://www.interactivebrokers.com/en/?f=tws&p1=papertrader">Interactive Brokers’ toolset</a> – Quantopian is privately testing IB API integration, so that’s promising</li>
</ul>
</li>
</ul>
<h1>Retrospective</h1>
<p>The pace for this month was quite high, but I enjoyed keeping up with it.
I’ve found it helpful to schedule reading nights on my calendar to try
and block some time off for paying attention.</p>
<p>I could not read some of the FRP papers for lack of understanding of
some foundational functional programming concepts (applicatives, monoids),
so I will read on those next month.</p>
<p>I wish I had done more hands-on programming with these new tools.</p>
<p>The part I have enjoyed the most is discussing these ideas with others.
I’d like to try small reading groups or journal clubs around some of my
future readings.</p>
<p>Next, onto <a href="https://github.com/jasonm/reading-list/wiki/2014-March">March reading: including Clojure, FP concepts, and core.async</a>.</p>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[RedStorm: Distributed Computation in Ruby]]></title>
<link href="http://jayunit.net/2013/01/11/redstorm/"/>
<updated>2013-01-11T17:43:00-08:00</updated>
<id>http://jayunit.net/2013/01/11/redstorm</id>
<content type="html"><![CDATA[<p>On December 11, 2012 I gave a talk at <a href="http://bostonrb.org">Boston.rb</a> about
writing distributed realtime computations in Ruby using
<a href="https://github.com/nathanmarz/storm">Storm</a> by Nathan Marz and
<a href="https://github.com/colinsurprenant/redstorm">RedStorm</a> by Colin Surprenant.</p>
<p>There is a <a href="http://bostonrb.org/presentations/redstorm-distributed-realtime-computation-in-ruby">video of the talk on the Boston.rb website</a>,
and <a href="http://jayunit.net/redstorm-talk">the slides are posted online</a>.</p>
<p>Basically, Storm provides a framework for building streaming/realtime
computations (like log analysis, for example) and distributed RPC for running
large adhoc computations on a cluster. RedStorm is a JRuby-based adapter for
writing these computations and assembling them into topologies (workflows) in
Ruby.</p>
<p>Here are the recommended resources from my talk:</p>
<h2>Getting started</h2>
<ul>
<li><a href="http://storm-project.net/">storm</a> is the main project.</li>
<li><a href="https://github.com/colinsurprenant/redstorm">RedStorm</a> is the JRuby adapter for Storm.</li>
<li><a href="https://github.com/nathanmarz/storm-starter">storm-starter</a> is a collection of examples in Storm.</li>
<li><a href="https://github.com/colinsurprenant/redstorm/tree/master/examples">redstorm examples</a> is a similar collection in RedStorm.</li>
</ul>
<h2>Related software tools</h2>
<ul>
<li><a href="https://github.com/nathanmarz/storm-contrib">storm-contrib</a> provides integration with many third-party tools like communicating with queues, service buses, and databases.</li>
<li><a href="https://github.com/nathanmarz/storm-deploy">storm-deploy</a> “makes it dead-simple to deploy Storm clusters on AWS.”</li>
<li><a href="https://github.com/nathanmarz/storm-mesos">storm-mesos</a> provides integration with Apache Mesos for cluster resource management.</li>
</ul>
<h2>Documentation</h2>
<ul>
<li><a href="https://github.com/nathanmarz/storm/wiki">Storm wiki</a> has about 40,000 words of excellent documentation.</li>
<li>The <a href="https://groups.google.com/group/storm-user">storm-user Google group</a> will cover any questions that the docs don’t.</li>
</ul>
<h2>Talks</h2>
<p>Two excellent talks by Storm author Nathan Marz:</p>
<ul>
<li><p>At the <a href="http://phillyemergingtech.com/2012">Philadelphia Emerging Technologies for the Enterprise</a>, <a href="http://vimeo.com/40972420">“Storm: Distributed and fault-tolerant realtime computation”</a> gives a more extended introduction to Storm. April 2012.</p></li>
<li><p>At <a href="https://thestrangeloop.com/">Strange Loop</a>, <a href="http://www.infoq.com/presentations/Complexity-Big-Data">Runaway complexity in Big Data</a> discussed “Common sources of complexity in data systems and a design for a fundamentally better data system”. October 2012.</p></li>
</ul>
<h2>Book</h2>
<ul>
<li><a href="http://manning.com/marz/">Big Data</a> is an early access book by Nathan Marz which covers “Principles and best practices of scalable realtime data systems”</li>
</ul>
<h2>Other ESP/CEP resources</h2>
<p>Storm lives in a space that’s often referred to as ESP (“Event Stream Processing”) or CEP (“Complex Event Processing”):</p>
<ul>
<li><a href="http://en.wikipedia.org/wiki/Event_stream_processing">Wikipedia: Event Stream Processing</a></li>
<li><a href="http://blog.sematext.com/2011/09/26/event-stream-processor-matrix/">Event Stream Processor Matrix</a></li>
<li><a href="http://www.quora.com/Complex-Event-Processing-CEP/Are-there-any-open-source-CEP-tools">Quora: Are there any open-source CEP tools?</a></li>
<li><a href="http://www.igvita.com/2011/05/27/streamsql-event-processing-with-esper/">Ilya Grigorik’s “StreamSQL: Event Processing with Esper”</a></li>
</ul>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[CLAHub: Easy Contributor Agreements on GitHub]]></title>
<link href="http://jayunit.net/2013/01/09/clahub-easy-contributor-agreements-on-github/"/>
<updated>2013-01-09T17:22:00-08:00</updated>
<id>http://jayunit.net/2013/01/09/clahub-easy-contributor-agreements-on-github</id>
<content type="html"><![CDATA[<p><img class="right" src="http://jayunit.net/assets/clahub/clipboard.png" width="150" height="150"></p>
<p><a href="http://clahub.herokuapp.com">CLAHub</a> is a small side project I cooked up a few
months ago, and just got around to open-sourcing. The goal is to remove the
friction of <a href="http://en.wikipedia.org/wiki/Contributor_License_Agreement">Contributor License Agreements</a>
for contributors and maintainers alike. It’s not done yet, but I’m curious to
hear what people think.</p>
<h2>What is it?</h2>
<p>The general idea with CLAs is this: contributors grant the maintainer a license
to distribute the their code, and state that they’re legally able to do so. A
fair number of projects have a CLA in place, including
<a href="http://jquery.github.com/cla.html">jQuery</a>,
<a href="http://nodejs.org/cla.html">Node.js</a>,
<a href="https://www.djangoproject.com/foundation/cla/">Django</a>, and
<a href="http://wiki.opscode.com/display/chef/How+to+Contribute">Chef</a>. In the best
cases the CLA is signed via electronic signature, like
<a href="http://nodejs.org/cla.html">Node.js does with a Google Form</a>. In the worst
cases you have to print, sign, and fax the agreement. In all cases,
maintainers are responsible for cross-referencing contributions and signatures
to make sure all contributions have a corresponding signature.</p>
<p>With <a href="http://clahub.herokuapp.com">CLAHub</a> and an open source project on GitHub
you can:</p>
<ul>
<li>Sign in with GitHub and create a CLA for your project.</li>
<li>Ask contributors to sign in with GitHub to electronically sign the CLA.</li>
<li>See on each pull request whether the contributors have all signed your CLA.
This uses the handy <a href="https://github.com/blog/1227-commit-status-api">Commit Status API</a>,
similar to what CI tools do.</li>
</ul>
<p><a href="http://clahub.herokuapp.com/">Here’s the app</a>. There’s a little slideshow on
the frontpage to see how it works. And <a href="https://github.com/jasonm/clahub">here’s the source on GitHub</a>.</p>
<h2>Learn more about CLAs</h2>
<p>Here’s some more background on CLAs:</p>
<ul>
<li><a href="http://jacobian.org/writing/contributor-license-agreements/"><em>Contributor License Agreements</em></a> by Jacob Kaplan-Moss.</li>
<li><a href="http://www.groklaw.net/article.php?story=20110524120303815"><em>A CLA By Any Other Name</em></a> on Groklaw.</li>
</ul>
<p>Want to choose a CLA? <a href="http://www.harmonyagreements.org/">Project Harmony</a> is a web tool that helps you quickly select a CLA.</p>
<h2>Feedback</h2>
<p>There’s more that needs to be done, but the core of the app works.
The <a href="https://github.com/jasonm/clahub/issues">next steps are in GitHub issues</a>.</p>
<p>Do you use a CLA for your project(s)? Would this encourage you to add a CLA if
you don’t have one already? (That’s not really my goal – just to reduce
friction where CLAs are already valuable.) If you have a CLA, would you use
something like this to reduce the barrier to entry and your overhead? What
kinds of features would be useful?</p>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[Papernaut: Exploring Online Discussion of Academic Papers]]></title>
<link href="http://jayunit.net/2013/01/06/papernaut-exploring-online-discussion-of-academic-papers/"/>
<updated>2013-01-06T09:00:00-08:00</updated>
<id>http://jayunit.net/2013/01/06/papernaut-exploring-online-discussion-of-academic-papers</id>
<content type="html"><![CDATA[<p><img class="right" src="http://jayunit.net/assets/papernaut/astronaut.png" width="150" height="150"></p>
<p>If you regularly read scholarly papers, you likely use a
<a href="http://en.wikipedia.org/wiki/Reference_management_software">reference manager</a> to
maintain your personal library. <a href="http://www.papernautapp.com">Papernaut</a>
connects to your library to find online coverage and discussion of your papers
in blogs, forums, and mainstream media. My hope is that these discussions can
provide broader perspective on research and, in some cases, be the spark that
starts a new collaboration.</p>
<p>Here’s a very quick video demo. We start with a <a href="http://zotero.org">Zotero</a>
library that includes a paper from Science on the
<a href="http://www.sciencemag.org/content/336/6079/348.short">effect of pesticides on honey bees</a>.
We then connect to Papernaut, and find several discussions and articles,
including one in <a href="http://www.guardian.co.uk/science/grrlscientist/2012/may/08/1">The Guardian</a>:</p>
<iframe width="560" height="349" src="http://www.youtube.com/embed/ACw3iLLsSXw?rel=0" frameborder="0" allowfullscreen></iframe>
<p>I’ve been working on Papernaut in my spare time for a few months, and I’m happy
to say that it’s now open source. The project comes in two parts, and the
source is on GitHub:</p>
<ul>
<li><a href="https://github.com/jasonm/papernaut-frontend">Papernaut-frontend</a> is the web frontend.</li>
<li><a href="https://github.com/jasonm/papernaut-engine">Papernaut-engine</a> is the feed crawler and matching backend.</li>
</ul>
<p>If you are interested in how the application is put together, the rest of this
article is a technical overview of the moving parts and how they interact.</p>
<h2>Overview: A simple example</h2>
<p>Let’s walk through a simplified example. Say I have only one paper in my
reference manager — that paper from earlier, about the effect of pesticides on
honey bees:</p>
<p>Henry, M., Beguin, M., Requier, F., Rollin, O., Odoux, J., Aupinel, P., Aptel,
J., Tchamitchian, S., & Decourtye, A. (2012).
<a href="http://www.sciencemag.org/content/336/6079/348.short">A Common Pesticide Decreases Foraging Success and Survival in Honey Bees.</a>
<em>Science</em>, 336 (6079), 348-350 DOI:<a href="http://dx.doi.org/10.1126/science.1215039">10.1126/science.1215039</a></p>
<p>Let’s also say that the engine is crawling content from only one source feed,
<a href="http://researchblogging.org">ResearchBlogging.org</a>.
Among many other content items, that source feed contains a
<a href="https://researchblogging.org/post-search/list?advanced=true&post_title=&journal=&blog_blogger_name=GrrlScientist&tags=&tag_id=&search_text=&from_date=05%2F08%2F2012&to_date=05%2F08%2F2012&send=Search">relevant entry</a>,
whose <a href="http://www.guardian.co.uk/science/grrlscientist/2012/may/08/1">content page is on The Guardian</a>.</p>
<p>We’ll look at how the engine crawls and indexes this source feed. Then,
we’ll see how the frontend pulls the paper from my reference manager and
asks the engine for relevant discussions.</p>
<h2>Papernaut-engine: Loading content and identifying papers</h2>
<p>The goal of the engine is to produce a collection of <code>Discussion</code> records, each
of which links to several <code>Identifier</code> records, representing journal papers
that are referenced from the <code>Discussion</code>. In our example, the <code>Discussion</code> is
the article in The Guardian, and the relevant <code>Identifier</code> is
<code>DOI:10.1126/science.1215039</code>. There are also intermediate objects, <code>Page</code> and
<code>Link</code> which connect <code>Discussion</code>s to <code>Identifier</code>s.</p>
<p>The engine consists of two main parts: loaders (which are Ruby classes), and the
query API (a Rails app). For loading, it also depends on an external running instance
of the <a href="https://github.com/zotero/translation-server">Zotero translation-server</a>.</p>
<p><img src="http://jayunit.net/assets/papernaut/diagram-engine.png" alt="" /></p>
<h3>Loading content by crawling feeds</h3>
<p>The loaders load discussion candidates from feeds and archives, extract
outbound links, and store these in the database.</p>
<p>In the first step, I invoke the <a href="researchblogging.org">ResearchBlogging.org</a>
loader to crawl and index the most recent 100 pages of their archives:</p>
<pre><code>[engine] rails runner "Loaders::ResearchbloggingWebLoader.new(100).load"
</code></pre>
<p>This will load a large number of <code>Discussion</code> entries into the database, with
zero or more <code>Page</code> entries for each <code>Discussion</code>, corresponding to outbound
links.</p>
<p>At this point, the engine database contains the <code>Discussion</code>:</p>
<pre><code>#<Discussion id: 3424,
url: "http://www.guardian.co.uk/science/grrlscientist/2012/may/08/1",
title: " Bee deaths linked to common pesticides | video | G...", ...>
</code></pre>
<p>and the linked <code>Page</code> entries:</p>
<pre><code>[#<Page id: 7531, url: "http://dx.doi.org/10.1126/science.1215039", ... >,
#<Page id: 7532, url: "http://pubget.com/doi/10.1126/science.1215039", ... >,
#<Page id: 7533, url: "http://dx.doi.org/10.1126/science.1215025", ... >,
#<Page id: 7534, url: "http://pubget.com/doi/10.1126/science.1215025", ... >]
</code></pre>
<h3>Identifying papers via the Zotero translation-server</h3>
<p>The engine determines which outbound links (or <code>Page</code>s) are academic papers by
issuing calls to the
<a href="https://github.com/zotero/translation-server">Zotero translation-server</a> HTTP API.
The translation-server is a third-party project from open-source reference
manager <a href="http://www.zotero.org/">Zotero</a>. It examines a given URL and, if
that page contains an academic paper, it returns common publication identifiers such as
<a href="http://en.wikipedia.org/wiki/Digital_object_identifier">DOI</a> or
<a href="http://en.wikipedia.org/wiki/PubMed#PubMed_identifier">PMID</a>.</p>
<p>The translation-server wraps the
<a href="https://github.com/zotero/translators">Zotero translators</a>,
a set of JavaScript scripts that do the heavy lifting of parsing a webpage and
attempting to identify it as one or more academic publications. These
translators are
<a href="https://github.com/zotero/translators/issues">maintained by the community</a>,
keeping them fairly up-to-date with publishers. The translation-server uses
<a href="https://developer.mozilla.org/en-US/docs/XULRunner">XULRunner</a> to run these
scripts in a Gecko environment, and makes them available through a simple HTTP
API:</p>
<pre><code>[~] ~/dev/zotero/translation-server/build/run_translation-server.sh &
zotero(3)(+0000000): HTTP server listening on *:1969
[~] curl -d '{"url":"http://www.sciencemag.org/content/336/6079/348.short","sessionid":"abc123"}' \
--header "Content-Type: application/json" \
http://localhost:1969/web | jsonpp
[
{
"itemType": "journalArticle",
"creators": [
{ "firstName": "M.", "lastName": "Henry", "creatorType": "author" },
{ "firstName": "M.", "lastName": "Beguin", "creatorType": "author" },
{ "firstName": "F.", "lastName": "Requier", "creatorType": "author" },
{ "firstName": "O.", "lastName": "Rollin", "creatorType": "author" },
{ "firstName": "J.-F.", "lastName": "Odoux", "creatorType": "author" },
{ "firstName": "P.", "lastName": "Aupinel", "creatorType": "author" },
{ "firstName": "J.", "lastName": "Aptel", "creatorType": "author" },
{ "firstName": "S.", "lastName": "Tchamitchian", "creatorType": "author" },
{ "firstName": "A.", "lastName": "Decourtye", "creatorType": "author" }
],
"notes": [],
"tags": [],
"publicationTitle": "Science",
"volume": "336",
"issue": "6079",
"ISSN": "0036-8075, 1095-9203",
"date": "2012-03-29",
"pages": "348-350",
"DOI": "10.1126/science.1215039",
"url": "http://www.sciencemag.org/content/336/6079/348.short",
"title": "A Common Pesticide Decreases Foraging Success and Survival in Honey Bees",
"libraryCatalog": "CrossRef",
"accessDate": "CURRENT_TIMESTAMP"
}
]
</code></pre>
<p>There are several useful standardized identifiers here – DOI, URL, and ISSN.</p>
<p>So, continuing with our example from above, I’ll next start the Zotero
translation server and identify the pages:</p>
<pre><code>[engine] ~/dev/zotero/translation-server/build/run_translation-server.sh &
zotero(3)(+0000000): HTTP server listening on *:1969
[engine] rails runner "ParallelIdentifier.new(Page.unidentified).run"
</code></pre>
<p>The engine issues calls to the translation-server and records new <code>Identifier</code>s.
Now, the <code>Page</code> entries we previously crawled:</p>
<pre><code>[#<Page id: 7531, url: "http://dx.doi.org/10.1126/science.1215039", ... >,
#<Page id: 7532, url: "http://pubget.com/doi/10.1126/science.1215039", ... >,
#<Page id: 7533, url: "http://dx.doi.org/10.1126/science.1215025", ... >,
#<Page id: 7534, url: "http://pubget.com/doi/10.1126/science.1215025", ... >]
</code></pre>
<p>have corresponding <code>Identifier</code> records:</p>
<pre><code>[#<Identifier id: 1819, page_id: 7531, body: "DOI:10.1126/science.1215039" ...>,
#<Identifier id: 1820, page_id: 7531, body: "URL:http://www.sciencemag.org/content/336/6079/348" ...>],
#<Identifier id: 1821, page_id: 7533, body: "DOI:10.1126/science.1215025" ...>,
#<Identifier id: 1822, page_id: 7533, body: "URL:http://www.sciencemag.org/content/336/6079/351" ...>,
</code></pre>
<p>Two of the four pages were identified (<code>7531</code> and <code>7533</code>), and both of those
pages received two identifiers apiece. This means that the Guardian <code>Discussion</code>
actually referenced two different papers, not just the one we’re interested in.</p>
<p>Now that there is a link between the paper in question and this discussion page,
we are ready to visit the frontend.</p>
<h2>Papernaut-frontend: importing libraries, finding discussions</h2>
<p>The frontend works in two distinct phases: first, it helps you import papers
from your reference manager. Second, it shows you discussions for those papers.</p>
<p>You can import your papers via the
<a href="http://www.zotero.org/support/dev/server_api/read_api">Zotero API</a> or
<a href="http://dev.mendeley.com/">Mendeley API</a> by giving Papernaut access to your
libraries via OAuth. This happens with
<a href="https://github.com/jasonm/omniauth-zotero"><code>omniauth-zotero</code></a> and
<a href="https://github.com/fractaloop/omniauth-mendeley"><code>omniauth-mendeley</code></a>
libraries, followed by the
<a href="https://github.com/jasonm/papernaut-frontend/blob/2013-01-06/lib/zotero_client.rb"><code>ZoteroClient</code></a> and
<a href="https://github.com/jasonm/papernaut-frontend/blob/2013-01-06/lib/mendeley_client.rb"><code>MendeleyClient</code></a>
classes.</p>
<p>Alternatively, you can import papers from most reference management software by
exporting and uploading a <a href="http://en.wikipedia.org/wiki/BibTeX"><code>.bibtex</code></a>
file. Papers and their identifiers are then extracted with the
<a href="https://github.com/jasonm/papernaut-frontend/blob/2013-01-06/app/models/bibtex_import.rb"><code>BibtexImport</code></a>
class.</p>
<p>Many papers will have multiple identifiers, and the frontend attempts to clean and validate
your papers’ identifiers as best it can in an attempt to find the best matches.</p>
<p>Once your papers are loaded into the frontend, it
<a href="https://github.com/jasonm/papernaut-frontend/blob/2013-01-06/lib/discussion.rb">issues requests to the <code>papernaut-engine</code> query API</a>
to find discussions that match papers in your library.</p>
<p><img src="http://jayunit.net/assets/papernaut/diagram-frontend.png" alt="" /></p>
<p>The interface between the frontend and the engine are <code>Identifier</code> strings,
which take a type/value form:</p>
<ul>
<li><code>DOI:10.1038/nphys2376</code></li>
<li><code>ISSN:1542-4065</code></li>
<li><code>PMID:10659856</code></li>
<li><code>URL:http://nar.oxfordjournals.org/content/40/D1/D742.full</code></li>
</ul>
<p>So, in our example video above, we authenticate via Zotero and authorize
Papernaut’s API access via OAuth. The frontend extracts our library of papers
from Zotero and stores their <code>Identifier</code>s locally. It issues requests to the
engine’s query API for matching discussions, and displays those to the end
user:</p>
<p><img src="http://jayunit.net/assets/papernaut/frontend-screenshot.png" alt="" /></p>
<h2>Deployment</h2>
<p>In production, the Papernaut engine and frontend are deployed to
<a href="https://heroku.com">Heroku</a>. The translation-server is deployed to EC2.
I spin it up and run the loaders periodically, to reduce hosting overhead.</p>
<p>There is a <code>DEPLOY.md</code> file for both
<a href="https://github.com/jasonm/papernaut-frontend/blob/master/DEPLOY.md">the frontend</a>
and <a href="https://github.com/jasonm/papernaut-engine/blob/master/DEPLOY.md">the engine</a>
that goes into further detail.</p>
<h2>Next steps</h2>
<p>I’m excited to see what kinds of results people get with Papernaut,
but it’s still very early software. I look forward to making a variety
of improvements.</p>
<p>I’d really like to add a bulk request API endpoint to the engine, so that the
frontend can discover discussions in a single HTTP request, rather that one
request per paper. That’s a big performance hit, and the user experience right
now for large libraries is that the frontend just hangs for a while.</p>
<p>On the engine side, I’d like to do a better job of culling false positives in
the matching engine, and of contributing to Zotero’s translators to improve the
match rate. I think the primary issue there is that the translator-server
actually only runs a subset of all the Zotero translators, as some declare that
they only work inside a real browser context
(<a href="http://www.zotero.org/support/dev/translators">see “browserSupport”</a>).</p>
<p>I’d like to get a larger sample set of BibTeX files to try, as there are
probably edge cases and assumptions in the importer waiting to be hit.</p>
<p>I’d also like to background some of the tasks in the frontend’s import process;
validating DOIs is a big one there. Ideally, the whole library import would be
backgrounded, and the user interface would be notified when the import is
complete.</p>
<p>Currently, some matches are missed because the engine and frontend have
different identifiers for the same paper – say a DOI and a PMID. I also have
an experimental branch that cross-references papers with the
<a href="http://help.crossref.org/#author_title_query">crossref.org API</a>,
which yields more complete information. Ideally that would happen in the engine.
I’ve also seen some library management and import tools that use Google Scholar
to improve matching and identification.</p>
<p>After that, I’d like loaders to run semi-continuously instead of manually, and
to have more robust infrastructure around paper identification.</p>
<p>In the long term, it would be interesting to try and bring the discussion
matching experience directly into reference managers. This is one reason why
I provide the engine query API separately from the frontend.</p>
<h2>Conclusion</h2>
<p>I’m most interested in hearing feedback from people. Is this useful to you?
If you use a reference manager,
<a href="http://www.papernautapp.com">give Papernaut a spin</a>
and <a href="mailto:jason.p.morrison@gmail.com">let me know</a> how it goes.</p>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[A Year of Travel]]></title>
<link href="http://jayunit.net/2012/12/31/a-year-of-travel/"/>
<updated>2012-12-31T09:00:00-08:00</updated>
<id>http://jayunit.net/2012/12/31/a-year-of-travel</id>
<content type="html"><![CDATA[<p>On December 4, Lindsay and I returned to the US after a year of <a href="http://jayunit.net/2011/11/11/hitting-the-road/">traveling
abroad</a>. Lindsay diligently blogged our
experiences and her photos at <a href="http://cadeparade.com">cadeparade.com</a>.</p>
<p>We have spent December visiting family and friends. On December 31, we
fly to San Francisco to start the next chapter of our lives.</p>
<h2>It’s adventure time all over again</h2>
<p>Time to sift through apartments and carefully consider our work, to reacquaint
ourselves with first world amenities and first world problems. To reunite with
family and friends, to fondly shuffle through our notes and photos, and to
reflect on our travel experiences and put them into context.</p>
<p>Also, to eat fajitas and burritos en masse, because let me tell you: Mexican
and Tex-Mex food outside the Americas just is not the same.</p>
<h2>The first half in photos</h2>
<p><em>All photos are by <a href="http://cadeparade">Lindsay Cade</a>, and are from the first
half of the year.</em></p>
<p>During the first six months of December 2011 through May 2012, we traveled in
India, Thailand, Laos, Vietname, Cambodia, and Burma (Myanmar).</p>
<p>We traveled to places beautiful and remote:</p>
<p><img src="http://farm9.staticflickr.com/8453/7936991528_886ea7ae7c_b.jpg" alt="" />
<img src="http://farm9.staticflickr.com/8448/7936993184_be9e720c99_c.jpg" alt="" /></p>
<p>Ate incredible foods:</p>
<p><img src="http://farm8.staticflickr.com/7257/7768788654_e7b744e282_b.jpg" alt="" />
<img src="http://farm8.staticflickr.com/7216/7215266698_43e7409e59_b.jpg" alt="" /></p>
<p>And some not-so-incredible ones:</p>
<p><img src="http://farm8.staticflickr.com/7199/6927499007_1732d60f76_b.jpg" alt="" /></p>
<p>We enjoyed amazing sunsets:</p>
<p><img src="http://farm8.staticflickr.com/7105/6981860512_18047acd9d_b.jpg" alt="" />
<img src="http://farm6.staticflickr.com/5032/7078843175_0eb29b087c_c.jpg" alt="" /></p>
<p>We ventured across deserts:</p>
<p><img src="http://farm8.staticflickr.com/7203/6891841828_dc95fc8352_c.jpg" alt="" />
<img src="http://farm8.staticflickr.com/7254/7031251719_51598ea65d_c.jpg" alt="" /></p>
<p>into backwaters:</p>
<p><img src="http://farm8.staticflickr.com/7208/6847221555_1d21839826_b.jpg" alt="" />
<img src="http://farm8.staticflickr.com/7077/7050364455_1d44c6d27b_b.jpg" alt="" /></p>
<p>through rivers and valleys:</p>
<p><img src="http://farm9.staticflickr.com/8421/7741985230_becb4193c3_b.jpg" alt="" />
<img src="http://farm8.staticflickr.com/7022/6784074323_212570b388_b.jpg" alt="" /></p>
<p>We marvelled at constructions old and new:</p>
<p><img src="http://farm8.staticflickr.com/7142/6640567045_49dc8ddc58_b.jpg" alt="" />
<img src="http://farm8.staticflickr.com/7032/6634037347_a7c9c91e4c_b.jpg" alt="" />
<img src="http://farm8.staticflickr.com/7071/7006734540_c688343639_b.jpg" alt="" /></p>
<p>During the second six months of June through November, we traveled in the Czech
Republic, Italy, Turkey, Germany, France, England, Thailand (again! we are
quite fond of it), South Korea, Malaysia, and Hong Kong. We ended the trip
where we began, returning to India for a month.</p>
<p>I cannot recommend this experience highly enough. My sense of perspective and
patience have been changed at a fundamental level. At the same time, I’m very
much ready for this return to the US, to be with friends and to focus on my
career, to do good in this world of which I’ve now seen a tiny slice more.</p>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[Hitting the Road!]]></title>
<link href="http://jayunit.net/2011/11/11/hitting-the-road/"/>
<updated>2011-11-11T09:00:00-08:00</updated>
<id>http://jayunit.net/2011/11/11/hitting-the-road</id>
<content type="html"><![CDATA[<p>On November 28, my wife Lindsay and I are flying to India. We have
no return tickets, and little plan. I’m leaving a <a href="http://thoughtbot.com">great job</a>;
“professional ennui” is the furthest thing from my motivations. What’s going on?!</p>
<p><img src="http://jayunit.net/images/uploads/adventure-time.png" alt="Adventure Time!" /></p>
<h2>It’s adventure time!</h2>
<p>If there’s one common lesson I could distill from my collegiate and
professional engagements, it would be the value of diverse experience, and the
difficulty of <em>planning</em> to build that experience. Sometimes you just gotta
jump in learning’s way.</p>
<p>We’re young, not tied down, and have seen like 0.0001% of the world. So,
earlier this year, after getting engaged, we decided: let’s hit the road! Our
plans are loose. As of now, we:</p>
<ul>
<li>Have 1-way tickets to Delhi and 5-year visas to India. Many countries in
Asia have VOA (visa on arrival) for US citizens.</li>
<li>Got our arms jabbed (immunizations).</li>
<li>Are brandishing a fat sack of doxy and a veritable menagerie of antibiotics.</li>
<li>Booked two days booked at a hotel to buffer our jetlag.</li>
<li>Asked a friend-of-a-friend to find a short-term lease in Delhi.</li>
<li>Are super frigging pumped. I mean, come on!</li>
</ul>
<p>I’ll miss the crap out of my friends here in the US. We’re flying around a bit
to visit folks before heading overseas – San Fran tomorrow through Wednesday,
then Buffalo, then Houston for Thanksgiving.</p>
<p>Then, on November 28, IAH-ORD-DEL.</p>
<h2>Closing thoughts</h2>
<blockquote><p>Journeys are the midwives of thought. Few places are more conducive to internal
conversations than a moving plane, ship or train. There is an almost quaint
correlation between what is in front of our eyes and the thoughts we are able
to have in our heads: large thoughts at times requiring large views, new
thoughts new places. Introspective reflections which are liable to stall are
helped along by the flow of the landscape. The mind may be reluctant to think
properly when thinking is all it is supposed to do.</p>
<p>If we find poetry in the service station and motel, if we are drawn to the
airport or train carriage, it is perhaps because, in spite of their
architectural compromises and discomforts, in spite of their garish colours and
harsh lighting, we implicitly feel that these isolated places offer us a
material setting for an alternative to the selfish ease, the habits and
confinement of the ordinary, rooted world.</p></blockquote>
<p>― Alain de Botton, The Art of Travel</p>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[Backbone.js Video Q&A]]></title>
<link href="http://jayunit.net/2011/10/24/backbone-js-video-q-and-a/"/>
<updated>2011-10-24T21:24:00-07:00</updated>
<id>http://jayunit.net/2011/10/24/backbone-js-video-q-and-a</id>
<content type="html"><![CDATA[<p>On Friday, October 14th, I hosted a two hour live Q&A chat for purchasers of the thoughtbot <a href="http://workshops.thoughtbot.com/backbone-js-on-rails">Backbone.js on Rails eBook</a>, which I am co-authoring. We invited people who have purchased the book to submit questions ahead of time, and then join me in chat for a discussion.</p>
<p>I’m pleased that we are offering the recording and notes as a free resources. You can <a href="http://workshops.thoughtbot.com/pages/backbone-js-on-rails-qa-live-chat-1">download the Backbone.js on Rails live Q&A chat audio and notes</a> over on the thoughtbot Workshops site.</p>
]]></content>
</entry>
<entry>
<title type="html"><![CDATA[Backbone.js on Rails Talk]]></title>
<link href="http://jayunit.net/2011/09/25/backbone-js-on-rails-talk/"/>
<updated>2011-09-25T22:40:00-07:00</updated>
<id>http://jayunit.net/2011/09/25/backbone-js-on-rails-talk</id>
<content type="html"><![CDATA[<p>On Tuesday, September 20, I gave a talk at the
<a href="http://nhruby.org/">New Hampshire Ruby Users Group</a> on Backbone.js on Rails.
I’ll be giving a very similar talk on Tuesday, October 11 at
<a href="http://bostonrb.org/presentations/backbonejs-and-rails">boston.rb</a> and a
version more targeted to front-end developers on Wednesday, October 26 at the
<a href="http://www.meetup.com/Boston-Frontend-Developers/">Boston Front End Developers meetup</a></p>
<p>I have posted the <a href="http://jayunit.net/backbone-js-on-rails-talk/">Backbone.js on Rails slides</a>
online, and the <a href="https://github.com/jasonm/backbone-js-on-rails-talk/tree/gh-pages">slide source is on my GitHub</a>.</p>
<p>As an aside, I’m using <a href="https://github.com/adamzap/landslide">landslide</a> for the
slides – I love the resulting HTML and interface, though I’ve heard great things
about <a href="http://imakewebthings.github.com/deck.js/">deck.js</a>.</p>
<p>People found the resources sections useful. Many of the links are buried in the
presenter notes, so I’ll repeat them here. There are plenty more online, and
I’m sure I’m missing some content. Please link to any of your favorites in the
comments, and I’ll add them.</p>
<h3>Testing</h3>
<ul>
<li>Isolation test with <a href="http://pivotal.github.com/jasmine/">Jasmine</a>:
<ul>
<li>Spy/stub/mock, even your HTTP, with <a href="http://sinonjs.org/">sinon.js</a></li>
<li>If you’re looking for factory_girl.js, it’s called <a href="https://github.com/bkeepers/rosie">Rosie</a></li>
<li><a href="https://github.com/netzpirat/guard-jasmine">guard-jasmine</a> autotest your Jasmine with headless webkit (<a href="http://www.phantomjs.org/">phantomjs</a>)</li>
<li>Write in CoffeeScript and use the 3.1 asset pipeline with <a href="https://github.com/bradphelan/jasminerice">jasminerice</a></li>
<li>Get started with James Newbery’s excellent blog posts on <a href="http://tinnedfruit.com/2011/03/03/testing-backbone-apps-with-jasmine-sinon.html">testing Backbone with Jasmine</a></li>
<li>Check out his <a href="https://github.com/froots/backbone-jasmine-examples">examples on GitHub</a></li>
</ul>
</li>
<li>Integration test with:
<ul>
<li><a href="https://github.com/thoughtbot/capybara-webkit">capybara-webkit</a> for fast, headless, accurate WebKit testing</li>
<li>Selenium for other browsers, or if capybara-webkit has issues.</li>
</ul>