Ambrose Bonnaire-Sergeant frenchy64

@copilot please concentrate on reproducing and describing the race condition in ./script/test-clr. I can't reproduce your results but it's happened several times in a copilot session (reported here clojure/clr.core.cli#4).

I conjecture that the race condition is here in ensure-git-dir (https://github.com/clojure/clr.core.cli/blob/9a09d7e73a15ecefec15c697eb1aff7d54392082/src/dotnet/Cljr/clojure/tools/gitlibs/impl.cljr):

(defn git-clone-bare
  [url ^DirectoryInfo git-dir]                                                                     ;;; ^File
  (printerrln "Cloning:" url)
  (let [git-path (.FullName git-dir)                                                               ;;; .getCanonicalPath
        {:keys [exit err] :as ret} (run-git "clone" "--quiet" "--mirror" url git-path)]

(This is a really long answer to feedback on plumatic/schema#445)

Sorry, I don't understand from here down.

My bad, there's a ton of implicit decisions and I'm only explaining the tiny details :) I'll try writing this again.

Are you basing this design off an existing language or library that I can read about to get a better understanding?

This is a combination of several ideas and tradeoffs.

https://github.com/cgrand/macrovich/commit/9f5bd6f2777f0494e46ce7c430fd1fcef2690475#r67189464

@viebel Without this, you need to write macros like this:

(defmacro my-macro []
  `(macros/case
     :clj 1
     :cljs 2))

The Hidden Data Flow in Types

On the surface, function types simply describe inputs and outputs—indeed, that's how they're used in most type systems. But there's more to function types!

Fascinatingly, a function type can be transformed into a data flow graph that predicts the inner workings of any function that has that type. Using this graph, intricate dependencies between function inputs and outputs can be inferred

RFC: Animation for cljfx

This is an initial attempt at supporting animations in cljfx. Running instructions are below.

The actual animation logic is here under the Demo comment.

The original code is here.

Running

Why Objects were successful

https://www.cs.cmu.edu/~charlie/courses/15-214/2014-fall/slides/25-history-oo.pdf

essense of objects is (dynamic) dispatch
dispatch provides interoperability
first-class interoperability is critical to frameworks and ecosystems
frameworks and ecosystems are economically critical to the software industry
likely a significant factor in objects' success
Also talks about early mistakes in Simula

Why objects are inevitable

	typed.clj.refactor=> (refactor-form-string "+" {})
	"clojure.core/+"
	typed.clj.refactor=> (refactor-form-string "(defn foo [a] (+ a 3))" {})
	"(clojure.core/defn foo [a__#0] (clojure.core/+ a__#0 3))"
	typed.clj.refactor=> (refactor-form-string "(defmacro foo [a] `(+ ~a 3))" {})
	"(clojure.core/defmacro foo [a__#0] `(+ ~a__#0 3))"

	#Sample code

	#Hello world

	"Hello world!" print

	#Factorial

	factorial := method(n, if(n == 1, 1, n * factorial(n - 1)))
	99 bottles of beer

	(ns colored-lti-clj.core)

	(defalias List
	(TFn [a]
	'{:match (All [b] [(ListVisitor a b) :-> b])}))

	(defalias ListVisitor
	(TFn [a b]
	'{:caseNil (All [:-> b])
	:caseCons (All [a (List a) :-> b])}))

	; Copyright (c) Rich Hickey. All rights reserved.
	; The use and distribution terms for this software are covered by the
	; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
	; which can be found in the file epl-v10.html at the root of this distribution.
	; By using this software in any fashion, you are agreeing to be bound by
	; the terms of this license.
	; You must not remove this notice, or any other, from this software.

	(ns cljs.compiler
	#?(:clj (:refer-clojure :exclude [munge macroexpand-1 ensure])