schaueho

(defn encrypt-test [plaintext]
  (go
    (let [sodium (.-sodium js/window)    ;; <-- this 
          nonce (<p! (.randombytes_buf sodium 24))
          key (<p! (.crypto_secretbox_keygen sodium))
          ciphertext (<p! (.crypto_secretbox sodium plaintext nonce key))]
      (println "key: " (.toString key "hex"))
      (println "cipher:" (.toString ciphertext "hex"))

      (println "decrypted:" (.toString (<p! (.crypto_secretbox_open sodium ciphertext nonce key)))))))

schaueho

Getting a Threadripper machine working under Debian

After a long long time of more than eight years my old machine started showing hardware problems: first the power supply failed and had to be replaced. Next the CMOS battery died. It became clear that finally a replacement would be in order. When the first reports about AMDs Ryzen family came out and in particular with the Threadripper tests, I became interested. In the end, I waited until the Threadripper 2950X was available before ordering a custom-built machine from a local vendor. Here is the basic hardware setup:

• CPU: Threadripper 2950X (32 cores)
• Mainboard: MSI 399X Carbon
• Memory: 32 GB
• GPU: Nvidia 1060
• SSD: Samsung 970 Evo NVM 1TB

schaueho

(ns aggregation.core
  (:require [clojure.core.async :refer [chan >!! <!! close!]]
            [onyx.extensions :as extensions]
            [onyx.plugin.core-async :refer [take-segments!]]
            [onyx.api])
  (:gen-class))

;;; Word count!

;;; Split a sentence into words, emit a seq of segments

schaueho

(defn file2wordlist [wordlistfile]
  (-> (slurp wordlistfile)
      (str/triml)
      (str/split #"\s+")
      ((partial concat ["." ","]))))

(defn generate-random-text-coll
  "Generate a random text collection with nrtexts texts that are up to maxlength long.
Wordlist should be a file with one word per line."
  [wordlist nrtexts maxlength]

schaueho

Notes on core.async usage:

go and thread will return a channel with buffer-size of zero containing the result of the body. That's exploited in the following snippet from the core.async walkthrough, which more or less "tests" (asserts) that the value "hello" is successfully communicated over the channel c.

(let [c (chan)]
	 (go (>! c "hello"))
	 (assert (= "hello" (<!! (go (<! c)))))
	 (async/close! c))

Note that the assert is neither within the go block nor directly outside go, because as outlined above, the result will be another channel. So the assertion checks the result of the blocking take !<< on the result channel. This is a useful pattern for testing core.async code: return the result channel from your taking code and run the test with a blocking take on it, like this: