#todo-tournament

Code-quality ranking of the five TodoMVC contestants in tommy's todo-tournament, based on a review of each implementation (structure, idiomatic use of language, elegance of the core mechanism, robustness, and clarity).

~/clojure-evaleval { Reference implementation of the evaleval pattern. Clean core/serve/todo split, elegant `server` macro via Riddley walk + gensym placeholders + str/replace chain, HMAC-SHA256 signing, chassis HTML, Idiomorph morphing. Best separation of concerns and most idiomatic Clojure. }

~/racket-evaleval { Native Racket implementation of the same pattern, well-commented, idiomatic X-expressions via the xml library. Slightly less polished: SHA1 vs HMAC, manual syntax-case walk vs Riddley, and a fragile `(syntax-source #'here)` static-dir hack. }

~/clojure-buzz { Concise, idiomatic use of the buzz framework (defui/defpart/server/server!/client), state in watched atoms, SSE patches. Clean and modern, but the design is mostly buzz's, not the contestant's. }

~/python-evaleval { Relies on an external `evaleval` package rather than implementing the pattern. The `Three[Selector(...)][MORPH][...]` DSL is clever but obscure; eval() on signed snippets; global mutable state. Reasonably clean but not self-contained. }

~/python-web1 { Deliberately minimal Web 1.0: plain forms, no JS, no eval. Honest and robust, but heavily inline-styled, global mutable state, little separation of concerns. Least design effort. }

{ The Clojure version is the reference implementation of the evaleval pattern: it builds the macro, signing, and JS DSL itself, with the cleanest separation of concerns and HMAC-SHA256. The Racket port is strong and native but slightly less polished (SHA1, manual syntax walk, fragile static-dir hack). }
~/clojure-evaleval > ~/racket-evaleval

{ Both implement the evaleval pattern natively, but the Racket version builds the macro and signing itself while clojure-buzz mostly leans on the buzz framework's design rather than its own. }
~/racket-evaleval > ~/clojure-buzz

{ clojure-buzz is concise, idiomatic, and uses a real reactive framework with watched atoms and SSE patches. python-evaleval leans on an external package and an obscure `Three[Selector[…][MORPH][…]]` DSL with eval() on snippets. }
~/clojure-buzz > ~/python-evaleval

{ python-evaleval at least implements the evaleval idea (signed snippets, morph responses). python-web1 is deliberately minimal Web 1.0 with no JS and no eval — honest and robust, but the least design effort and heavily inline-styled. }
~/python-evaleval > ~/python-web1

{ clojure-evaleval is the most complete and well-structured of all; clojure-buzz is clean but owes its design to the buzz framework. }
~/clojure-evaleval > ~/clojure-buzz

{ clojure-evaleval implements the pattern end-to-end with the best code quality; python-evaleval relies on an external package and a clever-but-obscure DSL. }
~/clojure-evaleval > ~/python-evaleval

{ racket-evaleval is a native, well-commented implementation; python-evaleval is not self-contained. }
~/racket-evaleval > ~/python-evaleval

{ clojure-buzz is a real framework-driven app; python-web1 is minimal Web 1.0 with little separation of concerns. }
~/clojure-buzz > ~/python-web1

{ racket-evaleval implements the pattern natively with good structure; python-web1 is the least design effort. }
~/racket-evaleval > ~/python-web1

{ clojure-evaleval is the clear top of the ranking; python-web1 is the bottom. }
~/clojure-evaleval > ~/python-web1