kachayev

(def open-for-business? (atom true))
(def haircut-count (agent 0))
(def waiting-room (ref []))
(def waiting-room-size 3)

(defn open-shop [duration]
  (do (Thread/sleep duration) (swap! open-for-business? not)))
 
(defn add-customers []
  (future

MaikBeckmann

(require 'ido)
(ido-mode t)
(setq ido-enable-prefix nil
      ido-enable-flex-matching nil
      ido-create-new-buffer 'never
      ido-max-prospects 10
      ido-default-buffer-method 'selected-window
      ido-default-file-method 'selected-window)

;; List of N most recent files, persisent between emacs session.

benhsu

(defun use-theme (theme &optional no-confirm no-enable)
  (interactive
   (list
    (intern (completing-read "Load custom theme: "
  		     (mapcar 'symbol-name
				     (custom-available-themes))))
    nil nil))
  (progn
    (dolist (curtheme (custom-available-themes))
      (disable-theme curtheme))

ecmendenhall

(require '[cascalog.io :refer [with-log-level])
(defmacro ?<-- [& forms] `(with-log-level :fatal (?<- ~@forms)))

evancz

Architecture in Elm

This document is a collection of concepts and strategies to make large Elm projects modular and extensible.

We will start by thinking about the structure of signals in our program. Broadly speaking, your application state should live in one big foldp. You will probably merge a bunch of input signals into a single stream of updates. This sounds a bit crazy at first, but it is in the same ballpark as Om or Facebook's Flux. There are a couple major benefits to having a centralized home for your application state:

1. There is a single source of truth. Traditional approaches force you to write a decent amount of custom and error prone code to synchronize state between many different stateful components. (The state of this widget needs to be synced with the application state, which needs to be synced with some other widget, etc.) By placing all of your state in one location, you eliminate an entire class of bugs in which two components get into inconsistent states. We also think yo

mkwatson

(defmacro while->
  "Takes a predicate, expression, and forms. Threads expr 
  through each form for which applying pred to the returned
  value is true. Threading short circuits after the first 
  false expression."
  [pred expr & forms]
  `(if (~pred ~expr)
     ~(if (not-empty forms)
        (let [next-expr `(-> ~expr ~(first forms))]
           `(if (~pred ~next-expr)

thaJeztah

Silly experiments with RUN --mount

relates to moby/moby#32507, moby/buildkit#442

Doing some silly experimenting with RUN --mount:

# syntax=docker/dockerfile:1

FROM alpine AS stage1