Eric Normand's Weekly Newsletter

Each week, enjoy a Clojure tip, a Clojure challenge, and a taste of news.

I started the newsletter in March, 2012. Since then, the newsletter has evolved.

Try out the challenge—a small exercise to practice your skills. And enjoy the tip—something practical to help you in your day-to-day Clojure. I try to capture the timeless ideas of functional programming and give them relevance today.

Sign up for weekly Clojure tips, software design, and a Clojure coding challenge.

Join thousands of happy subscribers

Here are just a few happy comments:

Even if you’re not interested in Clojure at all, this newsletter is an excellent read every week.

Oliver CaldwellOliver Caldwell

Oliver Caldwell

A free, weekly email to inspire Clojure programmers :D

Daniel HigginbothamDaniel Higginbotham

Daniel Higginbotham

If you’re a Clojure programmer, you should subscribe to the (free) newsletter by Eric Normand.

Steve MinerSteve Miner

Steve Miner

Your friendly reminder that if you aren’t reading Eric's newsletter, you are missing out… NOTE: It's not Clojure specific!

Sean AllenSean Allen

Sean Allen

BTW, if you read RubyWeekly, you’ll love Eric Normand's newsletter.

Norbert WójtowiczNorbert Wójtowicz

Norbert Wójtowicz

Eric's newsletter is so simply great. Love it!

Mathieu GagnonMathieu Gagnon

Mathieu Gagnon

Read it and weep (with joy)

Alan ShawAlan Shaw

Alan Shaw

Lots of great content in the latest newsletter! Really glad I subscribed. Thanks, Eric, for your work.

Nicolas HeryNicolas Hery

Nicolas Hery

Past issues

Eric Normand Newsletter 473: On the meanings of software design

On the meanings of software design

Eric Normand Newsletter 472: Working on Domain Modeling book

Working on Domain Modeling book

Eric Normand Newsletter 471: I’m back!

I’m back!

Eric Normand Newsletter 470: Worked Example: Days of the week

Worked Example: Days of the week

Eric Normand Newsletter 469: Everything is a center

Everything is a center

Eric Normand Newsletter 468: Choice of abstraction matters

Choice of abstraction matters

Eric Normand Newsletter 467: Koppel's abstractions

Koppel's abstractions

Eric Normand Newsletter 466: You need two abstractions to model

You need two abstractions to model

Eric Normand Newsletter 465: Abstraction is the essence of programming

Abstraction is the essence of programming

Eric Normand Newsletter 464: 10 years!

10 years!

PurelyFunctional.tv Newsletter 463: What is beautiful code?

PurelyFunctional.tv Newsletter 462: PurelyFunctional.tv Migration

PurelyFunctional.tv Newsletter 461: Rules of thumb don't scale

PurelyFunctional.tv Newsletter 460: Interface polymorphism

PurelyFunctional.tv Newsletter 459: Revisiting the open/closed principle

PurelyFunctional.tv Newsletter 458: Three doorways of domain modeling

PurelyFunctional.tv Newsletter 457: Take a stance

PurelyFunctional.tv Newsletter 456: A sense of mystery

PurelyFunctional.tv Newsletter 455: How and when to apply domain modeling

PurelyFunctional.tv Newsletter 454: Not a prescriptive process

PurelyFunctional.tv Newsletter 453: Model as Toy

PurelyFunctional.tv Newsletter 452: Domain Invariants

PurelyFunctional.tv Newsletter 451: Signature-Driven Development

PurelyFunctional.tv Newsletter 450: Runnable specifications

PurelyFunctional.tv Newsletter 449: Domain model correctness and simplicity

PurelyFunctional.tv Newsletter 448: Domain model convenience

PurelyFunctional.tv Newsletter 447: Domain model fit

PurelyFunctional.tv Newsletter 446: The Art of Domain Modeling

PurelyFunctional.tv Newsletter 445: 2 Kinds of genericity?

PurelyFunctional.tv Newsletter 444: Humane models of errors

PurelyFunctional.tv Newsletter 443: Simulating and visualizing time

