- Craig Andera
- Cognitect
- craig@cognitect.com
- http://cognitect.com/podcast
- Sending values between applications
# Update: This micro-blog is now also a guide on clojurescript.org: | |
# http://clojurescript.org/guides/native-executables | |
# Hello! This is a micro-post about how to produce native executables | |
# from ClojureScript source. The basic idea is to produce a | |
# JavaScript file using the ClojureScript compiler, and then use a | |
# Node.js tool called nexe (https://github.com/jaredallard/nexe) to | |
# compile that into an executable. The resulting file can be run | |
# without requiring a node install on the target machine, which can | |
# be handy. |
(let [opacity-ch (async/chan (async/dropping-buffer 1))] | |
(async/go-loop [last-set (:opacity @app-state) | |
last-received nil] | |
(let [t (async/timeout 100) | |
[ch val] (async/alts! [t opacity-ch]) | |
[new-set new-received] (cond | |
(= ch opacity-ch) | |
[last-set val] |
(require '[clojure.math.combinatorics :as combo] | |
'[clojure.core.async :as async]) | |
(def zeus-route | |
["Kadena" | |
"Pohang" | |
"Pusan" | |
"Kimhae" | |
"Sachon" | |
"Taegu" |
(require '[scad-clj.scad :refer :all] | |
'[scad-clj.model :refer :all]) | |
(defn degrees [d] | |
(-> d (/ 180.0) (* Math/PI))) | |
(def x-axis [1 0 0]) | |
(def y-axis [0 1 0]) | |
(def z-axis [0 0 1]) |
import time | |
class Utils: | |
@staticmethod | |
def mapmouse(val): | |
if abs(val) <= 13: | |
return val * 128 | |
elif abs(val) <= 25: | |
return val * 256 |
(defn- cpu-stats | |
"Returns measures of the various types of CPU usage to date" | |
[] | |
(->> (-> (clojure.java.shell/sh "cat" "/proc/stat") | |
:out | |
(clojure.string/split #"\n") | |
first | |
(clojure.string/split #"\s")) | |
(remove clojure.string/blank?) | |
(drop 1) |
N.B. This is now a library, thanks to the efforts of the wonderful @mtnygard. And the README does a good job of making clear just how terrible an idea it is to actually do this. :)
As any Clojurist knows, the REPL is an incredibly handy development tool. It can also be useful as a tool for debugging running programs. Of course, this raises the question of how to limit access to the REPL to authorized parties. With the Apache SSHD library, you can embed an SSH server in any JVM process. It takes only a little code to hook this up to a REPL, and to limit access either by public key or
;; This has to be a separate function. The way we had it before, with | |
;; a loop inside a future, creates a closure that captures the head of | |
;; the sequence. Locals clearing here saves us from that. | |
(defn- enqueue-transactions | |
"Transact a (potentially infinite) sequence of transactions on `q`, | |
reporting status via `status`. Pause for `delay` (if non-nil) | |
between each transaction." | |
[conn [tx & more] q status delay] | |
(if (or (not tx) (:done @status)) | |
(.put q (future :done)) |
(defn dopar | |
"Given a (potentially infinite) sequence `coll`, uses core.async to | |
run `f` for side effects against each value in the collection. | |
Performs at most `concur` operations in parallel, and never enqueues | |
more than `lead` items ahead of the ones being consumed. If any call | |
to `f` throws an exception, it will be rethrown from this function. | |
Otherwise, returns nil. Optional timeout value is number of | |
milliseconds to wait for all operations to complete." | |
([coll f concur lead] (dopar coll f concur lead nil)) | |
([coll f concur lead timeout-ms] |