The Changelog - Open Source moves fast. Keep up.
Latest episode

Episode 0.7.9 - Adhearsion, telephony, and XMPP with Ben Klang and Ben Langfeld

Wynn caught up with Ben Klang and Ben Langfeld of the Adhearsion project to talk about Adhearsion 2.0, the future of telephony apps, XMPP, and more.

Go to episode
The Changelog is a weekly podcast and blog that covers what's fresh and new in Open Source.
May 18, 2012

SSPullToRefresh - Simple pull to refresh view for iPhone

Wynn Netherland posted this 1 day ago

As I continue to dive into iOS development, I’m on the lookout for time saving Cocoa projects. Sam’s SSPullToRefresh is an easy, customizable way to add pull-to-refresh views like those made popular in Loren Brichter’s original Tweetie for iPhone app. SSPullToRefresh hides all the pulling and animating logic away, leaving you to implement what you care about - fetching and refreshing your view.

- (void)viewDidLoad {
   [super viewDidLoad];
   self.pullToRefreshView = [[SSPullToRefreshView alloc] initWithScrollView:self.tableView delegate:self];
}


- (void)refresh {
   [self.pullToRefreshView startLoading];
   // Load data...
   [self.pullToRefreshView finishLoading];
}

- (void)pullToRefreshViewDidStartLoading:(SSPullToRefreshView *)view {
   [self refresh];
}

You can use a couple of provided content views or you can subclass and implement your own. Check out the source on GitHub or see it in action in Cheddar.

May 16, 2012

Redis-faina - query analyzer for Redis

Wynn Netherland posted this 3 days ago

From folks that know something about scale, the Instagram team has realeased Redis-faina, a tool that parses Redis’ MONITOR command to provide stats on Redis queries:

# reading from stdin
redis-cli -p 6490 MONITOR | head -n <NUMBER OF LINES TO ANALYZE> | ./redis-faina.py

Overall Stats
========================================
Lines Processed     117773
Commands/Sec        11483.44

Top Prefixes
========================================
friendlist          69945
followedbycounter   25419
followingcounter    10139
recentcomments      3276
queued              7

Top Keys
========================================
friendlist:zzz:1:2     534
followingcount:zzz     227
friendlist:zxz:1:2     167
friendlist:xzz:1:2     165
friendlist:yzz:1:2     160
friendlist:gzz:1:2     160
friendlist:zdz:1:2     160
friendlist:zpz:1:2     156

...

Check out the source on GitHub. If you’re new to Redis, Episode 0.4.5 with @antirez is a classic.

May 14, 2012

MGTileMenu - pop-up tile-based contextual menu for iOS5

Wynn Netherland posted this 5 days ago

MGTileMenu is an innovative context menu for iOS from Matt Gemmell. Resembling Path’s oft imitated corner menu in some respects, it appears to be more contextual than navigational, as the screencast demonstrates:

Matt’s introductory blog post provides a deep introduction on the design or you can grab the source on GitHub. The license requires attribution, or you can purchase a non-attribution license online.

May 12, 2012

Plumbum - Pythonic, cross-platform shell syntax

Wynn Netherland posted this 1 week ago

Plubmum logo

Plumbum is an interesting project from Tomer Filiba that aims to bring shell syntax to Python scripts:

The motto of the library is “Never write shell scripts again”, and thus it attempts to mimic the shell syntax (shell combinators) where it makes sense, while keeping it all pythonic and cross-platform.

A piping example:

>>> chain = ls["-a"] | grep["-v", "\\.py"] | wc["-l"]
>>> print chain
/bin/ls -a | /bin/grep -v '\.py' | /usr/bin/wc -l
>>> chain()
u'13\n'

In addition to piping, Plumbum supports redirection and even remote commands over SSH. Check out the source on GitHub, Tomer’s introductory blog post or the excellent project docs for more.

May 11, 2012

fr_public: Demoscene tools

Steve Klabnik posted this 1 week ago

Hey everyone! It’s Friday, and a good friend of mine (@DeMarko) just tipped me off to a really interesting repository.

If you’re not aware of the Demoscene, you should be. Basically, they make awesome crazy videos with computer graphics. That sounds boring, until you realize that they work within crazy constraints.

For example, here’s a ten minute Demo made on the Amiga:

http://www.youtube.com/watch?v=k8JbAdEzvMA

Here’s one on the Commodore 64, in 1982:

http://www.youtube.com/watch?v=8Nfgdr4fOS8

While these videos are old, the Demoscene certainly isn’t dead. Here’s another C64 demo, this time from 2010:

http://www.youtube.com/watch?v=L8onlB0F1_A

Anyway, I could go on and on. Point is, many modern demos are made on modern computers, but with a different constraint: file size. Generally, it’s “make an awesome video with graphics and sound that’s less than 4k.” That’s smaller than a blank word document. Here’s an example of one of these:

http://www.youtube.com/watch?feature=player_embedded&v=0w_xEUoK79o

Make sure to tell YouTube you want the 1080p (!) version.

