words

on sallust on the gods

2018-06-01T00:00:00Z

I wanted to talk a little bit about the different meanings of fables as they are related by Sallustius in his On the Gods and the World.

In the text Sallust describes the meaning behind some of the maxims inscribed at the temple at delphi, where apollo would speak through his pythia on matters of particular interest to the lives of the men of the day

Know Thyself and Nothing in Excess

By this was meant that one should both understand their inner life and operation,

but also to know their place in the great cosmic chain of being.

greek legendry is full of these sorts of cautionary tales where through great immoderation people receive great punishment, such as the stories of tantalus or sisyphus

And it’s exactly this that sallust was elaborating on In the Gods and the World.

He wanted to talk about the nature of Deity, and in particular about how the Gods could have qualities that were less than admirable.

The conclusion he arrives at is that the fables are meant to be considered as parables, as multiple orders of intersecting meaning.

Let me give an example of the sort of fable that is said to relate these distinct classes of meaning.

In the story of Adonis, the most beautiful of mortals, the mother of the Gods saw him sitting by the river Gallus and fell in love with him, where she placed upon him a starry hat, and mingled with him for all his wants.

But Adonis being drawn like a magnet by lust of his own fell in love with a Nymph. In order that he should not descend to depths of too deep a depravity the mother of the gods turned his mind and had him castrate his own genitals, whereby the union between the Mother of the Gods and the Adonis was restored.

So what can we say about this story? Firstly, it is said not to be a tragedy but a beautiful and vivific story. Greek myth has a long history of castration as detachment from generation, or a shift from begotten to unbegotten things.

We can remember how the Fathers of the Gods were usurped by their sons through castration, Cronos castrating his father Sky with a sickle while still in his mothers womb, during a particularly unpleasant act of copulation. Aphrodite or lust itself was thus formed when his genitals were cast into the sea.

on mythic harmony

2016-10-29T00:00:00Z

Robert Fludd’s Monochord, figuring the scales of creation as cosmic harmony

There is a rich history in The Music of the Spheres and it comes down to us through the seasons of the mind. The stamp left on our soul by our love of music is so immensely profound it can hardly be overestimated.

In this pair of lectures I want to discuss the various forms that harmony has taken in the life of man and what we can learn by it’s shape and motion. I will argue that music is essential to life and that our love of music is our greatest treasure. I want to distinguish between what I will call mythic harmony and scientific harmony. In the first of these two lectures I want to focus on Mythic harmony how the idea of Universal Harmony has come to down to us and what it meant to those who believed in it.

The Music of the Spheres presents the image of man’s life being bound by the musical operations of his environment. The life lived becomes the bow to the string drawn and adjacent tones alone compose the chords of truth and beauty. In these lectures we will discuss the search for universal language and our relationship with music both as artists and as celebrants.

Of the earliest echoes from the memories of man we find the story of Orpheus and Eurydice recounted by the poets Virgil and Ovid

Orpheus was a renowned musician son of Apollo. Eurydice was his lover and earthly muse. In the myth Eurydice suffers an early death which turns Orpheus to greif. Drunk on his own suffering he becomes the first mortal to travel to the underworld. Orpheus who was granted the musical gifts of his father petitions Hades and Persophene to let his wife return with him to the land of the living:

As Virgil puts it in his Georgics:

He even entered the jaws of Taenarus the high gates
of Dis and the grove dim with dark fear
and came to the spirits and their dread king and hearts
that do not know how to soften at human prayer

Orpheus and Eurydice in the Underworld, unknown painter(s) from the Antwerp School

But Orpheus is armed with his lyre and his love and so we see the story continued by Ovid in his Metamorphoses

And with his words the music
made the pale phantoms weep: Ixion’s wheel
Was still Tityus' vulture left the liver
Tantalus tried no more to reach for the water
And Belus' daughters rested from their urns
And Sisyphus climbed on his rock to listen.
That was the first time ever in all the world
The furies wept.

Here we see music as a motive force and these hearts not moved by prayer are moved by this song of love loaned and borrowed. What are we to make here of the collection of cautionary brothers those who bear the burden of the mark of man granted temporary forgiveness through Orpheus' song? The ending of the myth is no happy tale; we see Orpheus struck by the forgetfulness of man losing his last chance to embrace his lover’s skin. He turns back to attend his lover, though forbade by Hades. Orpheus’s tragic gaze is often discussed by philosophers throughout the ages.

So Orpheus is said to have lost love twice and in the passing of time the Muses take his tongue as a medallion. His head is placed on a silver platter long after his death the Thracian Bard continues to sing the song of love twice lost.

Thracian Girl Carrying the Head of Orpheus on His Lyre by Gustave Moreau

We can learn much from the morals of this story as applied to our lives, for it bears fruit for thousands of years to come and many of our greatest thinkers have turned it over in their minds. I think many more still will turn it over to come. But what does this show us about the relationship between music and the gods? How was it that Orpheus’ melody turned their hand and granted Eurydice a second life?

We can look further back in greek mythology though we have to travel forward to the musings of the roman Emperor Julian the apostate, who converted from his Christian faith to the last dying cry of greek paganism.

Here in his Oration to the Sovereign Sun:

“The divine race of intellectual gods above the heavens are replenished from the Sun with boniform powers to those whose authority the whole choir of the stars submits and whose nod generation which he governs by his providence attentively obeys. For the planets indeed dancing round him as their king harmoniously revolve in a circle with definite intervals about his orb producing certain stable energies and advancing backwards and forwards … to which we may add as manifest to every one that the light of the moon is augmented or diminished according to her distance from the sun.”

Here we see plainly Julian’s view of a cosmic harmony noting the harmonic intervals the planets take in their relative revolutions around the sun. And so the moon is said to be occultly defined by the light of sun.

Apollo and His Chariot, unknown artist

In the Greek legends Apollo, the God of the Sun, had a twin sister Artemis who ruled over the Moon. These twin gods were the masculine and feminine incarnations of harmony in motion. Artemis was the Goddess of the hunt, of the Moon, of childbearing, and ritual magic. Apollo was the God of medicine, the Sun, of music, and divination. But both are characterized by two key qualities: Action at a distance and the reckoning of opposites. It was said that Apollo and Artemis were far-darting: Apollo roughly translating as ‘he who is always shooting’ and Artemis as ‘she who acts from afar’. Both are said to have been the causes of sudden death; Apollo in men and Artemis in women. If you fell over struck dead you’d know who caused it.

Thomas Taylor the great English Neoplatonist in his introduction to the Emperor’s Orations lays bare the occult meaning of Apollo:

