davidcharlesweber

desc 'Generate and execute jmeter test plan'
task :generate_jmeter_plan do |t, args|
  require 'ruby-jmeter'
  generate_report
end

def generate_report
  uri = URI('https://yourapp.com')
  domain = uri.host
  test do

kule

require 'bundler/inline'

gemfile do
  source 'https://rubygems.org'
  gem 'colorize'
end

class MatcherInterface
  def initialize(some_object)
    @some_object = some_object

skiadas

The thing that students have the hardest time on when learning functional programming is how to process a recursive structure while maintaining some sort of "state", the result if you will. I'll attempt here to demystify the process.

Functional programming languages almost always use a lot of recursively defined structures. Depending on the language those can be implemented in various ways, but in any case the end result is the same. A structure of this type is either an "atom", i.e. an irreducible thing, or a "compound" consisting of substructures of the same form.

For example a "list" is either an Empty/Nil list (the "atom") or it is formed as a Cons of a value and another list (compound form). That other "sublist" can itself be empty or another cons and so on and so forth. A tree is similar. It is either empty, or it consists of a triple of a value and two sub-trees, left and right.

Almost every problem we encounter is a question about doing something with all entries in a structure. To solve these prob

staltz

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

---

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.

---

nabucosound

#!/bin/bash

# Source: http://blog.nonuby.com/blog/2012/07/05/copying-env-vars-from-one-heroku-app-to-another/

set -e

sourceApp="$1"
targetApp="$2"

while read key value; do

mkyed

class Delayed::Job
  scope :waiting, lambda{where(failed_at: nil).where(locked_at: nil)}

  def self.include?(object, method_name = nil, queue = :default)
    object_class = object.respond_to?(:id) ? object.class : object
    object_id = object.respond_to?(:id) && object.id
    waiting.where(queue: queue).detect do |job|
      o = job.payload_object.object
      m = method_name.present? ? job.payload_object.method_name : nil
      o_class = o.respond_to?(:id) ? o.class : o

mpeteuil

#!/usr/bin/env ruby

require 'english'
require 'rubocop'

ADDED_OR_MODIFIED = /A|AM|^M/.freeze

changed_files = `git status --porcelain`.split(/\n/).
    select { |file_name_with_status|
      file_name_with_status =~ ADDED_OR_MODIFIED