PurelyFunctional.tv Newsletter 442: Human interfaces should be rich and composed

PurelyFunctional.tv Newsletter 441: Hurricane update

PurelyFunctional.tv Newsletter 440: Pub/sub done really well

PurelyFunctional.tv Newsletter 439: How to invent the future

PurelyFunctional.tv Newsletter 438: The unbearable lightness of programming

PurelyFunctional.tv Newsletter 437: To build or not to build, that is the question

PurelyFunctional.tv Newsletter 436: Software as Soulcraft

PurelyFunctional.tv Newsletter 435: The software crisis

PurelyFunctional.tv Newsletter 434: Re-combination of parts

PurelyFunctional.tv Newsletter 433: The "Clojure Effect"

PurelyFunctional.tv Newsletter 432: Specific vs. general

PurelyFunctional.tv Newsletter 431: Clojure directness

PurelyFunctional.tv Newsletter 430: Use :: keyword notation for unique values

PurelyFunctional.tv Newsletter 429: CRUD Authorization

PurelyFunctional.tv Newsletter 428: CRUD Paging

PurelyFunctional.tv Newsletter 427: CRUD Handlers

PurelyFunctional.tv Newsletter 426: Ring for CRUD

PurelyFunctional.tv Newsletter 425: Specify a data abstraction

PurelyFunctional.tv Newsletter 424: Leverage in a thriving ecosystem

PurelyFunctional.tv Newsletter 423: Grokking Simplicity is in print!

PurelyFunctional.tv Newsletter 422: Don't write your own language

PurelyFunctional.tv Newsletter 421: Programming monism

PurelyFunctional.tv Newsletter 420: Say what you mean

PurelyFunctional.tv Newsletter 419: Why not write your own language?

PurelyFunctional.tv Newsletter 418: Clojure's buzz

PurelyFunctional.tv Newsletter 417: Clojure at heart 🥰

PurelyFunctional.tv Newsletter 416: Why do we program in hard mode?

PurelyFunctional.tv Newsletter 415: What is worth sacrificing clarity?

PurelyFunctional.tv Newsletter 414: Constrain your design with composition first

PurelyFunctional.tv Newsletter 413: Affordances in software

PurelyFunctional.tv Newsletter 412: use and abuse of the decorator pattern

PurelyFunctional.tv Newsletter 412: module depth is bogus

PurelyFunctional.tv Newsletter 411: is it easier after Clojure?

PurelyFunctional.tv Newsletter 410: don't encode your policy

PurelyFunctional.tv Newsletter 409: the 3-stakeholders model

PurelyFunctional.tv Newsletter 408: 3 stakeholders of programming

PurelyFunctional.tv Newsletter 407: two layers of design

PurelyFunctional.tv Newsletter 406: design, false nominalization?

PurelyFunctional.tv Newsletter 405: giving thanks

PurelyFunctional.tv Newsletter 404: where to find timeless truths

PurelyFunctional.tv Newsletter 403: the timeless in an unstable domain

PurelyFunctional.tv Newsletter 402: up-front vs incremental design

PurelyFunctional.tv Newsletter 401: design is not about ease of change

PurelyFunctional.tv Newsletter 400: is software design worthless?

PurelyFunctional.tv Newsletter 399: is more layers better?

PurelyFunctional.tv Newsletter 398: semantics over syntax

PurelyFunctional.tv Newsletter 397: unknown keys in maps

PurelyFunctional.tv Newsletter 396: how types help you reason

PurelyFunctional.tv Newsletter 395: types depend on context

PurelyFunctional.tv Newsletter 394: on the feedback of types

PurelyFunctional.tv Newsletter 393: always start with a repl

PurelyFunctional.tv Newsletter 392: command your repl

PurelyFunctional.tv Newsletter 391: the immediacy interval

PurelyFunctional.tv Newsletter 390: the elements of flow in a REPL environment

PurelyFunctional.tv Newsletter 389: repl withdrawal

PurelyFunctional.tv Newsletter 388: further down (or is it up?) the stack

