zhangzhihong jiyouyou125

ClojureScript REPL Workflow

Short write up on using REPL when developing UIs in ClojureScript.

Hot-reload on save or Eval in REPL?

Everyone's standard approach to hot-reloading is to use a tool (Figwheel or shadow-cljs) that reloads changed namespaces automatically. This works really well: you change the code, the tool picks up changed files, compiles namespaces and dependants, notifies REPL client which then pulls in compiled changes, and re-runs a function that re-renders UI.

The other approach is to use ClojureScript's REPL directly and rely only on eval from the editor. This more or less matches Clojure style workflow. This approach might be useful when you don't want tools overhead or hot-reloading becomes slow for you or you just used to this style of interactions. Also changing code doesn't always mean that you want to reload all the changes. On the other hand it is very easy to change a couple of top-level forms and forget to eval one of them.

Introductory resources

High level overview https://yogthos.github.io/ClojureDistilled.html
An Animated Introduction to Clojure https://markm208.github.io/cljbook/
Interactive tutorial in a browser https://tryclojure.org/
Interactive exercises http://clojurescriptkoans.com/
Clerk notebooks with introductory examples https://github.clerk.garden/anthonygalea/notes-on-clojure
More interactive exercises https://4clojure.oxal.org/
Lambda Island tutorials https://lambdaisland.com/
Functional Programming with Clojure resources https://practicalli.github.io/

Hello Friends,

This elf begging to climb onto the web for Christmas began as a personal email, a review of Paul Graham's little Lisp Bel. He sprouted arms, legs, and in gingerstyle ran away. Arms for symbols, legs for conses: these primitives are the mark a Lisp — even more so than the parenthesis. What do we get when we remove these foundation stones: naming and pairing?

No pairs. No cons. No structure. Unordered. Chaos. Eve, a beautifully incomplete aspect oriented triple store. No need for legs when you can effortlessly transport to your destination. Lazy. Pure. Here and now, a retrospective.

No symbols. No names. No variables. Combinators. Forth. No need for arms when you can effortlessly push and pop your stack. No words. A world without words. Virtual worlds. Virtual reality. Space. Time. Motion. Action. Kinetic Programming, a proposal.

I apologize in advance. Checking my pocketwatch, I see I haven't t

	(ns drewverlee.webcrawler
	(:require [clojure.core.async
	:as a
	:refer [>! <! >!! <!! go chan buffer close! thread
	onto-chan
	alts! alts!!]]))


	;; Note in both solutions we mock the web crawl

	(def safe-requires
	"List of namespaces to require and refer when inside user ns at load time.

	Can be given an initialization body to execute after having been required.
	To do so, wrap the lib spec in a vector, and all elements after the lib
	spec vector will be evaled after the lib spec has been required."
	'[[clojure.repl :as repl :refer (source apropos dir pst doc find-doc)]
	[clojure.java.javadoc :as javadoc :refer (javadoc)]
	[clojure.pprint :as pprint :refer (pp pprint)]
	[clojure.stacktrace :as stacktrace :refer (e)]

	#!/bin/sh
	#_(

	#_DEPS is same format as deps.edn. Multiline is okay.
	DEPS='
	{:deps {clj-time {:mvn/version "0.14.2"}}}
	'

	#_You can put other options here
	OPTS='

	(ns cljsmadeeasy.core
	(:require [cljs.core.async :as a])
	(:require-macros [cljs.core.async.macros :refer [go]]))

	(defn fill-load-chan [number-of-pages]
	(let [partitions (partition-all NUM-PAGES-PER-LOAD
	(range 1 (inc number-of-pages)))
	c (a/chan)]
	(go
	(doseq [page-numbers partitions]


	(defn create-function-call [param expr]
	"Create an sexp for calling expr with a first argument provided by a promise.
	If expr is a list (already in form suitable for a function call), insert the first argument at second position,
	otherwise turn expr into a function call expression, unless the function is an fn, which is simply returned.

	println -> (fn [param] (println param))

	(* 2) -> (fn [param] (* param 2))

	# Add these to your .bash_profile / .zshrc / etc.

	# Starts a Clojure repl
	function rebel-clj() {
	clojure -Sdeps "{:deps {com.bhauman/rebel-readline {:mvn/version \"0.1.4\"} $@}}" -m rebel-readline.main
	}

	# Starts a browser REPL
	function rebel-cljs() {
	clojure -Sdeps "{:deps {com.bhauman/figwheel-main {:mvn/version \"0.1.7\"} com.bhauman/rebel-readline-cljs {:mvn/version \"0.1.4\"} $@}}" -m figwheel.main

	;;;; A webserver in Emacs, because why not.
	;;;; Basically a fast replacement for serve_this in Fish.



	(use-package web-server
	:config
	(defvar my/file-server nil "Is the file server running? Holds an instance if so.")

	(defun my/ws-start (handlers port &optional log-buffer &rest network-args)