There is a great multitude of medicinal prophetic harmonic and arrow-darting angels daemons and heroes suspended from Apollo who distribute in a partial manner the uniform powers of the God. … The Telestic or mystic art endeavors through sympathy to conjoin these ultimate participants with the gods. … For the medicinal power which takes away the multiform nature of disease imparts uniform health since health is symmetry.”

Just as notes in a symphony suspend partially from the totality of the work so a votary to Apollo partially imparts the totality of harmonic symmetry. Here we can see the best of the Pythagorean and Platonic systems in resonance. They enacted harmony through rituals of song and dance; through the act of analogy or sympathy they had second births and created something where before it was not.

Apollo and Diana by Lucas Cranach

To understand this sympathetic link between the emissaries of Apollo we should turn to the Orphic tradition as interpreted by the Pythagorean school.

The Orphites were the ritualistic followers of the Orpheus from our stories. Most likely inspired by the Chaldean Oracles the Orphic tradition introduced a symbolic emanationism on top of the Greek legendry. To these religious few our story of Orpheus and Eurydice was full of occult substance and received many and varied expansions. They believed Orpheus lived several years after his return from the underworld and taught disciples the things he saw. What survives of these teachings are the Hymns of Orpheus recorded by Onomacritus which taught of a precession of supervening deities suspended from one another in a chain of necessity.

Pythagoras was said to have received the teachings of the thracian bard and modified many of these teachings to his own work. Simplicius in his Commentaries on Aristotle writes:

“The Pythagoreans believed a harmonic sound was produced from the motion of the celestial bodies and they scientifically collected this from the analogy of their intervals.”

Analogy is fundamental to Pythagorean thought as we can see in the life of the Pythagorean: Aristotle records in his Metaphysics:

Eurytus determined which number belongs to which thing—e.g. this number to man and this to horse—by using pebbles to copy the shape of natural objects like those who arrange numbers in the form of geometrical figures the triangle and the square.

This form of point-wise visualization of figures through their numbers has captured the imagination of mathematicians throughout history from Ford’s tangential circles to Pascal’s geometric triangle but it’s origin lies in Pythagorean thought. A figurate number can be thought of as a collection of dots as a triangle can be made of 1 dot of 3 dots of 6 or 10. There is a simple formula for triangle numbers you start with n=1 and add n=n+1 each step. 1+2+3+4….

Progressions of the tetraktys, each phase is what is known as a “triangular number”

Eurytus turns this on it’s head and says that things can be analogized on account of their sharing the same number of composite dots! A number like 64 then can be both a square and a cube on account of it having both a square and a cube root. This style of thinking was evidently passed to him by the Pythagorean school for Pythagoras saw patterns of number in the motions of the heavens the same on the motion of a string. Pythagoras was said to be the father of music theory on account of his recognition of the rational intervals described by succession of the first few integers.

More than sound however the numbers described an alchemical cosmology as Strabo preserves the writings of the Pythagorean Ocellus Lucanis here quoting from his On the Nature of the Universe:

“Every nature which has a progression possesses three boundaries and two intervals. The three boundaries therefore are beginning middle and end but the intervals are the progression from beginning to middle and from middle to end. … Thus animals require a conjunction with air for the purpose of respiration but light for the purpose of sight other senses with something else. … The sun and moon the planets and the zodiac have likewise a harmony with the world as being parts of its common arrangement. … Fire which imparts heat is itself hot and honey which is sweet to the taste is itself from itself sweet. … That which is to other things the cause of their harmony is itself from itself co-harmonized.”

Geometric proof “squaring the circle”

How robust was the Pythagorean system that it saw the same in the transmutation of the elements as the scale of the octave as the tasting of honey? That each could be considered in terms of a conjunction between boundaries and interval of things in themselves and the transferrence of relation between them - Quoting the work again:

“Fire indeed when it is congregated into one thing generates air but air generates water and water earth. From earth also there is the same circuit of mutation as far as to fire from whence it began to be changed. And fruits and most plants that derive their origin from a root receive the beginning of their generation from seeds. When however they bear fruit and arrive at a maturity they are resolved into seed nature producing a complete circulation from the same to the same.”

Aristotle and later Proclus go on to expand this system but first we see it move through Plato’s account of Pythagorean Cosmology in his Timaeus, on the harmonic creation of the soul:

“He bent them into a circular form connecting them with themselves … he made the one the outer and the other the inner circle. Now the motion of the outer circle he called the motion of the same and the motion of the inner circle the motion of difference”

It is clear that we see the echoes of Pythagorean thought here in Plato’s - the circles of sameness and difference of unity and duality. The ratios on the circle describe intervals the same as are described by the motions of the heavens revolving around their axis according to their quality and kind. Here we see Plato borrow from the Pythagorean tradition to give wings to his flight of the soul. But it was Pythagoras who heard the music of the spheres and recorded it in his tetraktys.

Music theory in the tetraktys

In the next lecture we will examine the mark of this theory of universal harmony on man’s life first through late antiquity then the renaissance and up to the modern age. We will see how it moves from astronomical theory to musical theory to number theory and astrophysics and socio-political theory explaining a rich and complex structure in terms of harmonic wave analysis. The greek legends and the Pythagorean tradition paint with broad strokes which creates a nutritive space for our mind to pull out harmonic tones.

The pythagorean style of life offered simply what we struggle so complexly for today the theurgic state of embodied meaning. We want our lives to mean something but we are afraid to define what that meaning might be. Still there is no shortage of ways to cut the octave and we will see how tunings will come in and out of focus like players in an orchestra harmonizing one another with the thing in themselves.

And thus much on mythic harmony.

on remembering and forgetting

2016-10-23T00:00:00Z

Prelude, from Paul Hindemith’s Die Harmonie der Welt (Harmony of the World)

How can we see what cannot be seen? How can we know what we do not know?

The Pythagoreans believed we could come into direct knowledge of the unknown through the contemplation of the numbers through their figures and their weddings. They believed that everything was part of one great equation that the harmonies of number rang out eternal in ourselves and in the world around us.

Plato no stranger to Pythagorean philosophy remarks in the 7th book of his Republic:

One may come to understand the nature of numbers … for facility in the energies of the soul itself and its conversion from generation to truth and essence.

In our lives things can be remembered and forgotten they can be lost and found given or taken away. We lose our keys the way we lose our minds constantly coming in and out of view like dancers in the dark.

Dante, drinking from the river

Goethe, in his Faust remembered well that we have a twin nature of spirit and substance:

Two souls alas! are housed within my breast
Which struggle there for undivided reign:
One to the world with obstinate desire
And closely-cleaving organs still adheres:
Above the mist the other doth aspire
With sacred vehemence to purer spheres.

We say that an idea forms like an eidolon, the specter and image of the thing in itself. So why are we so afraid of ghosts, the gusts, spirits wandering in the air? Like the greek pneuma or the fire of heaven. For those we make are our children born from ourselves, condensing like dew drops, like Psyche drawn into Demeter’s somber night. Just as we are the images of our creators dim reflections of our holy ghost.

