esperlu

#!/bin/sh

# Converts a mysqldump file into a Sqlite 3 compatible file. It also extracts the MySQL `KEY xxxxx` from the
# CREATE block and create them in separate commands _after_ all the INSERTs.

# Awk is choosen because it's fast and portable. You can use gawk, original awk or even the lightning fast mawk.
# The mysqldump file is traversed only once.

# Usage: $ ./mysql2sqlite mysqldump-opts db-name | sqlite3 database.sqlite
# Example: $ ./mysql2sqlite --no-data -u root -pMySecretPassWord myDbase | sqlite3 database.sqlite

olivierlacan

# switch default editor for pry to sublime text
Pry.config.editor = "sublime"

# format prompt to be <Rails version>@<ruby version>(<object>)>
Pry.config.prompt = proc do |obj, level, _|
  prompt = "\e[1;30m"
  prompt << "#{Rails.version} @ " if defined?(Rails)
  prompt << "#{RUBY_VERSION}"
  "#{prompt} (#{obj})>\e[0m"
end

db.go

package dropbox

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strconv"

ordinaryzelig

I'm a fan of MiniTest::Spec. It strikes a nice balance between the simplicity of TestUnit and the readable syntax of RSpec. When I first switched from RSpec to MiniTest::Spec, one thing I was worried I would miss was the ability to add matchers. (A note in terminology: "matchers" in MiniTest::Spec refer to something completely different than "matchers" in RSpec. I won't get into it, but from now on, let's use the proper term: "expectations").

Understanding MiniTest::Expectations

Let's take a look in the code (I'm specifically referring to the gem, not the standard library that's built into Ruby 1.9):

# minitest/spec.rb

module MiniTest::Expectations

AlexBaranosky

(def g
  [[:a1 :rdf/type :sdx/FederationService]
   [:a1 :sdx/exposesServices :a2]
   [:a2 :rdf/type :sdx/ServiceCollection]
   [:a2 :sdx/service :b1]
   [:a2 :sdx/service :c1]
   [:a2 :sdx/service :d1]

   [:b1 :rdf/type :sdx/FederatedService]
   [:b1 :sdx/exposesServices :b2]

zspine

dominictarr

node_modules/A/node_modules/B/node_modules/C/all.js

ptaoussanis

(def ^:private gc-sm-cache!                                                                                                                                                          
  "Maintains maximum cache size by intelligently pruning less valuable items."
  (let [gc-running? (atom false)]                                                                                                                                                 
    (fn [cache ttl max-items now]                                                                                                                                                  
      (when-not @gc-running?                                                                                                                                                      
        (reset! gc-running? true)                                                                                                                                                 
        (let [snapshot @cache                 

martintrojer

;; http://www.infoq.com/presentations/core-logic

(ns rdf
  (:refer-clojure :exclude [==])
  (:use [clojure.core.logic]))

(def g
  [[:a1 :rdf/type :sdx/FederationService]
   [:a1 :rdf/type :sdx/name "movies"]
   [:a1 :rdf/exposedServices :_syscoll1]

jakearchibald

Snow in canvas land

Other people's code is awful, and your own code from months previous counts as someone else's. With this and the festive spirit in mind, I dug up a canvas snow demo I made two years ago to see how bad my code really was.

Turns out the performance landscape has changed quite a bit, but after applying a couple of workarounds, best practices, and memory management, I got the demo running smoother than it ever did.

Ugh, I can't believe I just wrote "performance landscape". Anyway...

How does the demo work?