ohanhi

Learning FP the hard way: Experiences on the Elm language

by Ossi Hanhinen, @ohanhi

with the support of Futurice 💚.

Licensed under CC BY 4.0.

Editorial note

seanjensengrey

This is a small demo of how to create a library in Rust and call it from Python (both CPython and PyPy) using the CFFI instead of ctypes.

Based on http://harkablog.com/calling-rust-from-c-and-python.html (dead) which used ctypes

CFFI is nice because:

• Reads C declarations (parses headers)
• Works in both CPython and PyPy (included with PyPy)
• Lower call overhead than ctypes

twotwotwo

github.com/twotwotwo/sorts is a Go package with parallel radix- and quicksorts. It can run up to 5x faster than stdlib sort on the right kind of large sort task, so it could be useful for analysis and indexing/database-y work in which you have to sort millions of items. (To be clear, I don't recommend most folks drop stdlib sort, which is great, and which sorts depends on.)

While the process of writing it's fresh on my mind, here are some technical details, some things that didn't make the cut, and some thoughts about the process:

Concretely, what this looks like inside:

• Both number and string versions are in-place MSD radix sorts that look at a byte at a time and, once the range being sorted gets down to 128 items, call (essentially) the stdlib's quicksort.

• The [parallelization code

sundararajana

Moved to openjdk nashorn project. 
Please check "samples" directory in http://hg.openjdk.java.net/jdk9/dev/nashorn.

jonhoo

Distributed Read-Write Mutex in Go

This project has moved to https://github.com/jonhoo/drwmutex so it can be imported into Go applications.

cdipaolo

// haversin(θ) function
func hsin(theta float64) float64 {
	return math.Pow(math.Sin(theta/2), 2)
}

// Distance function returns the distance (in meters) between two points of
//     a given longitude and latitude relatively accurately (using a spherical
//     approximation of the Earth) through the Haversin Distance Formula for
//     great arc distance on a sphere with accuracy for small distances
//

14427

use std::rc::Rc;

trait HKT<U> {
    type C; // Current type
    type T; // Type with C swapped with U
}

macro_rules! derive_hkt {
    ($t:ident) => {
        impl<T, U> HKT<U> for $t<T> {

lavalamp

There are three easy to make mistakes in go. I present them here in the way they are often found in the wild, not in the way that is easiest to understand.

All three of these mistakes have been made in Kubernetes code, getting past code review at least once each that I know of.

1. Loop variables are scoped outside the loop.

What do these lines do? Make predictions and then scroll down.

func print(pi *int) { fmt.Println(*pi) }

paulirish

console.log wrap resolving for your wrapped console logs

I've heard this before:

What I really get frustrated by is that I cannot wrap console.* and preserve line numbers

We enabled this in Chrome DevTools via blackboxing a bit ago.

If you blackbox the script file the contains the console log wrapper, the script location shown in the console will be corrected to the original source file and line number. Click, and the full source is looking longingly into your eyes.

getify

// please comment if you know of other BOOKS (not considering blogs just yet) on ES6 that are out or coming out

• Understanding ECMAScript 6 -- Nicholas Zakas
• Exploring ES6 -- Axel Rauschmayer
• YDKJS: ES6 & Beyond -- Kyle Simpson
• JS.next: A Manager's Guide -- Aaron Frost
• Expert JavaScript -- Mark E. Daggett
• JavaScript Allongé, The "Six" Edition -- Reginald Braithwaite
• Learning ECMAScript 6 -- Narayan Prusty