And what of our knowledge and of ourselves? We remember and we forget.

The poet Homer recalled the way that divine bees spun our souls into flesh and bone drawing us from two rivers: Lethe and Mnemosyne, with one to the north and one to the south*; one for the dying and one for the deathless. * For the northern winds are cold and bring winter and dying, but the southern winds are warm and bring summer and life.

In the 13th book of the Odyssey

The busy bees within the urns secure
Honey delicious and like nectar pure.
Perpetual waters through the grotto glide
A lofty gate unfolds on either side

We translate mathematics as the art of learning but more properly it should be known as the art of remembering. For the square is there before we draw it in the sand and will be there long after it is blown to dust. The doctrine of anamnesis so often recited by our most divine Plato is essential to Pythagorean thought. Socrates phrases the problem of meaning directly to Meno asking: What is justice? This question like our most famous gorgon Medusa paralyzes those who entertain it.

In his famous paradox Meno inquires how he can find something without being able to identify it. Were it right in front of him he’s afraid he could not see it. In response socrates turns to geometry, mathematics, and learning. He teaches one without formal education how to double the square using only basic means of doubling and halving. We can clearly see that we do not understand such things until we have learned them. We could not identify them if they were right in front of us but somehow we are granted vision through the act of learning.

Socrates' solution to Meno’s paradox is no accidental turn of dialogue but is the heart of the Pythagorean doctrine. The numbers are prior to generation and never pass through the cradle nor grave. No number was ever turned to be anything but itself and the numbers like the gods are never seen to die or to be corrupted.

In the following series we will take an account of The Fall of Arithmetic into Geometry and will try to understand our own deeply complex relationship with numbers and mathematics.

We will find that numbers can be used as tools for reasoning and for meditation. They can be used as objects of worship as characters in a story or as sigils and curses. Numbers can be used to trap us in prisons of our own thoughts or to turn our souls toward the things most divine.

I want to leave you with this fair warning from the poet Alexander Pope and his Essay on Criticism:

A little learning is a dangerous thing
Drink deep or taste not the Pierian spring:
There shallow draughts intoxicate the brain
And drinking largely sobers us again

I hope that we can drink sufficiently deep and that these ideas flower like blossoms in our minds.

chasing your tail

2014-05-18T00:00:00Z

Who are you? What do you want?

I want to be healthier, stronger, funnier, smarter. I want to be respected and powerful and trusted and loved. I want to see my desires in a mirror looking back at me, a double wanting the same from a vision of myself. I want pure expression.

Someone once told me that the best way to get what you want is to know what you want. The depth and simplicity of this struck me hard but I couldn’t answer to it. I tried things like “I want to make the world a better place” or “I want there to be less wasted effort”. But everything I tried fell flat against the weight of the thing itself.

In our lives we can use our desires as a guiding light, helping us stay our course when we find ourselves in strange places. But our ship will never leave the port without a destination. So where are you going?

The things that guide us in the dark also free us from the burden of answering these questions. We can close our eyes and follow the thread that pulls us. And still, the easiest way to get moving is to have somewhere to go.

I wanted to be a computer programmer. So I became one. I poured 5 years of my life into trading my free time for experience. I stayed up too late obsessing over the tiniest details of my strange little programs.

Then one day I realized I had arrived at the place I set out to be. I was writing code that major companies were trusting on their websites, spending my days paid by a megacorp to dive deeper down the rabbit hole of weird tech. And I still wasn’t where I wanted to be. When I had lived outside myself I saw programming as a land of milk & honey, a sort of magic for making the imagined real. And I lamented that the thing itself was not the picture in my mind. I had broke through to the other side and I still had pains and fears and was still a weak person afraid of my own shadow.

And this is how life works.

Now I see it like language, a game of chaining together fragmented elements in hope of creating some greater meaning.

I am the same person now as I was before, just as you are the same person as you were before you learned to play the piano, before you heard your favorite song, before you became a singer or dancer. You are already the person you dream of being, separated only by a lack of action & understanding.

We live our lives from the outside looking in, thinking “Once I get there things will be different. People will finally see me for who I am, not as a pale imitation of myself”.

You are who you are, you have real passions and fears, real beauty and talent, you are already there on the other side.

deploying meatspace

2013-03-04T00:00:00Z

Have you ever wanted your own meatspace? For your school, work, or your sweater knitting crew? Now you can have one! For 5 dollars a month you can host your own meatspace chat room on the cloud and invite all your friends and chat chat chat all day and night, without any pesky ‘regular meats’ getting in your way.

If you make an account on Digital Ocean, the official host of meatspace, you can use the ansible meatspace deployer to start up a virtual server with meatspace installed. Within minutes your instance will be running and you can invite all the best chatters.

Before we get started deploying meatspace chat there are a few system requirements we will need. The automation is done with ansible so you’ll need that installed. Unfortunately this process this won’t work on windows, but should work most everywhere else. We also need to make sure we have the digital ocean python library.

If you don’t have pip, check the installation page for help setting it up. This is different on every system but is probably something like brew install pip or apt-get install python-pip.

Next, we’ll need to make sure that we have a copy of the ansible project.

Edit the contents of .do to include your digital ocean credentials. Visit their api page if you don’t know these.

Optionally we can edit the vars file located at ansible/group_vars/all to configure the server with custom client api keys, domain name information, and any other desired configuration.

To deploy the new meatspace droplet just run:

This will create a $5/mo ubuntu server in digital ocean’s nyc datacenter and install meatspace chat onto it. The whole process takes about 10 minutes, so you might want to go get some coffee or reflect on your life in the meantime.

If you ever want to update your meatspace instance to the latest version or configuration you can run:

That’s it! Hopefully this makes meatspace-chat easier to setup for some people. Check out the github project or ping me on twitter for comments or support.

Happy meats,
– Thomas

chat on the web

2013-03-02T00:00:00Z

I wanted to share a chatroom I’ve been hanging out on, and some ideas that came floating out of it.

Communication is hard.
Communication is easy.

Which is true, and why? This simple paradox dominates so much of our social lives, and yet a website for gif chat has put the whole thing in a new light.

Communication is hard because often we misinterpret the meaning. It is hard because our words rarely line up with the things they are supposed to represent. It is hard because we are afraid of the unintentional impact that our communications can have.

Communication is easy because we are social creatures and it comes to us involuntarily. Simple things like tension in the neck can communicate discomfort, or a smile or grimace in a particular context. A simple wink or sigh can betray a depth of knowledge.

