JasonHeppler.org - History in the Digital

Content on the Web

2012-05-24T14:01:10-05:00

Over 70% of new content on the web is now produced by individuals, & very little of it can be archived because it's in places like Facebook.

An amazing statistic. I tend to keep a lot of the things I create -- blog posts, shared links, and so on -- publically available because I don't want things locked behind a wall. Hence my preference for Twitter and Tumblr (which, incidentally, also updates Facebook and Twitter when I post something new).

Forking the Rubyist Historian

2012-05-22T21:21:30-05:00

In early 2011 I wrote a series of blog posts based off of Steve Ramsay's course on electronic text and Ruby programming, where part of our goal was to think about ways we could apply programming to humanistic data. The course became something of a pivot point for me. Although I've long been a computer geek, programming was something I never deeply used and hadn't touched any computer language since high school (and even then, it was BASIC and Visual Basic). But Ramsay's course made me realize the power that programming can offer researchers. The digitization of our cultural heritage means we have a growing abudance of material being released electronically by libraries, museums, archives, and digital centers, leaving us with a vast array of material that can be manipulated, queried, browsed, and visualized through computational methods. When the course was finished, I decided to write a series of blog posts for others who might be interested in applying Ruby to humanistic inquery. The result was The Rubyist Historian.¹

When I originally wrote the first post kicking off the series, I promised the release of an electronic book. At the time I was running WordPress and the plugin Anthologize had recently been released. I wanted to test it out, and thought some of the things I was doing would also generate some good feedback for the Anthologize team. Shortly after, however, I switched my blog platform to Jekyll and, as other projects demanded my attention, I never got around to publishing the material into a format beyond my blog posts.

That changes today.

I had a new idea. Instead of pushing a static project as a PDF or epub format I decided to build something dynamic. After all, the electronic medium offers me a much easier way of updating material over time. So, this afternoon I pushed the seven posts to Github under a single file, and pushed that file to Github pages. This offers two advantages: 1) Anyone interested can now download a copy of the Rubyist Historian and all example code to use, 2) Any updates I make can also be pushed to the page, as well as tracked in version history.

But I want more. As a bit of an experiment in open publishing, I've decided to open source The Rubyist Historian for public contributions. I take my inspiration from William Turkel and Alan MacEachern's The Programming Historian, which used a wiki to allow public suggestions and contributions to the book. I hope to offer the same through a different venue in using Github pages and version control.

People are free to fork The Rubyist Historian and offer corrections, clear (or better, or more) examples, and overall contribute to what I hope can become a collaborative project and reference for humanities scholars looking to get started in Ruby programming. The text could also be extended in other ways, such as rewriting parts that would make more sense for Windows users (the text, as it exists, is meant primarily for *nix environments), or porting the examples to other languages (someone should do Lisp, just for fun), or add "homework" exercises, or new lessons. Or new examples could push beyond the text analysis I offer and explore different computational methods over different sets of data. Or perhaps you'd like to see a PDF or epub format for Rubyist. There are no limitations to the ideas that could be offered and incorporated.

How to Contribute

My current idea and workflow for contributions will operate as follows:

If you want to make contributions, make a fork of the project in your Github repository.
Changes you make should be made to the fulltext.md file. Then changes can be pushed back to my repository.
If new lessons are offered, a corresponding directory for code examples should accompany the lesson. Discussions of new lessons can be had on the Github wiki page.
As changes are merged into the full text, the Github page will be manually updated by me (this appears to be the only way to do this right now.)

This may undergo some evolution -- as I mentioned, this is an experiment and I haven't fully thought through how everything will work. I'll work out issues as time goes on.

So, go check out the new Rubyist Historian page and start forking.

The other pivot point, which the course also contributed to, was a switch in my research agenda towards the history of computers. More on this in an upcoming post.

The Bastards Book of Ruby

2012-05-16T21:24:24-05:00

If you're looking for an excellent starting point for learning Ruby (besides, of course, the Rubyist Historian, check out "The Bastards Book of Ruby" by Dan Nguyen. He lays out his chapters really well, and I love how he has organized his table of contents and gives the status of each section's progress.

(Via Steve Ramsay.)

Visit Link →

It's About the Problem

2012-05-15T22:49:09-05:00

There have been a lot of discussions today about developer Jeff Atwood's post pleading people to not learn to code. Atwood is responding to the "everyone should code" and new features like Code Academy that promises to introduce people to the ins and outs of programming.

I tend to agree with the sentiment behind Gina Trapani and Benjamin Stein -- there's a big difference between professional development and coding. One of the things coding teaches is analytical skills, logical workflow, and debugging. Few other activities combine these into situations that require all three.

