FizzBuzz is back in fashion! Everybody is doing it again (and again, and again). So I figured why should I miss out on the action?

Why not use (and abuse) as many features as possible, of my favourite FP language Clojure, to FizzBuzz in as many ways as I can possibly muster?

Why not up the ante by leaking the four other ways I discovered so far? And why not make it harder on myself by committing to spectacular public failure if I can't find more? Why. Not?!

So here we are...

(def range-of-fizzbuzzees (range 1 101))

(def fizbuzz map)

(= (fizzbuzz canonical-fizbuzzer
             range-of-fizzbuzees)
   (fizzbuzz or-fizbuzzer
             range-of-fizzbuzees)
   (fizzbuzz juxt-fizbuzzer
             range-of-fizzbuzees)
   (fizzbuzz lookup-fizbuzzer
             range-of-fizzbuzees)
   (fizzbuzz (fn [f n] (f n))
             cyclical-fizbuzzer
             range-of-fizzbuzees))

The chase has begun! Who knows what will happen?

(Edit: 2022-03-05: Well. What happened was demofail due to networkfail.

But, Plan B is live... the blog post is up with even more detail than the talk (see also, links below)).

What scares the Shell out of people?

Artefacts of the long and idiosyncratic history of Unix.

We have so many powerful, stable, widely-available Unix tools and standards, but also plenty of inconsistencies, variants, and arcane caveats; enough to help us... surprise... ourselves in creative new ways. See that cliff you're currently falling off? Yeah, someone went down that road when you were still eating chalk in kindergarten. (Or perhaps you fell off it once before, when I was eating chalk in kindergarten, but it was so long ago that you forgot you've been there done that :-))

Worse, there's no adult supervision, only user manuals. Within Shell's neon-lit environs, one must learn to tread with care, creativity, and cool calculation.

One must learn to accept the silent echo as reward for success.

Why go to Shell at all?

Several of us already get by just fine with a few memorised spells from Shell. That's not a bad way to live, but we miss out on tremendous everyday value that we can unlock with the Unix way.

For there exists a vast no-man's land between memorised tricks and large scale "designed" solutions; wherein no single software tool can really solve all the problems we encounter.

Yet, any modern *nix PC has all one needs to adequately and speedily tailor-make solutions for almost any problem we may encounter in the underserved no man's land.

Solutions that we can use effectively until we truly hit the kind of scale problems or domain complexity that merit use of specialised tools.

Unix nature is deeply Functional

The Unix tools philosophy naturally leads to functional architectures that can scale almost effortlessly. And functional programmers could do worse than learn to exploit such power.

I'll just leave you with Douglas McIlroy's answer to "Read a file of text, determine the n most frequently used words, and print out a sorted list of those words along with their frequencies.", as seen in More Shell, Less Egg:

tr -cs A-Za-z '\n' |
tr A-Z a-z |
sort |
uniq -c |
sort -rn |
sed ${1}q

A purely functional, automatically buffered data processing pipeline, built with standard reusable parts, written in 1986, directly usable on today's computers.

Imaginative Functional Programmers (aren't we all?!) will find striking parallels between the facilities, concepts, and design principles available in their $Langs, and their *nix environments.

No surprise, because in the dreamy mists of time, the wise hackers of Unix lore, and SmallTalk lore, and APL lore, and Lisp lore, and Forth lore etc... were all different, but they were all together, too.

The goal is to introduce how a Clojure programmer would (typically) model things with pure data, design APIs, compose purely functional logic, and use the REPL to interactively "grow" and introspect code.

This demo-style workshop is for practising programmers and CS undergrads/grads (not absolute beginners).