Ambrose Bonnaire-Sergeant frenchy64

Malli: ref schema Performance Optimizations

In my previous Clojurists Together work for malli I improved the performance of validating recursive refs, bounding the amount of memory required for validation regardless of the depth of input values. This is implemented by eagerly expanding recursive schemas until recursive points are discovered, instead of lazily realizing and caching (an unbounded number of) new levels of recursion as inputs require.

While this increases the reliability of long-running systems by preventing memory leaks caused by validating large inputs, it came with the drawback that more memory was required upfront during validator compilation. This is an obstacle Metabase has been navigating when testing this optimization. While they are excited to see

@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])}))