First off, if you haven’t yet enabled the System Monitor, just right-click on your Panel and you should see it on the list. (Othewise: apt-get install gnome-system-monitor first)

By default the colors are all pretty similar. The first important tweak is to differentiate the Processor colors. Use whatever you want, but make sure they have enough contrast. (Not shown: I just fixed my green User color to contrast a little better.) Watching the Processor usage can show you a bit about the sites you spend time on (among several other things). If you’ve got a constant green bar (hmm, that sounds backwards to TDDers; maybe I should stay away from green), you might want to hunt down the tab hosting the unruly flash widget. Ideally, your system at rest should most often show a beautiful black box.

The second tweak I just made recently — and it’s growing on me — is to make outgoing network traffic red, and incoming yellow. Now I can see my backups to S3 in full swing when they kick in. And I might notice if anything is unexpectedly drifting outbound.

I also recently added the fourth Swap Space indicator just in case it ever kicks in, at which point I’ll know something is really awry. This one is probably not too important to have showing if you’re shy on Panel space.

Great! Now I can watch Firefox and a Mongrel take off with all my memory and know when to kill them. The monitor is also handy to see when something you’ve been running is (too often unexpectedly) finished. (I like using beep at the end of a long command for this too.)

I do still use top on occasion for its light weight. But sometimes it’s a bit more convenient to have a one-click GUI view of your system. Please share if you’ve got a more effective color scheme or if you use another light-weight tool for continuous monitoring.

Geo Services

There’s no lack of geo-aware tools out there: fireeagle, brightkite, latitude, shizzow, foursquare, loopt, more I don’t remember trying and tossing, and I’m sure a bunch more I’ve never heard of. I tried most of them just this year, as most are pretty new.  But they generally lack users, at least compared to Twitter, who’s new to the geo game. Just try importing your friends from gmail, twitter, and facebook with some of these services, and you’ll see what I mean. Latitude will be interesting to watch — given android’s impending ubiquity — but Google’s may be too big to be the real innovator in this space (despite all their leverage).

Mobility

I wonder where we’re going with mobility.  I gather that the majority of Twits are still using non-browser-based Twitter Desktop Clients (TDCs).  Maybe the sea-change to smartphones is underway.  But I’m not sure. Granted, this luddite got a MyTouch a few months ago, and I’ve got latitude and foursquare (and other random android apps crashing my phone) constantly sending my location around (after giving up on brightkite and shizzow clients).  But I know a lot of (predominantly AIR?) desktop apps are still overwhelmingly popular; they’re just lacking something…

The Problem With Desktop Geo-awareness

Quick background. Smartphones now have GPS, and it tends to be readily available (and now easy enough to turn off to save batteries) and incredibly accurate, often pinning you to the residence/office/coffee shop/place you shouldn’t be, you’re actually in. That constant information stream can really open some doors to innovation (e.g., geo-time-plot-animating your week). It’s the impetus for all those geo-services. Also, browsers like Firefox 3.5 can pinpoint you with similar accuracy with a little magic that I haven’t completely figured out.  It seems to have to do with IP lookup combined with unique MAC address locations and a nice relationship with Google who’s probably got MACs/SSIDs for most routers in your neighborhood. Probably collected while taking pictures of your street. So at least one bleeding-edge browser has it. Some others will figure it out too over the coming years.

But what about all those TDCs? When will they really become geo-aware? I tried out Python Twitter Tools today and it actually supported the geo-tag features just introduced into the Twitter API. I’m expecting it’s one of the few language libs with support as of today.  It’s really simplistic and naturally adapts to API changes (for better or worse), unlike the de facto python-twitter whose recent patches we’re insufficient and thus far ignored (by all but me?). So pretending to be a TDC I wanted to figure out how to send accurate geo-info alongside a tweet.

The TDC scenario is that we have no GPS and we’re outside a browser. That leaves us with a local IP address, like 192.168.1.X, and some mapping APIs. You can determine your un-NAT-ed IP most easily with somthing like:

curl www.whatismyip.com/automation/n09230945.asp

Then you can make use of GeoIP, which (along with its database) is installable via apt-get and some path-tweaking (or a bunch of other commercial offerings) to determine your approximate location, for widely varying degrees of approximate. I understand this approach can be way off outside the US, and my testing shows it’s not too great here either — something like “in the vicinity” 80% of the time.

