To save some trouble for those of you who want to switch but haven’t yet, here’s what to look out for on the conversion.

#1: Sidekiq is too darn fast

It sounds ridiculous, but Sidekiq is so fast that it can run your worker before your model even finishes saving. There’s one easy solution for this: don’t use after_create or after_save, but instead use after_commit to make sure that model is done with the database.

after_commit :run_expensive_hello_world, :on => :create

This will solve 99% of your use-cases, but if you use something like state_machine, you won’t be able to use any of state_machine’s transitions to push out a worker. Instead, we solved it by creating an instance variable that the after_commit callback uses.

attr_accessor :just_moved

after_commit :tell_neighbors_hi, :if => :just_moved

state_machine :status, :initial => :sitting do
  # ...
  after_transition any => :moved do |i|
    i.just_moved = true
  end
end

#2: You can’t see failed jobs. Well, sort of.

Sidekiq is different from Resque in that it doesn’t keep a permanent record of your failed jobs, so you won’t always be able to go back later and run it again after it’s fixed.

The reasoning behind this design decision is that Sidekiq, unlike Resque, will retry your job at increasing intervals automatically up until about 20 days, along with giving you the ability to manually retry it — plenty of time to see the error, assign the bug and fix it. After that, you can say sayonara to that record. Sidekiq has some nice docs of how to handle errors, though, including saying one last goodbye to the error, so it’s not too hard to set up some safeguards against losing data.

If you don’t want to take the time to set all that up, there’s always sidekiq-failures.

#3: Sidekiq’s perform is not Resque’s self.perform

Mike Perham has done a good job of making the terminology fairly similar when switching from Resque to Sidekiq. However, make note that Sidekiq’s perform method is an instance-level method, whereas Resque’s is class-level.

The main takeaway from this is that in Resque, it’s not uncommon to throw the perform method on whatever object you want to use for the worker. In Sidekiq, you’ve got to watch out for initializing that new object. You might be able to get away with it if your initialize method has no arguments, but you’re better off creating a new class just for the worker.

After getting accustomed to some of the differences between Resque and Sidekiq, it’s pretty easy to see that Sidekiq can shave time and money off your server and is definitely worth the switch.

The post Earn a Sidekiq blackbelt by breaking a few boards appeared first on The Changelog.

Stringer is Matt Swanson’s entry into the RSS ecosystem. Matt describes Stringer like so:

Stringer has no external dependencies, no social recommendations/sharing, and no fancy machine learning algorithms. But it does have keyboard shortcuts and was made with love! When BIG_FREE_READER shuts down, your instance of Stringer will still be kicking.

Here’s a screenshot of it in action. (Bonus points for featuring a Changelog post!)

Stringer is written in Ruby and built on Sinatra with a PostgreSQL datastore. It deploys easily to Heroku and is a self-professed work-in-progress. One thing the web app currently lacks is a solid mobile offering, so please get involved if you have mobile ideas and/or chops!

The project is MIT licensed and hosted on GitHub.

The post Stringer: a self-hosted, anti-social RSS reader appeared first on The Changelog.

<script type='text/ruby'>
  window.onload do
    introduction = document.create_element('p')
    introduction.inner_text = 'Hello, world!'
    document.body.append_child(introduction)
  end
</script>

It only works on the Mac right now, and there are a few other gotcha’s to keep in mind:

• In Ruby, methods and attributes are specified in underscore_case instead of camelCase.
• The window variable is accessible from only the top-most scope. Elsewhere you can use the global $window.
• Ruby accepts Procs and blocks as callbacks and listeners. View an example.

You can go to the project homepage, get the latest release or view the source on GitHub.

The post Run Ruby in the browser with Decaf, a fork of WebKit. appeared first on The Changelog.

I gave it a test drive on one of the student apps and it took 5 minutes, at most, to get up and running.

Just drop this in your Gemfile:

group :development do
  gem 'xray-rails'
end

Bundle and delete the cached assets:

$ bundle && rm -rf tmp/cache/assets

Restart your app, visit it in your browser, and press cmd+shift+x

By far the best feature in Xray is the fact that it allows you to actually click on the overlay and go straight to the file or partial being rendered. It defaults to Sublime, which is easy for new users, but is simple enough to customize to another tool for seasoned pros.

Xray is great for:

• Helping new Rails developers while pairing to get clearer understanding of views
• Gaining quick insight into complex views
• Debugging templates, partials, and backbone views

See Xray in action

Right now Xray is a tool for the Rails framework but there are plans to expand and make it available for any framework. You can check it out on Github.

The post Xray-rails reveals which files are being rendered in your view appeared first on The Changelog.

Tune in LIVE every Tuesday at 3pm PT / 6pm ET.

• We’re live every Tuesday! thechangelog.com/live
• Hack in style with your very own Changelog tee!
• We are now member supported!
• We’re joined by Jeff Atwood, from codinghorror.com and stackexchange.com
• Stack Overflow is a community Q&A platform.
• Discourse is an open source discussion platform.
• WordPress is an open source CMS in PHP.
• Shapado is a Q&A platform in ruby.
• OSQA is an open source Q&A system.
• Reddit is an online community where users vote on content.
• Steve Yegge’s tour de babel is a language roundup from 2006.
• Why Ruby? is a blog post by Jeff about why he did Discourse in ruby.
• mono is an open source .NET development framework.
• Discourse as Your First Rails App is a blog post about setting up the Discourse development environment.
• ember is a JavaScript framework for ambitious web applications.

