Wilfrido Nuqui Jr. wnuqui

Inheritance is a key concept in most object-oriented languages, but applying it skillfully can be challenging in practice. Back in 1989, M. Sakkinen wrote a paper called Disciplined inheritance that addresses these problems and offers some useful criteria for working around them. Despite being more than two decades old, this paper is extremely relevant to the modern Ruby programmer.

Sakkinen's central point seems to be that most traditional uses of inheritance lead to poor encapsulation, bloated object contracts, and accidental namespace collisions. He provides two patterns for disciplined inheritance and suggests that by normalizing the way that we model things, we can apply these two patterns to a very wide range of scenarios. He goes on to show that code that conforms to these design rules can easily be modeled as ordinary object composition, exposing a solid alternative to tradi

	# https://www.varnish-cache.org/docs/2.1/tutorial/vcl.html
	# https://www.varnish-cache.org/trac/wiki/VCLExamples

	# Summary
	# 1. Varnish will poll the backend at /health_check to make sure it is
	# healthy. If the backend goes down, varnish will server stale content
	# from the cache for up to 1 hour.
	# 2. Varnish will pass X-Forwarded-For headers through to the backend
	# 3. Varnish will remove cookies from urls that match static content file
	# extensions (jpg, gif, ...)

	require "amqp"

	EventMachine.run do
	connection = AMQP.connect
	channel = AMQP::Channel.new(connection)

	replies_queue = channel.queue("", :exclusive => true, :auto_delete => true)
	replies_queue.subscribe do \|metadata, payload\|
	puts "[response] Response for #{metadata.correlation_id}: #{payload.inspect}"
	end

	Feature: Updating an existing request
	In order to change my mind about what I need
	I want to be able to edit my Request

	Background: Logged in via facebook with one request
	Given I am logged in with facebook
	And I have a request for "Dragon's Lair Arcade Game" at $2000

	Scenario: Logged in users can edit requests
	When I change the request to "iPhone6" at $300

	# Example of .jrubyrc

	# Set compilation mode. JIT = at runtime; FORCE = before execution. (JIT, FORCE, OFF, OFFIR)
	# compile.mode = FORCE

	# Dump to console all bytecode generated at runtime.
	# compile.dump = true

	# Enable verbose JIT logging (reports failed compilation)
	# jit.logging.verbose = true

	# MOTIVATION: As rails apps are growing, people are noticing the drawbacks
	# of the ActiveRecord pattern. Several apps I have seen, and several
	# developers I have spoken to are looking towards other patterns for object
	# persistence. The major drawback with ActiveRecord is that the notion
	# of the domain object is conflated with what it means to store/retrieve
	# it in any given format (like sql, json, key/value, etc).
	#
	# This is an attempt to codify the Repository pattern in a way that would
	# feel comfortable to beginner and seasoned Ruby developers alike.
	#

	tables = ActiveRecord::Base.connection.tables
	tables.delete(ActiveRecord::Migrator.schema_migrations_table_name)
	tables.each { \|table\| ActiveRecord::Base.connection.reset_pk_sequence!(table) }

	if Rails.env.development?

	Rails.application.assets.logger = Logger.new('/dev/null')

	Rails::Rack::Logger.class_eval do
	def call_with_quiet_assets(env)
	previous_level = Rails.logger.level
	Rails.logger.level = Logger::ERROR if env['PATH_INFO'] =~ %r{^/assets/}
	call_without_quiet_assets(env)
	ensure

	def collect(&block)
	inject([]) { \|memo, obj\| memo << block.call(obj) }
	end

	def detect(&block)
	inject(nil) { \|memo, obj\| memo \|\|= obj if block.call(obj) }
	end

	def reject(&block)
	inject([]) { \|memo, obj\| block.call(obj) ? memo : memo << obj }

	describe Article do
	def article; Article.new :title => "Lorem ipsum"; end

	it "has a title" do
	article.title.should eq("Lorem ipsum")
	end
	end