For serious geo-tracking (illnesses, events, friends, advertising, etc) that’s usually not good enough. So I’m perplexed — what are all the TDCs going to do to make use of this compelling feature? Seriously, leave a comment if you’ve got some insights.

Redundant and Confusing

Since Day 1 Twitter has offered a “Location” field, to represent the city you live in (I guess). It’s been bastardized by various mobile clients to reflect a user’s current location.  Through the API a client can mess with a user’s profile to be constantly updating the Location field when she tweets. It apparently wasn’t designed to be used this way (or else why are they rolling out this shiny coord-only geo stuff?), but it has worked. In fact it works just about as well as the new-geo-facilities. But now we have two ways to do it.

The difference is that the new formal mechanism seems to enforce (or just encourage?) GeoRSS/GeoJSON (which have their own odd inconsistencies, like disagreeing on lat/lon and lon/lat). And it’s on a tweet-by-tweet basis, so the location is associated with the tweet itself; not the user (picture the schema). That’s really cool to be able to see where a user has been as he sends each tweet. But it would be a lot better IMHO if Twitter enabled geo updating without the tweets themselves (no, @devnull is not available for constant dumping of DMs with geo-coords). Then it might supplant any of the other new geo-services. I find it a little annoying to see floods of “I’m here!” tweets from the geo-aware-ati(?) I follow. So new-geo is for tweets, and I guess old-geo (Location field) is for users, and should be kept pretty static, maybe conventionally indicating where the user lives permanently.

I wish the intended uses of the fields had been made more clear. For now, I’m just hoping that the TDCs figure out how to get accurate geo-info, and start making use of new-geo. I’ll try to be tweeting from a mobile client like Twidroid that supports new-geo. And I’ll continue to let Latitude and FourSquare track me automatically, in hopes that their gathered data becomes useful. Eventually I hope to see a massive adoption of geo-aware clients so we can start to do real things with all that data (assuming we can continue to mine it en masse). I expect that Facebook will again be playing fast-follower once this really catches on.

Easiest way

Almost a decade ago the Happy Hacking keyboard came out.  This was a brilliant product that I can’t believe hasn’t altogether replaced the PC layout and monster keyboard footprint.  I’ve had a few through the years, and I highly recommend them.  They have been at the $70 mark all along though, so I’ve decided to stop buying them, when commodity keyboards are a dime a dozen, even the small footprinted ones.  I’ve also had the legendary OMNIKEY (and maintain it as a keepsake), which is hands down the best keyboard ever made (clickety-click-clack).  But they’re even pre-PS/2, so probably impossible to get working with USB (let me know if you’ve done it!).  So that’s the first and simplest solution if you’ve got the budget: spend the money to get a great UNIX keyboard.

Harder, cheaper way (still easy enough)

But you probably work at various machines, and everyone has a budget.  And sometimes we have to use that silly laptop keyboard.  So now you’re looking at a keyboard reconfig.  If you just want to make CapsLock go away (not a bad idea) and put Ctrl where it’s supposed to be (left of ‘A‘), you can use GNOME to swap them.  Something like: System -> Preferences -> Keyboard -> Layouts -> Other Options -> Ctrl Key Position -> Make CapsLock an additional Ctrl.  There’s also some swapping options, but overall the options there are pretty rigid and don’t get you all the way there.  So don’t bother with this approach, unless you only want to fix the Ctrl key.

What you really need is xkeycaps.  You can install it in a Debian-based system with apt-get install xkeycaps.  Other distros should also make it easy.  It’s not the most intuitive tool to use if you haven’t played with it before (that’s why I’m writing this), so I’ll walk you through what I did with it.  BTW, it’s an ancient tool, from the legendary hacker Jamie Zawinski.