The post Episode 0.8.6 – Discourse, Ruby and more with Jeff Atwood (aka Coding Horror) appeared first on The Changelog.

It’s a Chrome extension which lets you see your server side logs right in the browser. There are currently libraries for:

• Python
• Ruby
• PHP
• Express

Is your server side language/environment of choice not on that list? Don’t worry, Chrome Logger uses an open and published protocol so you can easily write client libraries of your own!

See the project’s home page for more info or check under the hood if you’re curious about how it all works.

The post Bring your server side debug logging into the browser with Chrome Logger appeared first on The Changelog.

Basically, hyperresource is intended to be a general hypermedia client. What’s that mean? It can work with any API that happens to use one of the media types it supports. Right now, that’s just HAL+JSON, but more will be added in the future.

What’s that mean in terms of code? Well, here’s an example from the README:

api = HyperResource.new(root: 'https://api.example.com')
# => #<HyperResource:0xABCD1234 @root="https://api.example.com" @href="" @namespace=nil ... >
root = api.get
# => #<HyperResource:0xABCD1234 @root="https://api.example.com" @href="" @namespace=nil ... >
root.response_body
# => { 'message' => 'Welcome to the Example.com API',
#      'version' => 1,
#      '_links' => {
#        'self' => {'href' => '/'},
#        'users' => {'href' => '/users{?email,last_name}', 'templated' => true},
#        'forums' => {'href' => '/forums{?title}', 'templated' => true}
#      }
#    }
jdoe_user = api.users.where(email: "jdoe@example.com").first
# => #<HyperResource:0x12312312 ...>

How does it know how to look up those users? Well, there’s a users link relation on in the response, and it has a templated URI as its href attribute. This lets the client reflect and know how to look up users by their email or last name.

The power of this generic tooling is that we no longer have to think about how to parse HAL, how to interpret the response… we have this one library which works with any HAL-powered API.

The biggest drawback of hyperresource is that it’s read-only at the moment, nothing but GET. But it shows a lot of promise, and I’m excited to see this kind of stuff pop up in the wild. Everything I see points to 2013 as the year of example code for hypermedia services.

Check it out on GitHub.

The post Hyperresource: a hypermedia API client for Ruby appeared first on The Changelog.

csscss will parse any CSS or Sass file you give it and let you know which rulesets have duplicated declarations.

It’s super easy to use:

$ gem install csscss
$ csscss path/to/styles.css path/to/other-styles.css

{.contact .content .primary} and {article, #comments} share 5 rules
{.profile-picture}, {.screenshot img} and {a.blurb img} share 4 rules
{.work h2:first-child, .archive h2:first-child, .missing h2:first-child, .about h2, .contact h2} and {body.home h2} share 4 rules
{article.blurb:hover} and {article:hover} share 3 rules

Cool! This really helps when you’re trying to get a handle on refactoring. Maybe it’s just me, but I find remembering all of my CSS rules very complicated. There’s a reason I’m more of a back-end developer…

For those who write their CSS in Sass, csscss can also parse Sass files, as well. Just point it at one and it’ll go to town!

Check out the homepage or the source on GitHub for more details.

There’s one other neat part about this gem, but it’s not for users of the gem — it’s for developers. csscss contains, as you’d expect, a full CSS parser written in parselet. I’m sure that others could do need static analysis stuff with CSS if they had a parser that was pre-built for them, as well.

The post csscss parses your CSS and shows your duplicated declarations appeared first on The Changelog.

The team at Stripe has open sourced a RubyGem that makes REST API’s easy to create, Poncho. It’s compatible with any rack-based framework — like Rails or Sinatra. Best of all, it has a slew of (simple to use) features:

• Standard Params: integer, array, boolean, etc
• Custom Params
• Standard Validators: presence, format, length, etc
• Custom Validators
• Method Filters
• And more…

Installation is simple, just install the poncho gem (or add gem poncho to your Gemfile). After installation, you can setup your API:

class ChargeResource < Poncho::Resource
  param :amount, :type => :integer
end

class ChargeCreateMethod < Poncho::JSONMethod
  param :amount, :type => :integer, :required => true

  def invoke
    charge = Charge.new
    charge.amount = param(:amount)
    charge.save

    ChargeResource.new(charge)
  end
end

post '/charges', &ChargeCreateMethod

The above code, which was pulled from the documentation is using Sinatra, but you could easily swap Rails out:

match '/charges' => ChargeCreateMethod, :via => :post

The documentation is thorough, and does a great job at explaining how to use Poncho. You can also view the source or discuss this on HackerNews.

The post Write Ruby API’s with Stripe’s Poncho (a DSL for REST interfaces) appeared first on The Changelog.

Helios is an open-source framework that provides essential backend services for iOS apps, from data synchronization and user accounts to push notifications, in-app purchases, and passbook integration. It allows developers to get a client-server app up-and-running in just a few minutes, and seamlessly incorporate functionality as necessary.

Getting started is easy:

$ gem install helios
$ helios new myapp
$ cd myapp; helios server
$ open http://localhost:5000/admin

Helios is broken down into useful components, too. If you check out the .gemspec, you’ll notice a few other gems that would be useful for anyone trying to build a backend service.

There’s a lot of startups that do “Backend as a Service,” such as Parse, so it’s nice to see an OSS competitor pop up.

The post Helios: a server side for your iOS app appeared first on The Changelog.

Basically, due to these awesome-looking flame graphs that Sam added to his MiniProfiler gem. Here’s what it does: it samples stack traces while your app runs, and then lays them all next to each other so you can see where they’re especially deep. He has a demo here, which you can click around and check out what was going on on Discourse’s home page before Sam started working on making it faster.

Anyway, so what’s this has to do with fast_blank? Well, Sam noticed that a ton of time in Discourse’s code was being spent in String#blank?, a method which was added to Rails by _why the lucky stiff way back in the day. Sam attempted to fix it, but making it 100% compatible, yet fast, was difficult.

This lead him to notice that Ruby and Rails have different implementations of #blank?, he decided to fix the issue in Discourse by writing a #blank? in C so that it was super fast.

To use fast_blank, just add it to your Gemfile:

gem 'fast_blank'

That’s it! Your String#blank? will be faster.

Actually, that’s not quite it. Over on GitHub, Sam told me that it’s not up on Rubygems yet, but will be in a few days. For now, you need to clone it down and use Bundler’s :github option:

gem 'fast_blank', github: "SamSaffron/fast_blank"

That’s it.

Now, you may be wondering why I’m making such a big deal out of all of this. Well, this is pretty much an absolutely model open source interaction between a bunch of different projects.

1. A performance issue was found. Rather than wonder or speculate, measurements were taken.
2. A new tool was developed to help make sense of the measurements.
3. Attempting to fix performance in the main project itself, with a pull request.
4. Recognizing that there was a lot going on here, so fixing it from himself via a patch.
5. Sharing the fix with everyone until the details in the main projects could be sorted out.

Obviously, this isn’t the end of this story. What will happen next? Will Rails and MRI end up with the same implementation? Can we make it work in Ruby as fast as the C version? Will fast_blank just replace the implementation of #blank? in MRI?

I guess you’ll have to stay tuned to find out. ;)

