mourjo

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Commentary                                                            ;;
;;                                                                       ;;
;; The goal for writing this started with the idea to have tests run in  ;;
;; parallel using the leiningen plugin eftest                            ;;
;; https://github.com/weavejester/eftest.                                ;;
;;                                                                       ;;
;; With tests using with-redefs, it was not possible to run them in      ;;
;; parallel if they were changing the root binding of the same           ;;
;; vars. Here, we are binding the root of the var to one function that   ;;

anthonytxie

 def calc_allocations(self, date, quantity, cap):
        """Figure out ideal allocations for a given date"""
        # {
        #     coin_name: (percent_allocation, data)
        # }

        top_market = self.get_top_market(date, quantity)
        total_cap = sum([coin.market_cap for coin in top_market])

        allocations = [{

ptarjan

Scaling your API with rate limiters

The following are examples of the four types rate limiters discussed in the accompanying blog post. In the examples below I've used pseudocode-like Ruby, so if you're unfamiliar with Ruby you should be able to easily translate this approach to other languages. Complete examples in Ruby are also provided later in this gist.

In most cases you'll want all these examples to be classes, but I've used simple functions here to keep the code samples brief.

Request rate limiter

This uses a basic token bucket algorithm and relies on the fact that Redis scripts execute atomically. No other operations can run between fetching the count and writing the new count.

light44

import nltk
import pandas as pd
import re
import pprint
import operator
import csv
import logging
from stop_words import get_stop_words
from collections import defaultdict
from gensim import corpora

ragingwind

Backend Architectures

Twitter

ror, scala, jetty, erlang, thrift, mongrel, comet server, my-sql, memchached, varnish, kestrel(mq), starling, gizzard, cassandra, hadoop, vertica, munin, nagios, awstats

• Introduce Gizzard of Twitter - 트위터의 새로운 분산 관리 라이브러리 Gizzard를 소개합니다.
• The Architecture Twitter Uses to Deal with 150M Active Users, 300K QPS, a 22 MB/S Firehose, and Send Tweets in Under 5 Seconds
• Scaling Twitter: Making Twitter 10000 Percent Faster

yanok

val wc = Wildcard
val x = Variable "x"
val y = Variable "y"
val z = Variable "z"

fun tpl vs = Tuple vs
fun pair (a,b) = Tuple [a,b]
fun tp ps = TupleP ps
fun pp (a,b) = TupleP [a,b]

kachayev

-module(barber).
-export([run/2, barber/1, clients/1, simulator/2]).

-define(CUT_DUTAION, 20).

run(RoomSize, Duration) ->
    % create barber
    BPid = spawn(?MODULE, barber, [?CUT_DUTAION]),
    % run simulartor with barber PID
    SPid = spawn(?MODULE, simulator, [BPid, RoomSize]),

gjcourt

(defbolt split-category ["category" "event"]
  [tuple collector]
  (let [event (.getString tuple 0)
        category "testing_category2"]
    (comment
      (emit-bolt! collector [category event] :anchor tuple)
      )
    (emit-bolt! collector [category event] :anchor tuple :stream "3")
    (ack! collector tuple)))

gjcourt

(ns example.storm.clj.spout.kafka-spout
  (:import ; [example.storm.spout UnreliableKafkaSpout]
           [storm.kafka HostPort KafkaSpout SpoutConfig StringScheme]))

(def ^:dynamic *kafka-hosts* ["kafka-1.example.net"
                              "kafka-2.example.net"
                              "kafka-3.example.net"])

(def ^:dynamic *kafka-ports* [9093
                              9094

wmorgan

(ns potato.core
  (:use [slingshot.slingshot :only [throw+ try+]])
  (:use [clojure.string :only [trim split]]))

;; use this provide template values at write time (i.e. not compile time).
;; "name" will be the name of the template variable. "context", when not nil,
;; will be the value previously returned by *template-value* for the enclosing
;; section.
(defn ^:dynamic *template-value* [name context])