lassik

At the beginning of 2030, I found this essay in my archives. From what I know today, I think it was very insightful at the moment of writing. And I feel it should be published because it can teach us, Rust developers, how to prevent that sad story from happening again.

What killed Haskell, could kill Rust, too

What killed Haskell, could kill Rust, too. Why would I even mention Haskell in this context? Well, Haskell and Rust are deeply related. Not because Rust is Haskell without HKTs. (Some of you know what that means, and the rest of you will wonder for a very long time). Much of the style of Rust is similar in many ways to the style of Haskell. In some sense Rust is a reincarnation of Haskell, with a little bit of C-ish like syntax, a very small amount.

Is Haskell dead?

Blog 2019/11/2

<- previous | index | next ->

Trivial performance comparison of some Scheme interpreters

Let's use a trivial (recursive) Fibonacci benchmark to compare the performance of a few Scheme interpreters.

Install VirtualBox (eg on Mac: brew cask install virtualbox)

Download Debian 3.1 from here: https://virtualboxes.org/images/debian/

Create a new VM in VirtualBox and select the vdi file from the above archive as a disk. Check the VM settings:

Make sure the disk is mounted as an IDE device, SATA errors out on boot (in the Storage tab)
Also, make sure the pointing device is set to PS/2 Mouse (in the General tab)

	#lang racket

	;; printing s-exps as DCS and TDCS, plus examples of what DCS and TDCS look like

	(define (dcs l)
	(cond ((pair? l)
	(begin
	(display ".")
	(dcs (car l))
	(dcs (cdr l))))

	(* See https://groups.google.com/forum/#!msg/fa.caml/i6IgSFX8XkY/4khF8z1V7loJ *)

	type expr =
	\| Int of int
	\| Var of string
	\| BinOp of [ `Add \| `Sub \| `Leq ] * expr * expr
	\| If of expr * expr * expr
	\| Apply of expr * expr

	type defn = LetRec of string * string * expr

	package main

	import (
	"context"
	"flag"
	"fmt"
	"io"
	"net"
	"net/http"
	"os"

	import time
	from http.server import BaseHTTPRequestHandler, HTTPServer

	HOST_NAME = 'localhost'
	PORT_NUMBER = 9000


	class MyHandler(BaseHTTPRequestHandler):
	def do_HEAD(self):
	self.send_response(200)

	# Implementation of a simple MLP network with one hidden layer. Tested on the iris data set.
	# Requires: numpy, sklearn>=0.18.1, tensorflow>=1.0

	# NOTE: In order to make the code simple, we rewrite x * W_1 + b_1 = x' * W_1'
	# where x' = [x \| 1] and W_1' is the matrix W_1 appended with a new row with elements b_1's.
	# Similarly, for h * W_2 + b_2
	import tensorflow as tf
	import numpy as np
	from sklearn import datasets
	from sklearn.model_selection import train_test_split

	#!/bin/bash
	TARGET=$1

	mkdir -p $TARGET

	files=$(
	dpkg -L ruby \| grep '/usr/bin/'
	dpkg -L ruby1.9.1 \| grep '/usr/bin/'
	echo '/usr/lib/ruby'
	)

	package main

	import (
	"fmt"
	"errors"
	)

	type Maybe interface {
	Return(value interface{}) Maybe
	Bind(func(interface{}) Maybe) Maybe