The post fast_blank: String#blank? in C appeared first on The Changelog.

But this isn’t a story about me. It’s a story about Joakim Ekberg. He did better than I ever did: when he put Sprockets on Sinatra, he made a gem out of it. He calls it sinatra-asset-pipeline.

It’s pretty easy to use: just

gem 'sinatra-asset-pipeline'

in your Gemfile. After bundling, add this to your Rakefile:

require 'sinatra/asset_pipeline/task.rb'
Sinatra::AssetPipeline::Task.define! MyApp

and add it to your application, too:

require 'sinatra/asset_pipeline'

class MyApp < Sinatra::Base
  register Sinatra::AssetPipeline
end

Then, sinatra-asset-pipeline gives you the rake tasks you’d expect:

$ rake assets:precompile
$ rake assets:clean

Sinatra-asset-pipeline is still pretty young, and currently only supports the stock Haml, Sass, and CoffeeScript options that the Rails asset pipeline uses. Hopefully, future releases will integrate Tilt so that you can use arbitrary endings, but there’s a reason why these are default in Rails: they’re the most popular alternate options from the defaults.

Vote this up on Hacker News.

The post sinatra-asset-pipeline: Sprockets for Sinatra appeared first on The Changelog.

Like any pragmatic programmer, I pick the appropriate tool for the job at hand. And as much as I may love .NET, it would be an extraordinarily poor choice for an 100% open source project like Discourse. Why? Three reasons, mainly …

Read the post for yourself.

And if you haven’t yet check out Discourse on GitHub and this thread on Hacker News.

The post Jeff Atwood on ‘Why Ruby?’ appeared first on The Changelog.

Rails Core member Jon Leighton has a new gem that helps solve this problem: it’s called spring. Basically, Spring is in the same ‘genre’ of gems as Spork and Zeus: it loads your app up and keeps it running in the background, so the next time you run your tests, things are fast.

Using spring is easy:

$  cat >> Gemfile
gem "spring"
^D
$ bundle
$ spring testunit

This boots up your app, runs the tests, and keeps the app running in the background. You can see that your app is running with spring status:

$ spring status
Spring is running:

26150 spring server | rails-3-2 | started 3 secs ago
26155 spring app    | rails-3-2 | started 3 secs ago | test mode 

Now, adding spring before every command is a lot of effort, so similar to bundle, spring can generate binstubs that take care of this for you:

$ spring binstub testunit
$ bin/testunit

Easy!

If you haven’t used Spring before, check out the README. If you were using earlier versions of Spring, Jon just released 0.8, so check out the CHANGELOG for details on what’s new.

The post Spring: pre-load your Rails apps appeared first on The Changelog.

Ruby has a long tail of web frameworks. There’s the big dogs, Rails and Sinatra, there’s some smaller frameworks with a devoted following like Padrino or Camping, and then there’s a ton of other frameworks like Ramaze, Merb, Cuba, or Renee.

Now, we have another: Scorched. Here’s what it has to say about itself:

Scorched is a true evolutionary enhancement of Sinatra, with more power, focus, and less clutter.

This looks to be true. Here’s a Hello World in Scorched:

require 'scorched'
class App < Scorched::Controller
  get '/' do
    'hello world'
  end
end
run App

Here it is in Sinatra:

require 'sinatra/base'
class App < Sinatra::Base
  get '/' do
    'Hello world!'
  end