Some keyboard layouts vary slightly from the 104-key standard, but I believe you can get any cheapo or absurd laptop layout to do the right thing with a little experimentation.  We’re going to be reassigning some keys.  It’s crucial that Esc is in a friendly spot — that probably means just left of your 1 key.  Even on a small keyboard with an Esc just one close row up, it’s still too far; you’ve gotta try putting it in the optimal spot.  But then you’ll be losing `~ (or something)!  What a dilemma!  You can’t code without those.  Some will disagree with me here, but I have found the RightAlt key to be a great, easily right-thumb-accessible, unused key, so that’s what I now use for `~.  RightAlt is a sad loss if you’ve got a crappy mouse (since RightAlt-LeftArrow have been the canonical browser back-button), but that may be the subject of another article.  Just get a 5-button or tilt-wheel mouse; recent Ubuntus do the right thing with the extra buttons, in my experience.  So we’ll proceed here to use RightAlt as the `~ replacement.  And we’ll be throwing away the original inaccessible Esc.  That top Function key row is off limits for touch-typists.

You can scramble a bunch of keys around as your see fit for your MO.  Here’s the process I used (as close as I can recall) for the Ctrl, Esc, `~ reassignments I’ve been describing:

• Fire it up from a terminal: xkeycaps
• Just say ‘ok’ on the first screen which should default to the right ‘PC’ layout.
• Hover over the Esc key and notice the KeySym at the top, indicating you’ve looking at Esc.  If you screw anything up, this is the place to see it.
• Move away and physically press Esc and watch it light up on the screen.  Now you can verify any key’s position, which you want to do for any changing keys.
• Make sure all the keys we care about are mapping to the right location.  I found that RightAlt on my wacky keyboard was actually mapping to my number pad’s Enter.  So figure out what your RightAlt is by pressing it.  That’s what we’ll reassign.
• Make the first reassignment.  Right-click-hold on `~ and select Duplicate key.  Then click on RightAlt (or its equivalent).  Now you’ve got another `~ key! (and you can probably figure out the rest).
• Now we can reassign the original `~ to be an Esc.
• Do the same Duplicate key trick to make the original Esc duplicated over `~.
• Finally, do that process one more time assigning the original Ctrl (crazy bottom-left postion) over the top of CapsLock.  Added bonus: no more CapsLock key (remedy that if you want).
• Write out the new layout with the Write Output button (just the Changed Keys is enough).
• Now you’ve got a new ~/.xmodmap-machinename file.  I believe it’s already been activated at this point, or at least xkeycaps has done some magic.
• You’re done.  You might find that some things are not working at this point.  You can always restart xkeycaps and restore to defaults.  But you’ve likely got things right, and just need to log out of X and log back in.  My arrow keys broke when I did this before restarting X.
• Every time you start up X you’ll need to run xmodmap ~/.xmodmap-machinename.  But Ubuntu (or something) actually automatically detected my new .xmodmap and prompted me to ask if I wanted to use it.  That was friendly!
• Use some white-out or tape to relabel your new keys. (optional)

Whew!  That was quite a few steps.  Fortunately, it’s just a one time setup, and subsequent uses of xmodmap at login are trivial (put it  in your .bash_profile or equivalent if not prompted; use $(uname -n) to make it flexible for a shared profile).  I hope you’ve got it working now.  You can leave a comment if you’re having any trouble with the steps and maybe I (or someone) will be able to figure it out.  Breathe a sigh of relief as you re-train your fingers to stop stretching.

I can no longer type without the hack described here.  You can probably alter it for any machine you’re on and any of your own different preferences.  I’m also considering making Ctrl-J a permanent duplicate for Enter.

I should also add a rant for why this article and tools need to exist: Shame on IBM and Microsoft and all the others involved for being such layout idiots and costing the world so much in ongoing CTS healthcare costs.  Especially when the optimal layout was already well-known and widely used.  Remind you of anything (backslash path separator, another ergonomic impropriety; plus countless others)?  It’s really interesting to just stare down at the PC location of Ctrl and Esc, two essential keys probably both in the top 5. They couldn’t possible have been put in less convenient places. Well, maybe they were just taking the QWERTY model of slowing down typists to the next level.  I’m surprised they didn’t think to move Shift up to F5 and Enter over to ScrollLock.

Be sure to thank Jamie for saving your wrist and adding years of screen time to your life.

* Furthermore, I make the typical assumption you’re using some *NIX variant.  Why else would you be here?  But if you’re using Windows or a Mac there are some other tools floating around that will help you customize your keyboard layout; I’m sure they’ll be different from xkeycaps.  Whether hacker or not, anyone can benefit by making these changes.

