duplicates = multiple editions
A Classical Introduction to Modern Number Theory, Kenneth Ireland Michael Rosen
A Classical Introduction to Modern Number Theory, Kenneth Ireland Michael Rosen
... or Why Pipelining Is Not That Easy
Golang Concurrency Patterns for brave and smart.
By @kachayev
(def parent {:x1 0 :y1 0 :x2 600 :y2 400}) | |
(def rs [{:x1 0 :y1 0 :x2 300 :y2 200 } | |
{:x1 0 :y1 200 :x2 300 :y2 400 }]) | |
(defn negative-space [parent rs] | |
(let [x (apply max (map :x2 rs)) | |
y (apply min (map :y1 (filter (comp (partial = x) :x2) rs)))] | |
{:x1 x :y1 y :x2 (parent :x2) :y2 (parent :y2)})) | |
(negative-space parent rs) |
Find it here: https://github.com/bitemyapp/learnhaskell
It is possible to compile Go programs for a different OS, even though go build
says otherwise.
You'll need:
golang-crosscompile
helper script https://github.com/davecheney/golang-crosscompileMy efforts to port http://www.youtube.com/watch?v=f6kdp27TYZs to Clojure.
func boring(msg string) {
for i := 0; ; i++ {
fmt.Println(msg, i)
time.Sleep(time.Second)
}
In the mid-80s, while reading through my roommate's collection of Scientific American back issues, I encountered this introduction to Lisp written by Douglas Hofstadter. I found it very charming at the time, and provide it here (somewhat illegally) for the edification of a new generation of Lispers.
In a testament to the timelessness of Lisp, you can still run all the examples below in emacs if you install these aliases:
(defalias 'plus #'+)
(defalias 'quotient #'/)
(defalias 'times #'*)
(defalias 'difference #'-)
A slightly updated version of this doc is here on my website.
I visited with PagerDuty yesterday for a little Friday beer and pizza. While there I got started talking about Go. I was asked by Alex, their CEO, why I liked it. Several other people have asked me the same question recently, so I figured it was worth posting.
The first 1/2 of Go's concurrency story. Lightweight, concurrent function execution. You can spawn tons of these if needed and the Go runtime multiplexes them onto the configured number of CPUs/Threads as needed. They start with a super small stack that can grow (and shrink) via dynamic allocation (and freeing). They are as simple as go f(x)
, where f()
is a function.
i'm doing a bittorrent client in erlang
task: parse a lump of raw binary data from a socket into a list of bittorrent messages
my original implementation worked but was messy; the logic for parsing individual bittorrent messages was tangled with the logic for accumulating them into a list [should show this, ought to be somewhere in github.com/happy4crazy/ebc]
### | |
# Scheme code is translated to YARV byte code, then evaluated in the | |
# Ruby Virtual Machine | |
require 'rbconfig' | |
require 'dl' | |
require 'fiddle' | |
require 'strscan' | |
class RubyVM |