We have always been mystified by communication, with great minds dedicating their lives in an attempt to bring back something valuable to the community, something to share with the rest of us. Poets, journalists, artists, musicians, and authors dedicate their lives in order to convey insight. To plant a seed so that it may grow. To go out into the areas of thought not yet before traveled and to bring something useful back to the commonwealth.

The Greek God Hermes was the archetype of this idea; embodying the translation between the mundane and divine. The Messenger of the Gods was the sigil of unification between the arts & sciences, using knowledge transfer as the medium, translating meaning from one system into another.

So what does a gif chatroom have to do with communication, poetry, & greek gods? Social revelations are primarily those of synchronicity and will, of looking at the chaos of missed connections and obfuscated meaning and shaping it into something useful, just in time.

Meatspace has this in spades, itself being a self regulating strange attractor for artists, hackers, geeks, weirdos, subgenius, discordians, musicians, makers, office workers, autodidacts, trolls, machinists, psychologists, professors, wives, parents, brothers, sisters, engineers, & students. And these people communicate with eachother. They chat!

In meatspac we make handcrafted artisinal gifs. We make gifs you can take home to your family. We do take them home to our family. The community of meatspace is full of people who looked into the technical landscape at the current forms of communication and wanted something more meaningful.

gifchat may seem counter-intuitive in the world of omni-present video conferencing, but there is something special about a short, looping snapshot of an emote accompanied by a small snippet of text. How can a simple gif and caption so well capture the essence of expression?

The more complete the emulation of face to face human interaction the more directly we are confronted with The Hard Parts. Did I phrase that right? What will you think of me if I phrase it wrong? Will I have an opportunity to make up for it? Don’t worry, just let go.

With meatspac you can take advantage of the subtle emotional platform that so much of our communication is built upon without any of the pressures of constant upkeep of social appearances thrusted upon us by direct face to face interactions.

On meatspac hit and run communication is common, popping on while at a restaurant, or when you just wake up, go to bed, or have some time in-between work meetings.

Meatspace is a place of sharing, a place of learning, for support, and humor. We have gifs to cry on and gifs to cheer us back up again.

Meat!

On the Internet!

Words cannot explain, come over to chat.meatspac.es and see for yourself!

three little birds

2013-01-03T00:00:00Z

Simple functions can be very surprising. With functional programming on the rise more and more of my time has been dedicated to understanding functions. In doing so I’ve discovered their deep and rich history in practical mathematics, in particular Combinatory Logic and Lambda Calculus. Understanding the contributions from these fields can help immensely when trying to reason about complex function chains, which are encountered more and more often in modern programing.

Lambda calculus is the use of anonymous function application for calculation and is defined in terms of simple substitution and conversion rules. For an excellent introduction to the lambda calculus I recommend Bret Victor’s Alligator Eggs

Combinatory logic is the use of functions to combine functions. A combinator is a function whose input are functions and whose body is defined only in terms of function application. This is another way of saying that a combinator cannot introduct anything new, it can only combine. For an introduction to Combinatory Logic you can do no better than Smullyan’s To Mock a Mockingbird or any of the various books or posts by @raganwald.

While all of this might sound complex, when viewed in the context of our everyday programming it is rather simple, though the implications are profound.

In To Mock a Mockingbird, Smullyan refers to the functions in combinatory logic as birds, and those of us whom wish to understand them as curious birdwatchers. (As we will see, the birds are quite curious themselves). The premise of the metaphor surrounds a birdwatcher who makes bird calls out to some bird in a forest, which responds back with a bird noise of its own. With some imagination, we can use this to represent function application.

There are a few important but subtle points around this metaphor that must be understood to see why it represents combinatory logic in particular (as opposed to general function application).

The first is that birds only speak in the language of the birds, so if you call out to them in some foreign tongue they may have unusual responses! If a bird is a combinator and a combinator is a higher order function (a function that operates on functions), then this implies that we should generally only pass functions to our birds (I’ll be using the terms interchangeably). Another key point lies hidden in the simplicity of the metaphor. If we make a bird noise and it responds with a noise in turn, assuming we made the bird call properly what the other bird hears would be indistinguishable from the bird we are imitating. If the response is a bird noise as well, then it is the same sort of thing as we supplied, a bird! If we can make a given bird noise, we have the essence of the thing, a first class reference. There is no distinction between a birds name and a birds sound. To understand what this means we can look at a notion called referential transparency which says that any time a name is used it can be swapped out with the value of the thing it names and maintain the same meaning. In the forest, if you can respond with the sound a bird makes you have may as well be the bird yourself. In summary, birds are those functions whose parameters are functions, who are defined in terms of function application, and whose resulting application yields a function!

I think this metaphor is marvelous for functional programming since many higher level abstractions don’t have suitable names, and remember, as all good wizards know: to name a thing is to have power over it.

This post introduces a number of functional programming techniques in order to provide some context for combinators. Uncle Bob has said that functional programming is programming without assignments. Whether or not this is the case it does serve to introduce a curious problem. Some concepts like recursion rely on assignment (what Bob calls the quintessential side-effect). How can we achieve truly functional, side-effect free recursion? Interestingly, the answer is within Smullyan’s forest.

As we enter the lush forest the first bird we see is one which many are too quick to judge. It’s called the idiot bird or the identity bird and when you make a bird call to it the idiot responds with the very same noise. Amazingly, this bird can make any possible sound! Can you? In javascript it would look like this:

This bird seems useless, a function that takes a parameter only to spit it back at us! What an idiot! Some have speculated that the idiot is actually deeply enamoured with other birds and so only mimics them out of appreciation.

As we continue our stroll, the next bird we encounter is the mockingbird. The mockingbird is a mystical bird which has the interesting property of duplicating its input (it takes one x in, but somehow has two copies of x in its body). While this is commonplace in programming it is not so common in the world of combinators. Because of this ones that do are in a special class called duplicative combinators. If you call some bird x to the mockingbird it will respond as if the bird x had called out to itself (or what is the same, the function x applied to itself). In javascript:

What use is this bird? It’s easy to find useless things we can do with it, for instance if you make the noise the idiot bird makes to the mockingbird it will call out the idiot bird back to you. That seems like the behavior of the idiot bird itself, however if you call the mockingbird to the mockingbird it will never stop trying to figure out what it should say about itself! We can demonstrate this by reducing:

Even with this, it’s hard to conceptualize a clear use case for this peculiar bird. The mockingbird lies at the heart of combinatory logic. Sometimes called the U combinator, the mockingbird is the primary tool for self application, which can be used to simulate recursion. Without recursion simple languages like Lambda or Combinator Calculus are not expressive enough for universal computation. Lucky they have the mockingbird!

