nlinn

Liebes blau-Team,

wir möchten uns für die tolle Zusammenarbeit in den letzten Jahren persönlich bedanken
und laden daher alte und neue Kollegen, Freelancer und Wegbegleiter ein, mit uns auf
die spannende, lehrreiche und manchmal auch anstrengende Zeit anzustoßen, die nun
hinter uns liegt.

Wir treffen uns an einem für blau vertrauten Ort

im 13. Stock (Max-Brauer-Allee 277, Ecke Schulterblatt)

henrik

# For Wasabi 3.0.0.
# Marshals WSDL for a huge speedup with large files.
# A 3 MB WSDL went from around 30 to 2 seconds.
# Marshalling: 3.1 MB -> 629 KB.
# Zipping: 629 KB -> 59 KB.

module Wasabi
  class Parser
    alias_method :old_parse, :parse

jfirebaugh

Researchers investigating the Rails parameter parsing vulnerability discovered that the same or similar vulnerable code had made its way into multiple other libraries. If your application uses these libraries to process untrusted data, it may still be vulnerable even if you have upgraded Rails. Check your Gemfile and Gemfile.lock for vulnerable versions of the following libraries.

Directly vulnerable libraries

rails

Vulnerable: <= 3.2.10, <= 3.1.9, <= 3.0.18, <= 2.3.14

Fixed: 3.2.11, 3.1.10, 3.0.19, 2.3.15

multi_xml

mislav

Jim Weirich:

This is how I explain it… Ruby has Procs and Lambdas. Procs are created with Proc.new { }, lambdas are created with lambda {} and ->() {}.

In Ruby 1.8, proc {} creates lambda, and Ruby 1.9 it creates procs (don't ask).

Lambdas use method semantics when handling parameters, procs use assignment semantics when handling parameters.

This means lambdas, like methods, will raise an ArgumentError when called with fewer arguments than they were defined with. Procs will simply assign nil to variables for arguments that were not passed in.

brentjanderson

/*jshint browser:true */
/*global DS:true, io:true, App:true */

(function() {
	'use strict';

	// Initializer for Models
	window.Models = {};
	console.warn("Don't pollute the global namespace with Models!");

ryanb

My issues with Modules

In researching topics for RailsCasts I often read code in Rails and other gems. This is a great exercise to do. Not only will you pick up some coding tips, but it can help you better understand what makes code readable.

A common practice to organize code in gems is to divide it into modules. When this is done extensively I find it becomes very difficult to read. Before I explain further, a quick detour on instance_eval.

You can find instance_eval used in many DSLs: from routes to state machines. Here's an example from Thinking Sphinx.

class Article < ActiveRecord::Base

peterc

I'm a Rubyist with a lot of admiration for Python. Both languages are
similar (in the grand scheme of things) and each has huge pros and cons.

Python does not click for me in the same way as Ruby does not
click for perhaps the majority of programmer-kind. German doesn't click
for me either and 100m+ people speak that ;-) But I recently saw an
example of WHY Python taxes my Ruby brain a little.

I found some code at http://lukeplant.me.uk/blog/posts/why-learning-haskell-python-makes-you-a-worse-programmer/:

jimweirich

Today I ran a quick twitter poll asking: "What is the state of the art
in Ruby SOAP clients".

Savon (http://savonrb.com/) was by far the big winner with 29
recommendations.

Surprisingly Soap4r actually got 6 votes, but most were accompanied by
comments like "the last time I used SOAP". It was also the only entry
that got negative votes (3) with comments like "soap4r is broken and
crap by the way".

jnicklas

require "timeout"

module WaitSteps
  extend RSpec::Matchers::DSL

  matcher :become_true do
    match do |block|
      begin
        Timeout.timeout(Capybara.default_wait_time) do
          sleep(0.1) until value = block.call

thenoseman

" Executes the current ruby line when there is a # =>
" marker at the end replacing it with the evaled
" result
function! RubyExecuteLineWithMarker()
    ruby << EOF
        marker = '# =>'
        buffer = VIM::Buffer.current
        if buffer.line.match(/#{marker}/)
          result = marker + ' ' + eval(buffer.line, binding).inspect
          buffer.line = buffer.line.sub(/#{marker}.*/, result).chomp