mattyoho

require 'httparty'
require 'json'

class Campfire
  include HTTParty
  base_uri 'https://YOUR_DOMAIN.campfirenow.com'
  basic_auth 'YOUR_API_KEY', 'X' # yes, that is a literal X string. it's needed to satisfy basic_auth(), but campfire ignores it.
  headers    'Content-Type' => 'application/json'
  
  def self.speak(message)

mattyoho

# Just drop this little diddy in your app to get some (not perfect) information on query times and such
# This will eventually become an official plugin but for those who can't wait, enjoy.
if defined?(NewRelic)
  module MMNewRelicTracing
    def self.included(model)
      model.metaclass.class_eval do
        add_method_tracer :find,        'Database/#{self.name}/find'
        add_method_tracer :find!,       'Database/#{self.name}/find!'
        add_method_tracer :paginate,    'Database/#{self.name}/paginate'
        add_method_tracer :first,       'Database/#{self.name}/first'

mattyoho

# This is how you can get a user's location using MacRuby and CoreLocation
framework 'CoreLocation'

def locationManager(manager, didUpdateToLocation: new_location, fromLocation: old_location)
  puts "location: #{new_location.description}"
  exit
end

loc = CLLocationManager.alloc.init
loc.delegate = self

mattyoho

namespace :resque do
  desc "Process exactly one job and quit"
  task :work_one => :setup do
    require 'resque'

    worker = nil
    queues = (ENV['QUEUES'] || ENV['QUEUE']).to_s.split(',')

    begin
      worker = Resque::Worker.new(*queues)

mattyoho

# I have a repo with two commits
failbowl:temp(master) grb$ git shortlog
Gary Bernhardt (2):
      commit 1
      commit 2

# I destroy the second commit
failbowl:temp(master) grb$ git reset --hard HEAD^
HEAD is now at 7454aa7 commit 1

mattyoho

/* This is when a refactoring really pays off.
 *
 * In order to make your code more modular, avoid hard-coding assumptions (or refactor them away).
 * The most fundamental, anti-modular assumption in Object-Oriented software is the concrete type of objects.
 * Any time you write "new MyClass" in your code (or in Ruby MyClass.new) you've hardcoded
 * an assumption about the concrete class of the object you're allocating. These makes it impossible, for example,
 * for someone to later add logging around method invocations of that object, or timeouts, or whatever.
 * 
 * In a very dynamic language like Ruby, open classes and method aliasing mitigate this problem, but
 * they don't solve it. If you manipulate a class to add logging, all instances of that class will have

mattyoho

module ParameterizedConcern
  def extended(mod = nil, &block)
    unless mod
      @extended_block = block
      return
    end

    mod.module_eval(&@extended_block) if @extended_block
  end

mattyoho

nkallen_: nkallen_: anyway, i want to stress that we basically agree about things so i want to be sure that the tone of the blog post is such
[7:25pm] nkallen_: [7:17pm] nkallen_: i would argue that what you do in rails 3 (according to these tweets I've read)
[7:25pm] nkallen_: [7:17pm] nkallen_: is exactly what I propose... this is just how one might do it in Ruby
[7:25pm] nkallen_: [7:18pm] nkallen_: but my point is conceptual and not about ruby
[7:25pm] nkallen_: [7:18pm] nkallen_: it applies to every oo language and also I might argue to functional languages
[7:25pm] nkallen_: [7:18pm] nkallen_: which is to structure a program around the ability to layer on enhanced functionality and ensure that no assumptions are hardcoded by abstracting over the manufacture of objects
[7:25pm] nkallen_: [7:19pm] nkallen_: in the literature, these techniques are called DI, decorators, and factories.
[7:25pm] nkallen_: [7:20pm] nkallen_: i like these terms because they reflect the concepts that are at work. because ruby m

mattyoho

# not sure if i like this or not
# but it was fun to write!

# :Foo => Foo, :Foo, :Bar => Foo::Bar, etc
def with_foo_like_class(*args)
  klass = if args.size == 1
    klass_obj = Class.new
    Object.const_set(args[0], klass_obj)
  else
    klass_sym = args.pop

mattyoho

2010 Modularity Olympics

This is a contest, open to programming languages from all nations, to write modular and extensible code to solve the following problem: Implement a service that can run queries on a database.

The Challenge

Sounds simple right? Wrong! A programmer without control over the source-code of that service must be able to later add enhancements such as statistics collecting, timeouts, memoization, and so forth. There are a few more requirements:

1. the “enhancements” must be specified in a configuration object which is consumed at run-time (e.g., it could be based on user-input).
2. The enhancements are ordered (stats collecting wraps timeouts, not the other way around) but it must be possible to reverse the order of the enhancements at run-time.
3. The enhancements must be “surgical” and not “global”. That is, it must be possible to simultaneously have two query services, one reversed and one not reversed, and even have a query service without any enhancements.