If it suits our fancy we can even engineer our own mechanical bird to calculate a factorial. It’s not quite a real bird (a classical combinator) since it does more than simply combine its input, but it’s close enough for our purposes. Since we’ve heard the rumour that the mockingbird enables anonymous recursion, we might try to build something that proves this. Many birdwatchers spoke to this magical bird chiefly for this purpose. Our bird doesn’t have to follow all the rules of classical combinators but it satisfies the chief property: being a function which takes in a function and returns a function.

Initially we call the strange factorial out to the mockingbird, or what is the same, strangeFact is applied to itself, which returns the bird from line 2. If we inspect the mechanics of our bird, we can see that fact bound to strangeFact, since strangeFact returns the factorial calculator, it only needs to ask should it ever require a copy. (We ask for a copy at line 8 initially, and line 4 if needed subsequently) I encourage you to take the time to understand what is happening above; while it may seem trivial it is the core mechanism of anonymous recursion. Consider the following:

If the mockingbird can give us a version of our bird that knows about itself, when we define our mechanical bird in terms of the mockingbird we also gain the ability to create functions with references to themselves.

This works but is very… strange. In modern javascript, we could write less code with fewer dependencies and wind up with something that is easier to use, simpler to reason about, and more performant to boot!

Observing this, we can now take great comfort in knowing that we no longer need to use anonymous recursion. While the use of the U combinator style recursion may seem outdated in modern programming parlance its impact on computer science cannot be overstated. Combinator and Lambda Calculus are much simpler notations than javascript which owes its higher level abstractions to the work of those who spoke to birds like these long before us.

As a birdwatcher who hopes to fashion birds of our own using the mockingbird to simulate recursion is awkward at best. We have to know about the mockingbird inside of our function and manually handle the self application at each step along the way, what’s more our bird must also be returned from the mockingbird. What we’d like is a way to be flexible enough in our bird creation to not have to worry about this technical detail and be free to focus on only the problem itself. Perhaps there is another bird who can help us achieve what we want.

The next bird we encounter, the most immediately practical of these strange birds is the bluebird. If you call out some bird x to the bluebird, it’ll call back to you with an entirely new bird which knows all about the bird x. This means it gives you back a new function with x in the environment’s scope. This new bird has the curious property that if you call out some bird y to it, it will return some even newer bird that knows about the birds x and y. And now we have both x and y in our functions environment. If you give this final bird some bird z, the bluebirds work will be done and it will return what results from calling out bird z to bird y, and calling the resulting bird out to the bird x. This is what is referred to as a closure, because each successive function closes over the value of one parameter. Having trouble picturing it?

The above is a special curried way to say:

The difference is that the first definition allows you to define a bluebird with only an x or only an x and y, rather than only with x y and z. This technique is called partial application. While the first of these functions all take in a single value, because it is their grouping that we are interested in we can say that bluebird simply takes three inputs (xyz).

The bluebird is also known in many circles as compose and can be used to thread some value through arbitrary function sequences. Traditionally in combinatory logic the threaded value is a function itself but as we will see it doesn’t have to be. The core of the bluebirds functionality is that it defers the application of x in favor of first applying y. Here is an example of using the bluebird to construct increasingly complex functions.

Here we have times being a closure that returns a fn with the value of n closed over. With times6 being a bluebird, we can reduce the above invocation by following the rule of Bxyz = (x·y)z = x(yz) where x is invert, y is times6 and z is -6.

The bluebird allows for some remarkably beautiful chaining, and we’ve only begun to scratch the surface with this example.

Continuing along, the next pair of birds we meet are the strangest yet. They seem to have much more in common with the mockingbird than the bluebird though in actuality they are simply a hybrid of the two. These birds are both dear friends of the mockingbird and in fact are defined in terms of it! The first of the pair is called the lark. When you call out some birds x and y to the lark, it will respond by calling the sound of y out to the mockingbird, then taking the response and calling it out to the bird x, or what is the same, applying y to the mockingbird then applying that resulting bird to x.

Given the lark we can show that the lark given identity is the same as the mockingbird, LI = M and the lark given the lark is something like two strange mockingbirds: LLxy = Mx(My)

The lark is a way to compose some function with self application. Given this and our knowledge of bluebirds, we could also define the lark as:

Next is the meadowlark. When you call out some x and y to the meadowlark, it will respond by calling out y to the mockingbird of x

Note: This bird was unnecessary in combinator calculus because it can also be written as Mxy. So how can we use the meadowlark?

Given the meadowlark we can show that MₑI = I:

Interestingly the meadowlark behaves much like the mockingbird duplicating for all time. In fact, this bird differs from mockingbird only in that it ensures that there is a y..

While interesting, both larks seem to be devoid of any practical use. It’s as if they took the good parts about the bluebird (generalized function composition), and tangled them up with the notion of the mockingbird. What we will see however, is that these birds are the primary methods of composing self application. (x(yy) or xxy). Why would we want to compose self application? If self application can be used to simulate recursion, then we can use higher order functions to compose our functions with the notion of recursion! Perhaps the there is a bird who can do this for us somewhere deeper in the combinator forest.

There are special birds in the combinator forest called Sage birds. Sage birds are particularly useful for finding the fixed points of other birds, where a fixed point is the element when called out to some bird will results in the element itself. That is, f(x) = x. Everything is a fixed point of identity, but finding the fixed points of other birds is much harder to reason about. So why is it useful to have a bird to help you find these invariant points? Well, having a fixed point means you have found the limit of the function, also known as the convergence. In recursive functions, the convergence is of particular importance since it is often the only way to terminate evaluation (those functions who never terminate are said to have diverged). Can you see why locating a convergence can be useful if we want to represent recursion abstractly? Consider how strangeFact uses the mockingbird to advance computation by a step. Can you see how we can use the lark and meadowlark to abstract these steps?

Haskell Curry saw this clearly and created the most popular of all sage birds, dubbed the Y combinator. Remember that phrase curried from earlier? That particular style of partial application, where one element is applied at a time, as well as the Haskell programming language both get their namesake from the very same! In the lambda calculus it would look like this:

If you look carefully you might notice that there are some familiar friends here, in particular the mockingbird (x)(x) and the lark x(yy) in the inner form resulting in (x(yy))(x(yy)). Can you find any other birds here?

First, here’s what it would look if we and translated the lambda terms literally:

This is a bit dizzying, but we can simplify it by recognizing that we are invoking a function with itself. This is the same thing as passing the function to the mockingbird.

And by realizing that the inner function is applying the mockingbird of x to some f, or what is the same, that the inner function is the lark of f.

And by realizing the above is simply a means of composing f (threading it through lark and then mockingbird):

This is fantastic! We’ve shown that the famous Y combinator can be represented as the combination of three little birds! The only problem is that the above code doesn’t actually work.

While we can show that it is mathematically sound, with Θ as the sage bird:

The last two reductions can be flipped and viewed as x(Lx(Lx)) = Lx(Lx), or x(y) = y where y = Lx(Lx) which shows that we have found the fixed point! The problem is that in modern programming environments, we can expand Lx(Lx) infinitely. Languages like javascript do.

This successful reduction strategy above is referred to as ‘normal order’ (call by name), which means we substitute the parameters before evaluating them, where the one expanding forever is called ‘applicative order’ (call by value) which instead reduces its parameters into values before expanding a functions body. In call by name systems we can simply call this thing by the name Lx(Lx), but in call by value languages (like javascript and most popular languages) we get lost when asking for the value, similar to a mockingbird attempting to mock itself. Maybe we can find a different bird that works in call by value systems.

Seeing the shortcomings of the Y combinator, we can see that if we can somehow defer evaluation of the lark we can avoid blowing up the stack, and thus make a sage bird that works with applicative order. So rather than invoking the lark at sage(x) we can defer this until we have some z to call it with. This means the z of bluebird should be the actual argument to the function returned by the this new combinator, not the function provided to it. This is a subtle note, but an important one. It means we will have to return a bird which returns partially applied bluebird rather than returning a partially applied bluebird ourselves.

The above combinator is known as the Z Combinator, though sometimes it is called the Y combinator since it reduces to Y. (Remember the meadowlark ensures the presence of some y). While the Z combinator is a bit more cumbersome and harder to reason about, it properly combines the pieces to work with a call by value system by using the meadowlark to manually defer evaluation. I encourage you to write down the reductions yourself in order to see what’s going on, it’s quite interesting!

Having seen this new bird, let’s revisit our strange factorial.

If we know we are working with a fixed point combinator we can forget the mockingbird from our previous version and focus our attention on the inner function alone (the actual factorial function), all thanks to higher order abstractions. Amazingly, our version of the factorial takes in the idea of what it means to recur! Let’s see it in action:

And without assignment:

The Z combinator or “the mockingbird of the bluebird of f and the meadowlark” can calculate all the way down to the fixed point of f by trampolining a functions invocation with its definition.. Unlike our U combinator, the Y and Z combinators also takes care of self application so we don’t have to worry about using the mockingbird to rebind our name inside our function. The above birds are achingly clever, and yet built of out relatively simple parts!

What a fantastic example of the power of combinators. Given such a massive problem as “how can we support recursion without assignment?” we’ve seen how combinators can be used not only to simplify the problem itself, but also serve to provide us with a tool for understanding larger concepts by breaking them down into simple ideas. I hope I’ve helped elucidate some small corner of the wonderful world of combinators for you, as others have done for me. I’ve heard it said that if classes are the nouns of programming and functions are the verbs then combinators are the adverbs. We’ve demonstrated how we can use these combinators to factor out common patterns from our functions or as building blocks in and of themselves. Even something as opaque as the infamous Y combinator can be reduced in terms of it’s simpler components.

It may surprise you to learn that there are an infinite number of sage birds to be found by combining simple combinators, can you find any others?

porting java to clojure

2012-08-10T00:00:00Z

Hi everyone!

I wanted to share some interesting things I found while porting a hashing function from java over to clojure. I needed to translate some unique identifiers from one format over to a different, universal, and shared format for some quick reports I was trying to pull; luckily this had already been done and was available as a simple standalone class. I could have (and arguably should have) just used the class file itself and not written a lick of code, but I like understanding how things worked and I figured porting it into native clojure would be a good chance to both understand it as well as learn a bit about clojure in the process!

So heres the original java class:

It’s pretty simple, first it creates some number boundaries, one the upper bounds of an unsigned 64 int represented as hex and secondly the upper limit of the universal identifiers. It also specifies a prime number in order to get a broader distribution of keys per character. I know this isn’t sha1, but it’s what we had currently in use, and so it was what I was going to replicate. My interest was porting it, but first I had to grok it.

The main work happens in the ‘hash’ method, which returns a long given a string. It generates a hash seed as an initial value and then proceeds to multiply this value by the prime declared earlier; it then finds the modulus between that new hash value and the u64-max-int (ensuring it is within bounds), followed by a bitwise exclusive or between the accumulated value and the value of the current character; repeating this process for each character in the given string. Finally it takes this newly built checksum and ensures that it’s within the bounds of the max universal ids, returning as a long. Whew!

This may or may not be the best way to create a hash within the limits of the universal id boundaries, but it seems to have worked so far. The syntax and notation above should hopefully be familiar to anyone who has used a c-style language.

So let’s take a look at the clojure (and lispy) equivalent.