PurelyFunctional.tv Newsletter 387: to stack or not to stack

PurelyFunctional.tv Newsletter 386: factoring equations in code

PurelyFunctional.tv Newsletter 385: two map patterns: entity vs index

PurelyFunctional.tv Newsletter 384: name your callbacks

PurelyFunctional.tv Newsletter 383: replace body with callback

PurelyFunctional.tv Newsletter 382: express implicit argument

PurelyFunctional.tv Newsletter 381: #BlackLivesMatter

PurelyFunctional.tv Newsletter 380: what can you iterate through?

PurelyFunctional.tv Newsletter 379: get produces unexpected behavior, as expected

PurelyFunctional.tv Newsletter 378: Clojure nudges us to constant-time operations

PurelyFunctional.tv Newsletter 377: Three states of key-value pairs

PurelyFunctional.tv Newsletter 376: Learn from core

PurelyFunctional.tv Newsletter 375: JS vs CLJ

PurelyFunctional.tv Newsletter 374: Seek truth, not convenience

PurelyFunctional.tv Newsletter 373: Don't sweat the stack

PurelyFunctional.tv Newsletter 372: Model change over time with state machines

PurelyFunctional.tv Newsletter 371: Chain map, filter, and reduce

PurelyFunctional.tv Newsletter 370: Refactoring: replace get, modify, set with update

PurelyFunctional.tv Newsletter 369: Refactoring: replace body with callback

PurelyFunctional.tv Newsletter 368: Refactoring: extract calculation from action

PurelyFunctional.tv Newsletter 367: What about errors?

PurelyFunctional.tv Newsletter 366: Is the Clojure philosophy bad for beginners?

PurelyFunctional.tv Newsletter 365: why not more convenience routines for CSV parsing?

PurelyFunctional.tv Newsletter 364: Tip: seek the model and enshrine it in code

PurelyFunctional.tv Newsletter 363: Learn to build and deploy a single-page application

PurelyFunctional.tv Newsletter 362: Tip: double recursion

PurelyFunctional.tv Newsletter 361: Tip: trampoline your tail recursion

PurelyFunctional.tv Newsletter 360: Tip: fold left vs fold right

PurelyFunctional.tv Newsletter 359: Tip: reduce as universal recursion over a list

PurelyFunctional.tv Newsletter 358: Tip: recursion rollercoaster

PurelyFunctional.tv Newsletter 357: Tip: recursion vs iteration

PurelyFunctional.tv Newsletter 356: Tip: convert recursion to iteration

PurelyFunctional.tv Newsletter 355: Tip: memoize to trade space for time

PurelyFunctional.tv Newsletter 354: Tip: beware how many threads you start

PurelyFunctional.tv Newsletter 353: Tip: String literals are interned

PurelyFunctional.tv Newsletter 352: Tip: use the right kind of comment for the job

PurelyFunctional.tv Newsletter 351: Clojure tool: babashka

PurelyFunctional.tv Newsletter 350: Monoid pattern submissions

PurelyFunctional.tv Newsletter 349: Tip: monoid pattern

PurelyFunctional.tv Newsletter 348: Tip: cleanup in finally

PurelyFunctional.tv Newsletter 347: Tip: catch and catch again

PurelyFunctional.tv Newsletter 346: Tip: just throw ex-info

PurelyFunctional.tv Newsletter 345: Tip: know your exception hierarchy

PurelyFunctional.tv Newsletter 344: Tip: thank a Clojure OSS dev today

PurelyFunctional.tv Newsletter 343: Tip: read the exception message

PurelyFunctional.tv Newsletter 342: Tip: learn to read Javadocs

PurelyFunctional.tv Newsletter 341: Tip: tidy up your ns form

PurelyFunctional.tv Newsletter 340: Fewer side-effects is better than more

PurelyFunctional.tv Newsletter 339: Design is about pulling things apart

PurelyFunctional.tv Newsletter 338: Tip: Re-implement multiple times

PurelyFunctional.tv Newsletter 337: Functional programming is deep

