Clojure 1.7.0-alpha2 by Alex Miller.
From the post:
Clojure 1.7.0-alpha1 is now available.
Try it via
Download: http://central.maven.org/maven2/org/clojure/clojure/1.7.0-alpha2/
Download securely: https://repo1.maven.org/maven2/org/clojure/clojure/1.7.0-alpha2/
Leiningen: [org.clojure/clojure “1.7.0-alpha2”]Highlights below, full change log here:
https://github.com/clojure/clojure/blob/master/changes.md
In case you want some excitement this weekend!
From the webpage:
We are re-creating Tetris™ in ClojureScript. We are mainly doing this to produce the pleasure and to celebrate the 30th anniversary of its original release in 1984. Our remake will enable us to host a small, local tournament and to share a montage of the game’s history, with each level resembling a different version from its past. (We are working on the game at least once a week):
- DevBlog 1 – data, collision, rotation, drawing
- DevBlog 2 – basic piece control
- DevBlog 3 – gravity, stack, collapse, hard-drop
- DevBlog 4 – ghost piece, flash before collapse
- DevBlog 5 – game over animation, score
- DevBlog 6 – level speeds, fluid drop, improve collapse animation, etc.
- DevBlog 7 – draw next piece, tilemap for themes
- DevBlog 8 – allow connected tiles for richer graphics
- DevBlog 9 – live board broadcasting
- DevBlog 10 – chat room, more tilemaps, page layouts
- DevBlog 11 – page routing, username
What could possibly go wrong with an additive video game as the target of a programming exercise? 😉
Shaun LeBron has posted Interactive Guide to Tetrix in ClojureScript.
The interactive guide is very helpful!
Will echoes of Tetris™ tempt you into functional programming? What video classics will you produce?
Onyx: Distributed Workflows for Dynamic Systems by Michael Drogalis.
From the post:
If you’ve ever jumped heads down into a codebase maintaining complex distributed activity and tried to simplify or change the processing workflow, not only will you scratch your head for 7 sleepless nights before you can get anywhere, but you’ll come to realize that workflows are often deeply complected with their mechanism of execution.
In this talk, we’ll survey contemporary frameworks such as Storm and Cascading. We’ll identify the pain points that seem to crop up time and time again: workflow specification, stateful lifecycle management, and developer testing – to name a few.
Onyx is a new distributed computation system written in Clojure that addresses these problems head-on. Hardware advancements in the last 10 years have enabled new designs that leverage fast networks and SSDs. Onyx takes advantage and adapts to this new environment. The concepts and tools discussed remove the incidental complexity that plagues modern frameworks.
Attendees will come away with new perspective on leveraging immutability, persistent data structures, queues, and transactions to tackle increasingly complex problem spaces.
This and much more at Strangeloop, St. Louis, Sept. 17-19th, 2014.
Representing Game Dialogue as Expressions in First Order Logic by Kaylen Wheeler.
Abstract:
Despite advancements in graphics, physics, and artificial intelligence, modern video games are still lacking in believable dialogue generation. The more complex and interactive stories in modern games may allow the player to experience diffierent paths in dialogue trees, but such trees are still required to be manually created by authors. Recently, there has been research on methods of creating emergent believable behaviour, but these are lacking true dialogue construction capabilities. Because the mapping of natural language to meaningful computational representations (logical forms) is a difficult problem, an important first step may be to develop a means of representing in-game dialogue as logical expressions. This thesis introduces and describes a system for representing dialogue as first-order logic predicates, demonstrates its equivalence with current dialogue authoring techniques, and shows how this representation is more dynamic and flexible.
If you remember the Knights and Knaves from Labyrinth or other sources, you will find this an enjoyable read. After solving the puzzle, Kaylen’s discussion shows that a robust solution requires information hiding and the capacity for higher-order questioning.
Clojure fans will appreciate the use of clojure.core.logic.
Enjoy!
I first saw this in a tweet by David Nolen.
SICP Distilled (Clojure) by Tom Hall.
Tom has started a Kickstarter campaign to finance the authoring of a Cloure-based companion to SICP.
A companion which Tom describes as:
As the book [SICP] itself is available online for free I want to make the perfect accompaniment to it – an ebook summarising the key ideas, short videos describing them, screencasts of solving some of the exercises, translation of the examples into Clojure, example projects, partial solutions for you to complete (similar to 4clojure and Clojure koans) and a place to discuss solving them with people.
Project will be funded on Tue, Sept. 16, 2014 4:12 EDT.
This should be enough notice for even the most disorganized of us to pledge in support of SICP Distilled (Clojure).
Please pass this along, tweet, re-post, etc.
The Hitchhiker’s Guide to the Curry-Howard Correspondence by Chris Ford.
From the description:
Slides can be found here: speakerdeck.com/ctford/the-hitchikers-guide-to-the-curry-howard-correspondence
Functions are proofs. Um, I can see how that might work. Go on.
Types are propositions. Really? In what sense?
In fact, a function is the proof of the proposition its type represents. Woah, you’ve lose me now.
Don’t Panic!
The Curry-Howard Correspondence is an elegant bridge between the planet of logic and the planet of programming, and it’s not actually that hard to understand.
In this talk I’ll use the Idris dependently-typed functional programming language for examples, as its type system is sophisticated enough to construct interesting automated proofs simply by writing functions. This talk is not designed to convert you into a theoretical computer scientist, but to share with you a wonderful sight in your journey through the vast and peculiar universe of programming.
A familiarity with functional programming would be useful for appreciating this talk, but it will not require any significant prior study of theoretical computer science.
Great presentation by Chris Ford at EuroClojure!
The only problem I had was coordinating the slides, which aren’t very visible in the presentation, with the slide deck you can download.
Definitely a watch more than once video.
Enjoy!
Useful links (references in the slides):
Edwin Brady, Indris
Edwin Brady, Programming in Indris: A Tutorial
Brian McKenna, EvenOdd in Agda, Idris, Haskell, Scala
Philip Wadler, Propositions as Types (Updated, June 2014)
Clojure Digest by Eric Normand.
Annotated report of four to five resources each week that are relevant to Clojure.
Enough useful information to keep you moving towards effective use of clojure but not enough to become a nest of electronic debris as opposed to a paper one.
I don’t know for sure that Christophe Grand is “desperately” seeking algorithms but he has tweeted a request for “favorite algorithms” to be cast into posts similar to:
Tarjan’s strongly connected components algorithm
I dislike algorithms that are full of indices and mutations. Not because they are bad but because I always have the feeling that the core idea is buried. As such, Tarjan’s SCC algorithm irked me.
So I took the traditional algorithm, implemented it in Clojure with explicit environment passing, then I replaced indices by explicit stacks (thanks to persistence!) and after some tweaks, I realized that I’ve gone full circle and could switch to stacks lengths instead of stacks themselves and get rid of the loop. However the whole process made the code cleaner to my eye. You can look at the whole history.
Here is the resulting code:
See the Tarjan post for the Clojure version. Something similar is planned for “favorite” algorithms.
What algorithm are you going to submit?
Pass this along.
Introducing Riffmuse by Dave Yarwood.
From the post:
I’ve written a simple command line app in Clojure that will take a musical scale as a command line argument and algorithmically generate a short musical idea or “riff” using the notes in that scale. I call it Riffmuse.
Here’s how Riffmuse works in a nutshell: it takes the command line argument(s), figures out what scale you want (For this, I used the awesome parser generator library Instaparse to create a parser that allows a flexible syntax in specifying scales. C major can be represented as, e.g., “C major,” “CMAJ” or even just “c”), determines what notes are in that scale, comes up with a rhythmic pattern for the notes (represented as 16 “slots” that can either have a note or no note), and then fills the slots with notes from the scale you’ve specified.
On the theory that you never know what will capture someone’s interest, this is a post that needs to be shared. It may spark an interest in some future Clojure or music rock star!
I first saw this in a tweet by coderpost.
Getting started in Clojure with IntelliJ, Cursive, and Gorilla
From Part 1:
This video goes through, step-by-step, how to setup a productive Clojure development environment from scratch. This part looks at getting the software installed and running. The second part to this video (vimeo.com/103812557) then looks at the sort of workflow you could use with this environment.
If you follow through both videos you’ll end up with Leiningen, IntelliJ, Cursive Clojure and Gorilla REPL all configured to work together 🙂
Some links:
leiningen.org
jetbrains.com/idea/
cursiveclojure.com
gorilla-repl.org
Nothing surprising but useful you are just starting out.
TF-IDF using flambo by Muslim Baig.
From the post:
flambo is a Clojure DSL for Spark created by the data team at Yieldbot. It allows you to create and manipulate Spark data structures using idiomatic Clojure. The following tutorial demonstrates typical flambo API usage and facilities by implementing the classic tf-idf algorithm.
The complete runnable file of the code presented in this tutorial is located under the flambo.example.tfidf namespace, under the flambo /test/flambo/example directory. We recommend you download flambo and follow along in your REPL.
…
Working through the Clojure code you will get a better understanding of the TF-IDF algorithm.
I don’t know if it was intentional, but the division of the data into “documents” illustrates one of the fundamental questions for most indexing techniques:
What do you mean by document?
It is a non-trivial question and one that has a major impact on the results of the algorithm.
If I get to choose what is considered a “document,” then I can weight the results while using the same algorithm as everyone else.
Think about it. My “documents” may have the term “example” in each one, as opposed to “example” appearing three times in a single document. See the last section in the Wikipedia article tf-idf for the impact of such splitting.
Other algorithms are subject to similar manipulation. It isn’t ever enough to know the algorithms applied to data, you need to see the data itself.
Painting in Clojure by Tom Booth is a great post that walks you though using Clojure to become a digital Jackson Pollock. I think you will enjoy the post a lot and perhaps the output, assuming you appreciate that style of art. 😉
But I have a copyright question on which I need your advice. Tom included on the webpage a blank canvas and a button that reads: “Fill canvas.”
Here is a portion of the results of my pushing the button:
My question is: Does Tom Booth own the copyright to this image or do I?
You may have heard of the monkey taking a selfie:
and the ensuing legal disputes, If a monkey takes a selfie in the forest, who owns the copyright? No one, says Wikimedia.
The Washington Post article quotes Wikimedia Foundation’s Chief Communications Officer Katherine Maher saying:
Monkeys don’t own copyrights.[…]” “What we found is that U.S. copyright law says that works that originate from a non-human source can’t claim copyright.
OK, but I can own a copyright and I did push the button, but Tom wrote the non-human source that created the image. So, who wins?
Yet another example of why intellectual property law reform, freeing it from its 18th century (and earlier) moorings is desperately needed.
The monkey copyright case is a good deal simpler. One alleged copyright infringer (Techdirt) responded to the claim in part saying:
David Slater, almost certainly did not have a claim, seeing as he did not take the photos, and even admits that the images were an accident from monkeys who found the camera (i.e., he has stated publicly that he did not “set up” the shot and let the monkeys take it).
David Slater, until most content owners (not content producers), is too honest for his own good. He has admitted he made no contribution to the photograph. No contribution = no copyright.
This story is going to end sadly. Slater says he is in debt, yet is seeking legal counsel in the United States. Remember the definition of “conflict of interest” in the United States:
😉
OK, time to get back to work and go through Tom’s Clojure post. It really is very good.
Understanding Clojure Transducers Through Types by Franklin Chen.
From the post:
Yesterday, Rich Hickey published a blog post, “Transducers are Coming”, which attracted a lot of attention.
I have a confession to make, which I have made before: I find it very difficult to understand ideas or code not presented with types. So I decided that the only way I could possibly understand what “transducers” are would be to actually implement them in a typed language. I ended up doing so and am sharing my findings here.
…
Franklin’s post is some of the discussion that Rich Hickey promised would follow!
Read both the post and the comments, which includes further comments from Rich Hickey on transducers.
I first saw this in a tweet by Bruno Lara Tavares.
Transducers Are Coming by Rich Hickey.
From the post:
Transducers are a powerful and composable way to build algorithmic transformations that you can reuse in many contexts, and they’re coming to Clojure core and core.async.
Two years ago, in a blog post describing how reducers work, I described the reducing function transformers on which they were based, and provided explicit examples like ‘mapping‘, ‘filtering‘ and ‘mapcatting‘. Because the reducers library intends to deliver an API with the same ‘shape’ as existing sequence function APIs, these transformers were never exposed a la carte, instead being encapsulated by the macrology of reducers.
In working recently on providing algorithmic combinators for core.async, I became more and more convinced of the superiority of reducing function transformers over channel->channel functions for algorithmic transformation. In fact, I think they are a better way to do many things for which we normally create bespoke replicas of map, filter etc.
So, reducing function transformers are getting a name – ‘transducers‘, and first-class support in Clojure core and core.async.
…
A glimpse of ongoing work on Clojure.
Would not be too late to start reading about transducers now.
I first saw this in a tweet by Cognitect, Inc.
A Very Gentle Introduction to Relational Programming & Functional Programming by David Nolen.
From the webpage:
This tutorial will guide you through the magic and fun of combining relational programming (also known as logic programming) with functional programming. This tutorial does not assume that you have any knowledge of Lisp, Clojure, Java, or even functional programming. The only thing this tutorial assumes is that you are not afraid of using the command line and you have used at least one programming language before in your life.
A fairly short tutorial but one where “relational” in the title is likely to result in confusion. Here “relational” is meant in the sense of “logical.”
Another one of those ambiguity problems.
Collection Pipeline by Martin Fowler.
From the post:
Collection pipelines are a programming pattern where you organize some computation as a sequence of operations which compose by taking a collection as output of one operation and feeding it into the next. (Common operations are filter, map, and reduce.) This pattern is common in functional programming, and also in object-oriented languages which have lambdas. This article describes the pattern with several examples of how to form pipelines, both to introduce the pattern to those unfamiliar with it, and to help people understand the core concepts so they can more easily take ideas from one language to another.
With a bit of Smalltalk history thrown in, this is a great read. Be mindful of software stories. You will learn that useful features have been dropped, ignored, re-invented throughout software history.
Enjoy!
Clojure Destructuring Tutorial and Cheat Sheet by John Louis Del Rosario.
From the post:
When I try to write or read some Clojure code, every now and then I get stuck on some destructuring forms. It’s like a broken record. One moment I’m in the zone, then this thing hits me and I have to stop what I’m doing to try and grok what I’m looking at.
So I decided I’d write a little tutorial/cheatsheet for Clojure destructuring, both as an attempt to really grok it (I absorb stuff more quickly if I write it down), and as future reference for myself and others.
Below is the whole thing, copied from the original gist. I’m planning on adding more (elaborate) examples and a section for compojure’s own destructuring forms. If you want to bookmark the cheat sheet, I recommend the gist since it has proper syntax highlighting and will be updated first.
John’s right, the gist version is easier to read.
As of 27 July 2014, the sections on “More Examples” and “Compojure” are blank if you feel like contributing.
I first saw this in a tweet by Daniel Higginbotham.
The Simplicity of Clojure by Bridget Hillyer and Clinton N. Dreisbach. OSCON 2014.
A great overview of Clojure that covers:
Granted they are slides so you need to fill in with other sources of content, such as Clojure for the Brave and True, but they do provide an outline for learning more.
I first saw this in a tweet by Christophe Lalanne.
Creating music with Clojure and Overtone by Chris Ford.
From the description:
Chris Ford will show how to make music with Clojure, starting with the basic building block of sound, the sine wave, and gradually accumulating abstractions culminating in a canon by Johann Sebastian Bach.
Very impressive! You will pick up some music theory, details on sound that you have forgotten since high school physics, and perhaps yet another reason to learn Clojure!
Chris mentions: Music For Geeks And Nerds (Python) as a resource.
Clojure in the Large by Stuart Sierra.
From the summary:
Stuart Sierra discusses various Clojure features: protocols, records, DI, managing startup/shutdown of components, dynamic binding, interactive development workflow, testing and mocking.
Stuart describes this presentation as “intermediate” level.
Great examples to get you past common problems and “thinking” in Clojure.
From the webpage:
These are Haskell translations of Ninety-Nine Lisp Problems, which are themselves translations of Ninety-Nine Prolog Problems.
Also listed are:
- 99 Problems in Perl 6 has an increasing number of Perl 6 solutions (running on Pugs).
- 99 Problems in OCaml contains Ocaml solutions to many problems.
Naming isn’t the only hard problem in computer science. The webpage points out that due to gaps and use of letters, there are 88 problems and not 99.
If you want something a bit more challenging, consider the Project Euler problems. No peeking but there is a wiki with some Clojure answers, http://clojure-euler.wikispaces.com/.
Enjoy!
I first saw this in a tweet by Computer Science.
From the description in Clojure Weekly, July 9th, 2014:
Grimoire is a new documentation service and community contributed example repo similar to ClojureDocs.org. ClojureDocs.org still comes up high in google searches despite it is documenting Clojure 1.3, by providing examples that are not easy to find elsewhere. Grimoire is instead up to date and also gives access to all the examples in clojuredocs. Grimoire is open to community contribution over git pull requests and will likely be improved in the future to make contributions easier.
For more on Grimoire see: Of Mages and Grimoires.
Use, contribute and enjoy!
Neo4j’s Cypher vs Clojure – Group by and Sorting by Mark Needham.
From the post:
One of the points that I emphasised during my talk on building Neo4j backed applications using Clojure last week is understanding when to use Cypher to solve a problem and when to use the programming language.
A good example of this is in the meetup application I’ve been working on. I have a collection of events and want to display past events in descending order and future events in ascending order.
…
Mark falls back on Clojure to cure the lack of sorting within a collection in Cypher.
My Top Clojure Articles by Adam Bard.
From the post:
For the past few years, most of my posts have been beginner-intermediate essays on various clojure features and coding techniques. Since a lot of people have told me that they like my blog as a genre piece, I decided to pull some of my favorites into one place, and order them by difficulty, from Clojure beginner on up so that folks don’t have to root around.
I really hope to see Clojure become a widely-used general-purpose language, because, although much has been made of its general elegance and its propensity to be written by extremely clever people, I think it has a lot to offer mediocre programmers (like yours truly) with its practical feature-set, strong encouragement of good practices (immutability, pure functions) and useful tools like Leiningen and the excellent lisp REPL.
With that in mind, and because I’m really not past the intermediate level yet, I try to write articles targeted at people who are new to Clojure. And now I have enough such articles that I think it’s worthwhile to assemble them in once place. I’ll try to keep them up to date as I write more in the future.
Just a few of the titles to tempt you into reading the full post:
Five Mistakes Clojure Newbies Make
Acceptable Error Handling in Clojure
There are more where those came from!
Enjoy!
Light Table 0.6.7 by Chris Granger.
From the post:
I just pushed 0.6.7, which while a small release has a few important bug fixes. There’s been a weird seemingly random issue with saving and sometimes evaling that forced you to switch tabs to get things correct again. That has finally been tracked down and fixed. Proxy support was added, initial load of workspace behaviors was fixed, and creating a clojure client by selecting a project.clj has been cleared up to. Thanks to everyone who contributed!
Time to download a new version of Light Table.
Better for errors to be from you than from the iDE. 😉
Prototyping in Clojure by Philip Potter.
From the post:
We recently completed an alpha on identity assurance for organisations. The objective of an alpha is to gain understanding of a service and validate a design approach by building a working prototype. As part of the alpha, we built a set of interacting prototype applications representing a number of separate services as assurers and consumers of identity information. Because our objective was understanding and validation, these prototypes did not use any real user’s data.
We wanted our prototype to:
- evolve rapidly, adapt quickly to feedback from our user research, and to be able to change direction entirely if necessary
- be realistic enough to validate whether the service we were exploring was technically feasible
- be simple and focus on the service we were trying to explore, rather than getting bogged down in implementation details
However, we didn’t need to worry about maintaining the code long-term: because the objective was better understanding through building a prototype, we were prepared to throw the code away at the end.
A government alpha IT project? That alone makes the post worth mentioning. Someday FRPs for alphas may be a feature of the United States Government 2.0. 😉
Philip covers the pluses, minuses and could be better aspects of using Clojure for prototyping. Particularly useful if you want to use or improve Clojure as a prototyping language.
Curious, even if prototype code is “thrown away,” does the clarity of understanding from functional coding have a measurable impact on the final code?
I doubt there is enough Clojure prototyping to form a basis for such a study now, but in a few years…, it could be a hot topic of research interest.
I first saw this in a tweet by P.F.
From the post:
“This is my workflow. There are many like it, but this one is mine.” –Anon.
This is the first in a sequence of posts about my current workflow for developing in Clojure. I call this workflow “advanced” because it takes time to learn the various tools involved, but also because it allows me to tackle harder problems than I otherwise could.
The basic ingredients of this workflow are:
- Lisp-related editor enhancements, including parenthesis magic, and, especially, in-editor REPL integration.
- Continuous testing with instant display of results
- Notebook-style semi-literate programming with continuous updating of documentation, display of math symbols, and in-page plots.
My setup has evolved over time and I expect it will be different by the time most people read this. I have found, though, that the right combination of tools allows me not only to manipulate Clojure code and see results quickly, but also to think more clearly about the problem at hand. In my experience, this leads to simpler, more elegant, more maintainable code.
These tools and techniques provide a sort of “sweet-spot” – they help me be productive in the language, and I find them fun to use together. Your mileage may vary – I have seen people be productive with vastly different workflows and toolsets.
In the first post in this series (Emacs Customization for Clojure) we learn:
I have been using Emacs since the 1990s, though I still consider myself a novice (Emacs is that way). Though good alternatives exist, over half of the Clojure community has adopted Emacs despite its lack of polish and its Himalayan learning curve. Emacs is massively customizable, with hundreds of plugins available, and can be extended to just about any degree using its own flavor of Lisp.
Could over half of the Clojure community be wrong?
It’s possible, but highly unlikely. 😉
I first saw this in a tweet by Christophe Lalanne.
From the webpage:
An idiosyncratic tour of the best of SICP in Clojure.
Have you always wanted to read SICP but either didn’t start or gave up mid-way?
Take a few days to experience a distillation of its most important lessons.
Followed by a sign-up form.
Don’t know any more than that but it is an interesting concept.
If and when I get more details, I will post that information.
Taming Asynchronous Workflows with Functional Reactive Programming by Leonardo Borges.
Unfortunately just the slides but they should be enough for you to get the gist of the presentation. And, Leonardo finishes with a number of pointers and references that will be helpful.
Managing subject identity in a workflow could have interesting implications for security. What if there is no “stored” data to be attacked? Either you were listening at the right time or not, to receive all the transmissions necessary to assemble a text? Or you were listening to all the right sources? And you need not store the message after receipt, it can always be re-created by the same processes that delivered it.
Lots of room for innovation and possible security improvements when we stop building targets (static data stores).
BTW, Leonardo is currently writing: “Clojure Reactive Programming: RAW.” (Packt) I like Packt books but do wish their website offered a search by title function. Try searching for “reactive” and see what you think.
EuroClojure 2014 (notes) by Philip Potter.
A truly amazing set of notes, with links, for EuroClojure 2014.
It’s not like being there but you will come away with new ideas, links to follow and the intention to attend EuroClojure 2015!
Enjoy!
Powered by WordPress