This probably looks very strange at first, but I think it’s a uniquely elegant way to represent transformations over data (in our particular case, the transformation is the one that turns a string id into a universal integer id). If you are new to clojure (def x 1) is the same as x = 1 and (defn my-fn [args] (use args)) can be read as function my-fn (args) {use(args); The first four lines equate to the static final fields in the java class, with the exception of the seed being extracted out of the hashing method (since it is unchanging).

The other caveat is the -> operator. This function is actually a macro, which says take the value of the first parameter provided to me, and slip it in as the first parameter to the following statement, then take the result of that statement and slide it in as the first parameter to the following statement… etc.

Above I represent where the prior value would be inserted as two commas (which the clojure reader interperates as whitespace). An example for this would be a transformation where "hello ".toUpperCase().strip(); is translated as (-> "hello " (.toUpperCase) (.strip)). This is called the thrush operator or the thread-first macro and it is unique to lisp.

Following along, on line 7 I pull out what was previously an inline parameter in our java class (a simple call to BigInteger.valueOf(charArray[i])), generalizing it into a function which can generate a hashcode for any clojure object.

I think the next section was a particular revelation for me, wherein I realized that every for-each body is intended for one of three things.

to derive some single value from a series – reduce
to produce an entirely new collection of values – map, filter
to perform a series of sequential side effects. – doseq, forEach

It’s only recently that I’m realizing I don’t need that last one to achieve the former. Reading over the body of the for-each loop, it was obvious that a new value was gradually being built up by iterating over the character array. I know that the reduce function is intended for just this purpose, so I sought out to see how I might write a reducing function that implemented the same functionality as the for-each body.

It was surpisingly simple once I saw the pattern, and the thrushing operator made the transformation so incredibly readable! Take the provided checksum value, multiply it by our prime, find the modulus of the u64 max, and perform the xor against the hash of the hashable.

Wow! This is exactly how we would describe this in english! The instance method invocation style offered by clojure allows for some really astonishing composition and generalization. I also believe that naming things forces you to think about their proper abstraction. Finally, we have our function to actually convert some collection (like a collection of characters, but really any collection) into a checksum. We get the checksum value by using our reducing function, providing it our seed as an init value and finally we ensure this number is within the universal id boundaries via mod and return it as a long.

I’m continually impressed by not only how enjoyable clojure is to work with, but how powerful and general the abstractions of functional programming are. So, do you prefer one of the above styles to the other? Why? I think it’s pretty obvious which camp I am in. :D

pattern matching & clojure

2012-08-03T00:00:00Z

Lately, I’ve been fascinated by clojure, a dynamically typed lisp hosted on the JVM. Clojure is known for its immutable data types and list processing capabilities, but as it turns out it’s really good at representing abstract ideas, too. A while back I came upon this gist by david nolen (who happens to have authored quite a number of awesome gists), and was reminded of it today while talking about different ways to structure some validation methods.

The gist shows user/pass validation using pattern matching in two languages, clojure and javascript. But more than that, it shows how sometimes all you need are simple case expressions. To explain it however, I think we may need a small primer in clojure.

If you don’t know clojure, or lisp, the syntax is pretty simple. Everything is a expression (called s-expression or s-exp), expressions are defined by parentheses, and the first thing in a expression is a function where the rest are the parameters to be supplied to that function.

So instead of saying printf("Hello, %s!", "world") you would say (printf "Hello, %s!" "world").

Since everything in clojure is just a function with parameters if you want to describe something you must realize it, or evaluate the code. A expression like (+ 1 (+ 3 4)) follows relatively simply; The function + is called with 1 and some form. That form is the value of the + function called with 3 and 4. When + finally returns the value of 7, the outer function can continue and realize its value of 8.

Consider the following:

How could we even explain this simple bit of code with our previous set of syntax rules? It’s impossible! This is because the previous problem of summing 1, 3, and 4 could be described as a pure function (which is a special way to say that the function is referentially transparent, or that given the same inputs it will always return the same outputs), while our javascript example involves simple mutable state. But do we need this state? When is it time to come and clean up the vars x and y? Are we done using them yet? Will we ever be?

We could represent the previous snippet in clojure like this:

This may look odd if you’ve never used a lisp before, but let’s try to apply our previous set of syntax rules to this single expression. The first part of the expression is the function let, invoked with 3 parameters; the value of some vector, and two s-exps (one is the println fn, and another is the let fn). These forms are all at the same level, so we can continue by taking the values from them sequentially. There’s a problem however, if we try to take the value of any of them, we will realize that we don’t yet have the value of x or y! (try it yourself). Clearly this ‘everything is a function’ stuff is a lie, if the syntax were only that simple, we wouldn’t be able to represent even the simplest of problems!

But we’ve yet to address the problem of the side effects; specifically, why does our javascript code have them while the same code in clojure does not? The reason for this is that the act of assignment itself is necessarily a side effect. Its entire purpose is to provide a particular value which other functions can reference at some other point in time. However, unchecked assignment is not always ideal as anyone familiar with concurrent assignment and referencing can tell you. And so, in order to resolve this issue once and for all, God invented the macro.

A macro is a special kind of fn that doesn’t immediately evaluate the parameters it receives. Instead it’s defined in terms of a special function recipe in which it reorganizes or modifies the expressions provided to it, transforming and evaluating the values it requires while substituting the values of others.

So then, let is a macro which doesn’t immediately evaluate its forms. Instead it takes as its first parameters a binding vector, containing an even amount of elements to be considered as keys and values. It then walks all subsequent forms, evaluating them and substituting the value of the required key any time it is asked for. So we could describe the previous snippet as follows:

Invoke the let macro with the binding vector where x is 1 and y is 2. With values in hand, continue walking the forms and evaluating, supplying the value of any given symbol should it be bound to some value. – The let macro has no problems when the lets are nested and shadows the old values for x and y while incrementing and decrementing them to get the new values to be bound only for the inner expressions!

Onwards to the code!

I’m sure the first thing you realize is that there is an awful lot of weird characters in this, as if someone were holding their shift key while sweeping their fingers around the keyboard; but don’t worry, the important thing is that each of those characters has a syntactic meaning!

The first line just invokes the defn macro, which names a function that takes some parameter list defined in the binding vector and subsequently, the form to bind the values of the parameters to. In our case the function is named validate-credentials, and it takes two arguments: username and password. It then uses let to get the shorthand for four symbols, uc, defined as the count of the characters in username, pc defined as the count of the characters in the password, a less-than-3? fn to determine whether a given number is less than 3, and the respective fn for less-than-4?. It then invokes the pattern matching macro supplying pairs of patterns to match and expressions to evaluate upon successful match. What it says on line 6 is to match against the values for the four symbols username, uc, password, and pc, in that specific order. Those _ are actually variables names, where the variables could be used in the following expession. Using an underscore as a variable name is a common idiom for saying ‘throw away this value’.

The first expression says:

If the username is nil or the empty string, and the rest of the values are anything, give a no username given error.

The second expression says:

If the password is nil or the empty string, and the rest of the values are anything, give a no password given error.

The third expression says:

I don’t care about the values for anything, but when the value of the username count is is less than 3, give a bad usercount error.

The fourth expression says:

If the passcount is less than 4, return the respective error.

The fifth expression says:

I care only that the username is in alphanumeric.

Once your eyes uncross from trying to read all those funny characters, the solution is really quite elegant. Things are always just defined in terms of simple pairs, a binding vector and the code to evaluate with those symbols bound, from the let form to the defn form to the matching form. Once you know how to read the pattern matcher, you don’t even need to think about how to implement your control flow, you simply describe the shape of your interesting cases and dispatch off of them. The core.match library shown above enables vastly richer pattern matching than simple case or conditional expressions, holding onto variables in a similar way to let, allowing for a refreshingly clear and succinct representation of complex scenarios.

But enough about musing about how great clojure is, let’s look at the javascript version!

Note: If you are less than familiar with javascript (and specifically ternary operators), you should check out mozilla’s awesome tutorial.

The first thing a few of my js hacker friends said when they saw this snippet was how readable and elegant it was for a validator in javascript, and I don’t disagree; but even still I want to take a closer look at it. It starts by defining an object named user, who has one attribute, a method named validateCredentials. This method also takes two parameters: username and password. Besides the extra concept of the Object, by line 2 we are still remarkably similar to the earlier clojure implementation. Line 3 specifies that the following expression is the return value of the function (clojure didn’t need to state this because the last form inside of a defn is implicitly the return value).

Finally, it begins its pattern matching rules by leveraging nested ternary expressions, or nested if ? then : else expressions. But wait, what’s going on in our first pattern?

If we try to convert that first pattern matching form to english it becomes something like: If the boolean opposite of the username plus the empty string or if the username is the empty string then give the no username given error

Wait, the opposite of the username plus the empty string? What does this even mean?! It turns out that in javascript, simple nil checks aren’t exactly simple, with the nil being possibly undefined or possibly some other falsey value (which may cause some unexpected behavior), and so in order to get at a boolean value, we coerce it into a string type by adding it to the empty string, then coerce it further into its boolean opposite using the ! operator. Since an empty string will evaluate as false the boolean opposite of this evaluation is true, causing the if expression to succeed, and giving our failure message! – Whew! Now in order to understand line 4 we must understand Ternaries, Type coercion, and Objects, as well as the short circuit logic of the || operator. Before we only needed to understand functions, macros and the shape of some data!

Once we know some rules about javascript the rest follow easily and clearly, save for the usage of the regular expression (which was also used in the clojure example). My point is that once you understand the idiosyncrasies of the language you are using, you forget what it is like to not have to deal with them. You say ah yes, this is simple because I know how to do it, it is clear because I can read it, and things like the above js pattern matching appear beautiful and elegant to you, regardless of their incidental complexity. And it is elegant javascript; it imports a simple idea into a language with complicated syntax. That is a good thing.

But wouldn’t you rather just use a language where the simple syntax made it trivial to represent your ideas, whether simple or complex? For more, I highly recommend watching author of clojure, Rich Hickey’s amazing talk on this sort of simplicity, Simple Made Easy. Oh, also, if you made it this far, drop me a line and tell me what you thought! twitter or g+

running with mynt

2012-01-26T00:00:00Z

I’ve been in the market for a solid blogging platform for some time. I’ve built fully featured blog engines with django, played with drop-in solutions like wordpress and drupal, as well as trying hosted solutions like tumblr. It always ended the same; I found myself spending more time worrying about the platform than actually writing. I would have to spend a non-trivial amount of time and effort becoming familiar with the domain specific idiosyncrasies of each product, what was required to theme the project, extend functionality, or more often than not, what was required to purge unnecessary features. All the platforms I mentioned are rich, mature and suitable blogging platforms. They also aren’t what I have been looking for.

Yesterday I read about a new static site generator on the Planet Python feed, called mynt written by Andrew Fricke. It boasted a rich feature-set and simplicity. It was written in python and used markdown and jinja2 for layout and content. I was familiar with the tools so I decided to give it a go.

Installation was a breeze, I created a new isolated python environment with mkvirtualenv samelog -p /usr/bin/python2.7 (mynt needs python 2.7 since it uses some core libraries like argparse not found in earlier versions of 2.x – oh, and you’re using Doug Hellmann’s virtualenvwrapper already, aren’t you?). I then installed with a simple pip install mynt, made sure that mynt --version returned a sane response to check the install and I was ready for the races.

Unfortunately mynt doesn’t come with any scripts to generate a dummy project, but I found the source to Andrew’s personal site helpful as a starting point. Luckily, you can find this up on github. In either case, you should be set by simply running this command in your project directory:

This will create all the necessary files for your project, of course you’ll need to fill in the content yourself.

Mynt uses yaml for configuration in both templates and project config. An exhaustive list of config options can be found at mynts documentation. However, I just needed one:

This tells mynt that it’s mounted at /log/ rather than / and to handle assets/urls accordingly, simple enough!

Fist things first, we’ll need a layout. Open up _templates/base.html in your favorite text editor and give it something like this:

Hopefully this is simple enough for you, if you’ve used twig in php, django, or jinja templates before. We’re just setting up two blocks to be replaced by other templates, accessible via block title and block content. The get_asset() bit is specific to mynt, it returns the uri path relative to your mynt project and the _assets/ folder we created earlier.

Next, let’s create our template for posts themselves. Posts can have any amount of variables thrown into them by yaml frontmatter. In our example however, we’ll reference only the posts variable provided by mynt.

_templates/post.html

This will set the title of our base template to ‘My Blog - My Post Title’ and fill the content section up with the data of the post itself.

Finally, we just need a simple way to view a list of the posts. We’ll do this by editing index.html. As a quick caveat, any html or xml file not located in _assets, _templates, or _posts, and not beginning with a . or _ will be treated as a standard jinja2 template, with folder structure preserved and access to the global variables site, posts, archives, and tags. (Yes, that means that your project/rss/rss.xml file can be a jinja2 template and available at /rss/rss.xml). Visit the mynt documentation for more information. We’ll leverage this right now when creating our post listing.

index.html

Nothing new here, save the use of a for loop to iterate over the posts object, and the get_url() builtin to generate the url string for a given post. But that’s all we need. With these 3 small templates, we are ready to start creating our content.

Content in mynt is written in markdown by default. Every piece of content must be located in the posts folder, begin with a YYYY-MM-DD date string, and the contents of the file must contain yaml frontmatter referencing the layout and the title of the post.

The post might not be all that shiny, but it’s the layout that matters. The three dashes delimit the yaml config for the post which in turn become variables accessible to your templates. (remember how we used post.title earlier? this is where it comes from!). Everything below gets parsed as markdown, with access to the special markdown fences for code blocks. (example of that here)

That’s it! Run mynt _deploy from your project root and your static blog will be generated! Easy, huh?

However, we can do better. When working with a static site generator, there are often a lot of tasks you need to repeat; generating the content, moving it to its proper deploy environment, or cleaning up the generated files. Luckily, fabric makes repeated tasks like these simple.

Let’s look at the fabfile all at once, and then we’ll drill down into the specifics of what each part does.

Fabric itself is a bit of an ssh toolkit for python, letting you run arbitrary operations across numerous machines. However, since we’re just working locally, we’ll only import ‘local’. We’ll import a fabric project to set things up, and declare a few variables to make the script easier to change down the line. Each function defined in a fabfile is available via the command fab function, so we could run fab clean to remove the _deploy directory, fab generate to generate the static blog, or build functions out of the combinations of these. The one I find myself running the most is fab redeploy to clean up the current deploy folder, regenerate the content, and push it over the wire to the folder that’s exposed to the web. (In my case I’m using scp, yours could very well be a cp). Finally after deploying we clean up the files we generated. Less typing, more time for other things!

All things considered, I’m enthralled by the simplicity and flexibility mynt offers. I was able to get it up and running in a day with minimal effort, and am bubbling with ideas about how to take advantage of the simple key/value store provided by the yaml frontmatter; accessible via the jinja2 templates. I had tried alternatives like hyde before but always wound up getting lost in the complexity, jumping down one of the rabbit holes in its feature-set and realizing hours later that I’ve yet to produce anything productive. mynt’s power on the other hand lies in its simplicity. It’s just python under the hood, but what you can do with jinja2/yaml/markdown alone is immense. The focus is exposed simplicity, not hiding waiting to be found. (That said I’ve yet to peek too deeply under the hood of mynt… but I’ll leave that for another day!).

In any case, I hope you try mynt out for yourself and let me know what you think!