robmiller

words = %w{foo bar baz}
n     = 10

# If we use sample, we get a random order but never
# more than 3 entries:
words.sample(n)
# => ["bar", "foo", "baz"]

# A solution:
n.times.map { words.sample }

robmiller

def method_a
  method_b do |thing|
    thing = 'hey'
  end
end

def method_b
  thing = nil
  thing = yield thing

robmiller

#!/usr/bin/env ruby

require 'av_capture'
require 'pathname'

session = AVCapture::Session.new
dev = AVCapture.devices.find(&:video?)

dir = Pathname(File.expand_path("~/Pictures/av"))
Dir.mkdir(dir) unless dir.exist?

robmiller

What is AOP?

Aspect Oriented Programming is a means to change the behaviour of – or add behaviour to – methods and functions (including constructors) non-invasively. The added behaviour is called “advice” and can be added before, after, or around the function it advises.

This description is similar to the Extract Surrounding refactoring method. The difference is in the direction of the change. It seems AOP is more focused at modifying existing behaviour non-invasively; where as the Extract Surrounding Method actually changes the source code to allow this type of behavioural modification.

robmiller

# foo.rb
def foo
  @db = PStore.new(data_file)
rescue PStore::Error
  raise DatabaseError.new("Database directory #{data_file} does not exist")
end

# foo_spec.rb
describe "#foo" do
  it "should raise an error when database directory is inaccessible" do

robmiller

class<<Golf=Class.new
  n=0;'a.reduce :*
    (?a..?z).to_a
    (1..a).reduce :*
    a.map{|s|z=s[0];z==?m?"hat(#{s})":z==?d?s[0..-2]+"(bone))":"dead"+s[3..-1]}
    (1..4).flat_map{|n|a.each_cons(n).to_a}
    (1..a).map{|a|a%15<1?"fizzbuzz":a%3<1?"fizz":a%5<1?"buzz":a}
    p=0;a.slice_before{|n|t=p+1<n;p=n;t}.map{|n|z="#{n[0]}";n.size>1?z+?-+"#{n[-1]}":z}
    i,j=0,1;(1..a).map{i=j+j=i}
    a.split.map{|s|s.size>10?s[0,4]+?.*3+s[-3,3]:s}.join" "'

robmiller

#!/usr/bin/env ruby

require 'net/http'
require "json"
require "pathname"
require "logger"

class Slack
  attr_reader :account, :token, :channel

robmiller

class Module
  def attribute(attribute, &block)
    case attribute
    when Hash
      name    = attribute.keys.first
      default = attribute[name]
    when String, Symbol
      name    = attribute
      default = nil
    end

robmiller

struct PrimeStream {
	current: int
}

impl PrimeStream {
	fn new() -> PrimeStream {
		PrimeStream { current: 1 }
	}
}

robmiller

use std::rand::{task_rng, Rng};
use std::os;
use std::collections::hashmap::HashSet;

fn main() {
	let num_threads = 8u;

	let args = os::args();
	let usage = "Usage: code-generator NUMCODES CODEFORMAT";