From the webpage:
Flambo is a Clojure DSL for Spark. It allows you to create and manipulate Spark data structures using idiomatic Clojure.
The README is the recommended place to get started.
Cool!
July 1, 2014
Flambo
Comments Off on Flambo
June 24, 2014
More Open-Source Clojure Systems, Please
More Open-Source Clojure Systems, Please by Paul Ingles and Thomas G. Kristensen.
From the post:
The threshold for learning and using Clojure has never been lower. A few years ago there were but a few books and only a handful of libraries from which to learn. We are now spoilt for choice when it comes to books and libraries, but new Clojure developers still find it difficult to get started with writing real-world applications.
The problem is that the pool of inspiration from which new developers can learn about Clojure is almost solely based on toy examples such as 4Clojure and open-source libraries; there are very few resources available for information on for building “real” applications.
At uSwitch, we’ve recently open-sourced two of the applications we use for running our data infrastructure. They both weigh in at around 400 lines of code, so they are fairly small and should be easy to read and understand. The applications are:
- Blueshift. An application for monitoring folders in a S3 bucket and automatically load TSV-files into Redshift. For more details into the rationale of Blueshift, see its design document.
- Bifrost. An application for consuming topics from Kafka (a message-broker system) and archiving them to S3. For more details into the rationale of Bifrost, see its README.
We’ve open-sourced Blueshift and Bifrost because they’re useful and Clojure systems. It is our hope that they will serve as inspiration for developers who are new to Clojure, who and want to see examples of applications running in the wild.
We also hope it serves as inspiration for battle-hardened Clojure developers looking for ideas when writing their next Clojure application.
The rest of this post will go through some of the common Clojure practices that we use here at uSwitch. We’ll give references to namespaces in Blueshift and Bifrost demonstrating these practices. Even if you’re not familiar with S3, Redshift or Kafka, the practices presented are general and context-independent.
….
A shortage of good open-source code hurts everyone: How Benjamin Franklin Would’ve Learned To Program.
Comments Off on More Open-Source Clojure Systems, Please
June 21, 2014
Revision of Serializing RDF Data…
Revision of Serializing RDF Data as Clojure Code Specification by Frédérick Giasson.
From the post:
In my previous blog post RDF Code: Serializing RDF Data as Clojure Code I did outline a first version of what a RDF serialization could look like if it would be serialized using Clojure code. However, after working with this proposal for two weeks, I found a few issues with the initial assumptions that I made that turned out to be bad design decisions in terms of Clojure code.
This blog post will discuss these issues, and I will update the initial set of rules that I defined in my previous blog post. Going forward, I will use the current rules as the way to serialize RDF data as Clojure code.
An example of where heavy data use with a proposal leads to its refinement!
Looking forward to more posts in this series.
Comments Off on Revision of Serializing RDF Data…
June 18, 2014
Om sweet Om:…
Om sweet Om: (high-)functional frontend engineering with ClojureScript and React.
From the post:
At Prismatic, we’re firm believers that great products come from a marriage of thoughtful design with rigorous engineering. Effective design requires making educated guesses about what works, building out solutions to test these hypotheses quickly, and iterating based on the results. For example, if you’ve read about our recent feed redesign, then you know that we tested three very different feed layouts in the past year before landing on a design that we and most of our users are quite happy with.
Constant experimentation and iteration presents us with an interesting technical challenge: creating a frontend architecture that allows us to build and test designs quickly, while maintaining acceptable performance for our users.
Specifically, (like most software engineering teams) our primary engineering goals are to maximize productivity and team participation by writing code that:
- is modular, with minimal coupling between independent components;
- is simple and readable; and
- has as few bugs as possible.
In our experience developing web, iOS, and backend applications, we’ve found that much (if not most) coupling, complexity, and bugs are a direct result of managing changes to application state. With ClojureScript and Om (a ClojureScript interface to React), we’ve finally found an architecture that shoulders most of this burden for us on the web. Two months ago, we rewrote our webapp in this architecture, and it’s been a huge boost to our productivity while maintaining snappy runtime performance.
…
Detailed and very interesting post on a functional approach to UI engineering.
And the promise of more posts to come Om.
One minor quibble with the engineering goal: “has as few bugs as possible.” That isn’t a goal or at least not a realistic one. There is no known measure for approaching the boundary of “as few bugs as possible.” Without a measure, it’s hard to call it a goal.
I first saw this in a tweet by David Nolen.
Comments Off on Om sweet Om:…
June 15, 2014
Applicative Parser [Clojure]
Applicative Parser by Jim Duey.
In the next couple of posts, I’m going to show how to build a parser library based on the Free Applicative Functor and what you can do with it. To follow along, clone (or update) this repo. Then ‘lein repl’ and you should be able to copy the code to see what it does.
This post runs long (again). The code is really not that long and it’s mostly very small functions. But the amount of details hidden by the abstractions takes a lot of prose to explain. Which is actually one of the very real benefits of using these abstractions. They let you implement an enormous amount of functionality in very few lines of code with fewer bugs.
If you want to see what the point of all this prose is, skip to the “Other Interpretations” section at the bottom and then come back to see how it was done.
Warning: Heavy sledding!
You may want to start with: The basics of applicative functors, put to practical work [Haskell] by Bryan O’Sullivan, which parses “[an] application/x-www-form-urlencoded string.”
On the other hand, if you want the full explanation, consider Applicative Programming with Effects by Conor McBride and Ross Paterson. in Journal of Functional Programming 18:1 (2008), pages 1-13.
Abstract:
In this paper, we introduce Applicative functors–an abstract characterisation of an applicative style of effectful programming, weaker than Monads and hence more widespread. Indeed, it is the ubiquity of this programming pattern that drew us to the abstraction. We retrace our steps in this paper, introducing the applicative pattern by diverse examples, then abstracting it to define the Applicative type class and introducing a bracket notation which interprets the normal application syntax in the idiom of an Applicative functor. Further, we develop the properties of applicative functors and the generic operations they support. We close by identifying the categorical structure of applicative functors and examining their relationship both with Monads and with Arrows.
The page for McBride and Patterson’s paper points to later resources as well.
Enjoy!
Comments Off on Applicative Parser [Clojure]
June 8, 2014
The Clojure Style Guide
The Clojure Style Guide by Bozhidar Batsov.
From the webpage:
Role models are important.
— Officer Alex J. Murphy / RoboCopThis Clojure style guide recommends best practices so that real-world Clojure programmers can write code that can be maintained by other real-world Clojure programmers. A style guide that reflects real-world usage gets used, and a style guide that holds to an ideal that has been rejected by the people it is supposed to help risks not getting used at all — no matter how good it is.
The guide is separated into several sections of related rules. I’ve tried to add the rationale behind the rules (if it’s omitted, I’ve assumed that it’s pretty obvious).
I didn’t come up with all the rules out of nowhere; they are mostly based on my extensive career as a professional software engineer, feedback and suggestions from members of the Clojure community, and various highly regarded Clojure programming resources, such as “Clojure Programming” and “The Joy of Clojure“.
The guide is still a work in progress; some sections are missing, others are incomplete, some rules are lacking examples, some rules don’t have examples that illustrate them clearly enough. In due time these issues will be addressed — just keep them in mind for now.
Please note, that the Clojure developing community maintains a list of coding standards for libraries, too.
You can generate a PDF or an HTML copy of this guide using Transmuter.
Another example where Ungoogleable Symbols from Clojure may be of interest.
A good index to Clojure resources needs to overcome the limitations of Google‘s search engine as well as others.
I first saw this in a tweet by LE Minh Triet.
Comments Off on The Clojure Style Guide
June 7, 2014
Enhanced Clojure Cheatsheet
Clojure Weekly, June 3rd, 2014 reports:
An enhanced version of the official clojure.org/cheatsheet with added popup tooltip and search box! The cheatsheet is quite useful to have a glance of the standard library functions grouped by functionality type. With this one you just hover over a function to see the docs and typing in the search box will filter down the list. Thanks Andy Fingerhut for posting this in the group list.
I like the pop-ups but wish they contained embedded links.
Enjoy!
Comments Off on Enhanced Clojure Cheatsheet
June 6, 2014
Ungoogleable Symbols from Clojure
The Weird and Wonderful Characters of Clojure by James Hughes.
From the post:
A reference collection of characters used in Clojure that are difficult to “google”. Descriptions sourced from various blogs, StackOverflow, Learning Clojure and the official Clojure docs – sources attributed where necessary. Type the symbols into the box below to search (or use CTRL-F). Sections not in any particular order but related items are grouped for ease. If I’m wrong or missing anything worthy of inclusion tweet me @kouphax or mail me at james@yobriefca.se.
Before reading further, do you agree/disagree that symbols are hard to search for?
Jot your reasons down.
Now try search for each of the following strings:
#
#{
#”
Hmmm, the post is on the WWW and indexed by Google.
I can prove that, search using Google for: “The Weird and Wonderful Characters of Clojure”.
I can understand the result for “#.” There are a variety of subjects that are all represented by “#” so that result isn’t surprising. You would have to distinguish the different subjects represented by “#,” something search engines don’t do.
That is search engines operate on surface strings only.
What is less understandable is the total failure on #{ and #”, with an without surrounding quotes.
If you are going to return results on “#,” it seems like you would return results on other arbitrary strings.
Can someone comment without violating their NDA with Google?
I first saw this in a tweet by Rob Stuttaford.
June 5, 2014
Leipzig from scratch
Leipzig from scratch (GitHub) by Chris Ford.
From the description:
I show you how to make a simple track using Leipzig, Overtone and Clojure, from “lein new” onwards.
And you can type along with the video!
Enjoy!
Comments Off on Leipzig from scratch
June 2, 2014
Light Table 0.6.6
Light Table 0.6.6 by Chris Granger.
From the post:
Happy to announce a new, and fairly big, release of Light Table today! The highlight of this release comes from moving LT to CodeMirror 4, which gives us multiple cursors, tons of performance improvements, and a few other little editing niceties. Here's a list of the new multiple cursors commands:
- Editor: Set selection to top most cursor
- Editor: Clear multiple cursors
- Editor: Insert line after
- Editor: Insert line before
- Editor: Select next occurrence of word
- Editor: Select between brackets
- Editor: Select scope
- Editor: Go to bracket
- Editor: Swap line up
- Editor: Swap line down
- Editor: Join lines
- Editor: Duplicate line
- Editor: Sort lines
- Editor: Sort lines insensitive
- Editor: Select lines upward with multiple cursors
- Editor: Select lines downward with multiple cursors
- Editor: Split selection into cursors per line
If you aren’t already wedded to an editor or IDE, now would be a good time to take a look at Light Table.
Comments Off on Light Table 0.6.6
May 30, 2014
Functional Geekery
Functional Geekery by Steve Proctor.
I stumbled across episode 9 of Functional Geekery (a podcast) in Clojure Weekly, May 29th, 2014 and was interested to hear the earlier podcasts.
It’s only nine other episodes and not a deep blog history but still, I thought it would be nice to have a single listing of all the episodes.
Do be aware that each episode has a rich set of links to materials mentioned/discussed in each podcast.
If you enjoy these podcasts, do be sure to encourage others to listen to them and encourage Steve to continue with his excellent work.
- Episode 1 – Robert C. Martin
In this episode I talk with Robert C. Martin, better known as Uncle Bob. We run the gamut from Structure and Interpretation of Computer Programs, introducing children to programming, TDD and the REPL, compatibility of Functional Programming and Object Oriented Programming
- Episode 2 – Craig Andera
In this episode I talk with fellow podcaster Craig Andera. We talk about working in Clojure, ClojureScript and Datomic, as well as making the transition to functional programming from C#, and working in Clojure on Windows. I also get him to give some recommendations on things he learned from guests on his podcast, The Cognicast.
- Episode 3 – Fogus
In this episode I talk with Fogus, author of The Joy of Clojure and Functional JavaScript. We cover his history with functional languages, working with JavaScript in a functional style, and digging into the history of software development.
- Episode 4 – Zach Kessin
In this episode I talk with fellow podcaster Zach Kessin. We cover his background in software development and podcasting, the background of Erlang, process recovery, testing tools, as well as profiling live running systems in Erlang.
- Episode 5 – Colin Jones
In this episode I talk with Colin Jones, software craftsman at 8th Light. We cover Colin’s work on the Clojure Koans, making the transition from Ruby to Clojure, how functional programming affects the way he does object oriented design now, and his venture into learning Haskell.
- Episode 6 – Reid Draper
In this episode I talk with Reid Draper. We cover Reid’s intro to functional programming through Haskell, working in Erlang, distributed systems, and property testing; including his property testing tool simple-check, which has since made it into a Clojure contrib project as test.check.
- Episode 7 – Angela Harms and Jason Felice on avi
In this episode I talk with Angela Harms and Jason Felice about avi. We talk about the motivation of a vi implementation written in Clojure, the road map of where avi might used, and expressivity of code.
- Functional Geekery Episode 08 – Jessica Kerr
In this episode I talk with Jessica Kerr. In this episode we talk bringing functional programming concepts to object oriented languages; her experience in Scala, using the actor model, and property testing; and much more!
- Functional Geekery Episode 9 – William E. Byrd
In this episode I talk with William Byrd. We talk about miniKanren and the differences between functional, logic and relational programming. We also cover the idea of thinking at higher levels of abstractions, and comparisons of relational programming to topics such as SQL, property testing, and code contracts.
- Functional Geekery Episode 10 – Paul Holser
In this episode I talk with Paul Holser. We start out by talking about his junit-quickcheck project, being a life long learner and exploring ideas about computation from other languages, and what Java 8 is looking like in with the support of closures and lambdas.
Enjoy!
Comments Off on Functional Geekery
May 29, 2014
Emacs Settings for Clojure
My Optimal GNU Emacs Settings for Developing Clojure (so far) by Frédérick Giasson.
From the post:
In the coming months, I will start to publish a series of blog posts that will explain how RDF data can be serialized in Clojure code and more importantly what are the benefits of doing this. At Structured Dynamics, we started to invest resources into this research project and we believe that it will become a game changer regarding how people will consume, use and produce RDF data.
But I want to take a humble first step into this journey just by explaining how I ended up configuring Emacs for working with Clojure. I want to take the time to do this since this is a trials and errors process, and that it may be somewhat time-consuming for the new comers.
In an interesting twist for an article on Emacs, Frédérick recommends strongly that the reader consider Light Table as an IDE for Clojure over Emacs, especially if they are not already Emacs users.
What follows is a detailed description of changes for your .emacs file should you want to follow the Emacs route, including a LightTable theme for Emacs.
A very useful post and I am looking forward the the Clojure/RDF post to follow.
Comments Off on Emacs Settings for Clojure
May 28, 2014
Functional programming with Clojure
Functional programming with Clojure
A MOOC being lead by: Juhana Laurinharju, Jani Rahkola, and Ilmari Vacklin.
From the homepage:
Functional programming is a programming paradigm where pure functions are the basic building blocks of programs. A pure function is like a function in the mathematical sense. The outputs of the function are fully determined by its inputs. The idea is that this restriction makes your programs easier to understand. This course shows how you can code meaningful programs with mainly pure functions. Pure functional programming differs from object-oriented programming in that e.g. it does not make use of variables or loops.
The course is an introduction to functional programming with a dynamically typed language Clojure. We start with an introduction to Clojure; its syntax and development environment. Clojure has a good selection of data structures and we cover most of them. We also go through the basics of recursion and higher-order functions. The course material is in English.
Clojure is a young Lispish functional programming language on the Java virtual machine (JVM) platform, suitable for small and large programs. Because it runs on the JVM, all Clojure programs can use all the standard and third-party Java libraries freely. It offers tools for many tasks that are harder with other languages and has a special focus on concurrent programming.
The only registration is a GitHub account.
Now that’s a friendly registration process!
Enjoy!
I first saw this in Christophe Lalanne’s A bag of tweets / May 2014.
Comments Off on Functional programming with Clojure
May 27, 2014
Data as Code. Code as Data:…
Data as Code. Code as Data: Tighther Semantic Web Development Using Clojure by Frédérick Giasson.
From the post:
I have been professionally working in the field of the Semantic Web for more than 7 years now. I have been developing all kind of Ontologies. I have been integrating all kind of datasets from various sources. I have been working with all kind of tools and technologies using all kind of technologies stacks. I have been developing services and user interfaces of all kinds. I have been developing a set of 27 web services packaged as the Open Semantic Framework and re-implemented the core Drupal modules to work with RDF data has I wanted it to. I did write hundred of thousands of line of codes with one goal in mind: leveraging the ideas and concepts of the Semantic Web to make me, other developers, ontologists and data-scientists working more accurately and efficiently with any kind data.
However, even after doing all that, I was still feeling a void: a disconnection between how I was think about data and how I was manipulating it using the programming languages I was using, the libraries I was leveraging and the web services that I was developing. Everything is working, and is working really well; I did gain a lot of productivity in all these years. However, I was still feeling that void, that disconnection between the data and the programming language.
…
Frédérick promises to walk us through serializing RDF data into Clojure code.
Doesn’t that sound interesting?
Hmmm, will we find that data has semantics? And subjects that the data represents?
Can’t say, don’t know. But I am very interested in finding out how far Frédérick will go with “Data as Code. Code as Data.”
Comments Off on Data as Code. Code as Data:…
May 25, 2014
Real Time Robot Dance Party
From the description:
From the 2014 Solid Conference: In this day and age, we usually consider robots to be utilitarian, problem solvers. But there is another use for robots, that is for artistic expression.
In this fun, energetic talk, we will explore controlling multiple robots in real time. Roombas sway to gentle computer generated music, while Sphero balls roll with flashing lights. This robot jam will culminate in spectacular finale when the AR Drones fly in to join the dance.
Using Emacs, Overture, Clojure, a live robot dance by Carin Meier and Peter Shanley.
A very impressive demonstration but of what I am not exactly sure. Which is of course, a perfect demonstration!
Enjoy!
I first saw this in a tweet by Michael Klishin
Comments Off on Real Time Robot Dance Party
May 24, 2014
Fluokitten
Fluokitten: Category theory concepts in Clojure – Functors, Applicatives, Monads, Monoids and more.
From the “getting started” page:
This is a brief introductory guide to Fluokitten that aims to give you the necessary information to get up and running, as well as a brief overview of some available resources for learning key category theory concepts and how to apply them in Clojure with Fluokitten.
…
Overview
Fluokitten is a Clojure library that enables programming paradigms derived from category theory (CT). It provides:
- A core library of CT functions
uncomplicate.fluokitten.core;- Protocols for many CT concepts
uncomplicate.fluokitten.protocols;- Implementations of these protocols for standard Clojure constructs (collections, functions, etc.)
uncomplicate.fluokitten.jvm;- Macros and functions to help you write custom protocol implementations.
- Accompanying website with learning resources.
Not your first resource on Clojure but certainly one to consult when you want to put category theory into practice with Clojure.
Comments Off on Fluokitten
Morph
Morph – A Library of Morphisms: Monoids, Functors, and Monads by Armando Blancas.
From the webpage:
Morph
Morph is a library of Haskell-style morphisms: monoids, functors, and monads. These constructs are helpful for designing programs that are purely functional and that encapsulate the boilerplate employed by many programming techniques.
Features
- Implementation based on protocols and data types.
- Predefined monoids and functors; with support for Clojure collections.
- Monads: Identity, Maybe, Either, Reader, Writer, State, Imperative.
- Monad Transformers: MaybeT, EitherT, ReaderT, WriterT, StateT.
- Support for curried functions.
- Library of generic functions for the above constructs.
- Sample code in
src/main/resources.These constructs have a reputation of being hard to explain and even harder to understand and to apply in everyday programming. I’ve made every effort to present them as regular techniques and idioms with practical benefits. Behind their strange or fancy names, these are just functions that work on data types.
An intuition of their behavior is all that’s needed to take advantage of these functions; you may never need or want to write your own. I’m pleased with the power and simplicity these techniques have to offer and I hope you may find them useful as well.
Lowering the learning curve for using functional programming languages? Is that a bit like being able to use a compiler but not write one? Whatever drives adoption is a good thing.
Comments Off on Morph
May 22, 2014
ClojureDocs
From the webpage:
ClojureDocs is a community-powered documentation and examples repository for the Clojure programming language.
Currently in beta but has an API to allow integration of ClojureDocs’ backend with other applications.
I like the integration of a quick reference with examples, when there are examples.
What would make this resource better would be the integration of existing source code, keyed to Clojure vars.
That sounds like a topic map doesn’t it?
Comments Off on ClojureDocs
May 19, 2014
Mastering Clojure Data Analysis Danger!
Mastering Clojure Data Analysis by Eric Rochester.
I marked this with Danger! because if you follow the download link in the video you will see:
Premium Content
Please complete an offer below to unlock the download link
The offers are very easy and take only a few minutes to complete.
Your support helps us to provide more premium content. Thanks!!!Get your auto insurance quote today!
Get Free Bathroom Samples
Get free samples for your pet!
Get 4 Tickets to the Movie Theater of your choice!
Get the brand new Xbox One!
Thinking how harmful could “Get Free Bathroom Samples” be? I followed that one.
Here is what I found:
By entering your email address and clicking “submit”, you agree to receive emails from Lifescript and/or trusted third parties containing promotions and other special offers and that Lifescript may provide your email address and corresponding information to such parties. If you do not wish to continue receiving such emails, you may unsubscribe at any time.
* No purchase necessary. In order to qualify for the Free Samples you must complete the Lifescript Advantage registration page providing your name, address, gender, date of birth and email address and then review a series of offers. Upon completion of the review of the offers, you will have the opportunity to choose from a selection of free samples. You may choose as many as you like. When you “click to redeem” a free sample, you will be directed to a third-party website and may be requested to provide information or take other actions (for example, it may request that you “Like” a Facebook page)….
(emphasis added)
The only upside is that they don’t ask for your bank account and routing information. 😉
Avoid this scam and go to Mastering Clojure Data Analysis at Packt Publishing. There is no TOC or sample chapters available at this time but it is a worthy topic.
Who would you report such a scam to? Suggestions?
Comments Off on Mastering Clojure Data Analysis Danger!
Game development in Clojure (with play-clj)
Uses Light Table so you will be getting an introduction to Light Table as well.
If you think about it, enterprise searches are very much treasure hunt adventures with poor graphics and no avatars. 😉
Comments Off on Game development in Clojure (with play-clj)
… Characters of Clojure
The Weird and Wonderful Characters of Clojure by James Hughes.
From the post:
A reference collection of characters used in Clojure that are difficult to “google”. Descriptions sourced from various blogs, StackOverflow, Learning Clojure and the official Clojure docs – sources attributed where necessary. Use CTRL-F “Character: …” to search or type the symbols into the box below. Sections not in any particular order but related items are grouped for ease. If I’m wrong or missing anything worthy of inclusion tweet me @kouphax or mail me at james@yobriefca.se.
Definitely a candidate for your browser toolbar!
I first saw this in a tweet by Daniel Higginbotham.
Comments Off on … Characters of Clojure
May 14, 2014
Lisp: Common Lisp, Racket, Clojure, Emacs Lisp
Lisp: Common Lisp, Racket, Clojure, Emacs Lisp
A “hyperpolyglot” (although technically only a quadglot) that is a side-by-side reference sheet for Common Lisp, Racket, Clojure, and, Emacs Lisp.
One of the Hexaglot versions of the Bible included: Old Testament in Hebrew, Greek, Latin, English, German and French; New Testament in Greek, Syriac, Latin, English, German and French.
For another interesting example of analog information retrieval, see: Complutensian Polyglot Bible
Note that the location of the parallel texts meant the reader did not lose their original context when consulting another text. Unlike hyperlinks that take a reader away from the current resource.
Just out of curiosity I backed up the URL and found: Hyperpolyglot.
Which includes side by side references for:
Programming Languages
commonly used features in a side-by-side format
Interpreted Languages: JavaScript, PHP, Python, Ruby More Interpreted Languages: Perl, Tcl, Lua, Groovy C++ Style Languages: C++, Objective-C, Java, C# Languages in the Key of C: C, Go Pascal Style Languages: Pascal, Ada, PL/pgSQL Lisp Dialects: Common Lisp, Racket, Clojure, Emacs Lisp ML Dialects and Friends: OCaml, F#, Scala, Haskell Prolog and Erlang: Prolog, Erlang Stack-Oriented Languages: Forth, PostScript, Factor Operating System Automation: POSIX Shell, AppleScript, PowerShell Relational Data Languages: SQL, Awk, Pig Numerical Analysis & Statistics: MATLAB, R, NumPy and Fortran Computer Algebra Software: Mathematica, SymPy, Pari/GP Programming Tools
Unix Shells: Bash, Fish, Ksh, Tcsh, Zsh Text Mode Editors: Vim, Emacs, Nano Version Control: Git, Mercurial Build Tools: Make, Rake, Ant Terminal Multiplexers: Screen, Tmux Databases: PostgreSQL, MySQL, SQLite, Redis, MongoDB, Neo4j Markup: Markdown, reStructuredText, MediaWiki, Wikidot, LaTeX 2D Vector Graphics: PostScript, Processing, SVG Mathematical Notation: LaTeX, Mathematica, HTML Entities, Unicode
Of course, one downside to such a listing is that it would be difficult to supplement the information given without manually editing the tables.
Comments Off on Lisp: Common Lisp, Racket, Clojure, Emacs Lisp
CrossClj
CrossClj: cross-referencing the clojure ecosystem
From the webpage:
CrossClj is a tool to explore the interconnected Clojure universe. As an example, you can find all the usages of the reduce function across all projects, or find all the functions called map. Or you can list all the projects using ring. You can also walk the source code across different projects.
Interesting search interface. You could lose some serious time just reading the project names. 😉
Makes me curious about the potential of listing functions and treating other functions/operators in their scope as facets?
Enjoy!
Comments Off on CrossClj
May 9, 2014
Tips for Clojure Beginners
Tips for Clojure Beginners by Ben Orenstein.
Ben has seven (7) practical tips for learning Clojure.
No one knows if Clojure will be the breakthrough functional programming language but when you realize that mutable data structures are artifacts of limited storage, any functional programming experience is going to be worthwhile.
Comments Off on Tips for Clojure Beginners
Clojure’s Persistent Data Structures
Clojure’s Persistent Data Structures by Craig Andera.
From the description:
A typical experience with Clojure is, “Come for the concurrency, stay for the data structures.” Clojure’s data structures are persistent, immutable, and performant. In this talk, we’ll discuss what they give you, how they work, and what you can do with them.
Craig Andera is a developer at Cognitect, where he builds large-scale web-based systems, primarily in Clojure. He is also the host of The Cognicast, Cognitect’s podcast. Craig can be found on Twitter @craigandera. The Cognicast is available at http://cognitect.com/podcast.
Best watched before this coming Sunday (Mother’s Day).
I first saw this at: Recommended Viewing : Clojure’s Persistent Data Structures by Charles Ditzel.
Comments Off on Clojure’s Persistent Data Structures
May 3, 2014
Clojure Cookbook – Revisited (Review)
Konrad Garus has published a review of the Clojure Cookbook that reads in part:
…
In my opinion the book is very uneven. It’s very detailed about the primitives and basic collections, but at the same time it doesn’t do justice to state management (atoms, refs, agents) or concurrency. Yet it has two chapters on building a red-black tree. It is very detailed about Datomic, but barely scratches the surface of much more common tools like core.async, core.logic or core.match. It does not include anything about graphics or ClojureScript.
…
Comments? Suggestions?
Comments Off on Clojure Cookbook – Revisited (Review)
April 26, 2014
From Geek to Clojure!
From Geek to Clojure! by Nada Amin and William Byrd.
From the description:
In his Lambda Jam keynote, “Everything I Have Learned I Have Learned From Someone Else,” David Nolen exposed the joys and benefits of reading academic papers and putting them to work. In this talk, we show how to translate the mathy figures in Computer Science papers into Clojure code using both core.match and core.logic. You’ll gain strategies for understanding concepts in academic papers by implementing them!
Nada Amin is a member of the Scala team at EPFL, where she studies type systems and hacks on programming languages. She has contributed to Clojure’s core.logic and Google’s Closure compiler. She’s loved helping others learn to program ever since tutoring SICP as an undergraduate lab assistant at MIT.
William E. Byrd is a Postdoctoral Researcher in the School of Computing at the University of Utah. He is co-author of The Reasoned Schemer, and co-designer of several declarative languages: miniKanren (logic programing), Harlan (GPU programming), and Kanor (cluster programming). His StarCraft 2 handle is ‘Rojex’ (character code 715).
An alternative title for this paper would be: How To Read An Academic CS Paper. Seriously.
From Geek to Clojure at Github has the slides and “Logical types for untyped languages” (mentioned near the end of the paper).
I don’t think you need a login at the ACM Digital Library to see who cites “Logical types for untyped languages.”
Some other resources of interest:
Logical Types for Untyped Languages by Sam Tobin-Hochstadt (speaker deck)
Logical Types for Untyped Languages by Sam Tobin-Hochstadt and Matthias Felleisen (video)
A series of videos by Nada Amin and William Byrd that makes fewer assumptions about the audience on reading CS papers would really rock!
Comments Off on From Geek to Clojure!
April 24, 2014
Decompiling Clojure
Guillermo Winkler has started a series of posts on decompiling Clojure.
Thus far, Decompiling Clojure I and Decompiling Clojure II, The Compiler have been posted.
From the first post:
This is the first in a series of articles about decompiling Clojure, that is, going from JVM bytecode created by the Clojure compiler, to some kind of higher level language, not necessarily Clojure.
This article was written in the scope of a larger project, building a better Clojure debugger, which I’ll probably blog about in the future.
These articles are going to build form the ground up, so you may skip forward if you find some of the stuff obvious.
Just in case you want to read something more challenging than the current FCC and/or security news.
Comments Off on Decompiling Clojure
April 23, 2014
Learning Clojure: … [What NOT to Read]
Learning Clojure: Tutorial, Books, and Resources for Beginners by Nikola Peric.
From the post:
New to Clojure and don’t know where to start? Here are some books, tutorials, blog posts, and other resources for beginners that I found useful while getting used to the language. I’ll also highlight some resources I’d recommend staying away from due to better alternatives. Brief disclaimer: I have either read at least ~75% of each of these resources – some just weren’t worth reading through to the end.
Let’s start with some books after the break!
A refreshing post on Clojure resources!
Nikola not only has positive suggestions but also says what resources he would avoid.
Reporting every book on Clojure could be useful for some purpose but for beginners, straight talk about what NOT to read is as important as what not to read.
Point anyone interested in Clojure to Nikola’s post.
Comments Off on Learning Clojure: … [What NOT to Read]
April 22, 2014
MIDI notes and enharmonic equivalence
MIDI notes and enharmonic equivalence – towards unequal temperaments in Clojure by Tim Regan.
From the post:
“Positiv Division, Manila Cathedral Pipe Organ” by Cealwyn on flickr
One current ‘when-I-get-spare-time-in-the-evening’ project is to explore how different keys sounded before the advent of equal temperament. Partly out of interest and partly because whenever I hear/read discussions of how keys got their distinctive characteristics (for example in answers to this question on the Musical Practise and Performance Stack Exchange) temperament is raised as an issue or explanation.
Having recently enjoyed Karsten Schmidt‘s Clojure workshop at Resonate 2014 Clojure and Overtone seem a good place to start. My first steps are with the easiest non-equal temperament to get my head around, the Pythagorean Temperament. My (albeit limited) understanding of temperaments has been helped enormously by the amazing chapters on the subject in David Benson’s book Music, a mathematical offering.
The pipes in the image caught my attention and reminded me of Jim Mason and his long association with pipe organs. Incredibly complex instruments, Jim was working on a topic map that mapped the relationships between a pipe organ’s many parts.
Well, that and enharmonic equivalence. 😉
Wikipedia avers (sans the hyperlinks):
In modern musical notation and tuning, an enharmonic equivalent is a note, interval, or key signature that is equivalent to some other note, interval, or key signature but “spelled”, or named differently.
Use that definition with caution as the Wikipedia articles goes on to state that the meaning of enharmonic equivalent has changed several times in history and across tuning systems.
Tim’s post will give you a start towards exploring enharmonic equivalence for yourself.
Clojure is not a substitute for a musician but you can explore music while waiting for a musician to arrive.
Comments Off on MIDI notes and enharmonic equivalence