Anyway, I’ll stop with the history. Here’s the point: There’s a repository that’s basically just a raw dump of the code people have written to make these kinds of demos. An archive of the last ten years of a bunch of people making awesome things.

The README warns that much of the code is hard to compile, and if you don’t know C or C++, you probably won’t be able to make heads or tails of it. Note also that these are tools used to make demos, not necessarily the code of the demo itself. Point is, there be dragons in this repo. Lots of dragons.

You can check out the Farbrausch tools repo here.

UPDATE: One of my other friends (@davewilkinsonii) pointed me to this article, which refers to the above repository, but also has links to download source code of a TON of demos: http://www.displayhack.org/2012/the-great-demoscene-sourcecode-giveaway/

May 9, 2012
May 8, 2012

Imperator - Command pattern for Ruby apps

Wynn Netherland posted this 1 week ago

Jon Leighton isn’t the only one picking a fight with Rails controllers. Keith Gaddis suggests in The Problem With Controllers that we’ve relegated the command pattern to the depths of our queuing frameworks:

The problem with controllers in Rails is that they’re a part of the web domain—their job is to respond to requests, and ONLY to respond to requests. Anything that happens between the receipt of a request and sending a response is Somebody Else’s Job™. Commands are that Somebody Else™. Commands are also very commonly utilized to put work into the background.

Why are commands an appropriate place to handle that logic? Commands give you the opportunity to encapsulate all of the logic required for an interaction in one spot. Sometimes that interaction is as simple as a method call—more often there are several method calls involved, not all of which deal with domain logic (and thus, are inappropriate for inclusion on the models). Commands give you a place to bring all of these together in one spot without increasing coupling in your controllers or models.

He’s released Imperator, a Ruby gem to help move that logic, simplify our controllers, and make them less model-dependent.

class DoSomethingCommand < Imperator::Command
  attribute :some_object_id
  attribute :some_value

  validates_presence_of :some_object_id

  action do
    obj = SomeObject.find(self.some_object_id)
    obj.do_something(self.some_value)
    end
  end
end

The project is brand new and will likely evolve so check the source on GitHub.

May 7, 2012

Opa - Event-driven, non-blocking, strongly statically typed web framework with JavaScript-like syntax

Wynn Netherland posted this 1 week ago

It seems our industry’s search for a unified theory of web development is resulting in a blurring of the line between client and server. Opa, the latest on our radar even goes so far to introduce client and server keywords:

 // Opa decides
function client_or_server(x, y) { ... }
 // Client-side
client function client_function(x, y) { ... }
 // Server-side
server function server_function(x, y) { ... }

Personally, Opa’s JavaScript-like syntax doesn’t get me excited. JavaScript’s strength lies in its ubiquity, not in its syntax.

Opa’s web site is very well done and the source is on GitHub for your perusal.

May 4, 2012

Ruby Motion Samples - Write iPhone Apps In Ruby

Sam Soffes posted this 2 weeks ago

RubyMotion was just released by Laurent Sansonetti, the creator of MacRuby. RubyMotion lets you write iOS apps in Ruby!

RubyMotion is a revolutionary toolchain for iOS. It lets you quickly develop and test native iOS applications for iPhone or iPad, all using the awesome Ruby language you know and love.

RubyMotion is a commercial product with introductory pricing of $149. We wanted to cover it on The Changelog anyway since it’s such an exciting new tool with an open source heritage.

Writing Objective-C in Ruby is really fantastic, especially for Ruby engineers new to iOS. You can use all of the Ruby features like mixins, monkey patching, etc but on Objective-C objects. So when you make a string, it’s really an NSMutableString which is a Ruby String in MacRuby.

Probably the coolest thing about RubyMotion is that it statically compiles your Ruby code so it doesn’t have to include the entire Ruby source and an interpreter. In theory, it should be just as fast as Objective-C code.

RubyMotion even has an interactive REPL. See it in action in their demo. Skip to 3:58 in if you just want to see the REPL.

There’s a ton of stuff in RubyMotion that is just fantastic like the build system, REPL, testing, etc. Read my full review on my blog. Also, there are several sample applications on GitHub.

May 3, 2012

Screenfull.js - Simple cross browser wrapper for Fullscreen API

Wynn Netherland posted this 2 weeks ago

The Fullscreen API is fairly new with growing support but the implementation varies across browsers. Screenfull.js is a simple script from Sindre Sorhus to change that, changing:

document.fullscreenEnabled = document.fullscreenEnabled || document.mozFullScreenEnabled || document.documentElement.webkitRequestFullScreen;

function requestFullscreen( element ) {
  if ( element.requestFullscreen ) {
    element.requestFullscreen();
  } else if ( element.mozRequestFullScreen ) {
    element.mozRequestFullScreen();
  } else if ( element.webkitRequestFullScreen ) {
    element.webkitRequestFullScreen( Element.ALLOW_KEYBOARD_INPUT );
  }
}

if ( document.fullscreenEnabled ) {
  requestFullscreen( document.documentElement );
}

to

if ( screenfull ) screenfull.request();

The source is on GitHub.