end
run App

Sooooo yeah. What’s different about it then? It takes on a very anti-”full stack” philosophy:

unlike other lightweight web frameworks that attempt to hide Rack in the background, Scorched makes no such attempts, very rarely providing functionality that overlaps with what’s already provided by Rack. In fact, familiarity with Rack is somewhat of a pre-requisite to mastering Scorched.

You can do this kind of thing with Scorched, which somehow makes it feel even more low-level than Sinatra, yet higher-level than Rack:

map pattern: '/', priority: -99, conditions: {methods: ['POST', 'PUT', 'DELETE']}, target: proc { |env|
  [200, {}, 'Bugger off']
}

The documentation is pretty, and seems very full.

Scorched is also sponsored by Phusion, who make the popular Passenger app server.

You can get the code on GitHub, of course!

One more note: it was pointed out to me on Twitter that Scorched requires Ruby 2.0 only, and that’s true:

Scorched requires Ruby 2.0 as it makes use of a couple of new features. By the time Scorched hits v1.0, there should be little reason not to be running Ruby 2.0.

The post Scorched: a new Ruby web framework appeared first on The Changelog.

From the announcement post:

Since our 0.10.7 release (June 20th 2012), development on Padrino has been moving forward very actively and as such this is probably our biggest release in terms of code modified and issues resolved that we have had in years.

Check out the announcement post to learn what’s new in 0.11.0 or fork the source on GitHub.

The post Padrino Lives! After almost a year, 0.11.0 is *finally* released. appeared first on The Changelog.

Today Shopify open sourced a core piece of our infrastructure: identity cachegithub.com/Shopify/identi…

As the quote says, Shopify took a step to open source their solution for caching ActiveRecord model objects in Memcached. An elegant solution backed by a powerful data store, IdentityCache has already been used in production. It’s fairly simple to install, straight from the README:

Add this to your Gemfile:

gem 'identity_cache', :git => 'git://github.com/Shopify/identity_cache.git'

Then bundle, and tell IdentityCache where Memcached is at:

config.identity_cache_store = :mem_cache_store, Memcached::Rails.new(:servers => ["mem1.server.com"])

Usage is even easier, again from the README!

class Product < ActiveRecord::Base
  include IdentityCache
  has_many :images
  cache_has_many :images, :embed => true
end

# Fetch the product by it's id, the primary index.
@product = Product.fetch(id)

# Fetch the images for the Product. 
# Images are embedded so the product fetch would have 
# already loaded them.
@images = @product.fetch_images

IdentityCache also has support for: Secondary Indexes, Caching Associations and more. Head on over to GitHub to View the README or the Source Code.

The post Cache ActiveRecord models in Memcached with IdentityCache by Shopify appeared first on The Changelog.

From the announcement post on ruby-lang.org:

We are pleased to announce the release of Ruby 2.0.0-p0.

Ruby 2.0.0 is the first stable release of the Ruby 2.0 series, with many new features and improvements in response to the increasingly diverse and expanding demands for Ruby.

Enjoy programming with Ruby 2.0.0!

New features include: Keyword arguments, utf-8 default encoding, a new regexp engine (Onigmo) and an asynchronous exception handling API (among others).

If you’re concerned about compatibility, the announcement has this to say about migrating from 1.9 to 2.0.

We have also taken care with the 2.0.0 design to make it compatible with 1.9. It will be easier to migrate from 1.9 to 2.0 than it was from 1.8 to 1.9.

If you’ve played a part in contributioning to Ruby 2.0, we thank you!

The post Ruby 2.0 is here! appeared first on The Changelog.

The Ruby community has started to accept certain guidelines on what writing good specs means, and Andrea Reginato is documenting those accepted rspec guidelines to help the rest of us keep up!

Checkout the examples at betterspecs.org. You can learn, share, and even debate the validity of the practices used. You can also view the source at GitHub.

The post Better Ruby specs with betterspecs.org appeared first on The Changelog.

Enter s3_multipart. From the README:

The S3 Multipart gem brings direct multipart uploading to S3 to Rails. Data is piped from the client straight to Amazon S3 and a server-side callback is run when the upload is complete.

Multipart uploading allows files to be split into many chunks and uploaded in parallel or succession (or both). This can result in dramatically increased upload speeds for the client and allows for the pausing and resuming of uploads.

Neat, eh? The README has more details of how to use the gem. It’s a bit complex: you need to set up CORS on your S3 bucket, run some generators, write some JavaScript.

The gem is still young, and looking for contributions. This is a tough problem, and having an easy way to solve it is great!

The post s3_multipart: Multi-part file uploads straight to S3 for Rails appeared first on The Changelog.

Two years ago Felipe Coury submitted a pull request to add ghost-ssh to manipulate ~/.ssh/config files. If it weren’t for Google pointing me to this pull request, I would have never known ghost-ssh existed. The readme says nothing about it!

This is what Felipe had to say when he submitted his patch:

I had a need to manipulate ~/.ssh/config file the same way I can manipulate my hosts entries, so I made this change.

Not sure if it will be useful for the upstream project, but be welcome to merge if you like.

An intro to ghost-ssh

Just like with ghost on the command line, ghost-ssh has basic list, add, and delete options, as well as an import operation to import files.

To save you some time, here’s the contents of ghost-ssh --help:

