-
Notifications
You must be signed in to change notification settings - Fork 1
/
index.html
862 lines (459 loc) · 62 KB
/
index.html
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
<!DOCTYPE html>
<!--[if IEMobile 7 ]><html class="no-js iem7"><![endif]-->
<!--[if lt IE 9]><html class="no-js lte-ie8"><![endif]-->
<!--[if (gt IE 8)|(gt IEMobile 7)|!(IEMobile)|!(IE)]><!--><html class="no-js" lang="en"><!--<![endif]-->
<head>
<meta charset="utf-8">
<title>Garbled</title>
<meta name="author" content="Ben Hamill">
<meta name="description" content="Whenever we interact with the world, we use cognitive shortcuts. It's handy, you know. We make assumptions about our environment so that, if we&# …">
<!-- http://t.co/dKP3o1e -->
<meta name="HandheldFriendly" content="True">
<meta name="MobileOptimized" content="320">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="canonical" href="http://garbled.benhamill.com/page/3">
<link href="/favicon.png" rel="icon">
<link href="/stylesheets/screen.css" media="screen, projection" rel="stylesheet" type="text/css">
<link href="/atom.xml" rel="alternate" title="Garbled" type="application/atom+xml">
<script src="/javascripts/modernizr-2.0.js"></script>
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<script>!window.jQuery && document.write(unescape('%3Cscript src="./javascripts/lib/jquery.min.js"%3E%3C/script%3E'))</script>
<script src="/javascripts/octopress.js" type="text/javascript"></script>
<!--Fonts from Google"s Web font directory at http://google.com/webfonts -->
<link href="http://fonts.googleapis.com/css?family=PT+Serif:regular,italic,bold,bolditalic" rel="stylesheet" type="text/css">
<link href="http://fonts.googleapis.com/css?family=PT+Sans:regular,italic,bold,bolditalic" rel="stylesheet" type="text/css">
</head>
<body >
<header role="banner"><hgroup>
<h1><a href="/">Garbled</a></h1>
</hgroup>
</header>
<nav role="navigation"><div>
<ul class="subscription" data-subscription="rss">
<li><a href="/atom.xml" rel="subscribe-rss" title="subscribe via RSS">RSS</a></li>
</ul>
<form action="http://google.com/search" method="get">
<fieldset role="search">
<input type="hidden" name="q" value="site:garbled.benhamill.com" />
<input class="search" type="text" name="q" results="0" placeholder="Search"/>
</fieldset>
</form>
<ul class="main-navigation">
<li><a href="/">Blog</a></li>
<li><a href="/blog/archives">Archives</a></li>
<li><a href="/about">About</a></li>
</ul>
<div>
</nav>
<div id="main-wrapper">
<div id="main">
<div id="content">
<div class="blog-index">
<article>
<header>
<h1 class="entry-title"><a href="/2009/07/31/breaking-expectations/">Breaking Expectations</a></h1>
<p class="meta">
<time datetime="2009-07-31T00:00:00-05:00" pubdate data-updated="true">Jul 31<span>st</span>, 2009</time>
</p>
</header>
<div class="entry-content"><p>Whenever we interact with the world, we use cognitive shortcuts. It's handy, you know. We make assumptions about our environment so that, if we've guessed right, we can respond appropriately to our environment more quickly as it changes. It's a survival technique.</p>
<p>However, it can sometimes get us into trouble, especially socially. We see someone dressed a certain way or giving some other kind of social cue and we assume other things about them. Most of the time, this works brilliantly; they're sending those cues on purpose and we're supposed to interpret them the way that we do. Or they're not sending those cues on purpose, but they're identifying with a group and so our reaction is still appropriate.</p>
<p>I have a hard time, sometimes, in social situations. I have had to learn, via careful and intentional observation and memorization, many social conventions that it seems others picked up earlier, easier or more instinctively. So I'm somewhat sensitive, now, to the social cues that others send. Which is to say that I'm more consciously aware of the ones I notice, not that I notice all the little ones; the fact that I have to consciously process them slows me down and I miss many cues because of it.</p>
<p>I struggled, for a long time, with the fact that others often acted as if I understood some cue I'd missed (a reasonable assumption on their part, statistically speaking). And I realized that I was sending as many "normal" social cues as I could in order to fit in (my younger self was less comfortable being a huge nerd than my present self). But this meant that people were under the impression that I conformed to their expectations… I was basically lying to them.</p>
<p>So I set about trying to find some things I could do that would indicate to someone that they'd be best served (assuming their goal was to communicate effectively with me) being fully mentally engaged, rather than on auto-pilot. When i first had this idea, I also had the idea that I was <em>special</em> and <em>different</em> and so more deserving of people's full attention. I've since become a bit more humble in that regard.</p>
<p>I don't want to get into a whole ton of detail about my personal expectation breaking journey. I want to come to my point, which is this: I wanted to break people's expectations so that they'd have a "What?" moment and hopefully clue in that something new or uncommon was going on. Instinctively, I knew I shouldn't go <em>too</em> far off, but it's not something I realized until recently.</p>
<p>Whether it's yourself or a product or brand, I think people often want to break expectations. And I feel like people hand out that advice a lot. It's decent advice, too. However, it's one thing to wear funny socks or something and another to dress in a gorilla suit every day. Funny socks are different enough that people will look at you oddly, but still feel like they can have a conversation with you. A gorilla suit is so radical that many people will assume they can't cope to the difference, whether they're right or wrong.</p>
<p>The analogy that popped into my head when I initially thought of this was a window. If you want people to see you (assuming you're transparent, like, you know, a window), then you might think that cracks would help. I certainly notice a window with a crack more than one without. But if you apply too much force, you'll shatter the glass and there will be gaps in the window and jaggey bits that people are afraid to some too near, etc. It's a much more upsetting experience. I guess my advice on the topic (for those that want it) is this: Break expectations if you like, but apply light pressure so you don't shatter them.</p>
</div>
</article>
<article>
<header>
<h1 class="entry-title"><a href="/2009/06/09/the-new-breed-of-hacker/">The New Breed of Hacker</a></h1>
<p class="meta">
<time datetime="2009-06-09T00:00:00-05:00" pubdate data-updated="true">Jun 9<span>th</span>, 2009</time>
</p>
</header>
<div class="entry-content"><p>In light of my last post, I got to thinking some more about old school hackers. Also, at my job, we've got some people who've been here a <em>long</em> time. One in particular, we'll call him Steve, is very smart, but… And, see, that's sort of the thing: I can't put my finger on it exactly. Steve is <em>blazingly</em> smart. But there's clearly a difference between he and I that isn't, I think, just accounted for by the 20 or so (I'm guessing) year difference in our ages.</p>
<p>If I see something I dislike—something that could be better—I really want to see it change. I want to be involved in that change if not driving it. Steve is often watching and present. He's paying attention mostly and if you ask him a question he'll have an insightful answer. If someone proposes a change that's actually a good one and addresses a real problem, etc. etc. he'll be glad the change is coming. But he never pushes for it. He never starts a conversation (in the wider sense, I mean; he <em>will</em> say hi to you in the hall or whatever) and hardly chimes in unless addressed directly.</p>
<p>And I think Steve fits a sort of archetype. He's very interested in low-level details (well, actually in almost any kind of technical detail). He seems to be pretty much interested in being left alone and tinkering in his shop to see how things work (to use a light metaphor, here). If something is bad or less than optimal for other programmers around him (and including him), he'll either ignore it or work around it on his own. His solution wont be general enough to apply to everyone, though and he wouldn't publicize it. He's very internally focused. And I associate this stereotype with older programmers or, more accurately, with old school programmers (how long have you been coding, not how long have you been alive).</p>
<p>On the other hand, I think think there's a newer breed of programmer that's becoming or has become very common. And I want to be very specific, here: I'm talking about hackers; folks who code because they enjoy it, not those who do it because its their job. People who would code to solve computer-related problems they have at home even if they were a news anchor or a trail guide. This new breed is more externally focused. We want our solutions to problems to be useful to other people. We want to have a conversation and (often) change the way things are done (for what we see as the better). We want powerful abstractions and like to live up away from the metal, generally.</p>
<p>I haven't cataloged all the differences and, in particular, I'm having a hard time figuring out the attributes for my "new breed" of hacker are. Of course I'm talking about generalizations and stereotypes, here, but I don't think that's intrinsically bad. Basically, I get a sense of a certain amount of cohesion in personality type and behavior in these two groups and it struck me as interesting. What do you think, am I drawing a distinction where there is none? Is this distinction useful for anything? Is there some interesting point I've missed?</p>
</div>
</article>
<article>
<header>
<h1 class="entry-title"><a href="/2009/06/05/the-happy-hacker/">The Happy Hacker</a></h1>
<p class="meta">
<time datetime="2009-06-05T00:00:00-05:00" pubdate data-updated="true">Jun 5<span>th</span>, 2009</time>
</p>
</header>
<div class="entry-content"><p>You frequently hear (or I do, anyway) the advice that if you're unhappy in your coding job, you should scratch your own itch, work on what you love… Work on something you'd be a user for. Because then you don't have to do a bunch of requirements gathering and get them inevitably wrong, etc. etc. The idea seems to be that if you love the business process, you'll love working on the code that enacts it. And, well, that's fine. It seems to make a lot of sense, on the surface. But then I thought about history.</p>
<p>As programmers, we don't have a lot of it (compare auto workers or, say, masons). History, I mean. But there's some and in the days of <a href="http://www.cs.utah.edu/~elb/folklore/mel.html">Mel</a> and COBOL Cowboys, things were different from what they are now. Today we have all these powerful abstractions and high level languages. Folks (well, not all, but many) consider it to be ideal if you're basically writing your code in a DSL specific to your business process. Which means your code is really tightly coupled to your business (on that layer, anyway). I don't know that that's a bad thing at all (in case I sounded critical). I just want to contrast it to what came before.</p>
<p>Those dudes were almost just writing ones and zeros. They were so far removed from the business processes they were enacting and the folks who were using their stuff that I wonder how much impact it had on them. Would Mel have been any more or less happy writing financial management apps for large companies than solitaire? I kind of think it wouldn't have mattered to him; he was in it for the code and playing with numbers. He enjoyed all that low-level stuff.</p>
<p>So I wonder, is our (figurative us, here) unhappiness when dealing with business processes we aren't personally invested in a symptom of all of our awesome high level languages and nice abstractions?</p>
</div>
</article>
<article>
<header>
<h1 class="entry-title"><a href="/2009/05/07/concern-over-separation-of-concerns/">Concern Over Separation of Concerns</a></h1>
<p class="meta">
<time datetime="2009-05-07T00:00:00-05:00" pubdate data-updated="true">May 7<span>th</span>, 2009</time>
</p>
</header>
<div class="entry-content"><p>I have a lot of online identities. Who doesn't these days? I've got a gmail account, which means I also have a gchat account and that account can also double as an OpenID. Because I got on the bandwagon before Google did, I have a different OpenID. I've got an AIM account (well, one active and a few that've atrophied over the years). I've got a Twitter account and an account at Hacker News and one over on the GURPS fora and an OtherInbox account and… a ton of other sites. Sometimes, it's all a lot to keep track of.</p>
<p>However, sometimes they get conflated in ways that annoy me. For instance, especially since getting hooked into OtherInbox, I've protected my gmail account a lot. I route to it from several @benhamill.com addresses, for instance. And, really, it's harder for other people to remember my picked-it-because-of-a-crowded-namespace-username at gmail.com than it is to remember my-first-name at my-full-name.com.</p>
<p>However, the circle of people I give my (or an) email address to is different from the circle of people I want to chat with over AIM (and is certainly different from the circle of sites I'd want to sign into with an OpenID). So I have warring desires: I like having an XMPP chat account now that I've used gchat and I wouldn't have tried it if it hadn't been handed to me, but now I wish it were a different account (so I could disclose my chat id, but not my email address). Problem is, now that I've got people used to that identity in that format, the overhead for switching is somewhat high. Also, there's the convenient merging of contact lists that Google does for me (probably possible with different identities, but certainly not as easy).</p>
<p>So, if I didn't have an OtherInbox account and I didn't have a separate OpenID: just my gmail account… I'd be (tacitly) giving my email address to people I wanted to chat with and websites I signed into with OpenID, I'd be giving my OpenID and email address to people I chatted with, etc. That seems… bad to me. Am I being paranoid? There's a balance, here, between lowering the bar of entry ("Want to try out New Thing X? Easily done: you already have an account.") and separation of concerns. What're your thoughts on the topic of identity management and separation thereof?</p>
</div>
</article>
<article>
<header>
<h1 class="entry-title"><a href="/2009/04/30/bad-getting-away-with-it/">Bad & Getting Away With It</a></h1>
<p class="meta">
<time datetime="2009-04-30T00:00:00-05:00" pubdate data-updated="true">Apr 30<span>th</span>, 2009</time>
</p>
</header>
<div class="entry-content"><p>There's been tons of hoopla about these slides that some guy showed at GoGaRuCo . Seriously, so much hoopla that I've been unable to absorb the guy's name (note: I have a really, really hard time with names as it is, so…). Also so much hoopla that I don't even really know what to link to so that people will have an idea of what I'm talking about if they don't already. I guess <a href="http://hackety.org/2009/04/29/aSelectionOfThoughtsFromActualWomen.html">_why did a decent job of explaining</a> it by not explaining it. The short story is that there were some slides in a presentation with very scantily clad ladies doing very suggestive things. Everyone's freakin' blogging about it and I hate to me-too this thing, but I do want to express a thought I haven't seen yet and I also neglected to make a post this month, which has been bugging me.</p>
<h2>And Now, a Tangent</h2>
<p>So in college, I played trombone in the marching band. It was good times and we had this principle that we called The Stupid. This may not make perfect sense to people who haven't experienced band social dynamics first hand, but I'm going to try. Basically, the trombone section had a reputation amongst the rest of the band (360ish total members) for doing ridiculous, stupid things for no reason. It had been decided amongst ourselves that, rather than try to live this down, we'd just run with it. So we did Stupid things on purpose; frequently to humorous effect. I mean–we were always entertained, others were only sometimes entertained.</p>
<p>That was the big flashy visible part of the Stupid. We got elaborate, spending large percentages of our meager college student incomes on Stupid ideas that we planned for weeks. We went to great lengths. The part of the Stupid that wasn't so visible was the great lengths we went to to ensure that we didn't… inflict the Stupid on anyone who didn't opt in. We had the goal of making so that if you missed some prank (or whatever you want to call it, not all of it was traditional pranks) of ours by a few hours, you'd never know it happened. We had varying levels of success with it, of course, but I think we did a pretty good job.</p>
<p>We also tried to go to Stupid lengths to be helpful to the band in general; we'd help clean up or take care of something that we saw needed doing rather than just waiting for someone else to do it or reporting it or whatever. I should point out that the directors found the Stupid highly unamusing in the way that I think is probably appropriate for teachers to find the antics of their students. Taking care of things and working hard was sort of our effort to come out net neutral in their minds and not get in hot water.</p>
<p>So the 'bones weren't nationwide (well, the Stupid did get on ESPN in the background a couple times and of course we were on TV performing at games, but not for our antics, generally), as <a href="http://gilesbowkett.blogspot.com/2007/10/im-bad-im-nationwide-job-security-vs.html">Giles says</a>, but we did have a reputation for being bad and (the key to being bad) getting away with it.</p>
<h2>The Moral of Our Story</h2>
<p>So, as things go in college, people get older and graduate and new folks come in, etc. Traditions shift and change. There came a day when some new kid was really jazzed up about the flashy, visible, <strong>bad</strong> part of The Stupid and didn't have the working-hard, cleaning-up-after-yourself, help-others-out part of the Stupid down so good. Basically, he was seeing the bad and didn't see what let us get away with it. And he (I'm actually talking about several people over a period of time and series of events) did something he thought was Stupid, but was just stupid. He got on people's nerves, got in people's way, maybe he broke something that cost money… and he didn't do anything that would make people think, "Well, that's alright, because… whatever."</p>
<p>So I hope you see where I'm going by now. Amongst Railsers (as a broad generalization and as distinct from Rubyists) there's a bit of a tradition of being bad. DHH is, arguably, the originator of <a href="http://www.flickr.com/photos/benhamill/3490074270/">that attitude</a> and he's certainly been an icon of it. I'm not even saying he's wrong. I'm saying that whenever you have people like him (and he is, I should stress, not alone, here, Cf. Chad Fowler, Giles Bowkett and Zed Shaw) there will be others who look up to that way of being, who idolize it, who imitate it, but who, ultimately, don't <em>get it</em>.</p>
<p>These freshman, as it were, will do the flashy, visible, bad part of the image (perhaps poorly, but perhaps not) but neglect to do the more subtle things that let their idols get away with it. I'm not sure what it is those idols are doing, specifically, that makes up for their behavior (they certainly aren't practicing their music the most). I suspect that, really, everyone has to find their own way to make up for acting like a jerk.</p>
<p>What I'm driving at is that if you're setting an example (as anyone highly visible in a community is) for being so awesome that no one minds when you're a jerk, you have to take a bit of responsibility when others imitate you and screw it up. I think Matz chose (probably by nature, rather than consciously) an easier path: If you set an example of being humble and nice and people imitate you and fail, they'll at least have the safety net of, "…well, his <em>intentions</em> were good."</p>
</div>
</article>
<article>
<header>
<h1 class="entry-title"><a href="/2009/03/18/git-tutorials-suck-a-sucky-git-tutorial/">Git Tutorials Suck, a Sucky Git Tutorial</a></h1>
<p class="meta">
<time datetime="2009-03-18T00:00:00-05:00" pubdate data-updated="true">Mar 18<span>th</span>, 2009</time>
</p>
</header>
<div class="entry-content"><h2>Context… Perhaps Too Much Of It</h2>
<p>So I was reading <a href="http://byorgey.wordpress.com/2009/01/12/abstraction-intuition-and-the-monad-tutorial-fallacy/">this blog post</a> about learning and explaining because Carl Youngblood <a href="http://twitter.com/carl_youngblood/status/1115967090">tweeted about it</a>. I think Carl's right: I had a hard time learning git (by which I don't mean to imply I'm some sort of expert now, but the learning is going easier now).</p>
<p>I think the main problem that I had was this: Having learned Subversion, with it's central repository, it was a hard abstract thing to understand. And some (I feel many of the ones I read, anyway) of the tutorials out there try to start at the abstract. Little help that did me (see above-linked article. Really, it's very good). And even ignoring those, I had to read a lot lot <em>lot</em> of the practical ones before things started sinking in.</p>
<p>So I've sort of come to understand that, actually, the tutorials don't suck; learning abstract things just takes time and, at the time, that can be frustrating. So I'm going to offer my own little sucky tutorial, which will focus on the practical aspects and, if you read this and don't get it, you can follow some links at the end to other articles I found helpful and maybe, after roughly a week, you'll have your 'ah-Ha!' moment and think about how git is just like monads… whatever the heck those are.</p>
<p>A lot of tutorials for git newbies start out explaining the Staging Area with some kind of metaphor so that it seems friendly or, I suspect, out of some subconscious wish to actually obscure it from Subversion converts so that git seems more familiar–more like SVN, which it is not very much like at all. I'm not going to really talk about it much. When we get to the commands that affect it (shortly, here), I'll explain what they do. You can make the abstraction your self.</p>
<p>I'm intentionally writing this off the top of my head for two reasons: If I have to look up a command, then you might as well read whatever tutorial I looked it up on and if I have to look it up, then I clearly don't use it all the time and thus, you don't need to know it to get going on Git.</p>
<h2>The Tutorial</h2>
<p>I've got six sections to this thing with (I hope) at least vaguely descriptive names. They are:
<ol>
<li>Setup</li>
<li>Initial Commit</li>
<li>SitRep</li>
<li> Staging Area</li>
<li> Remote Repo</li>
<li>Conclusion/Links</li>
</ol></p>
<h3>Setup</h3>
<p>You have a project you just started in a directory called 'notes'. This isn't even code, it's just notes about something that you want to version control and back up. It's a collection of text files and the directory structure is something like this.</p>
<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>$ pwd
</span><span class='line'>~/notes/
</span><span class='line'>$ ls
</span><span class='line'>contact_info.txt general.txt outline.txt</span></code></pre></td></tr></table></div></figure>
<p>After <a href="http://git-scm.com/download/">installing git</a> as appropriate for your operating system, you start out by typing in the command line <code>git init</code>. This will create a directory called <code>.git</code> in <code>notes/</code>. There's some stuff in there, but for the most part, you can ignore this for now. Suffice to say it's where git does it's book-keeping. What you've got now is a local git repository or, as the kids say, a "local repo", but nothing's in it.</p>
<h3>Initial Commit</h3>
<p>So you do a <code>git add .</code> (note the trailing period). This will toss everything (that's what the period means) in <code>notes/</code> into the staging area (including stuff that's in directories that're in directories that're in <code>notes/</code> etc.). The repo is still empty. To actual save stuff once it's been staged, you do like this:</p>
<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>$ git commit -m 'Initial commit.'
</span><span class='line'>[master (root-commit)]: created 7db8343: "Initial commit."
</span><span class='line'>0 files changed, 0 insertions(+), 0 deletions(-)
</span><span class='line'>create mode 100644 contact_info.txt
</span><span class='line'>create mode 100644 general.txt
</span><span class='line'>create mode 100644 outline.txt</span></code></pre></td></tr></table></div></figure>
<p>The <code>-m</code> option says you're going to specify your commit message right after. Sometimes, you'll want to leave a longer message, in which case, you forget the <code>-m</code> and git will automatically fire up a default text editor where you can put in longer stuff. Since a lot of that varies widely from OS to OS, I'm going to skip it and you can read more details on other tutorials (see below). Notice that you get a list of what's changed (you created 3 new files in the repo) and you get your comment back in the output. Splendid.</p>
<h3>SitRep</h3>
<p>Now you've made your initial commit, and your stuff is in version control. Go into <code>contact_info.txt</code> and add something (doesn't matter what for these purposes). Imagine you've made that change and then walked away and forgotten about it. You can use <code>git status</code> to see what's new, thusly:</p>
<figure class='code'><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
</pre></td><td class='code'><pre><code class=''><span class='line'>$ git status
</span><span class='line'># On branch master
</span><span class='line'># Changed but not updated:
</span><span class='line'># (use "git add <file>..." to update what will be committed)
</span><span class='line'># (use "git checkout -- <file>..." to discard changes in working directory)
</span><span class='line'>#
</span><span class='line'># modified: contact_info.txt
</span><span class='line'>#
</span><span class='line'>no changes added to commit (use "git add" and/or "git commit -a")</span></code></pre></td></tr></table></div></figure>
<p>Using <code>git status</code> is just like a reminder. It doesn't tell you much, but it can jog your memory about what you've already staged or what you changed and didn't stage or what files you added. To get the real scoop about how a file changed, you use <code>git diff</code>. When you run <code>git diff contact_info.txt</code> the output will vary depending on what you had initially and what you added, but the gist is this: It will show you the changes (all of them) with a + before the line for additions and a - before the line for deletions. Generally, it gives a few lines before and after a change for context.</p>
<p>So let's add our new <code>contact_info</code> change to the staging area and commit it, yeah? Do <code>git add contact_info.txt</code> and then <code>git commit -m 'Updated contact info'</code> or similar. Whatever comment you write is fine. Note we could've used <code>git add .</code> but I wanted to show the single-file syntax.</p>
<h3>Staging Area</h3>
<p>Now let's put in some stuff into the <code>outline.txt</code>. Whatever you want. Just some stuff. Save it. But wait! We should also add some stuff to the general notes, just a quick overview at least, so put some stuff in there. We'll finish the outline changes in a second. This is so much more pressing. Obviously.</p>
<p>Now, it's good repo etiquette to only commit stuff atomically, which is to say that all the changes have to do with each other. Some people will say that you should only commit stuff that works (code compiles or whatever), but with git that's less of a concern. I'll come back to this point. What I'm getting at now is that you started one change and realized another needed to be made before you finished the first one. Now you want to commit only the second one, right? Simple: <code>git add general.txt</code> then <code>git commit -m 'Added overview'</code>. Because you never staged the outline (with your half-way-made changes), it doesn't get committed. Later, if you need to revert that commit or whatever, you won't have to worry that something else is mixed in there. Now, go ahead and finish your outline changes, and commit them. You should be able to do it on your own now.</p>
<h3>Remote Repo</h3>
<p>So, then… we're version controlling this stuff. What if you want to get at it from another computer or let someone else get at it or… something? Pop on over to <a href="http://github.com/">Git Hub</a> which is my remote repo host of choice. There are others. Shop around, if you like. After you create an account, you can <a href="https://github.com/repositories/new">create a new remote repo</a> called whatever you want. You'll then be shown a page with some directions. Follow the ones under the heading "Existing Git Repo?"</p>
<p>The <code>git remote add origin git@github.com:<username>/<project>.git</code> command basically tells git where your remote repo is. You can have more than one if you like and, actually, do all sorts of crazy things with naming if you like, but I just want to handle the default, assumed case with this tutorial. One interesting thing: Github gives you two addresses for each repository (other hosts may do the same, I don't know). The one that starts <code>git@github.com</code> is your read/write address and there's one that starts <code>git://github.com</code> which is your read-only address. Since this is your own repo, you want to make sure to use the read/write address.</p>
<p>The <code>git push origin master</code> command is what actually moves your commits to the remote repo. <em>This</em> is where I recommend you adhere to the "only stuff that works" doctrine. If this is code, and you're sharing the repo with your team or whatever, this is where they can get at it, so you don't want to hand them broken stuff or half-finished ideas or whatever. So only <strong>push</strong> code that compiles/works. Pushing your code updates the remote repo with all the commits you've made since your last push.</p>
<p>The way you (or someone else) gets commits out of a repo is by using <code>git pull</code>. It takes the same arguments as <code>git push</code>. It will pull the commits down and then try to reconcile those changes with any that you've made since the last time your local repo was in the same state as the remote repo.</p>
<h3>Conclusion/Links</h3>
<p>I feel like this has gotten pretty long and I don't want to put too much information all at once. That should be enough to get you started and, really, just try it out for a while and get comfortable with the basics. Don't be afraid, if you get something out of whack and realize you've done something wrong, to kill your .git directory (which will delete the local repo) and start again from the top. I've intentionally left a lot of stuff out (like push/pull and branches and multiple remote repos can get kind of hairy), so here's some documentation, blog posts and articles that I've found helpful. These are in no particular order and some are more advanced than others, so just start clicking and see what you like:</p>
<ul>
<li><a href="http://github.com/guides/home">Github’s Guides page</a></li>
<li><a href="http://git-scm.com/">The Git Homepage</a></li>
<li><a href="http://www-cs-students.stanford.edu/~blynn/gitmagic/">Git Magic</a> (a huge work)</li>
<li>Using Git Without Feeling Stupid <a href="http://smalltalk.gnu.org/blog/bonzinip/using-git-without-feeling-stupid-part-1">part 1</a> and <a href="http://smalltalk.gnu.org/blog/bonzinip/using-git-without-feeling-stupid-part-2">part 2</a></li>
<li><a href="http://stackoverflow.com/questions/315911/git-for-beginners-the-definitive-practical-guide">Awesome StackOverflow page</a></li>
<li><a href="http://cheat.errtheblog.com/s/git">$ cheat git</a></li>
<li><a href="http://www.eecs.harvard.edu/~cduan/technical/git/">Understanding Git Conceptually</a></li>
<li><a href="http://eagain.net/articles/git-for-computer-scientists/">Git for Computer Scientists</a> (highly technical and abstract)</li>
<li><a href="http://whygitisbetterthanx.com/">Why Git is Better Than X</a> (Not only evangelical, but some helpful stuff)</li>
<li><a href="http://learn.github.com/">Github’s Learn page</a></li>
</ul>
<p>If you want to ask me about git or whatever, feel free to email me or leave something in the comments. Also, if you spot a mistake or something here doesn't make sense, <em>please</em> let me know. Hope this is helpful to someone.</p>
</div>
</article>
<article>
<header>
<h1 class="entry-title"><a href="/2009/02/12/version-control-your-computer/">Version Control Your Computer</a></h1>
<p class="meta">
<time datetime="2009-02-12T00:00:00-06:00" pubdate data-updated="true">Feb 12<span>th</span>, 2009</time>
</p>
</header>
<div class="entry-content"><p>I've mentioned @<a href="http://twitter.com/carl_youngblood">carl_youngblood</a> here before. Someone once was trying to buy him something with his name on it. I think it was a key chain. You know the kind, right? However, then didn't have "Carl" only "Carlos". So we joked that, one day, he needs to write an operating system and name it CarlOS. Aren't we funny? I know. I'm sorry. Anyway, the other day, we actually got into some OS discussion that I thought had some interesting enough ideas to post here.</p>
<p>So how many computers do you own and use? I've got a desktop at home, a laptop and a machine at work. It's sort of a bummer to have different stuff or different versions of stuff, or stuff with different preferences on different computers. At least, for me it can really jack up my work flow. Especially if there is some application I use a lot with non-default preferences. Man, that bugs me! Remembering it all, bleh.</p>
<p>One thing Carl's fantasized about is having a computing environment the same everywhere you go. That's sort of a mainframe or dumb-workstation idea, which is not new at all. However, what if your whole computer were version controlled? You could branch it (so you don't have your work apps at home, etc.) and merge changes from one branch to another, if you wanted. You could check out a different branch on one machine and it would feel like you were on another.</p>
<p>Clearly an OS would have to be built from the ground up for this idea. You'd also have to have some kind of provision about storing the non-checked out branches locally. Also cloning the repo would be a hassle at current average (even high speed) connection speeds. But how cool would it be to install, say, Textmate at work and get all your settings right, etc. and then go home and merge that change in (You could merge it from work, I guess and then just pull from home. Whatever.)? You could get diff data (hard to implement, but with metadat not impossible):</p>
<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
</pre></td><td class='code'><pre><code class='diff'><span class='line'>$ os diff gaming HEAD
</span><span class='line'><span class="gi">+ Steam</span>
</span><span class='line'><span class="gi">+ Half-Life 2</span>
</span><span class='line'><span class="gi">+ X-Fire</span>
</span><span class='line'><span class="gd">- Textmate</span>
</span></code></pre></td></tr></table></div></figure>
<p>Or whatever. You get the idea. Reverting would making backing up and creating, uh… what does Windows call them? Recovery Points? It would make all that easy and moot. Clearly Linus Torvalds needs to be in on this "project"; he has the experience in both OS design and version controlling that would be invaluable. Not that, you know, Carl or I are actually considering doing anything with this idea. It's an interesting thought experiment, though.</p>
</div>
</article>
<article>
<header>
<h1 class="entry-title"><a href="/2009/02/10/my-twitter-project-atreply/">My Twitter Project: Atreply</a></h1>
<p class="meta">
<time datetime="2009-02-10T00:00:00-06:00" pubdate data-updated="true">Feb 10<span>th</span>, 2009</time>
</p>
</header>
<div class="entry-content"><p>I use <a href="http://twitterfox.net/">Twitterfox</a> to read and create tweets most of the time. I follow enough people that, when I open my browser for the first time for the day, more than 20 tweets have accumulated and, really, I don't want to go back and read all 60-odd or whatever that have accumulated overnight. Twenty, I should note, is just what Twitterfox picks up when it first turns on.</p>
<p>Occasionally, I'll come in and see the last few tweets in a conversation between two people I'm following (I only see @replies by others who are to people I'm also following). If it seems interesting enough, I'll go back and page through to see what they were talking about, reading in reverse order. Sort of like reading a chat log written by the guys that made <a href="http://www.imdb.com/title/tt0209144/">Memento</a>. It's not horrible, but neither is it ideal.</p>
<p>So I had an idea about it and I've started work. Twitter tracks what tweet (technically called a "Twitter status", apparently) any given tweet was a reply to. And, I figured, it would be relatively simple to, given a Twitter status ID, recursively follow the reply chain back and get the whole conversation. Turns out, I was right.</p>
<p>A proof of concept:</p>
<figure class='code'><figcaption><span></span></figcaption><div class="highlight"><table><tr><td class="gutter"><pre class="line-numbers"><span class='line-number'>1</span>
<span class='line-number'>2</span>
<span class='line-number'>3</span>
<span class='line-number'>4</span>
<span class='line-number'>5</span>
<span class='line-number'>6</span>
<span class='line-number'>7</span>
<span class='line-number'>8</span>
<span class='line-number'>9</span>
<span class='line-number'>10</span>
<span class='line-number'>11</span>
<span class='line-number'>12</span>
<span class='line-number'>13</span>
<span class='line-number'>14</span>
<span class='line-number'>15</span>
<span class='line-number'>16</span>
<span class='line-number'>17</span>
<span class='line-number'>18</span>
<span class='line-number'>19</span>
<span class='line-number'>20</span>
<span class='line-number'>21</span>
<span class='line-number'>22</span>
<span class='line-number'>23</span>
<span class='line-number'>24</span>
<span class='line-number'>25</span>
<span class='line-number'>26</span>
<span class='line-number'>27</span>
<span class='line-number'>28</span>
<span class='line-number'>29</span>
<span class='line-number'>30</span>
<span class='line-number'>31</span>
<span class='line-number'>32</span>
<span class='line-number'>33</span>
<span class='line-number'>34</span>
</pre></td><td class='code'><pre><code class='ruby'><span class='line'><span class="nb">require</span> <span class="s1">'rubygems'</span>
</span><span class='line'><span class="nb">require</span> <span class="s1">'twitter'</span>
</span><span class='line'>
</span><span class='line'><span class="k">class</span> <span class="nc">Reply</span>
</span><span class='line'> <span class="kp">attr_accessor</span> <span class="ss">:text</span><span class="p">,</span> <span class="ss">:author</span><span class="p">,</span> <span class="ss">:in_reply_to</span><span class="p">,</span> <span class="ss">:time</span><span class="p">,</span> <span class="ss">:atreply</span>
</span><span class='line'>
</span><span class='line'> <span class="k">def</span> <span class="nf">initialize</span> <span class="n">status_id</span>
</span><span class='line'> <span class="n">status</span> <span class="o">=</span> <span class="ss">Twitter</span><span class="p">:</span><span class="ss">:Client</span><span class="o">.</span><span class="n">new</span><span class="o">.</span><span class="n">status</span> <span class="ss">:get</span><span class="p">,</span> <span class="n">status_id</span>
</span><span class='line'>
</span><span class='line'> <span class="nb">self</span><span class="o">.</span><span class="n">text</span> <span class="o">=</span> <span class="n">status</span><span class="o">.</span><span class="n">text</span>
</span><span class='line'> <span class="nb">self</span><span class="o">.</span><span class="n">author</span> <span class="o">=</span> <span class="k">if</span> <span class="n">status</span><span class="o">.</span><span class="n">user</span><span class="o">.</span><span class="n">name</span> <span class="k">then</span> <span class="n">status</span><span class="o">.</span><span class="n">user</span><span class="o">.</span><span class="n">name</span> <span class="k">else</span> <span class="n">status</span><span class="o">.</span><span class="n">user</span><span class="o">.</span><span class="n">screen_name</span> <span class="k">end</span>
</span><span class='line'> <span class="nb">self</span><span class="o">.</span><span class="n">time</span> <span class="o">=</span> <span class="n">status</span><span class="o">.</span><span class="n">created_at</span>
</span><span class='line'> <span class="nb">self</span><span class="o">.</span><span class="n">in_reply_to</span> <span class="o">=</span> <span class="n">status</span><span class="o">.</span><span class="n">in_reply_to_status_id</span>
</span><span class='line'> <span class="nb">self</span><span class="o">.</span><span class="n">atreply</span> <span class="o">=</span> <span class="no">Reply</span><span class="o">.</span><span class="n">new</span> <span class="nb">self</span><span class="o">.</span><span class="n">in_reply_to</span> <span class="k">unless</span> <span class="nb">self</span><span class="o">.</span><span class="n">in_reply_to</span><span class="o">.</span><span class="n">nil?</span>
</span><span class='line'> <span class="k">end</span>
</span><span class='line'>
</span><span class='line'> <span class="k">def</span> <span class="nf">each_reply</span> <span class="o">&</span><span class="n">amp</span><span class="p">;</span><span class="n">block</span>
</span><span class='line'> <span class="n">reply_chain</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">reply</span><span class="o">|</span>
</span><span class='line'> <span class="k">yield</span> <span class="n">reply</span>
</span><span class='line'> <span class="k">end</span>
</span><span class='line'> <span class="k">end</span>
</span><span class='line'>
</span><span class='line'> <span class="k">def</span> <span class="nf">to_s</span>
</span><span class='line'> <span class="nb">self</span><span class="o">.</span><span class="n">author</span> <span class="o">+</span> <span class="s1">' - '</span> <span class="o">+</span> <span class="nb">self</span><span class="o">.</span><span class="n">time</span><span class="o">.</span><span class="n">to_s</span> <span class="o">+</span> <span class="s2">"</span><span class="se">\n</span><span class="s2">"</span> <span class="o">+</span> <span class="nb">self</span><span class="o">.</span><span class="n">text</span>
</span><span class='line'> <span class="k">end</span>
</span><span class='line'>
</span><span class='line'> <span class="kp">protected</span>
</span><span class='line'>
</span><span class='line'> <span class="k">def</span> <span class="nf">reply_chain</span>
</span><span class='line'> <span class="k">return</span> <span class="o">[</span><span class="nb">self</span><span class="o">]</span> <span class="k">unless</span> <span class="nb">self</span><span class="o">.</span><span class="n">atreply</span>
</span><span class='line'>
</span><span class='line'> <span class="nb">self</span><span class="o">.</span><span class="n">atreply</span><span class="o">.</span><span class="n">reply_chain</span> <span class="o">&</span><span class="n">lt</span><span class="p">;</span><span class="o">&</span><span class="n">lt</span><span class="p">;</span> <span class="nb">self</span>
</span><span class='line'> <span class="k">end</span>
</span><span class='line'><span class="k">end</span>
</span></code></pre></td></tr></table></div></figure>
<p>This has a dependency on <a href="http://github.com/joshuamiller/twitter4r/tree/master">Joshuamiller's version of twitter4r</a>. My medium-term plan is to make a one-trick-website that will take an ID or twitter URL and give you the replies all pretty-like. Maybe make a bookmarklet for convenience's sake. I plan on using Rails, even though that's overkill because I figure it'll be a good learning experience on that front. Find it on <a href="http://github.com/BenHamill/atreply/tree/master">Github</a>.</p>
</div>
</article>
<article>
<header>
<h1 class="entry-title"><a href="/2009/01/09/save-versus-github/">Save Versus GitHub!</a></h1>
<p class="meta">
<time datetime="2009-01-09T00:00:00-06:00" pubdate data-updated="true">Jan 9<span>th</span>, 2009</time>
</p>
</header>
<div class="entry-content"><p>I'm reaching a point where I want everything in my life to be version controlled. I made a desktop making fun of my friend in the GIMP the other day and realized that I wanted it version controlled. I don't think Git will handle .xcf's. Pity, though.</p>
<p>My most recent action on this front doesn't actually have to do with Dungeons & Dragons, but that's only because my system of choice is GURPS. I game master role playing games as a hobby and keeping track of campaign ideas has, in the past, been very disorganized and messy. I had scraps of paper all over and various emails to myself. If I have some brilliant idea at work, I can't just incorporate it into my notes or whatever, I'd have to email it to myself and then hope it was clear enough to remember what the actual idea was later, etc. If I was on the bus, I had my laptop (which I use to assist in GMing) and I could put it right into the notes, but recently I had some major stability issues with that machine and so became concerned about backups, etc.</p>
<p>Thus, I <a href="http://twitter.com/benhamill/status/1090481503">had an idea</a>. I've converted the essentials from my current campaign and put them in a repo and I'm working on notes for my next campaign there. There are several benefits, here:</p>
<p>The first is that before, I was using OpenOffice documents for my notes. This allowed for some pretty formatting, but when I had my timeline open, my NPC list, my session notes and my location notes all open, well… Open Office isn't a lean program and my lappy isn't the beefiest of machines. So now everything is a .txt and that's super lean. Yay. I'm aware, by the way, that this is very tangentially related to version controlling my notes, but still.</p>
<p>Secondly, I can check out a copy on any machine I'm sitting at when I have an idea. Or, if I really want to, I can edit them right on GitHub. Neat. As a sort of corollary to this is the fact that if my lappy were to get dropped, say, off a mountain, I could borrow anyone else's laptop and be ready to roll in about 20 minutes as long as I had internet access.</p>
<p>Thirdly, since I'm using git as opposed to, say, SVN, I don't <strong>have</strong> to have internet access. Local repos means I can make a commit on my laptop while on the bus and then push when I get home. Very handy since I do a lot of my thinking about campaigns on the bus.</p>
<p>Fourthly (this list is getting longer than I thought it would), is character data. So there is a piece of software that you can buy to help you create and track GURPS characters (whether non-player character or player character). Handily, it saves them in plaintext (I think it's actually .Net code or something unhelpful, not YAML or XML or similar, but nothing's perfect), so I can version control the characters, too, not just notes.</p>
<p>Fifthly (good grief), a friend of mine and sort of my GM mentor moved away and doesn't have a gaming group. In order to get his fix, he's convinced me (for the good and the bad of it) to let him help me plan and brainstorm my next campaign. He can check out a copy, branch it, issue a pull request (or I'll give him push access, not sure). Collaborative GMing is something that often can go wrong, but this tool, teamed up with some other guidelines we've adopted will help ensure that we get only the benefits out of this.</p>
<p>About the only things that I'd use for a campaign that it won't version control are pictures and sound files, but I don't expect to do a lot of changing of those over the course of things and, any way, it <strong>will</strong> save them, so it at least acts as a backup. While we're talking about negatives… My players could snoop the notes. Oh noes! In reality, I'll have to just trust them to stay out. They'd only be ruining their own fun, anyway.</p>
<p>So, a sixth, I guess, benefit is that I can share my notes with the world and if someone else sees something cool they want to steal or sees something sucky that they can do better then I've inspired them or at least helped them out a bit. If you like (and aren't one of my players), feel free to <a href="https://github.com/BenHamill/rpg-notes/tree">check it out</a>. If you have questions about anything in there, feel free to shoot me an email. I make no promises that anything in there will be better than total suck.</p>
</div>
</article>
<article>
<header>
<h1 class="entry-title"><a href="/2008/12/23/otherinbox-is-for-email-from-computers/">OtherInbox Is for Email From Computers</a></h1>
<p class="meta">
<time datetime="2008-12-23T00:00:00-06:00" pubdate data-updated="true">Dec 23<span>rd</span>, 2008</time>
</p>
</header>
<div class="entry-content"><p>So I use this great thing called <a href="http://otherinbox.com">OtherInbox</a>. They're in closed beta just now, but if you <a href="http://twitter.com/otherinbox">follow them on Twitter</a> you're likely to see when they hand out another round of invites (which they recently tweeted would be coming early in January, if I remember right). Let me tell you a bit about OI before I go into my rant. Hopefully it will segue nicely.</p>
<p>OtherInbox is an email, uh… application. Like Gmail or Hotmail, sort of. When you sign up for OI, though, you don't get <em>username</em>@otherinbox.com, you get a whole subdomain and infinite email addresses at it. So, <em>whateveryouwant</em>@<em>username</em>.otherinbox.com. Then, when you login to your account, you're presented with folders based on the email address that the email came to. It's sort of like filters in other email clients, except you don't have to set them up, you just hand out a new email address. So if I sign up for a new site, I hand it <em>sitename</em>@<em>username</em>.otherinbox.com and when they send me email, it automatically goes to a folder in my OI named after that site. So I have an Amazon folder and a Twitter folder, etc. etc.</p>
<p>You can also have a vanity URL and edit your MX records on the host so that email gets routed to OI's servers, so that you don't have to use the long <em>username</em>.otherinbox.com in your emails. So I have benhamill.com set up that way. Very, very nice feature, that.</p>
<p>Okay, so why might you want this service? Well, spam, firstly. If I've only ever given a certain email address away to amazon.com and I start getting spam to that address, I know who the culprit is. Also, if I want to sign up for something that I expect to get spam from, I can do so without fear. After getting that confirmation email, I can just hit the "Block All" button and OI will just not show me those messages. I don't have to worry about it ever again.</p>
<p>Another use case which I'm loving is when you sign up for what's called bacn; stuff you want, but not, you know, right now. I use OI to sign up for email lists and such that I don't want cluttering up my inbox. Stuff I might want to read, but over the weekend or whatever; stuff that's not time-sensitive.</p>
<p>Which leads me to my rant. If you're not an OtherInbox user, the following might not make a lot of sense, so you might want to skip it until you are. And I highly recommend you become one. I found that the more I used it, the more I liked it. So, rant on…</p>
<p>OtherInbox is <strong>not your primary inbox</strong>. It's right there in the name. I was confused about this at first, too, but it should be obvious. You don't ditch gmail for OI. You use them both. How you divide it up is something people do differently, but here's my rule of thumb: If it is sent by a computer (as opposed to a human), it goes to OI. What this does (ideally, since I haven't finished converting all my accounts over to OI addresses) is makes it such that the only emails that show up in my gmail account are ones that are actually to me.</p>
<p>I mean–how many emails do you get from computers? If you're like me then a lot. I get email every time someone follows me on Twitter and every time someone sends me a message in my online Diplomacy game and every month when Rock Band sends out their "zine". Why not have a computer help me deal with it all? It's not going to read it for me, of course, but it <em>will</em> help me process them. If I know I ordered something from Amazon, then I will look at new emails to my amazon address when they show up. Otherwise, I'll probably ignore it.</p>
<p>However, OI is pretty bad at displaying conversations. I mean–that's not a fault, that's not part of their core mission. They've been talking about adding a feature like that since it makes sense for mailing lists, but for personal email, gmail is still king. Tags and search and conversation view, etc. That's what gmail is good at. OI is good at sorting spam and bacn.</p>
<p>People who talk about having their friends each email an OI address based on their name just confuse me. Your friends aren't going to sell your email address to spammers or send you stuff you don't want to read (or, if they are, get new friends… elderly relatives, on the other hand, who will send you random jokes might warrant an OI address), so there's no need to hide you <em>real</em> email address. If you want, you can set up auto-forwarding for an OI address, but just hand that out to real people like you would your real address.</p>
<p>It can get sort of heady, making up any old address to give to people, but if you're handing out OI addresses to real people, you're sort of defeating the purpose of OtherInbox. Either you're using OI's interface, which is optimized for dealing with emails en mass, or you're having to set up a bunch of auto-forwards to your primary inbox (with the nice interface for dealing with individual emails). OI is supposed to make it so you <em>don't</em> have to set up filters or auto-forwards all the time.</p>
<p>I really love OtherInbox. If you're not a user (and you didn't skip the rant), really go follow them on Twitter and get an invite code. Or find someone who's in the beta now and see if they have any invites left (I have a single one as of this writing). I didn't think I was really an awesome candidate for an OI user, but that's only because I didn't realize how much email I get from computers. It's really freeing to be able to click "Yes, send me updates" on everything. If you never get anything from them that's worth your time, you never waste any time on it. Throwing away that email address it completely trivial. The real trick to having OtherInbox improve your life is not swimming against the stream, though. So remember my rant when you sign up.</p>
</div>
</article>
<div class="pagination">
<a class="prev" href="/page/4/">← Older</a>
<a href="/blog/archives">Blog Archives</a>
<a class="next" href="/page/2/">Newer →</a>
</div>
</div>
<aside class="sidebar">
<section>
<h1>About Me</h1>
<div id="twitter-profile">
<div id="author-card">
<img src="http://www.gravatar.com/avatar/4938b4569f1366168b705ce9c774ea5e" alt="Gravatar of Ben Hamill " title="Gravatar of Ben Hamill" />
<p id="name">Ben Hamill</p>
<p id="handle">@<a href="http://twitter.com/benhamill">benhamill</a></p>
<p id="liame">
<span id="obf"><script>document.getElementById("obf").innerHTML="<n uers=\"znvygb:ora@oraunzvyy.pbz\" gnetrg=\"_oynax\">ora@oraunzvyy.pbz</n>".replace(/[a-zA-Z]/g,function(c){return String.fromCharCode((c<="Z"?90:122)>=(c=c.charCodeAt(0)+13)?c:c-26);});</script>
<noscript><span style="unicode-bidi:bidi-override;direction:rtl;">moc.llimahneb@neb</span></noscript></span>
</p>
</div>
<p>Rubyist, hacker, gamer (video, board, role-playing), fanboy (Linux, git, vim, Firefly, Dr Pepper), language pedant. Nerd.</p>
</div>
</section>
<section>
<h1>Recent Posts</h1>
<ul id="recent_posts">
<li class="post">
<a href="/2012/08/31/lol-civil-liberties/">LOL Civil Liberties</a>
</li>
<li class="post">
<a href="/2012/02/03/install-ruby-enterprise-edition-with-ruby-install-on-arch-linux/">Install Ruby Enterprise Edition With ruby-build On Arch Linux</a>
</li>
<li class="post">
<a href="/2012/01/19/changems/">Changems</a>
</li>
<li class="post">
<a href="/2012/01/04/the-parameter-object-pattern/">The Parameter Object Pattern</a>
</li>
<li class="post">
<a href="/2011/08/25/a-smarter-has_many-through/">A Smarter has_many :through?</a>
</li>
</ul>
</section>
<section>
<h1>GitHub Repos</h1>
<ul id="gh_repos">
<li class="loading">Status updating…</li>
</ul>
<a href="https://github.com/benhamill">@benhamill</a> on GitHub
<script type="text/javascript">
$(document).ready(function(){
if (!window.jXHR){
var jxhr = document.createElement('script');
jxhr.type = 'text/javascript';
jxhr.src = '/javascripts/libs/jXHR.js';
var s = document.getElementsByTagName('script')[0];
s.parentNode.insertBefore(jxhr, s);
}
github.showRepos({
user: 'benhamill',
count: 5,
skip_forks: true,
target: '#gh_repos'
});
});
</script>
<script src="/javascripts/github.js" type="text/javascript"> </script>
</section>
</aside>
</div>
</div>
</div>
<footer role="contentinfo"><p>
Copyright © 2013 - Ben Hamill -
<span class="credit">Powered by <a href="http://octopress.org">Octopress</a></span>
</p>
</footer>
<script type="text/javascript">
(function(){
var twitterWidgets = document.createElement('script');
twitterWidgets.type = 'text/javascript';
twitterWidgets.async = true;
twitterWidgets.src = 'http://platform.twitter.com/widgets.js';
document.getElementsByTagName('head')[0].appendChild(twitterWidgets);
})();
</script>
</body>
</html>