PurelyFunctional.tv Newsletter 336: My book: next week?

PurelyFunctional.tv Newsletter 335: Idea: when can you use property-based testing?

PurelyFunctional.tv Newsletter 334: Tip: can you fill in the blanks?

PurelyFunctional.tv Newsletter 333: Tool: rebel readline

PurelyFunctional.tv Newsletter 332: Tool: jEnv

PurelyFunctional.tv Newsletter 331: Tool: shadow-cljs

PurelyFunctional.tv Newsletter 330: Tool: Figwheel

PurelyFunctional.tv Newsletter 329: Tool: cljdoc

PurelyFunctional.tv Newsletter 328: Tip: don't use def inside a defn

PurelyFunctional.tv Newsletter 327: Tip: always be decomplecting

PurelyFunctional.tv Newsletter 326: Tip: consult the repl

PurelyFunctional.tv Newsletter 325: Tip: don't use a protocol to make testing easier

PurelyFunctional.tv Newsletter 324: Tip: Use tuples for local data, entities for global data

PurelyFunctional.tv Newsletter 323: Tip: Keep your workflow simple

PurelyFunctional.tv Newsletter 322: Tip: Avoid flatten when possible

PurelyFunctional.tv Newsletter 321: Tip: Do not count sequences from strangers

PurelyFunctional.tv Newsletter 320: Tip: Know Clojure's execution semantics for better Repl-Driven Development

PurelyFunctional.tv Newsletter 319: Tip: Shebang scripting with the Clojure CLI

PurelyFunctional.tv Newsletter 318: Tip: Beware the order of keys in hashmaps

PurelyFunctional.tv Newsletter 317: When you see a job, apply

PurelyFunctional.tv Newsletter 316: Avoid licensing and support issues with the right JDK for you

PurelyFunctional.tv Newsletter 315: Use the correct data structure for the job

PurelyFunctional.tv Newsletter 314: Collection functions vs. sequence functions

PurelyFunctional.tv Newsletter 313: Always use the 3-argument version of reduce

PurelyFunctional.tv Newsletter 312: Maybe, Arcadia, Improvements

PurelyFunctional.tv Newsletter 311: Stewardship, Trees, Databases

PurelyFunctional.tv Newsletter 310: Quines, REPLs, HTML forms

PurelyFunctional.tv Newsletter 309: Hiring, cljdoc, Probability

PurelyFunctional.tv Newsletter 308: Conferences, Unison, NULL

PurelyFunctional.tv Newsletter 307: Performance, Architecture, Semantics

PurelyFunctional.tv Newsletter 306: Error Messages, Milky Way, Microservices

PurelyFunctional.tv Newsletter 305: Legacy, Tables, Pioneers

PurelyFunctional.tv Newsletter 304: Back to the factory

PurelyFunctional.tv Newsletter 303: The Clojure Process Debate

PurelyFunctional.tv Newsletter 302: The Agile Software Factory

PurelyFunctional.tv Newsletter 301: GraphQL, Hiccup, Symbolic Execution

PurelyFunctional.tv Newsletter 300: Rust, React,

PurelyFunctional.tv Newsletter 299: Fullstack, ClojureScript, Class hierarchies

PurelyFunctional.tv Newsletter 298: UX, Deliverables, Dependent Types

PurelyFunctional.tv Newsletter 297: Beginner Experience Edition

PurelyFunctional.tv Newsletter 296: Design, Success, and Conj Speakers

PurelyFunctional.tv Newsletter 295: Deps, Categories, Dystopia

PurelyFunctional.tv Newsletter 294: Ions, Elm, Reason

PurelyFunctional.tv Newsletter 293: Design, deps.edn, Type Inference

PurelyFunctional.tv Newsletter 292: Composition, Modeling, Scope

PurelyFunctional.tv Newsletter 291: Metaphor, Puzzles, Ions

PurelyFunctional.tv Newsletter 290: Generative, Non-events, Hammocks

PurelyFunctional.tv Newsletter 289: More Spec, Fewer Classes, Threading Macros