$ ghost-ssh --help
USAGE: ghost-ssh add <host> <hostname> [--user=<user>] [--port=<port>]
       ghost-ssh modify <host> <hostname> [--user=<user>] [--port=<port>]
       ghost-ssh delete <host>
       ghost-ssh list
       ghost-ssh empty
       ghost-ssh export
       ghost-ssh import <file>

An example of adding a new entry to your ssh/config might look something like this:

$ ghost-ssh add tclprod xxxxxx.gridserver.com --user=tcladmin
  [Adding] tclprod -> xxxxxx.gridserver.com

You can confirm the entry was added to ssh/config by running the ghost-ssh list command:

$ghost-ssh list                                             
Listing 1 configs(s):
  tclprod -> tcladmin@xxxxxx.gridserver.com:22

Now that I have this new entry in place, I can easily ssh into the server by running ssh tclprod and boom goes the dynamite!

Checkout the source for Ghost on GitHub for install and usage details.

Discuss on Hacker News if you’d like.

The post Ghost means never having to touch ssh/config again (either) appeared first on The Changelog.

How do I upgrade?

You need to do two things:

1. Upgrade your Rails. Make sure to get 3.2.12, 3.1.11, or 2.3.17.
2. Upgrade your JSON gem. Make sure you get 1.7.7, 1.6.8, 1.5.5.

Most of this can be done by changing your Gemfile to look like this:

gem "rails", "3.2.12"

And then running bundle update rails. This will probably update your JSON gem as well, but to be sure, check your Gemfile.lock.

Run cat Gemfile.lock | grep "rails" and cat Gemfile.lock | grep "json", if you see lines that look like rails (= 3.1.12) and json (1.7.7), then you’re good to go.

What are the vulnerabilities?

First, there is one fix in the 3.x series: CVE-2013-0276.

If you’re using attr_protected to blacklist items for mass assignment, a poor regex could allow someone to assign those attributes anyway. If you’re using attr_accessible to whitelist items, you’re fine.

This is also a good time to plug strong_parameters. Released as a gem for Rails 3.x, it will replace attr_accessible as the default security solution for Rails 4. If you’re starting a new Rails 3.x app today, you should default to using it, as it’s a much better solution.

If you’re on Rails 2.3 or 3.0, you have CVE-2013-0277.

If you serialize attributes into the database, they can be deserialized via YAML, with the same implications as the previous YAML vulnerabilities.

Finally, the JSON gem has CVE-2013-0269.

The JSON gem can be made to symbolize user input, which can cause a denial of service attack, since symbols are not garbage collected.

For More

You might also want to see the official release announcement, which includes hashes of the gemfiles.

Discuss at Hacker News if you have questions or thoughts to share.

The post New security releases for Rails: Rails 3.2.12, 3.1.11, and 2.3.17 appeared first on The Changelog.

Topaz is written in Python on top of the RPython translation toolchain (the same one that powers PyPy). Its primary goals are simplicity and performance.

Because Topaz builds on RPython, and thus much of the fantastic work of the PyPy developers, it comes out of the box with a high performance garbage collector, and a state of the art JIT (just-in-time) compiler. What does this mean? Out of the box Topaz is extremely fast.

Topaz is far from complete and is missing many builtin methods and classes. However, it does have nearly every element of Ruby, including classes, blocks, many builtin types, all sorts of method calls, and much much more. We don’t yet consider it stable, but it’s getting closer every day.

Check out the source and readme on GitHub to get started.

Give a shout out to Alex Gaynor for his hard work on this.

The post Topaz, a new Ruby written in Python on top of RPython appeared first on The Changelog.

He wrote a great article on why he decided to launch HashiCorp now, and I encourage you to read it. The best way to summarize the change comes from the article itself:

I must stress that Vagrant will always remain open source and liberally licensed. The difference moving forward is that I will be working on it full-time.

As always, you can visit Vagrant’s website or view the source on GitHub.

The post Vagrant, by HashiCorp appeared first on The Changelog.

From the readme:

Linotype is a simple ruby implementation of the Letterpress for iOS game mechanic. Letterpress was created by Loren Brichter and is sold on iTunes. Linotype is meant to be used to write other programs such as simple player command line games, cheating/simulation programs, web-based versions, or whatever else you can think of. My goal is that the community will submit pull requests to this project so that programs can share a common engine.

Sean’s goal with this project is to have the community submit pull requests so the other programs can share a common game engine. Also the readme has a few feature ideas mentioned.

Check out the source on GitHub to get started, or discuss at Hacker News.

The post Linotype is atebits’ Letterpress game engine in Ruby appeared first on The Changelog.

Rake 10 is out (and its backwards compatibility release 0.9.3) is out as well. github.com/jimweirich/rak…

— Jim Weirich (@jimweirich) November 12, 2012

Also, below is a screenshot of Rake’s version history shown at RubyGems.org. Notice the jump from 0.9.6 to 10.0.0.beta.1. What’s up with that?

If you’ve had a chance to hear Jim talk at conferences or over twitter about Rake’s version history, he often gets asked, “Jim, when will Rake reach version 1.0?”

Well, from the readme for 10.0.0, he has this to say in response to that question:

Over the past several years I’ve been asked that question at conferences, panels and over twitter. Due to historical reasons (or maybe just plain laziness) Rake has (incorrectly) been treating the second digit of the version as the major release number. So in my head Rake was already at version 9.

