non

What is the appeal of dynamically-typed languages?

Kris Nuttycombe asks:

I genuinely wish I understood the appeal of unityped languages better. Can someone who really knows both well-typed and unityped explain?

I think the terms well-typed and unityped are a bit of question-begging here (you might as well say good-typed versus bad-typed), so instead I will say statically-typed and dynamically-typed.

I'm going to approach this article using Scala to stand-in for static typing and Python for dynamic typing. I feel like I am credibly proficient both languages: I don't currently write a lot of Python, but I still have affection for the language, and have probably written hundreds of thousands of lines of Python code over the years.

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.

max-mapper

Disclaimer: This is an unofficial post by a random person from the community. I am not an official representative of io.js. Want to ask a question? open an issue on the node-forward discussions repo

io.js - what you need to know

• io is a fork of node v0.12 (the next stable version of node.js, currently unreleased)
• io.js will be totally compatible with node.js
• the people who created io.js are node core contributors who have different ideas on how to run the project
• it is not a zero-sum game. many core contributors will help maintain both node.js and io.js

nrc

Rust developer tools - status and strategy

Availability and quality of developer tools are an important factor in the success of a programming language. C/C++ has remained dominant in the systems space in part because of the huge number of tools tailored to these lanaguages. Succesful modern languages have had excellent tool support (Java in particular, Scala, Javascript, etc.). Finally, LLVM has been successful in part because it is much easier to extend than GCC. So far, Rust has done pretty well with developer tools, we have a compiler which produces good quality code in reasonable time, good support for debug symbols which lets us leverage C++/lanaguge agnostic tools such as debuggers, profilers, etc., there are also syntax highlighting, cross-reference, code completion, and documentation tools.

In this document I want to layout what Rust tools exist and where to find them, highlight opportunities for tool developement in the short and long term, and start a discussion about where to focus our time an

omeid

package main

import (
	"log"
	"net/http"
	"time"
)

type Handler func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc)

acous

body {
    background: #333;
	color: #CCC;
	font: 16px Lato, sans-serif;
	margin: 0;
}
#main {
	background: #222;
	border-radius: 0px;
	bottom: 0px;

Eltiech

#Author: Malsententia <Malsententia@gmail.com>
#Purpose: Colorized man pages, with random themes seeded by
#         the command and/or section. That is, every man page
#         has its own consistent color scheme. For example
#         man tar is always yellow, green, and blue, man less
#         is always pink, blue, and yellow, etc.(on zsh, anyway)
#Note: Colorization will differ between bash and zsh, since their 
#      RNGs are different
#Requires: bash or zsh(may support others), and perl
#Setup: Name it .mancolor.sh, source it in your bashrc/zshrc,

andyshinn

Deis in Google Compute Engine

Let's build a Deis cluster in Google's Compute Engine!

Google

Get a few Google things squared away so we can provison VM instances.

Google Cloud SDK

chaitanyagupta

Reader Macros in Common Lisp

This post also appears on lisper.in.

Reader macros are perhaps not as famous as ordinary macros. While macros are a great way to create your own DSL, reader macros provide even greater flexibility by allowing you to create entirely new syntax on top of Lisp.

Paul Graham explains them very well in [On Lisp][] (Chapter 17, Read-Macros):

The three big moments in a Lisp expression's life are read-time, compile-time, and runtime. Functions are in control at runtime. Macros give us a chance to perform transformations on programs at compile-time. ...read-macros... do their work at read-time.

jsound

package de.am.gc.benchmarks;

/**
 * A GC micro benchmark running a given number of threads that create objects of a given size and dereference them immediately
 * 
 * @author jsound
 */
public class GarbageOnly {
    // object size in bytes
    private static final int DEFAULT_NUMBEROFTHREADS=8;