merlinmann

Merlin's Wisdom Project

Or: “Everybody likes being given a glass of water.”

By Merlin Mann.

It's only advice for you because it had to be advice for me.

oliyh

(import '[java.util Timer TimerTask])

(defn debounce
  ([f] (debounce f 1000))
  ([f timeout]
    (let [timer (Timer.)
          task (atom nil)]
      (with-meta
        (fn [& args]
          (when-let [t ^TimerTask @task]

djspiewak

Quick Tips for Fast Code on the JVM

I was talking to a coworker recently about general techniques that almost always form the core of any effort to write very fast, down-to-the-metal hot path code on the JVM, and they pointed out that there really isn't a particularly good place to go for this information. It occurred to me that, really, I had more or less picked up all of it by word of mouth and experience, and there just aren't any good reference sources on the topic. So… here's my word of mouth.

This is by no means a comprehensive gist. It's also important to understand that the techniques that I outline in here are not 100% absolute either. Performance on the JVM is an incredibly complicated subject, and while there are rules that almost always hold true, the "almost" remains very salient. Also, for many or even most applications, there will be other techniques that I'm not mentioning which will have a greater impact. JMH, Java Flight Recorder, and a good profiler are your very best friend! Mea

djspiewak

Getting Started in Scala

This is my attempt to give Scala newcomers a quick-and-easy rundown to the prerequisite steps they need to a) try Scala, and b) get a standard project up and running on their machine. I'm not going to talk about the language at all; there are plenty of better resources a google search away. This is just focused on the prerequisite tooling and machine setup. I will not be assuming you have any background in JVM languages. So if you're coming from Python, Ruby, JavaScript, Haskell, or anywhere…  I hope to present the information you need without assuming anything.

Disclaimer It has been over a decade since I was new to Scala, and when I was new to Scala, I was coming from a Java and Ruby background. This has probably caused me to unknowingly make some assumptions. Please feel free to call me out in comments/tweets!

One assumption I'm knowingly making is that you're on a Unix-like platform. Sorry, Windows users.

Getting the JVM

garybernhardt

Things that programmers don't know but should

(A book that I might eventually write!)

Gary Bernhardt

I imagine each of these chapters being about 2,000 words, making the whole book about the size of a small novel. For comparison, articles in large papers like the New York Times average about 1,200 words. Each topic gets whatever level of detail I can fit into that space. For simple topics, that's a lot of space: I can probably walk through a very basic, but working, implementation of the IP protocol.

tel

/* eslint-disable new-cap */

/**
 * Lens types.
 * ===========
 *
 * a * b = {fst: a, snd: b}
 * a + b = {index: Boolean, value: a | b}
 *
 * Iso   s t a b = forall (~>) . Profunctor (~>) => (a ~> b) -> (s ~> t)

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.

selfsame

(ns farm.core
  (:use 
    [arcadia.core]
    [hard.core] 
    [hard.physics]
    [hard.input]
    [tween.core :as tween]
    [hard.edit :only [active]]
    [farm.invaders :as invaders])
  (:import

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) }

nasser

(ns game.ghost
  (:use arcadia.core
        nasser.linear)
  (:require [nasser.proto :as proto]
            [nasser.component :refer [component]])
  (:import [UnityEngine Transform Component Time Vector3 Debug Color]))

(defn fly-towards! [^Transform tf ^Vector3 p ^double speed ^double turn-rate]
  (let [ds (* speed Time/deltaTime)
        target-dir (Vector3/Normalize (v- p (.. tf position)))]