Well, it’s time to fix things. This next version of Rake drops old, crufty, backwards compatibility hacks such as top level constants, DSL methods defined in Object and numerous other features that are just no longer desired. It’s also time to drop the leading zero from the version number as well and call this new version of rake what it really is: Version 10.

So, welcome to Rake 10.0!

At The Changelog, we love semantic versioning, and this is a case where the change was the right move to make!

The post Jim Weirich’s Rake goes from 0.9.6 to 10.0.0 appeared first on The Changelog.

I like to pair the guard-shell gem with ImageOptim to help me keep my project’s image assets compressed and ready for production. Make sure you have both guard and guard-shell in your Gemfile and set up a watcher in your Guardfile for new or edited images:

# Gemfile
gem 'guard'
gem 'guard-shell'

# Guardfile
guard 'shell' do
  watch %r{^public/images/.} do |file|
    n file[0], "#{file[0]} changed"
    `open #{file[0]} -a ImageOptim`
  end
end

An interesting side effect to note is that guard will catch the file change when ImageOptim is done compressing and re-open it in ImageOptim and continue this loop untill there’s nothing else ImageOptim can compress out of the image.

The post Using ImageOptim with guard-shell appeared first on The Changelog.

We’d love to start OpenHack in as many cities as possible. This site is meant to facilitate starting new OpenHack groups, but isn’t meant to actually “run” or “RSVP” for groups.

If you want to start an OpenHack in your city, just fork the openhack.github.com repo and follow the instructions at openhack.github.com/yours. If you have feedback or issues with the process, open an issue and ask for help.

BTW, I love how issues are used with this project, not to mention, the OpenHack site(s) are hosted on GitHub for free.

OpenHack basics

Copy and pasted from the homepage:

• You can hack on anything! Any language, framework, public/open-source, personal, etc.
• You don’t have to have an idea to hack on! You’re more than welcome to come just to pair with someone.
• Start off with a quick round of introductions (every night!), to say who you are, what you’re working on, and if you’d like help with your idea.
• Provide food and some coffee/drinks for attendees. Sponsors will help immensely with funding this.
• Someone has to host the meetup. That person is in charge of ordering food and starting off the intro.
• Don’t go too late. 9-10pm is good. Focus usually wanes by this point, for obvious reasons! Maybe if there’s interest head to a bar for more discussion.

What are you waiting for? OpenHack your city.

The post OpenHack your city appeared first on The Changelog.

• Full stack trace.
• Source code inspection, with highlighting.

As a bonus, if you install the extra dependency, you get access to the following features:

• REPL
• Local/instance variable inspection.

Installing it couldn’t be easier. While the project is usable outside of Rails, let’s assume you are using Rails/Bundler:

group :development do
  gem "better_errors"
  gem "binding_of_caller" # Optional, only for the advanced features
end

That’s it! Checkout the project on GitHub or view the README.

The post Better Rails development with better_errors! appeared first on The Changelog.

We’re making use of it :)

For example, we can…

Search by organization name:

Guidestar::Client.search(:name => "Help One Now")

Search by EIN:

Guidestar::Client.search(:ein => "26-3618295")

and more …

From the about page:

If you care about nonprofits and the work they do, then you’re affected by what GuideStar does. We gather and publicize information about nonprofit organizations. Our reach is far and wide. Our database is broad and deep. We encourage nonprofits to share information about their organizations openly and completely.

If you’re new to GuideStar, you can search and find the nonprofit information you need (or integrate with their API) – and it’s free.

Check out the source on GitHub or create your account to get started.

UPDATE: It turns out that access to the web search is free, but API access is not free. Bummer. Personally, I think a free limited API would be a smart choice for GuideStar.

The post Work with 1.8 million IRS-recognized Nonprofits in Ruby with the GuideStar API appeared first on The Changelog.

Selfstarter is an open source starting point for building out your own ad-hoc crowdfunding site. After getting rejected by Kickstarter, the fine folks at Lockitron decided to follow in the footsteps of App.net and make their own crowdfunding site for Lockitron.

Selfstarter is a starting point, so you’re going to have to make some additions to tailor it for your project.

The post Roll your own crowdfunding with Selfstarter appeared first on The Changelog.

• 1.9 based
• Low false positives
• Very fast (even on large code bases)
• Zero external dependencies

Using it is simple:

gem install cane
cane --abc-glob '{lib,spec}/**/*.rb' --abc-max 15

I spoke with Xavier, and two things he would love to see from the community are a flag for machine readable output, with an easy way to hook it into Jenkins, and a “sane way to wire in new checks.” Currently, extending cane requires you edit far too many files, visit this pull request for some background.

This is an extremely small, fast, and easy-to-use project that gives you some very cool features with a very small learning curve. View the Source at GitHub.

The post Cane – Ruby code quality thresholds appeared first on The Changelog.

require 'bundler'
Bundler.require

# Rack::CoreData requires a Sequel connection to a database  
DB = Sequel.connect(ENV['DATABASE_URL'] || "postgres://localhost:5432/coredata")

run Rack::CoreData('./Example.xcdatamodeld')

In summary:• AFIncrementalStore: *poof* no client code.• Rack::CoreData: *poof* no server code.

— Mattt Thompson (@mattt) July 24, 2012

View the Source for this project on GitHub.