Why Learn a New Language?

You may disagree or have your own unrelated reasons, but addressing the why seems a necessary start for such a how post.  Here are the reasons I could think of:

1. You want to impress someone. Your present/future boss? Peers? Just padding your resume? This is not a very good reason. Maybe just stick with perl/C++/Java.
2. Pursue a new domain. E.g., I’m heading into R because it’s touted as the best for visualization and statistics, and even has some epidemiologic facilities I hope to make use of.
3. You want to expand your mind. Given your new learnings, you’ll be able to achieve better/faster results with your present favorite language. E.g., learning FP is sure to help you with many other languages.
4. You’re actually going to need to use the new language for real work. You need to work on some app written in it, or you think it will be the best tool for your next challenge.
5. Get connected to a new community. Maybe those relationships will lead to finding startup founders.
6. Have something new to write about. Not a great reason, but I suppose I’m guilty.
7. Feed the hype machine. Maybe you’ve just heard too much buzz about a language and have to know what everyone’s talking about.  This was why I explored Ruby!

There’s got to be more reasons.  What have been yours?

How Long Should it Take?

Depending on your background and the new language you’re targeting, you should plan to dedicate some significant time to learning it. This is ESR on his first run-in with Python:

Not that it took me very long to learn the feature set. I wrote a working, usable fetchmailconf, with GUI, in six working days, of which perhaps the equivalent of two days were spent learning Python itself.

Or you could side with Peter Norvig and devote 10 years to it:

…it takes about ten years to develop expertise in [a programming language].

Maybe Peter only knows perl*, in which case I’d heartily agree, and so would others. Personally, I think a typical competent programmer can pick up a well-designed language in a couple solid months of hands-on study, though this estimate may be off by a couple years.

How To Actually Learn It

We all have to learn a bunch of languages throughout our hacking careers. How do you go about picking up a new one? Get a book? Start hacking? Stare at some existing code? Those are all useful things to do, but I want to streamline the process and get to the best practices. Here’s the checklist I’ve come up with for effectively and efficiently learning a new programming language:

• Click around on the home site. Discover the documentation pages, FAQs, wiki, community, etc. You’ll be back here a lot.
• See what Wikipedia has to say about it. You should see some interesting history and learn about why it behaves and looks the way it does. Maybe you’ll even find something to add.
• Print out the Tutorial and work through it. Mark it up with colors. Type the snippets into your REPL. Change them.
• Read the FAQ. At least browse it so you know something about the common pitfalls.
  