PurelyFunctional.tv Newsletter 288: Clojure Spec Tools

PurelyFunctional.tv Newsletter 287: DataScript, GraphQL, CRDTs

PurelyFunctional.tv Newsletter 286: Broken APIs, CIDER, Immutability

PurelyFunctional.tv Newsletter 285: Scraping, Laziness, Design Patterns

PurelyFunctional.tv Newsletter 284: Threading, React, OTP

PurelyFunctional.tv Newsletter 283: Spec, Error messages!, Games

PurelyFunctional.tv Newsletter 282: Careers, Errors, P2P

PurelyFunctional.tv Newsletter 281: Intelligence Augmentation, Complexity, Game Engines

PurelyFunctional.tv Newsletter 280: Datomic Ions, Costly Code, Monad drama

PurelyFunctional.tv Newsletter 279: Clojure web frameworks

PurelyFunctional.tv Newsletter 278: Parinfer, Naming, GraphQL

PurelyFunctional.tv Newsletter 277: Clojure Career Workshop

PurelyFunctional.tv Newsletter 276: Turing, Bottom-up Design, go blocks

PurelyFunctional.tv Newsletter 275: Data, Spec, Types

PurelyFunctional.tv Newsletter 274: Datomic, Strange Loop, Clojurists Together

PurelyFunctional.tv Newsletter 273: Robots, Categories, Aikido

PurelyFunctional.tv Newsletter 272: Did you see the redesign?

PurelyFunctional.tv Newsletter 271: Falsehoods, Deliverability, cljs.main

PurelyFunctional.tv Newsletter 270: Lisp and the metacircular interpreter

PurelyFunctional.tv Newsletter 269: Elements, Domains, Revenge!

PurelyFunctional.tv Newsletter 268: Apropos, Datomic, Serverless

PurelyFunctional.tv Newsletter 267: Debugging, REPLs, Theory

PurelyFunctional.tv Newsletter 266: Beginner Experience

PurelyFunctional.tv Newsletter 265: The one after the first Clojure SYNC

PurelyFunctional.tv Newsletter 264: Happy Lundi Gras

PurelyFunctional.tv Newsletter 263: The Power of Definitions

PurelyFunctional.tv Newsletter 262: Launching, Jargon, Fearless

PurelyFunctional.tv Newsletter 261: Cool, Calm, Coast

PurelyFunctional.tv Newsletter 260: Orchestra, Logic, Lambda

PurelyFunctional.tv Newsletter 259: Smalltalk, Slowness, Learning

PurelyFunctional.tv Newsletter 258: Reality, Hiccup, Relational

PurelyFunctional.tv Newsletter 257: Dynamic, Benchmarks, Design Patterns

PurelyFunctional.tv Newsletter 256: Jobs, SYNC, Patterns

PurelyFunctional.tv Newsletter 255: Scene, CLI, Neural Net

PurelyFunctional.tv Newsletter 254: Calm, Microservices, Complexity

PurelyFunctional.tv Newsletter 253: Poe, Cookies, Flash

PurelyFunctional.tv Newsletter 252: Brand, Distributed, Feelings

PurelyFunctional.tv Newsletter 251: Machine Learning, ClojureScript, The Future

PurelyFunctional.tv Newsletter 250: Lean, Creole Cuisine, Types

PurelyFunctional.tv Newsletter 249: The unbearable lightness of static type erasure...

PurelyFunctional.tv Newsletter 248: Weapons, GraphQL, and the return of an old acquaintance

PurelyFunctional.tv Newsletter 247: Clojure SYNC, Guy Steele, Zach Tellman

PurelyFunctional.tv Newsletter 246: 2 CFPs, Clojurecademy, Data Science

PurelyFunctional.tv Newsletter 245: V2, Scale, Perl

PurelyFunctional.tv Newsletter 244: Comics, Infinity, Scaling

PurelyFunctional.tv Newsletter 243: Specialization, McLuhan, Lumo

PurelyFunctional.tv Newsletter 242: Flexibility, Measurement, Metaphors