What Atwood is correct in noting is "[coding] puts the method before the problem. Before you go rushing out to learn to code, figure out what your problem actually is."

For better or worse, in my department I am the person most people come to for questions regarding programming and code. People wonder if they should take Steve Ramsay's Ruby course (they should, it's great) or what language they should start with. Writing code, however, is not the first step.

Writing code is about solving problems. Digital humanities practitioners should be building, and writing code certainly falls within that domain. But if you think writing code is your starting point, then you are framing the issue incorrectly. What you need is to identify solutions to problems. Building your tool is little different than your standard research paper: identify your problem, determine your users (audience), do your research, figure out where your solution fits and how it's different from existing solutions.

Writing code is not your first step. Identify the problem first.

World Aeropress Championship

2012-05-15T16:16:56-05:00

AeroPress recipes from the World AeroPress Championship. Yes, this exists.

And for the record, I'm the happy owner of a new AeroPress, which has replaced my previous brewing method of the French press. It is that good.

Visit Link →

(Via Marco.)

Hemingway on Writing

2012-05-10T09:25:45-05:00

Ernest Hemingway in a 1958 interview with George Plimpton:

When I am working on a book or a story I write every morning as soon after first light as possible. There is no one to disturb you and it is cool or cold and you come to your work and warm as you write. You read what you have written and, as you always stop when you know what is going to happen next, you go on from there. You write until you come to a place where you still have your juice and know what will happen next and you stop and try to live through until the next day when you hit it again.

Great advice.

(Via John Gruber.)

Open Source Data Journalism Handbook Launched

2012-05-08T07:46:29-05:00

The free Data Journalism Handbook seeks to help journalists with the challenges of working with lots of data. The handbook contains case studies and serves as a guide to gathering, understanding, and delivering data.

It was born at a 48 hour workshop at MozFest 2011 in London. It subsequently spilled over into an international, collaborative effort involving dozens of data journalism's leading advocates and best practitioners - including from the Australian Broadcasting Corporation, the BBC, the Chicago Tribune, Deutsche Welle, the Guardian, the Financial Times, Helsingin Sanomat, La Nacion, the New York Times, ProPublica, the Washington Post, the Texas Tribune, Verdens Gang, Wales Online, Zeit Online and many others.

It looks like an excellent resource for anyone looking to learn more about working with data, not just if you're a journalist. You can also find the book available in other formats (including epub and mobi) on Github.

Adam Lisagor's AeroPress Tribute

2012-04-25T21:44:48-05:00

I'm a fan of the French press, but I really would like to try out the AeroPress someday soon.

A Simple Ruby NGram Generator

2012-04-24T15:45:43-05:00

I was playing around with Ruby the other night and wrote a simple n-gram generator. In case anyone is interested, here is the script:

#!/usr/bin/env ruby -w
# r_ngram.rb
# Generate a simple bi- and tri-gram, prints to STDOUT
# Usage: ruby ngram.rb file.txt
# To save the output to a file: ruby ngram.rb file.txt > output.txt

$words = File.read(ARGV[0]).downcase.scan(/[a-z]+/)

bi_grams = Hash.new(0)
tri_grams = Hash.new(0)

num = $words.length - 2
num.times {|i|
  bi = $words[i] + ' ' + $words[i+1]
  tri = bi + ' ' + $words[i+2]
  bi_grams[bi] += 1
  tri_grams[tri] += 1
}

puts "## -- bi-grams -- ##"
bg = bi_grams.sort{|a,b| b[1] <=> a[1]}
(num / 10).times {|i| puts "#{bg[i][0]} : #{bg[i][1]}"}
puts "\n"
puts "## -- tri-grams -- ##"
tg = tri_grams.sort{|a,b| b[1] <=> a[1]}
(num / 10).times {|i| puts "#{tg[i][0]} : #{tg[i][1]}"}

1862 Great Plains Symposium

2012-03-28T15:19:36-05:00

Starting tonight with a talk by Donald Worster, the Center for Great Plains Studies is hosting their symposium 1862: The Making of the Great Plains. I'll be at the electronic poster session on Thursday discussing the William F. Cody Archive. Featured speakers at the symposium this year also include Elliott West, Martin Jischke, Richard White, William Thomas, Myron Gutmann, and David Von Drehle.

Saturday, the history graduate students are kicking off the seventh annual James A. Rawley Conference, which we are holding at the Homestead National Monument this year. Coming fresh off of comprehensive exams, this should make for a nice way to end the week.