• Read the style guide. If it doesn’t have one, figure out why.  Hopefully you can find editor settings that will enforce it.
• Get a book. Sometimes it takes a couple. With Perl you’ll need eight tomes, all of which will be witty, yet combinedly inconsistent. With Python you’ll need one. (some will argue which one that is, many are great).
• Avoid certain languages. If you can’t find a book that dedicates fewer than 100 pages to wholly describing the language core, then something is wrong with the language. C++ and perl are violators of this, and prime examples of languages to avoid in all capacities, at all costs. You will waste all your energy on learning and remembering their quirks, instead of focusing on problems to solve. I can’t believe some institutions (my undergrad!) have used these to teach OOP. I would go so far as to call their paradigm QOP, or “quirks-oriented programming”. (WOP — “warts-oriented programming” — isn’t undeservedly harsh, but maybe not PC.). They will damage your thinking process, waste years of your programming career, or destroy it altogether, and you will actually become less competent for having ingrained their quirks into your cognition.*
• Work through the examples in the book. Highlight and scribble all over it. If the book is more than 600 pages, then either the language is crufty or the book is poorly organized, and you might not want either.
• Start collecting miscellaneous pages from around the web and bookmark and tag them appropriately. Look for language luminaries that have created nice bookmark collections.
• Hang out on the IRC channel. That will be irc.freenode.net.  The traffic on some of these is overwhelming, but you can quickly get a feel for what are the tricky corners of the language.
• Find a local user group to meet people and get connected. You can even get a feel for the language by surveying the attendees. Watch for excessive drool! If a SIG doesn’t exist yet, then start one. If no one is interested in joining, move to a bigger town or find a new language, or try to associate with one online.
• Join the users (and announcements) mailing list. You’ll get to see lots of code written by others and see solutions to common problems.
• Watch some videos (Google tech talks) and slideshows.
• Play in the REPL. Get a better REPL if available (ipython). What, no REPL? Beanshell doesn’t count. Bye-bye, Java!
• Try the debugger. See if there are better ones.  Can you dive right into it from crashing code?
• Get the tool suite. Get familiar with the tools and understand why they’re necessary.
• Explore the vaults. Examples are Python’s PyPI (Cheeseshop), R’s CRAN, perl’s CPAN (though CPAN has similar issues to its books). Having extensive add-ons is a good language health indicator. Also note how difficult their packages are to install.
• Write a simple tool. That will season you in making use of important facilities. A good example is grep, which will exercise regexes, getopt (Erlang’s was hard to find), command line, strings, files, etc.
• Blog about your experience. Trying to describe your learnings to others will ensure that you understand what you’re talking about.  Do I?   Learn by teaching can be even more effective than learn by doing.
• Find the right interpreter/compiler. Some languages (Lisp) provide many.
• Install it, and its documentation.  apt-get install ... Not available in apt?  Then it’s too new, or you’re seriously bleeding edge, or it’s not viable.
• Figure out how to use the documentation systems. Manpages, info, –help, REPL-tab-completion, special tool (pydoc, Edoc, perldoc))
• Make sure your editor is equipped. What? it prescribes an IDE for you? Later, Smalltalk (Squeak)! Mess with your editor until it’s working as intended. Syntax highlighting, auto-completion, auto-indent, macros, etc.
• Learn a bit about its history. Why was the language created.  For what niche?  Are its strengths and weaknesses reflected in that history?
• Make sure it’s open. I shouldn”t go into this again, and I realize it’s a loaded statement, but I say avoid anything that doesn’t have an excessively open community and standards body around it.  I’m still teetering on the Flex (Adobe) fence, but anything that Microsoft has had its hands in developing is simply poisonous.
• Compare to a language you know.  What’s it most similar to?
• Take a class. This is often not necessary, but if you’ve got some college nearby they may offer something helpful.
• Get certified. Some languages have (silly) certifications.  The main benefit of them is that there is training material built around them that help you focus on what someone thinks are the important pieces of the language.  Doing this with Java helped my focus quite a bit (though I’ve since left the language behind).
• Watch/shadow a pro. This can be the absolute fastest way to see what to do, or what not to do.  Careful that you choose the right pro.
• Study the idioms and quirks. All languages have some quirks, even Python.  It’s best to know about them early.
• Find and explore a project source base that is known to be well-written. Dive into the code.  Try making some changes.

I’m not suggesting you need to do all these things for every language you explore.  This list could even serve as an evaluation for a new language you’re just considering.

Bonus: Go Deep

If you’d like to move on to the next prescribed level, here are some bonus activities:

• Find a bug in a library, and submit it to the BTS.
• Fix a bug and submit a patch.
• Understand how to mark up your code for document auto-generation.  Write a manpage/vignette.
• Check out the source using the VCS and build the compiler/interpreter yourself. If this is hard, you might consider if your apps to-be-written in this language can ever be deployed.  (Huge language bonus if they’ve got it together enough to be using a DVCS.)
• Try your app on multiple OSs. If you can get it to work on Linux, Mac, and Windows (at least Cygwin), you’re probably safe. Even a web app should have some portability since you never know what future co-developers might think they need to do.
• Start or join a real project.
• Make use of shared memory or message passing or whatever concurrency facilities are provided. Measure the quality of the language by how long it takes to figure out how to do robust parallel programming. Erlang takes a week. If it’s years, like most, you may want to move on, or read the next item.
• Integrate with another language, particularly C.  If this is impossible, it’s probably a showstopper.  Compare to Python and R as benchmark examples.

If you can’t accomplish all these things with the new language you’re considering, just move on to the next. There are plenty to try!

Note that these are all great things to do when getting started with a new language. However, you probably don’t want to be hanging out on IRC or mailing lists forever, or writing excessive posts about your fascinating new learnings, or reading too many books. I’ve fallen into all those traps.  The best advice I can give you (and myself) is to get those hands dirty!