The post Rack::CoreData – Automatically generate REST APIs for Core Data models appeared first on The Changelog.

Automate administrative tasks that you would normally have to do through the Apple Dev Center websites. Life’s too short to manage device identifiers by hand!

You can easily list devices like this:

$ ios devices:list

Easily add one like this:

$ ios devices:add "Sam's iPhone":abcdefg...

There’s support for the following commands:

• devices:add
• devices:remove
• certificates:list [-e development|distribution]
• certificates:add [-e development|distribution]
• certificates:download CERTIFICATE_NAME
• certificates:revoke CERTIFICATE_NAME
• app_ids:list
• app_ids:new

Definitely worth checking out if you spend any amount of time in the iOS Provisioning Portal. Thanks Mattt!

The post Cupertino – Mechanize the Apple Dev Center appeared first on The Changelog.

One of the most interesting things I’ve seen in awhile is EventMachine implemented using GCD.

If you’re doing any RubyMotion work, I think you should definitely checkout BubbleWrap!

The post BubbleWrap – Cocoa wrappers and helpers for RubyMotion (Ruby for iOS) – Making Cocoa APIs more Ruby like, one API at a time. appeared first on The Changelog.

Some of the engineers from Ooyala have released a new project that “makes code reviews fun.” It is a standalone piece of software that you host on your own (they recommend using Vagrant/VirtualBox).

With barkeep you get syntax-highlighted colored diffs, the ability to easily add your own features, a simple CLI, a REST API and plaintext (threadable) emails. Out of the box, barkeep offers many more features that will keep code reviews quick and entertaining. You can use barkeep with any git repo that has a reachable URL.

The team at Ooyala plans on growing barkeep as the community sees fit. Open issues as you play around with it – better yet, fork it and add new features yourself! Their style guidelines are simple: “mimic the style around you.”

You can view a live example, get some more information or browse the source at GitHub.

The post Barkeep – the Friendly Code Review System appeared first on The Changelog.

From the readme:

kinectable_pipe is a command-line utility that dumps user skeleton data from a Microsoft Kinect device to a standard Unix pipe.

Check out the project page or the source on GitHub for installation, background, and usage.

The post kinectable_pipe – Microsoft Kinect data in the command line appeared first on The Changelog.

Items mentioned in the show:

• Bully is Sam’s Pusher client for Objective-C.
• Get some Cheddar, Sam’s TODO app (soon in the App Store).
• Laurent Sansonetti, creator of RubyMotion (and MacRuby)
• MacRuby is an implementation of Ruby 1.9 on top of Mac OS X core technologies
• RubyMotion is a port of MacRuby for iOS
• RubyMotion comes with a built-in REPL.
• RubyMotion allows you to run your application using rake at the command line.
• Titanium lets you create iOS apps using JavaScript
• MonoTouch allows you to create iOS apps with C# and .NET
• RubyMotion is not entirely open source, but the command line toolchain is.
• Redcar is an open source editor that Laurent likes.
• RubyMotion allows you to work entirely in the command line.
• CocoaPods was on a previous episode.
• The creator of CocoaPods, Eloy Durán is Laurent’s personal hero.
• Sam Soffes, an Objective-C developer and a Rubyist sees a great fit for RubyMotion.
• RubyMotion will have a debugger in the future that can run in the simulator and on the device.
• The REPL will not be ported back to MacRuby.
• RubyMotion memory management is very similar to ARC, but it happens at runtime.
• A new version of memory management will be released in a few months.
• Laurent uses macvim and gdb.
• Laurent wants to backport the memory model of RubyMotion to MacRuby.
• RubyMotion ships with a flavor of bacon for testing. Bacon is a small RSpec clone.
• Laurent mentioned rm-redgreen to colorize your rake specs.
• Wynn mentioned cucumber.
• Sam mentioned capybara.

The post Episode 0.8.2 – Ruby Motion, MacRuby and more with Laurent Sansonetti appeared first on The Changelog.

> require 'descriptive_statistics'
 => true 
> data = [2,6,9,3,5,1,8,3,6,9,2]
 => [2, 6, 9, 3, 5, 1, 8, 3, 6, 9, 2] 
> data.number
 => 11.0 
> data.sum
 => 54 
> data.mean
 => 4.909090909090909 
> data.median
 => 5.0 
> data.variance
 => 7.7190082644628095 
> data.standard_deviation
 => 2.778310325442932 
> data.percentile(70)
 => 6.0

Browse the source or fork on GitHub.

Update: Francois-Guillaume Ribreau has ported the project to JavaScript as a NPM package.

Update 2: Gleicon Moraes has created a Python port.

The post Descriptive statistics – extend Ruby Enumerable for common stats methods appeared first on The Changelog.

$ Mass.index Foo #=> {}

$ f = Foo.new
$ b1 = Foo::Bar.new
$ b2 = Foo::Bar.new
$ t = Thing.new

$ f.object_id #=> 2154166500
$ b1.object_id #=> 2154037400
$ b2.object_id #=> 2154126780
$ t.object_id #=> 2154372180

$ Mass.index Foo #=> {"Foo"=>[2154166500], "Foo::Bar"=>[2154037400, 2154126780]}
$ Mass.index Foo::Bar #=> {"Foo::Bar"=>[2154037400, 2154126780]}
$ Mass.index Thing #=> {"Thing"=>[2154372180]}
$ Mass.index #=> {"String"=>[2151797000, 2151797080, 2151797120, 2151797140, ... a lot of more classes and object_ids}
$ Mass.index OneMoreThing #=> {}