PurelyFunctional.tv Newsletter 241: Paradigms, Data Science, Style

PurelyFunctional.tv Newsletter 240: The revolution will not be computerized.

PurelyFunctional.tv Newsletter 239: Clojure SYNC tickets on sale

PurelyFunctional.tv Newsletter 238: History, Abstraction, Play

PurelyFunctional.tv Newsletter 237: Unicycles, Evolution, Chasm

PurelyFunctional.tv Newsletter 236: Contrarians, Software, Side Projects

PurelyFunctional.tv Newsletter 235: 10x Programmers, Types and Design, Deep Learning

PurelyFunctional.tv Newsletter 234: 50% off, Teams, War

PurelyFunctional.tv Newsletter 233: Parasites, Carpenters, Re-frame

PurelyFunctional.tv Newsletter 232: AI, Jobs, Batman

PurelyFunctional.tv Newsletter 231: Luna, Beautiful, Abstraction

PurelyFunctional.tv Newsletter 230: Brutalism, Delays, Characters

PurelyFunctional.tv Newsletter 229: Concurrency, Declarative, Addiction

PurelyFunctional.tv Newsletter 228: Klipse, Cortex, Performance

PurelyFunctional.tv Newsletter 227: Drama Edition

PurelyFunctional.tv Newsletter 226: Hacking+Ruby+Clojure

PurelyFunctional.tv Newsletter 225: Spec, Deep Learning, New Orleans

PurelyFunctional.tv Newsletter 224: Dune, Leiningen, CIDER

PurelyFunctional.tv Newsletter 223: The Clojure Density of the Universe

PurelyFunctional.tv Newsletter 222: Laziness, core.async, and Re-frame

PurelyFunctional.tv Newsletter 221: Trampolines, Typing, and Feeling Good

PurelyFunctional.tv Newsletter 220: Re-frame Components

PurelyFunctional.tv Newsletter 219: Clojure/West

PurelyFunctional.tv Newsletter 218: Lisp and Flow

PurelyFunctional.tv Newsletter 217: Re-frame

PurelyFunctional.tv Newsletter 216: ClojureScript vs JavaScript

PurelyFunctional.tv Newsletter 215: Clojure and Generative Testing

PurelyFunctional.tv Newsletter 214: JVM Fundamentals for Clojure Sale Begins

PurelyFunctional.tv Newsletter 213: Clojure and the JVM

PurelyFunctional.tv Newsletter 212: Clojure's simple bravery

PurelyFunctional.tv Newsletter 211: Collaborative Clojuring, SICP, Union Types

PurelyFunctional.tv Newsletter 210: CLJS: Externs inference, Why CLJS?, Live editor

PurelyFunctional.tv Newsletter 209: Peter Landin and Christopher Alexander

PurelyFunctional.tv Newsletter 208: Alan Kay

PurelyFunctional.tv Newsletter 207: Guy Steele, Jr.

PurelyFunctional.tv Newsletter 205: Parallelism, Reducers, Datomic

PurelyFunctional.tv Newsletter 204: Artificial, Mutants, Causal Laws

PurelyFunctional.tv Newsletter 203: Video Deluge, Salaries, JVM, Clojure Remote

PurelyFunctional.tv Newsletter 202: The Clojure/conj edition

PurelyFunctional.tv Newsletter 201: Consulting, Wizards, Looking Glass

PurelyFunctional.tv Newsletter 200: Patterns, Bell Labs, Aliens

Clojure Gazette 199: Clockwork, Personal Computing, Fun

Clojure Gazette 198: Alan Kay, The Matrix, John Hughes

Clojure Gazette 197: core.match, DSLs, and functional salaries

Clojure Gazette 196: We've got links again!

Clojure Gazette 195: The next conference frontier

Clojure Gazette 194: OOP: Why the bashing?

Clojure Gazette 193: Where are the good FP books?

Clojure Gazette 192: Composition is about Decomposing

Clojure Gazette 191: Where does Clojure shine?