What other things do you do to get comfortable with a new language?

* Notes: [1] Peter is actually pretty bright, and I was joking about perl. I sat on the floor right next to him last year at Startup School, without realizing who he was until he excused himself to give the next talk. [2] Wow, Stevey; that second glass certainly does get the juices flowing!

More concretely, it’s really easy for entrepreneurs — particularly developers — to fall into the trap of focusing on what their product does.  This gets reflected in presentations and messages, and ultimately in the shape of the product.  For example, in my case I could be saying that uGraph is a technology stack that does round-the-clock data mining, processing, and analytics to produce novel, real-time visualizations about health.  But that tells nothing about why the product is compelling to customers.  I’ve made that mistake, almost so blatantly.  The why message should be more like: Our product enables medical detectives to understand sickness so that they can detect and avoid it.  (That’s a bit simplistic, but at least the right emphasis.)  Focusing on the why seems pretty obvious now, right?  Wonder why nearly all of the recent 30 elevator pitches I’ve heard have been what-focused.  Maybe it’s not so obvious.

That brings up the next point: who.  As we started working through elevator pitches, we had some confusion about who our customers are.  For many at this stage it’s hard to exclude any potential markets.  But there needs to be a focus on a near-single customer; not the world at large.  Of course our technologies can be tailored or generalized for various markets.  It’s hard to throw out so many opportunities, but the bottom line is that we need to narrow in on a specific customer, or at least differentiate for disparate groups.  We still have a few potential markets since we’re still testing the waters, but now I’m simply lumping them all into a “medical detective” class, which I now define as Epidemiologists.  It turns out that a lot of types of end-users (news companies and sickos) would like to wear Amateur Epidemiologist hats, and we’ll target them too (though most may not even know what epidemiology is).  We are now building Epidemiological visualizations — that’s pretty specific.  This narrowing really helps to simplify my elevator pitch (which we’ll work more on next week), and really the grand vision (which may be different next week .

With that in mind, I’ll expand our who and why to: We provide tools the CDC uses to immediately see an illness spread and take necessary action, or what the news companies use to captivate their audience so they stick around through the next commercial, or what end-users use to avoid getting sick and understand why they’ve been sick.  The why is now addressing the real needs/pain points of our actual who: customers.

Here are some great things I’ve discovered about R:

• Functional. Although I’ve dabbled in Erlang, Haskell, and ML, and grown towards using Python in various functional ways (Mertz, AMK), I can’t say I’m fluent in any sanctioned functional language (okay, I just added R to that list, but it should have been there: “R’s functional parts come from Scheme.”)  I want to continue “breaking my brain in useful and creative ways”, and R fits the bill for completing this repertory need (I’ll probably head back to Haskell if/when a strong need for concurrency arises).
• Statistics and data analysis. The Numerati and other sources say statisticians rule the world.  My eyes have been opened and I believe they’re right, so I’m working back my math chops.  It would appear that R’s statistics packages are more expansive than Python’s, and more is built into the language itself.
• Mathematical learning tool. It’s been a decade since I finished that math degree, but now the investment is finally paying off… I, uh, hypothesize.  I’ll blame the hiatus on not having found very interesting work to do until now — another reason to be self-employed, and why I’m loving life this year.  Anyway, I’m already getting re-versed in stats just by starting to use the language.  It’s looking like playing with R is a much better way to learn statistics than muddling through textbooks and paper-based homework.
• Graphical. Don’t know where to start.  There are so many graphical tools for R it is mind-numbing.  I’m starting to look at RGgobi, but there are lots of others to get acquainted with, including what’s built in.  I’ve worked through a couple graphical tutorials, and they seem to just magically pop up amazing graphs without having installed anything.  Try: > demo('graphics') Notice how few lines of code are doing all that. Wow!
• Geospatial. I’ve got a need to be plotting data on maps in a variety of formats.  I’ve found a lot of ways to do this, but R seems to be the lightest, and very capable.
• High-level. Everything is a data structure.  Operations applied to variables are done across the whole set with no loops or treatment of individual items.  The syntax appears to be a bit richer (higher level, more sugar) than found in Python.
• I/O. R seamlessly slurps table-oriented text files for processing.  Output is also automatically formatted in nice text tables.  A mini-book (PDF) describes this and much more.  My next learning task is to start interfacing with PostgreSQL.
• Kind of Python-like. I’ve started outlining another article that I hope to actually write someday called “R For Python Programmers” (since I can’t find such a guide).  Isn’t Python the gold standard to which great books make comparisons these days?  I won’t duplicate that here, but simply say that I can’t believe how comfortable the syntax feels coming from Python nativity.  And R appears to integrate very well with Python (this probably being the more important point).
• Best REPL evar! I start evaluating any language simply by firing up its REPL and comparing its facilities to those of IPython.  R’s REPL is on par with it (readline editing with vim-mode support, tab completion for everything, extensive help), and even has some extra niceties; e.g., function parameter tab-completion.  While getting started, note that the help system uses ? and ?? prefixes instead of IPython’s suffix notation.  IOW, use ?topic instead of topic? I’m getting the impression that a common workflow is spending lots of time in the REPL working with files and graphics.  This is probably the killer feature that enables me to quickly get up to speed.
• Documentation. The pages aren’t pretty, but there is a mass of info on the R site.  And AFAICT R is the foremost language used in recent Statistics textbooks.  There’s also a free 100-page (a good length, compare to Python Tutorial) intro book.  It’s horrible for non-programmers, and less than perfect for non-statisticians, but will get you familiar with some language features.  Appendix A offers a nice REPL walk-thru of language features.  I can’t find any Python books with much treatment of numerics, except for this one which seems to touch on some but shares space with language basics.
• CRAN. Incredibly diverse libraries (list of packages) for statistics, graphics, and even Epidemiology (probably overkill for my present needs).
• Mature and well-designed. R has been growing as the de facto FOSS statistical/graphical language for over a decade (inception in 1993, in the golden age).  It has grown up from the learnings of its ancestor S (shouldn’t R then be T??; I guess similar to C->B->A progression), which came onto the scene circa 1976 (a good year .
• Widely used. A survey of university statistics courses and Public Health curricula show R as a prevalent tool; e.g., UC Berkeley and Iowa State.
• UNIX-friendly. I was humored to see that R is more apt to borrow names from UNIX commands than from other languages.  The commands for managing a namespace are rm and ls — easy for me to remember.   And I’m glad to see it has good roots.
• Trivial Ubuntu installation. Try this: apt-get install r-recommended r-cran-<tab><tab>
• Script-friendly. Rscript enables R to act as a scripting language.
• PDX-visualization group. This month we’re starting up a group to discuss visualization technology/advances, and R will be the primary language under discussion.  My statistician friend, Ed, won’t stop talking about R, and he’s someone I’ve come to listen intently to.

It’s a bit early to be writing an article on a language I haven’t done much with yet.  But I had to explore what’s pushing me towards R.  Looks pretty compelling now, so I’m very close to diving in (actually using it in a project).  I’ve sprinkled a number of resources throughout this post which I hope will be helpful for newcomers to R (including myself).  I should also mention that the best articles I’ve seen on introducing R are by David Mertz (a very capable Pythonista): Statistical Programming with R, Part I and Part II.

I can’t ignore what’s been growing out of  Scipy, especially the maps.  And matplotlib’s gallery is incredible (and I have some of them working).  The above items are all great features of R, but if I can accomplish them nearly as well in Python I probably shouldn’t invest too much into R.  At this point it does appear that R offers some facilities beyond Python.  Have you worked with both Python and R and found compelling reasons to prefer R?  For which types of tasks?

My pain points with Python today are in analyzing query data (ad hoc in loops and heuristics), and creating a bunch of different formats to send to various third-party visualizations.  My analysis is going to need to get more sophisticated, and I’d like to be able to look at data visually quickly with less overhead.

I’m probably overstating the investment required in getting up and running with R; it’s supposed to be easy to pick up.  I’d really like to get to being comfortable with applying non-trivial statistics, which means working through some R books.  I’ve made it this far (and now so have you), so I’m going for it, hoping it will be a pretty quick learn.  Please feel free to share your experiences with learning and using R!

• $ apt-get install graphviz python-pydot python-pygraphviz # Python/Ubuntu friendly
• $ man graphviz (will lead to many other pages)
• O’Reilly tutorial by Michele Simionato (some other tutorials are not great)
• Some flickr example images, some with sample code included
• Simplest first use: $ dot hello.dot -Tpng -o hello.png && firefox hello.png
• Use from Python
• Plug Graphvis into your wiki (MoinMoin)

I (with Tim) am also planning to show some of our progress on visualizations for uGraph, so be sure to show up for the meeting.  And what a fantastic group of folks: many entrepreneurs and data miners.  Should be a great after-party!

The NIC and USB are obviously present.  ssh is highly expected (how else would you get in?), as is the ability to install anything that will fit in the 512 MiB of flash.  The audio output is missing, but if it supports any USB hub, you could connect an external USB drive and a USB amp like this one, and feed into your sound system.  Wonder what distro it’s using?

I’ve been using an old laptop to drive the audio for my whole house for several years.  This is not a great solution since it’s comparatively power hungry, loud, takes up space, and is dying.  With the wall-wart, that old system can disappear, and the wart can probably put out a lot better sound (with the USB amp).  I’ve considered replacing the laptop with an iTouch or some device, but I really like using the machine as a server for other purposes that a handheld would not support.

So far this system is just theoretical.  But I hope to get my hands on one of these and try it out.  Hmm, there are even USB monitors now; that could be interesting!

It would also make for a nice little backup server, hosting a drive for automated rsync.  There’s also the need for USB-powered eXtreme Feedback Devices (XFDs).  The ShivaPlug could handle some of that with a USB light or lava lamp.  Any other possibilities?  Let me know your experiences if you’re playing with one.

Thanks Jon for the link!

After some hunting around I found a help article at Webfaction describing the process of sending mail from a script (with Python, nice! give it a thumbs up; those guys are great).  I could easily enough put some code like that into a function in a utility module to be called from various places, but it’s kind of ugly and repeats some data multiple times and requires a couple more imports.  On a development box I got Django’s handy send_mail function to work, but even with the described smtplib setup work on the webhost, the Django convenience was not going to fly.  But shortly into that Django article you see some setting parameters that are not part of the default django-admin-generated skeleton.  I tried setting these like so:

if platform.uname()[1].lower() == 'myserver.webfaction.com':
    EMAIL_HOST = 'smtp.webfaction.com'
    EMAIL_HOST_USER = 'my_user_name'
    EMAIL_HOST_PASSWORD = get_my_password()

And now I can simply send myself emails by making calls to send_mail, like this:

from django.core.mail import send_mail
...
send_mail("New beta user signed up!",
    "%s\n%s" % (email, text),
    "beta@mycompany.com", [ADMIN])

• Build something that I would really like to have/use (satisfy a personal need; understanding/tracking health, in my case)
• Benefit large group of people (make a difference in the world)
• Feel in control of life (bypass corporate agendas)
• Pursue own creative ideas
• Make own decisions (or at least have a major say)
• Have fun, be passionate (thus be able/motivated to really be devoted to making it successful)
• Make enough money to pay mortgage and support family (but maintain frugality/minimalism perspective with children), and give back
• Contribute to FOSS (many projects require new tooling/libraries, some of which can be used by others)
• Work with excellent people: friends, role models, apprentices, visionaries of my choosing
• Create jobs for capable people, for my (evolving) definition of capable
• Learn new technologies, follow cutting edge developments (data mining/visualization, programming language/tools progression, web frameworks)
• Better understand users/crowds (and how to make sense of the huge data sets they generate)
• Have something interesting to write about
• Take a rollercoaster ride; experience the extreme/rush/thrill
• Make contacts/friends/future partners around new technologies
• Justify getting ridiculously connected on social networks
• Get further experience in all aspects of running a business
• Gain the wisdom (business savvy, engineering, writing, presentation, art) to pass on to my children and anyone else who will listen
• Build reputation and equity to enable pursuit of larger future projects
• Optimize the business creation process (be able to start up many more quickly with discretional insights)

Some books that I have found to be influential in getting started: Tribes, Career Renegade, The Big Moo, Founders At Work.  And blogs: Paul Graham, Seth Godin.

Are you thinking about taking the plunge?  Done it already?  What are your reasons?