Timo Sulg timgluz

## LICENSE.txt
            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
                    Version 2, December 2004

 Copyright (C) 2011 YOUR_NAME_HERE <YOUR_URL_HERE>

 Everyone is permitted to copy and distribute verbatim or modified
 copies of this license document, and changing it is allowed as long
 as the name is changed.

            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE

## gist:2752959

      
              1 file
            
          
              0 forks
            
          
              0 comments
            
          
              1 star
            
          
                anaisbetts
                / gist:2752959
            
            
              Created
              May 20, 2012 05:47
            
              
                Data Miner
              
          
    Data Miner

GitHub has lots of data. User data, repository data, event data, you name it. We need someone to aggregate it, query it, and report back to us really interesting things to help better serve our community. Being a number geek that realizes R isn’t just a letter and loves Hadoop is great, but you also have to be able to communicate well within our team.
Our data is stored in a variety of formats such as MySQL, Redis, MongoDB, Riak, and Graphite, so knowledge of SQL and NoSQL databases and their associated querying languages would be useful.
We’d love if you’d work out of our San Francisco office, and we’ll pay to help you move. GitHub is a chance for you to come work with highly skilled, highly motivated professionals that are determined to build the best developer tools on the planet.
We provide an excellent compensation package: health, vision, and dental benefits + HSA contributions, competitive salary, and an open and friendly work environment. Read more about how GitHub works here: https:

  
## latency.txt
Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD

## anonymous
;; chouser's solution to Infinite Matrix
;; https://4clojure.com/problem/168

(fn [r f & [m n s t]]
  (map #(map (fn [x] (f % x)) (r n t)) (r m s)))
(fn r [a b]
  ({0 ()} b (lazy-cat [(or a 0)]
                      (r (+ (or a 0) 1) (- (or b 0) 1)))))

## ClientApp.java
package msgpack.rpc.sample.client;

import org.msgpack.rpc.Client;
import org.msgpack.rpc.loop.EventLoop;

public class ClientApp {
	private static class SpawnRequest {
		private SpawnRequest(final int clientCount, final int requestCount, final RPCInterface iface) {
			new Thread(new Runnable() {
				public void run() {

## pedantically_commented_playbook.yml
This playbook has been removed as it is now very outdated.

## scheme.sjs
macro sexp {
  case () => {
    ;
  }
  case ($p) => {
    $p
  }
  case ($x $y) => {
    $x($y);
  }

## resources.md

      
              1 file
            
          
              7 forks
            
          
              4 comments
            
          
              42 stars
            
          
                teropa
                / resources.md
            
            
              Last active
              December 4, 2020 05:42
            
              
                Clojure Resources
              
          
    Tutorials


The best tutorials are in the introductory books. See below.
Getting Started with Clojure - A detailed tutorial on getting a modern (as of Jan 2013) Clojure workflow going.

Emacs Live is a nice development environment based on Emacs.


Understanding The Clojure Development Ecosystem
Clojure Docs Site is a community-driven doc site with good tutorials, and reference material going somewhat deeper than individual API docs.
Functional Programming for the Rest of Us is a classic introduction to functional thinking
[A comprehensive article on namespaces and different ways of requiring them](http://blog.8thlight.com/colin-jones/2010/12/05/clojure-libs-and-namespaces-require-use-import-and-ns.


## golang-vs-clojure-async.md

      
              1 file
            
          
              9 forks
            
          
              7 comments
            
          
              58 stars
            
          
                danneu
                / golang-vs-clojure-async.md
            
            
              Last active
              November 6, 2023 04:09
            
              
                Google I/O 2012 - Go Concurrency Patterns ported to Clojure Video: http://www.youtube.com/watch?v=f6kdp27TYZs
              
          
    My efforts to port http://www.youtube.com/watch?v=f6kdp27TYZs to Clojure.
A boring function (6:22)

func boring(msg string) {
  for i := 0; ; i++ {
    fmt.Println(msg, i)
    time.Sleep(time.Second)
 }

  
## spellcheck.clj
;; Example implementation of Norvig's Spellchecker in Clojure,
;; using core.async
;;
;; There are probably some bugs in this.
;;
;; Original problem: https://github.com/ericnormand/spelling-jam
;; from Lambda Jam, Chicago, 2013: http://lambdajam.com/
;;
;; Clojure core.async introduction:
;; http://clojure.com/blog/2013/06/28/clojure-core-async-channels.html
	DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
	Version 2, December 2004

	Copyright (C) 2011 YOUR_NAME_HERE <YOUR_URL_HERE>

	Everyone is permitted to copy and distribute verbatim or modified
	copies of this license document, and changing it is allowed as long
	as the name is changed.

	DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
	Latency Comparison Numbers (~2012)
	----------------------------------
	L1 cache reference 0.5 ns
	Branch mispredict 5 ns
	L2 cache reference 7 ns 14x L1 cache
	Mutex lock/unlock 25 ns
	Main memory reference 100 ns 20x L2 cache, 200x L1 cache
	Compress 1K bytes with Zippy 3,000 ns 3 us
	Send 1K bytes over 1 Gbps network 10,000 ns 10 us
	Read 4K randomly from SSD* 150,000 ns 150 us ~1GB/sec SSD
	;; chouser's solution to Infinite Matrix
	;; https://4clojure.com/problem/168

	(fn [r f & [m n s t]]
	(map #(map (fn [x] (f % x)) (r n t)) (r m s)))
	(fn r [a b]
	({0 ()} b (lazy-cat [(or a 0)]
	(r (+ (or a 0) 1) (- (or b 0) 1)))))
	package msgpack.rpc.sample.client;

	import org.msgpack.rpc.Client;
	import org.msgpack.rpc.loop.EventLoop;

	public class ClientApp {
	private static class SpawnRequest {
	private SpawnRequest(final int clientCount, final int requestCount, final RPCInterface iface) {
	new Thread(new Runnable() {
	public void run() {
	macro sexp {
	case () => {
	;
	}
	case ($p) => {
	$p
	}
	case ($x $y) => {
	$x($y);
	}
	;; Example implementation of Norvig's Spellchecker in Clojure,
	;; using core.async
	;;
	;; There are probably some bugs in this.
	;;
	;; Original problem: https://github.com/ericnormand/spelling-jam
	;; from Lambda Jam, Chicago, 2013: http://lambdajam.com/
	;;
	;; Clojure core.async introduction:
	;; http://clojure.com/blog/2013/06/28/clojure-core-async-channels.html