Clojure Gazette 190: Reusability and Composition

Clojure Gazette 189: Expertise sounds mystical

Clojure Gazette 188: Separation of concerns

Clojure Gazette 187: Who won the language wars?

Clojure Gazette 186: How Small Abstractions Help Beginners

Clojure Gazette 185: What is Functional Programming?

Clojure Gazette 184: The Onslaught of States

Clojure Gazette 183: The Magic of Abstraction

Clojure Gazette 182: The Joy of Programming to Learn

Clojure Gazette 181: Leaps of Abstraction

Clojure Gazette 180: "How do you structure your apps?"

Clojure Gazette 179: Trade user stories for hammock time

Clojure Gazette 178: The Biggest Waste in Our Industry

Clojure Gazette 177: The Hidden Costs of Abstraction

Clojure Gazette 176: The Ultimate Abstraction

Clojure Gazette 175: Can larger abstractions help more than they hurt?

Clojure Gazette 174: Deepening the tree

Clojure Gazette 173: Dealers of Abstraction

Clojure Gazette 172: Comparing designs from different contexts

Clojure Gazette 171: The Structure of Structure

Clojure Gazette 170: Continuous Evolution

Clojure Gazette 169: Web, Art, Nomads

Clojure Gazette 168: Podcasts and Statistics

Clojure Gazette 167: Cider, Jepsen, Naid

Clojure Gazette 166: Dead code, Bias, Books

Clojure Gazette 165: Newbie, Open Source, Tufte

Clojure Gazette 164: Simplicity, Lists, Jobs

Clojure Gazette 163: Conference, REPL, Tuples

Clojure Gazette 162: Grace Hopper, Fork, Lisp

Clojure Gazette 161: Design Patterns, ClojureScript, Learning

Clojure Gazette 160: Om Next, Fairy Tales, Lambda

Clojure Gazette 159: Overtone, Boot, Specter

Clojure Gazette 158: Survey, Mystics, Embodiment

Clojure Gazette 157: Om Next, Opportunity Grants, Refinement Types

Clojure Gazette 156: Martin Luther King, Microservices, Naming

Clojure Gazette 155: Labor, Internet, Datomic

PurelyFunctional.tv Newsletter 206: Fractals, Reagent, McCarthy

Clojure Gazette 154: Parentheses, Interactivity, Speaking

Clojure Gazette 153: Survey, CIDER, Om Next

Clojure Gazette 152: Static, Dynamic, Business

Clojure Gazette 151: Top Down, Emacs, CQRS

Clojure Gazette 150: Creativity, Runtime, Documentation

Clojure Gazette 149: London, Om/Next, CIDER

Clojure Gazette 148: Performance, Learning, Eventual Consistency

Clojure Gazette 147: Evidence, Denotation, Alan Kay

Clojure Gazette 146: Refactoring, Structural Typing, Clojure Remote

Clojure Gazette 145: Subversive thoughts inside.

Clojure Gazette 144: Can manipulating deep data structures be faster than update-in?

Clojure Gazette 143: Strange Loop, Activism, Typed Clojure

Clojure Gazette 142: Hoplon, React Native, Lisp-Flavored Erlang

Clojure Gazette 141: Spam, Transit, Modules

Clojure Gazette 140: Devcards, Smalltalk, React Native

Clojure Gazette 139: core.async, Haskell, Pairing

Clojure Gazette 138: Tenure, Adventure, Zines!

Clojure Gazette 136: Typed Clojure Core Annotations

Clojure Gazette 135: Transients with Core Typed

Clojure Gazette 134: Custom documentation for Clojure

Clojure Gazette 133: TDD in Clojure on Android

Clojure Gazette 132: Integrating ClojureScript with the Javascript ecosystem

Clojure Gazette 137: Knuth, Om, Objects

Clojure Gazette 131: YAGNI, LaTeX, React

Clojure Gazette 130: iOS, Types, Web

Clojure Gazette 129

Clojure Gazette 128

Clojure Gazette 127

Clojure Gazette 126

Clojure Gazette 125