As always, check the README for usage. The source is on GitHub.

The post Ruby Mass – introspection for the heap appeared first on The Changelog.

Thanks to Mike’s linkblog, another project has caught my eye. Virtus from Piotr Solnica extracts DataMapper’s Property API, for the times when you need to implement attributes on your objects yet maintain a bit more encapsulation. I love the module approach for defining properties:

module Name
  include Virtus

  attribute :name, String
end

module Age
  include Virtus

  attribute :age, Integer
end

class User
  include Name, Age
end

user = User.new(:name => 'John', :age => '30')

Check the excellent README or source on GitHub for more.

The post Virtus – give your Ruby objects DataMapper-like attributes appeared first on The Changelog.

One of the biggest updates in this version is the switch to OAuth as the default authentication method. This was necessary because Userstreams and Site Streams exclusively work on OAuth. You can still use basic authentication, but both Twitter and TweetStream strongly encourage you to switch, so you can enjoy the new features. Don’t worry, it’s simple.

The gem itself is built on top of em-twitter, which is an EventMachine client for the Twitter Streaming API.

Getting up and running couldn’t be easier:

require 'tweetstream'

TweetStream.configure do |config|
  config.consumer_key  = "123456789"
  config.consumer_secret = "abcdefghijklmnopqrstuvwxyz"
  config.oauth_token = "123456789"
  config.oauth_token_secret = "abcdefghijklmnopqrstuvwxyz"
  config.auth_method = :oauth
end

TweetStream::Client.new.userstream do |status|
  puts "#{status.user.screen_name}: #{status.text}"
end

t, a command line interface for twitter (covered in a previous article), is also built on top of the TweetStream gem.

Head on over to GitHub to view the source code and browse the documentation.

The post TweetStream – Easily access the Twitter Streaming API appeared first on The Changelog.

Stay tuned, Laurent will be our guest on the next episode.

The post RubyMotion toolchain now open source appeared first on The Changelog.

# Send a metric
RestClient.post("https://backstop.example.com/publish/custom",
   [{:metric => key, :value => value, :measure_time => Time.now.to_i}].to_json)

# Send an annotation
RestClient.post("https://backstop.example.com/publish/note",
   [{:metric => "foobar.release", :value => "v214", :measure_time => Time.now.to_i}].to_json)

Check the README for local usage and instructions for deploying to Heroku.

The post Backstop – Simple HTTP service for submitting metrics to Graphite appeared first on The Changelog.

Items mentioned in the show

• Tony Arcieri, creator of Celluloid.
• Celluloid is painless multithreaded programming for Ruby.
• Celluloid:IO provides evented I/O for Celluloid actors.
• DCell lets you build distributed Celluloid apps over 0MQ.
• Adam Keys, formerly of Gowalla, is now teammates with Tony at Living Social.
• Zed gave us the lowdown on 0MQ on 0.3.4.
• Reel aims to be a fast, non-blocking evented web server without a Rack API.
• Tony is aiming to get Reel working with Webmachine.
• Sean Cribbs talked Riak on a previous episode.
• Hubot is GitHub’s awesome Campfire bot.
• Travis uses Celluloid, as discussed on 0.7.5.
• Tony is shutting down LightRail since the release of Rails::API, from Santiago Pastorino.
• ActiveModel::Serializer aims to provide an object to encapsulate serialization of ActiveModel objects, including ActiveRecord objects.
• Wynn loves jbuilder despite its name.
• E is the secure distributed pure-object platform and p2p scripting language.
• Data, context and interaction is a paradigm used in computer software to program systems of communicating objects.
• Tahoe-LAFS is a Python-powered decentralized secure filesystem.
• Tony likes Clojure.
• Joe Armstrong and Robert Virding, creators of Erlang are Tony’s programming heroes.

The post Episode 0.8.1 – Celluloid, concurrency, and more with Tony Arcieri appeared first on The Changelog.

Since your web server is presumably already booted, there’s no startup tax to see your routes. Check out Richard’s blog post or the source on GitHub for more.

The post Sextant – view your Rails routes without waiting on Rake appeared first on The Changelog.

rake rspec:uncommitted    
rake rspec:unpushed
rake rspec:unmerged

It looks like a nice way to filter specs for those using a git-based workflow. Source on GitHub.

UPDATE: As Alex Soulim points out, it works with SVN, too.

The post rspec-rails-uncommitted – Selectively run specs based on git status appeared first on The Changelog.

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.

The post Imperator – Command pattern for Ruby apps appeared first on The Changelog.

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.

The post Ruby Motion Samples – Write iPhone Apps In Ruby appeared first on The Changelog.

T supports a massive list of commands and subcommands including anything you’d expect in a Twitter client, but the real power is in piping commands together, Unix style:

Favorite the last 10 tweets that mention you:

t mentions -n 10 -l | awk '{print $1}' | xargs t favorite

Count the number of employees who work for Twitter:

t list members twitter team | wc -l

Add everyone you’re following to that list (up to 500 users):

t followings | xargs t list add following-`date "+%Y-%m-%d"

Check out the README for installation and usage.

The post t – Powerful command line interface for Twitter appeared first on The Changelog.