hiredman

(defonce ^Logger logger (doto (Logger/getLogger "clojure")
                          (.setUseParentHandlers false)
                          (.addHandler
                           (doto (ConsoleHandler.)
                             (.setLevel Level/ALL)
                             (.setFormatter
                              (proxy [SimpleFormatter] []
                                (format [^LogRecord record]
                                  (let [sb (StringBuilder.)]
                                    (.append sb "#:log{")

hiredman

(defn header-encoder% [client-channel]
  (let-cont%
   [header-encode-service (return% (cml/channel))
    _ (fork%
       (let-cont%
        [ten (label%)
         frame (sync% (cml/rx header-encode-service))
         _ (if (cml/event? frame)
             (let-cont%
              [eleven (label%)

hiredman

(delete-other-windows)

(let* ((left-window (selected-window))
       (right-top-window (split-window-right))
       (_ (select-window right-top-window))
       (right-bottom-window (split-window-below)))
  (progn
    (select-window left-window)
    (find-file "~/src/thursday/thursday.clj")
    (select-window right-top-window)

hiredman

#!/bin/sh

VPN_IF="wg0"
LAN_IF="eno1"
MAPPED="192.168.38.1/24"
LAN="192.168.1.0/24"
VPN="10.20.40.0/24"

ifconfig eno1 add 192.168.1.27

hiredman

;; use spec to define stateful protocols inspired by UBF(b)
;; https://ubf.github.io/ubf/ubf-user-guide.en.html

(require '[clojure.spec.alpha :as s]
         '[clojure.core.async :as async])

(defn ubfish
  "Takes a protocol definition and four channels. Checks for protocol
  violations while copying from-server to-client and from-client
  to-server."

hiredman

(require '[clojure.core.async.impl.protocols :as impl]
         '[clojure.core.async.impl.dispatch :as dispatch]
         '[clojure.core.async.impl.channels :as c]
         '[clojure.core.async :as async])

;;=> nil

(defn wait [watchable expected?]
  (reify
    impl/ReadPort

hiredman

(require '[clojure.core.async.impl.protocols :as impl]
         '[clojure.core.async.impl.dispatch :as dispatch])

;;=> nil

(extend-type java.util.concurrent.CompletionStage
  impl/ReadPort
  (take! [this handler]
    (.whenCompleteAsync this
                        (reify

hiredman

(defn message-queue-read-port [take-message ack-message nack-message]
  (let [q (java.util.concurrent.LinkedBlockingQueue.)]
    (async/thread
      (loop [msg nil
             handler nil]
        (cond (and msg handler)
              (let [_ (.lock handler)
                    take-cb (when (and (clojure.core.async.impl.protocols/active? handler)
                                       (clojure.core.async.impl.protocols/commit handler))
                              handler)

hiredman

user=> (require '[clojure.core.async :as async])
nil
user=> (def ^java.net.Socket s nil)
#'user/s
user=> (defn f [] (async/go (.getOutputStream s)))
#'user/f
user=> (defn f [] (async/go (try (.getOutputStream s) (catch Exception e nil))))
#'user/f
user=>

hiredman

var cml = {
    Buffer:function (n) {
        var buf = [];
        this.full=function() {
            return !(buf.length < n);
        }
        this.add=function(item){
            buf.push(item);
        }
        this.remove=function(item){