Clojure Gazette 124

Clojure Gazette 123

Clojure Gazette 122

Clojure Gazette 121

Clojure Gazette 120

Clojure Gazette 119: Continuous Integration Special

Clojure Gazette 118

Clojure Gazette 117

Clojure Gazette 116

Clojure Gazette 115

Clojure Gazette 114

Clojure Gazette 113

Clojure Gazette 112

Clojure Gazette 111

Clojure Gazette 110

Clojure Gazette 109

Clojure Gazette 108

Clojure Gazette 107

Clojure Gazette 106

Clojure Gazette 105

Clojure Gazette 104

Clojure Gazette 103

Clojure Gazette 102

Clojure Gazette 101

Clojure Gazette 100

Clojure Gazette 1.99

Clojure Gazette 1.98

Clojure Gazette 1.97

Clojure Gazette 1.96

Clojure Gazette 1.95

Clojure Gazette 1.94

Clojure Gazette 1.93

Clojure Gazette 1.92

Clojure Gazette 1.91

Clojure Gazette 1.90

Clojure Gazette 1.89

Clojure Gazette 1.88

Clojure Gazette 1.87

Clojure Gazette 1.86

Clojure Gazette 1.85

Clojure Gazette 1.84

Clojure Gazette 1.83

Clojure Gazette 1.82

Clojure Gazette 1.81

Clojure Gazette 1.80

Clojure Gazette 1.79

Clojure Gazette 1.78

Clojure Gazette 1.77

Clojure Gazette 1.76

Clojure Gazette 1.75

Clojure Gazette 1.74

Clojure Gazette 1.73

Clojure Gazette 1.72

Clojure Gazette 1.71

Clojure Gazette 1.70

Clojure Gazette 1.69

Clojure Gazette 1.68

Clojure Gazette 1.67

Clojure Gazette 1.66

Clojure Gazette 1.63

Clojure Gazette 1.62

Clojure Gazette 1.61

Clojure Gazette 1.60

Clojure Gazette 1.59

Clojure Gazette 1.58

Clojure Gazette 1.57

Clojure Gazette 1.56

Clojure Gazette 1.55

Clojure Gazette 1.54

Clojure Gazette 1.53

Clojure Gazette 1.52

Clojure Gazette 1.50

Clojure Gazette 1.51

Clojure Gazette 1.49

Clojure Gazette 1.48 (correction)

Clojure Gazette 1.48

Clojure Gazette 1.47

Clojure Gazette 1.46

Clojure Gazette 1.45

Clojure Gazette 1.44

Clojure Gazette 1.43

Clojure Gazette 1.42

Clojure Gazette 1.41

Clojure Gazette 1.40

Clojure Gazette 1.39

Clojure Gazette 1.38

Clojure Gazette 1.37

Clojure Gazette 1.36

Clojure Gazette 1.35

Clojure Gazette 1.34

Clojure Gazette 1.33

Clojure Gazette 1.32

Clojure Gazette 1.31

Clojure Gazette 1.30

Clojure Gazette 1.29

Clojure Gazette 1.65

Clojure Gazette 1.28

Clojure Gazette 1.64

Clojure Gazette 1.27

Clojure Gazette 1.26

Clojure Gazette 1.25

Clojure Gazette 1.24

Clojure Gazette 1.23

Clojure Gazette 1.22

Clojure Gazette 1.21

Clojure Gazette 1.20

Clojure Gazette 1.19

Clojure Gazette 1.18

Clojure Gazette 1.17

Clojure Gazette 1.16

Clojure Gazette 1.15

Clojure Gazette 1.14

Clojure Gazette 1.13

Clojure Gazette 1.12

Clojure Gazette 1.11

Clojure Gazette 1.10

Clojure Gazette 1.9

Clojure Gazette 1.8

Clojure Gazette 1.7

Clojure Gazette 1.6

Clojure Gazette 1.5

Clojure Gazette 1.4

Clojure Gazette 1.3

Clojure Gazette 1.2

Clojure Gazette 1.1