Wilson Silva wilsonsilva

The introduction to Reactive Programming you've been missing

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

Dependency Injection in Ruby 07 Oct 04

Introduction

At the 2004 Ruby Conference, Jamis Buck had the unenviable task to explain Dependency Injection to a bunch of Ruby developers. First of all, Dependency Injection (DI) and Inversion of Control (IoC) is hard to explain, the benefits are subtle and the dynamic nature of Ruby make those benefits even more marginal. Furthermore examples using DI/IoC are either too simple (and don’t convey the usefulness) or too complex (and difficult to explain in the space of an article or presentation). I once attempted to explain DI/IoC to a room of Java programmers (see onestepback.org/articles/dependencyinjection/), so I can’t pass up trying to explain it to Ruby developers.

Thanks goes to Jamis Buck (the author of the Copland DI/IoC framework) who took the time to review this article and provide feedback.

What is Dependency Injection?

Producer consumer pattern

Question: Can you write code implementing the consumer and producer pattern?

This is a classic concurrency problem where we have threads generating data to be consumed (producers) by other threads (consumers).

The implementation with POSIX threads can be a pain in the ass but it is quite straight forward in golang thanks to its concurrency constructs.

Concept

People talk about two servers: a web server (e.g. Nginx, Apache, etc.) and a app server (e.g. Language specific servers like Unicorn, Node.js, Tomcat, Http-Kit, etc.). There are exceptions where app servers not required at all (as web server itself provides preprocessors for handling), but let's not talk about now.
Web servers are really fast and supports lot of standard and commonly used MIME-type requests. Concept of serving a file is -- forming and sending a response of bytes of data and labeling it with requested MIME-type by a client (e.g. web browser).
Every response format (in layman's language, a file) is recognized by it's MIME-type, for e.g. a PNG image file has "image/png" MIME-type. JavaScript file has "text/javascript". HTML responses (or files) has "text/html". Plain text files have "text/plain".
Modern Browsers supports a lot of standard MIME-types. Images, videos, text files (XML, HTML, SVG, JS), and they better know how to visualize it. Browser also knows unrec

	namespace :ci do
	desc 'Run rubocop for CI environment'
	task :rubocop do
	args = %w{
	--require ./lib/rubocop/formatter/progress_formatter_no_report
	--format Rubocop::Formatter::ProgressFormatterNoReport
	--require rubocop/formatter/checkstyle_formatter
	--format Rubocop::Formatter::CheckstyleFormatter
	--rails
	--fail-level error

	#! /usr/bin/env ruby

	require 'socket'

	def log( source, message)
	time = Time.now.strftime("%Y-%m-%d %H:%M:%S")
	puts "[%s] %s => %s" % [time, source, message]
	end

	server = TCPServer.new ARGV.first.to_i

	#! /usr/bin/env ruby

	require 'socket'

	def log(source, message)
	time = Time.now.strftime("%Y-%m-%d %H:%M:%S")
	puts "[%s] %s => %s" % [time, source, message]
	end

	# Class representing HTTP Requests

	#!/bin/bash
	#####################################################
	# Name: Bash CheatSheet for Mac OSX
	#
	# A little overlook of the Bash basics
	#
	# Usage:
	#
	# Author: J. Le Coupanec
	# Date: 2014/11/04

	# Elixir has pipes `\|>`. Let's try to implement those in Ruby.
	#
	# I want to write this:
	#
	# email.body \| RemoveSignature \| HighlightMentions \| :html_safe
	#
	# instead of:
	#
	# HighlightMentions.call(RemoveSignature.call(email.body)).html_safe
	#

	A = ->(s){ s << "a" }
	B = ->(s){ s << "b" }
	C = ->(s){ s << "c" }

	str = ""


	class Object
	PIPED = ->(args, arg){ arg.is_a?(Proc) ? arg[PIPED[args]] : arg }