justinko

Dear Rubyists,

I just lost a contract because of my code in a Rails project.

The specific code in question is related to a "posting a comment" feature. Here are the details:

In this project, "posting a comment" does not simply entail inserting a row into the database. It involves a procedure to yes, insert a row, but also detect its language, check for spam, send emails, and "share" it to Twitter and Facebook. I believe this algorithm should be encapsulated. I do not believe it belongs in a controller or a model. I do not believe Active Record callbacks should be used.

The "senior developer", whom is the stake holder's right hand man, said this:

saleandro

module Models::Storage
  class Artist < ActiveRecord::Base
     validates_presence_of :name   
  end
end

---

module Models
  class Artist

croaky

module DelayedJob
  module Matchers
    def enqueue_delayed_job(handler)
      DelayedJobMatcher.new handler
    end

    class DelayedJobMatcher
      def initialize(handler)
        @handler = handler
        @attributes = {}

andkerosine

$stack, $draws = [], {}

def method_missing *args
  return if args[0][/^to_/]
  $stack << args.map { |a| a or $stack.pop }
  $draws[$stack.pop(2)[0][0]] = args[1] if args[0] == :<
end

class Array
  def +@

mattetti

::Redis::Client.class_eval do

  # Support older versions of Redis::Client that used the method
  # +raw_call_command+.
  call_method = ::Redis::Client.new.respond_to?(:call) ? :call : :raw_call_command

  def call_with_stats_trace(*args, &blk)
    method_name = args[0].is_a?(Array) ? args[0][0] : args[0]
    start = Time.now
    begin

alandotcom

Originally posted as a private gist

Inspiration: What's that & doing?

Before I get started, the inspiration behind this was a piece of code written to solve a Ruby exercise: Write a method reverse_words which takes a sentence as a string and reverse each word in it.

The solution that set me on a journey of diving deeper into closures was this one, by Daniela Grossman:

	def reverse_words(str)
 str.split(' ').map(&:reverse).join(' ')

jasonrudolph

About

This gist is a collection of my rough notes from Strange Loop 2012.

@jasonrudolph on Twitter | @jasonrudolph on GitHub

Did I Mention That They're Rough?

brianstorti

#Practical Object Oriented Design in Ruby

Design that anticipate specific future requirements almost always end badly.
Practical design does not anticipate what will happen to your application, it merely accepts that something
will and that, in the present, you cannot know what. It does not guess the future; it preserves your options for accommodating the future.
It doesn't choose; it leaves you room to move.
The purpose of design it to allow you to do it later and its primary goal is to reduce the cost of change.

Design is more the art of preserving changeability than it is the act of achieving perfection.

jcoglan

$VERBOSE = nil
require File.expand_path('../rooby', __FILE__)


Person = Rooby::Class.new 'Person' do
  define :initialize do |name|
    @name = name
  end
  
  define :name do

pmarreck

# Ruby fizzbuzz, functional style, no conditionals whatsoever

one_if_divisible_by = lambda{|num, x| (1-((x.to_f / num) % 1).ceil)}.curry
fizz1 = one_if_divisible_by.(3)
buzz1 = one_if_divisible_by.(5)
one_to_word = lambda{|func, word, n| word * func.(n)}.curry
one_to_n_to_s = lambda{|func, n| n.to_s * func.(n)}.curry
fizz = one_to_word.(fizz1,'Fizz')
buzz = one_to_word.(buzz1,'Buzz')