Clojure « Another Word For It

Clojure’s sequence library and the threading macro make lazy sequence operations like map, filter, and reduce composable, and their immutable semantics allow efficient re-use of intermediate results. Core.reducers combine multiple map, filter, takes, et al into a single *fold*, taking advantage of stream fusion–and in the upcoming Clojure 1.7, transducers abstract away the underlying collection entirely.

I’ve been working on concurrent folds, where we sacrifice some order in exchange for parallelism. Tesser generalizes reducers to a two-dimensional fold: concurrent reductions over independent chunks of a sequence, and a second reduction over those values. Higher-order fold combinators allow us to build up faceted data structures which compute many properties of a dataset in a single pass. The same fold can be run efficiently on multicore systems or transparently distributed–e.g. over Hadoop.

Heavy wading but definitely worth the effort.

BTW, how do you like the hand drawn slides? I ask because I am toying with the idea of a graphics tablet for the Linux box.

Comments Off

November 29, 2014

Game Of Live in Clojure with Quil

Filed under: Clojure,Game of Life,Processing — Patrick Durusau @ 8:39 pm

Game Of Live in Clojure with Quil by Nazarii Bardiuk.

You already know Conway’s Game of Life. You may not know Quil, a Clojure wrapper for Processing (version 2.0 is out). Look on this as a learning opportunity.

It doesn’t take long for the Game of Life to turn into serious research so advance this work with caution. 😉

Enjoy!

I first saw this in a tweet by Anna Pawlicka.

PS: I don’t know if “Live” in the title is a typo or intentional so I left it.

Comments Off

November 25, 2014

Datomic 0.9.5078 now available

Filed under: Clojure,Datomic — Patrick Durusau @ 5:26 pm

Datomic 0.9.5078 now available by Ben Kamphaus.

From the post:

This message covers changes in this release. For a summary of critical release notices, see http://docs.datomic.com/release-notices.html.

The Datomic Team recommends that you always take a backup before adopting a new release.

## Changed in 0.9.5078

New CloudWatch metrics: `WriterMemcachedPutMusec`, `WriterMemcachedPutFailedMusec` `ReaderMemcachedPutMusec` and `ReaderMemcachedPutFailedMusec` track writes to memcache. See http://docs.datomic.com/caching.html#memcached

Improvement: Better startup performance for databases using fulltext.

Improvement: Enhanced the Getting Started examples to include the Pull API and find specifications.

Improvement: Better scheduling of indexing jobs during bursty transaction volumes

Fixed bug where Pull API could incorrectly return renamed attributes.

Fixed bug that caused `db.fn/cas` to throw an exception when `false` was passed as the new value.

http://www.datomic.com/get-datomic.html

In case you haven’t walked through Datomic, you really should.

Here is one example why:

Next download the subset of the mbrainz database covering the period 1968-1973 (which the Datomic team has scientifically determined as being the most important period in the history of recorded music): [From: https://github.com/Datomic/mbrainz-sample]

Truer words were never spoken! 😉

Enjoy!

Comments Off

November 24, 2014

Clojure is still not for geniuses

Filed under: Clojure,Functional Programming,Programming — Patrick Durusau @ 4:32 pm

Clojure is still not for geniuses (You — yes, you, dummy — could be productive in Clojure today.) by Adam Bard.

From the post:

The inspiration for the article I wrote last week entitled Clojure is not for geniuses was inspired by Tommy Hall‘s talk at Euroclojure 2014, wherein he made an offhand joke about preferring Clojure for its minimal syntax, as he possesses a small brain (both his blog and his head suggest this assertion is false). I had intended to bring this up with the original article, but got sidetracked talking about immutable things and never got back around to it. Here I’d like to address that, along with some discussion that arose in various forums after the first article.

This article is not about how Clojure is great. I mean, it is, but I’d like to focus on the points that make it an accessible and practical language, without any faffing about with homoiconicity and macros and DSLs and all that.

Today’s all about illustrating some more ways in which I believe our good comrade Clojure can appeal to and empower the proletariat in ways that certain other languages can’t, through the power of simplicity.

This is a great post but I would like to add something to:

So why isn’t everyone using it?

That’s the big question. Clojure has grown immensely in popularity, but it’s still not a household name. There are a lot of reasons for that – mainstreamn languages have been around a lot longer, naturally, and obviously people are still producing software in them.

That’s not a big question. Think about the years people have invested in C, COBOL, Fortran, C++ and ask yourself: Do I prefer programming where I am comfortable or do I prefer something new and not familiar. Be honest now.

The other thing to consider is the ongoing investment in programs written in C/C++, COBOL, etc. Funders don’t find risk of transition all that attractive, even if a new language has “cool” features. They are interested in results, not how you got them.

The universe of programs needs to expand to create space for Clojure to gain marketshare. The demand for concurrency is a distinct possibility. The old software markets will remain glutted with C/C++, etc., for the foreseeable future. But that’s ok, older programmers need something to fall back on.

Pressing forward on Clojure’s strengths, such as simplicity and concurrency and producing results that other current languages can’t match is the best way to increase Clojure’s share of an expanding market. (Or to put it in the negative, who wants to worry about a non-concurrent and slowly dying market?)

Comments Off

November 22, 2014

Compojure Address Book

Filed under: Clojure,Functional Programming,PostgreSQL — Patrick Durusau @ 9:04 pm

Jarrod C. Taylor writes in part 1:

Introduction

Clojure is a great language that is continuing to improve itself and expand its user base year over year. The Clojure ecosystem has many great libraries focused on being highly composable. This composability allows developers to easily build impressive applications from seemingly simple parts. Once you have a solid understanding of how Clojure libraries fit together, integration between them can become very intuitive. However, if you have not reached this level of understanding, knowing how all of the parts fit together can be daunting. Fear not, this series will walk you through start to finish, building a tested compojure web app backed by a Postgres Database.

Where We Are Going

The project we will build and test over the course of this blog series is an address book application. We will build the app using ring and Compojure and persist the data in a Postgres Database. The app will be a traditional client server app with no JavaScript. Here is a teaser of the final product.

Not that I need another address book but as an exercise in onboarding, this rocks!

Compojure Address Book Part 1 by

(see above)

Compojure Address Book Part 2

Recap and Restructure

So far we have modified the default Compojure template to include a basic POST route and used Midje and Ring-Mock to write a test to confirm that it works. Before we get started with templates and creating our address book we should provide some additional structure to our application in an effort to keep things organized as the project grows.

Compojure Address Book Part 3

Introduction

In this installment of the address book series we are finally ready to start building the actual application. We have laid all of the ground work required to finally get to work.

Compojure Address Book Part 4

Persisting Data in Postgres

At this point we have an address book that will allow us to add new contacts. However, we are not persisting our new additions. It’s time to change that. You will need to have Postgres installed. If you are using a Mac, postgresapp is a very simple way of installing. If you are on another OS you will need to follow the install instructions from the Postgres website.

Once you have Postgres installed and running we are going to create a test user and two databases.

Compojure Address Book Part 5

The Finish Line

Our address book application has finally taken shape and we are in a position to put the finishing touches on it. All that remains is to allow the user the ability to edit and delete existing contacts.

One clever thing Jarrod has done is post all five (5) parts to this series on one day. You can go as fast or as slow as you choose to go.

Another clever thing is that testing is part of the development process.

How many programmers actually incorporate testing day to day? Given the prevalence of security bugs (to say nothing at all of other bugs), I would say less than one hundred percent (100%).

You?

How much less than 100% I won’t hazard a guess.

Comments Off

Clojure 1.3-1.6 Cheat Sheet (v13)

Filed under: Clojure,Functional Programming — Patrick Durusau @ 3:40 pm

Clojure 1.3-1.6 Cheat Sheet (v13)

The Clojure CheatSheet has been updated to Clojure 1.6.

Available in PDF, the cheatsheet for an entire language only runs two (2) pages. Some sources would stretch that to at least twenty (20) or more and make it far less useful.

Do you know of a legend to the colors used in the PDF? I can see that Documentation, Zippers, Macros, Loading and Other are all some shade of green but I’m not sure what binds them together? Pointers anyone?

Comments Off

Thanks to the Clojure Community!

Filed under: Clojure,Programming,Tweets — Patrick Durusau @ 3:30 pm

Thanks to the Clojure Community! by Alex Miller.

Today at the Clojure/conj, I gave thanks to many community members for their contributions. Any such list is inherently incomplete – I simply can’t capture everyone doing great work. If I missed someone important, please drop a comment and accept my apologies.

Alex has a list of people with GitHub, website and Twitter URLs.

I have extracted the Twitter URLs and created a Twitter handle followed by a Python comment marker and the users name for your convenience with Twitter feed scripts:

timbaldridge # Tim Baldridge

bbatsov # Bozhidar Batsov

fbellomi # Francesco Bellomi

ambrosebs # Ambrose Bonnaire-Sergeant

reborg # Renzo Borgatti

reiddraper # Reid Draper

colinfleming # Colin Fleming

deepbluelambda # Daniel Solano Gomez

nonrecursive # Daniel Higginbotham

bridgethillyer # Bridget Hillyer

heyzk # Zachary Kim

aphyr # Kyle Kingsbury

alanmalloy # Alan Malloy

gigasquid # Carin Meier

dmiller2718 # David Miller

bronsa_ # Nicola Mometto

ra # Ramsey Nasser

swannodette # David Nolen

ericnormand # Eric Normand

petitlaurent # Laurent Petit

tpope # Tim Pope

smashthepast # Ghadi Shayban

stuartsierra # Stuart Sierra

You will, of course, have to delete the blank lines with I retained for ease of human reading. Any mistakes or errors in this listing are solely my responsibility.

Enjoy!

Comments Off

November 21, 2014

Building an AirPair Dashboard Using Apache Spark and Clojure

Filed under: Clojure,Functional Programming,Spark — Patrick Durusau @ 8:19 pm

Building an AirPair Dashboard Using Apache Spark and Clojure by Sébastien Arnaud.

From the post:

Have you ever wondered how much you should charge per hour for your skills as an expert on AirPair.com? How many opportunities are available on this platform? Which skills are in high demand? My name is Sébastien Arnaud and I am going to introduce you to the basics of how to gather, refine and analyze publicly available data using Apache Spark with Clojure, while attempting to generate basic insights about the AirPair platform.

1.1 Objectives

Here are some of the basic questions we will be trying to answer through this tutorial:

What is the lowest and the highest hourly rate?

What is the average hourly rate?

What is the most sought out skill?

What is the skill that pays the most on average?

1.2 Chosen tools

In order to make this journey a lot more interesting, we are going to step out of the usual comfort zone of using a standard iPython notebook using pandas with matplotlib. Instead we are going to explore one of the hottest data technologies of the year: Apache Spark, along with one of the up and coming functional languages of the moment: Clojure.

As it turns out, these two technologies can work relatively well together thanks to Flambo, a library developed and maintained by YieldBot's engineers who have improved upon clj-spark (an earlier attempt from the Climate Corporation). Finally, in order to share the results, we will attempt to build a small dashboard using DucksBoard, which makes pushing data to a public dashboard easy.

…

In addition to illustrating the use of Apache Spark and Clojure, Sébastien also covers harvesting data from Twitter and processing it into a useful format.

Definitely worth some time over a weekend!

Comments Off

Clojure/conf 2014 Videos! (Complete Set)

Filed under: Clojure,ClojureScript,Programming — Patrick Durusau @ 9:04 am

Updated: As of November 23, 2014, 09:35 AM EST, the complete set of Clojure/conf 2014 videos have been posted to ClojureTV:

Presentations listing more than one author appear twice, once under each author’s last name.

Jeanine Adkisson – Variants are Not Unions

Bozhidar Batsov – The evolution of the Emacs tooling for Clojure

Lucas Cavalcanti & Edward Wible – Exploring four hidden superpowers of Datomic

Clojure/conj Washington, D.C. – Lightning talks

Paul deGrandis – Unlocking data-driven systems

Colin Fleming – Cursive: A different type of IDE

Julian Gamble – Applying the paradigms of core.async in ClojureScript

Brian Goetz – Stewardship: the Sobering Parts

Nathan Herzing & Chris Shea – Helping voters with Pedestal, Datomic, Om and core.async

Rich Hickey – Inside Transducers

Ashton Kemerling – Generative Integration Tests

Michał Marczyk – Persistent Data Structures for Special Occasions

Steve Miner – Generating Generators

Zach Oakes – Making Games at Runtime with Clojure

Anna Pawlicka – Om nom nom nom

David Pick – Building a Data Pipeline with Clojure and Kafka

Chris Shea & Nathan Herzing – Helping voters with Pedestal, Datomic, Om and core.async

Ghadi Shayban – JVM Creature Comforts

Zach Tellman – Always Be Composing

Glenn Vanderburg – Cló: The Algorithms of TeX in Clojure

Edward Wible & Lucas Cavalcanti – Exploring four hidden superpowers of Datomic

Steven Yi – Developing Music Systems on the JVM with Pink and Score

The set is now complete!

Enjoy!

Comments Off

November 19, 2014

ClojureTV & Clojure/conf 2014

Filed under: Clojure,Programming — Patrick Durusau @ 4:13 pm

I saw a tweet today from Clojure/conf:

We will be doing same day conference video publishing this week at #clojure_conj! Watch youtube.com/user/ClojureTV for updates

Now there’s a great idea!

Enjoy!

Comments Off

November 17, 2014

My Way Into Clojure: Building a Card Game with OM – Part 1

Filed under: Clojure,Functional Programming,Programming — Patrick Durusau @ 6:03 pm

My Way Into Clojure: Building a Card Game with OM – Part 1

From the introduction:

This two-part blog post tells the story of my venturing into Clojure. To get a better grasp of the language, I wanted to move beyond solving programming puzzles and build something tangible in the browser. Omingard is a Solitaire-like HTML5 card game built with Om, a ClojureScript interface to Facebook’s React.

In this first part, “My Way into Clojure”, I’ll provide some background on why I built Omingard and introduce the concepts behind Clojure. What’s so fascinating about functional programming in general, and Clojure in particular, and why was the appearance of Om a game changer for me?

In the upcoming second part, “Building a Card Game with Om”, we’ll look at how I built Omingard. What are the rules of the game, and what role do React, ClojureScript, Om, Leiningen, Garden, and Google Closure Tools play in its implementation? We’ll also take a detailed look at the concepts behind Om, and how it achieves even faster performance than React.

This is a very cool exercise in learning Clojure.

Do try the game. The version I know, has slightly different rules than the ones I observe here.

Comments Off

November 13, 2014

Using Clojure To Generate Java To Reimplement Clojure

Filed under: Clojure,Data Structures,Immutable,Java — Patrick Durusau @ 7:01 pm

Using Clojure To Generate Java To Reimplement Clojure by Zach Tellman.

From the post:

Most data structures are designed to hold arbitrary amounts of data. When we talk about their complexity in time and space, we use big O notation, which is only concerned with performance characteristics as n grows arbitrarily large. Understanding how to cast an O(n) problem as O(log n) or even O(1) is certainly valuable, and necessary for much of the work we do at Factual. And yet, most instances of data structures used in non-numerical software are very small. Most lists are tuples of a few entries, and most maps are a few keys representing different facets of related data. These may be elements in a much larger collection, but this still means that the majority of operations we perform are on small instances.

But except in special cases, like 2 or 3-vectors that represent coordinates, it’s rarely practical to specify that a particular tuple or map will always have a certain number of entries. And so our data structures have to straddle both cases, behaving efficiently at all possible sizes. Clojure, however, uses immutable data structures, which means it can do an end run on this problem. Each operation returns a new collection, which means that if we add an element to a small collection, it can return something more suited to hold a large collection.

…

Tellman describes this problem and his solution in Predictably Fast Clojure. (The URL is to a time mark but I think the entire video is worth your time.)

If that weren’t cool enough, Tellman details the creation of 1000 lines of Clojure that generate 5500 lines of Java so his proposal can be rolled into Clojure.

What other data structures can be different when immutability is a feature?

Comments Off

November 11, 2014

clj-turtle: A Clojure Domain Specific Language (DSL) for RDF/Turtle

Filed under: Clojure,DSL,RDF,Semantic Web — Patrick Durusau @ 5:04 pm

clj-turtle: A Clojure Domain Specific Language (DSL) for RDF/Turtle by Frédéerick Giasson.

From the post:

Some of my recent work leaded me to heavily use Clojure to develop all kind of new capabilities for Structured Dynamics. The ones that knows us, knows that every we do is related to RDF and OWL ontologies. All this work with Clojure is no exception.

Recently, while developing a Domain Specific Language (DSL) for using the Open Semantic Framework (OSF) web service endpoints, I did some research to try to find some kind of simple Clojure DSL that I could use to generate RDF data (in any well-known serialization). After some time, I figured out that no such a thing was currently existing in the Clojure ecosystem, so I choose to create my simple DSL for creating RDF data.

The primary goal of this new project was to have a DSL that users could use to created RDF data that could be feed to the OSF web services endpoints such as the CRUD: Create or CRUD: Update endpoints.

What I choose to do is to create a new project called clj-turtle that generates RDF/Turtle code from Clojure code. The Turtle code that is produced by this DSL is currently quite verbose. This means that all the URIs are extended, that the triple quotes are used and that the triples are fully described.

This new DSL is mean to be a really simple and easy way to create RDF data. It could even be used by non-Clojure coder to create RDF/Turtle compatible data using the DSL. New services could easily be created that takes the DSL code as input and output the RDF/Turtle code. That way, no Clojure environment would be required to use the DSL for generating RDF data.

…

I mention Frédéerick’s DSL for RDF despite my doubts about RDF. Good or not, RDF has achieved the status of legacy data.

Comments Off

November 9, 2014

Clojure

Filed under: Clojure,Programming — Patrick Durusau @ 8:14 pm

Clojure by Harris Brakmic.

A very nice curated set of Clojure links.

I count thirty-three (33) links but they all appear to be high quality links.

Hosted at ZEEF.com, which has 1,170 pages of links by 730 curators.

But you can apparently start your own page, which results in Clojure, but by Vlad Bokov.

It’s not a bad idea, curated links, but there doesn’t appear to be any annotation capacity or ways to avoid duplication of links.

Use this for the links but not as an example of an interface for curating links.

Comments Off

November 8, 2014

Transducers – java, js, python, ruby

Filed under: Clojure,Functional Programming,Java,Javascript,Python,Ruby — Patrick Durusau @ 10:59 am

Transducers – java, js, python, ruby

Struggling with transducers?

Learn better by example?

Cognitect Labs has released transducers for Java, JavaScript, Ruby, and Python.

Clojure recently added support for transducers – composable algorithmic transformations. These projects bring the benefits of transducers to other languages:

transducers-java

transducers-js

transducers-ruby

transducers-python

BTW, take a look at Rich Hickey’s latest (as of Nov. 2014) video on Transducers.

Please forward to language specific forums.

Comments Off

October 28, 2014

Datomic Pull API

Filed under: Clojure,Datomic,Functional Programming,Programming — Patrick Durusau @ 7:19 pm

Datomic Pull API by Stuart Holloway.

From the post:

Datomic‘s new Pull API is a declarative way to make hierarchical selections of information about entities. You supply a pattern to specify which attributes of the entity (and nested entities) you want to pull, and db.pull returns a map for each entity.

Pull API vs. Entity API

The Pull API has two important advantages over the existing Entity API:

Pull uses a declarative, data-driven spec, whereas Entity encourages building results via code. Data-driven specs are easier to build, compose, transmit and store. Pull patterns are smaller than entity code that does the same job, and can be easier to understand and maintain.

Pull API results match standard collection interfaces (e.g. Java maps) in programming languages, where Entity results do not. This eliminates the need for an additional allocation/transformation step per entity.
…

A sign that it is time to catch up on what has been happening with Datomic!

Comments Off

October 23, 2014

Results of 2014 State of Clojure and ClojureScript Survey

Filed under: Clojure,ClojureScript,Documentation — Patrick Durusau @ 6:06 pm

Results of 2014 State of Clojure and ClojureScript Survey by Alex Miller.

From the post:

The 2014 State of Clojure and ClojureScript Survey was open from Oct. 8-17th. The State of Clojure survey (which was applicable to all users of Clojure, ClojureScript, and ClojureCLR) had 1339 respondents. The more targeted State of ClojureScript survey had 642 respondents.
…

The responses to “What has been most frustrating for you in your use of Clojure/CLJS? put “Availability of comprehensive / approachable documentation, tutorials, etc” at #2 and #3 respectively.

Improved technical capabilities is important for existing users but increasing mind share is an issue of “onboarding” new users of Clojure. If you have ever experienced or “read about” the welcoming given even casual visitors in some churches, you will have a good idea of some effective ideas at building membership.

If you try to build a community using techniques not found in churches, you need better techniques. Remember churches have had centuries to practice their membership building techniques.

Let me put it this way: When was the last time you saw a church passing out information as poorly written, organized and incomplete as that for most computer languages? Guess who is winning the membership race by any measure?

Are you up for studying and emulating building church membership techniques? (as appropriate or adapted)

Comments Off

October 15, 2014

Concatenative Clojure

Filed under: Clojure,DSL,Programming — Patrick Durusau @ 10:49 am

Concatenative Clojure by Brandon Bloom.

Summary:

Brandon Bloom introduces Factor and demonstrates Factjor –concatenative DSL – and DomScript –DOM library written in ClojureScript – in the context of concatenative programming.

Brandon compares and contrasts applicative and concatenative programming languages, concluding with this table:

Urges viewers to explore Factjor and to understand the differences between between applicative and contatenative programming languages. It is a fast moving presentation that will require viewing more than once!

Watch for new developments at: https://github.com/brandonbloom

I first saw this in a tweet by Wiliam Byrd.

Comments Off

October 9, 2014

These aren’t the reducing functions you are looking for

Filed under: Clojure,Functional Programming,Programming — Patrick Durusau @ 7:06 pm

These aren’t the reducing functions you are looking for by Christophe Grand.

From the post:

Transducers are powerful and easy to grasp when they claim they transform reducing functions. However once you scratch their surface you quickly realize that’s not their true nature: they transform stateful processes.

In a previous post, I explained why seeded transduce forces transducers to return stateful reducing functions. However this can be fixed. The current implementation of transduce reads:
…

Heavy sledding but the leading edge always is. Relevance depends on your need for/dedication to advancing a paradigm.

I first saw this in a tweet by Johnathan Winandy.

Comments Off

2014 State of Clojure & ClojureScript Survey

Filed under: Clojure,ClojureScript,Conferences,Functional Programming — Patrick Durusau @ 6:44 pm

2014 State of Clojure & ClojureScript Survey by Alex Miller.

From the post:

For the past four years, Chas Emerick has run an annual State of Clojure survey (expanded last year to cover ClojureScript as well). Due to recent happy arrivals in the Emerick household, Chas has asked Cognitect to run the survey this year.

The survey has been broken into two parts. A link to the second survey will appear after you submit the first, or you can use these links directly:

State of Clojure 2014 – for everyone that uses Clojure, ClojureScript, or ClojureCLR

State of ClojureScript 2014 – additional questions only for ClojureScript users (please fill out both!)

The surveys will be open until October 17th. Shortly thereafter we will release all of the data and some analysis.

If you’re not yet planning to attend the Clojure/conj in Washington DC, Nov 20-22, tickets are on sale now (regular registration rate ends Oct. 17th)!

Summary:

Two Important Dates:

Oct. 17th – Deadline for State of Clojure/ClojureScript 2014 surveys and regular registration for Clojure/conj.

Nov. 20-22 – Clojure/conj in Washington, DC.

Avoid entering Oct. 17th in your calendar by completing the surveys and purchasing your ticket to Clojure/conj after reading this post.

Comments Off

October 7, 2014

Boiling Sous-Vide Eggs using Clojure’s Transducers

Filed under: Clojure,Programming — Patrick Durusau @ 6:45 pm

Boiling Sous-Vide Eggs using Clojure’s Transducers by Stian Eikeland.

From the post:

I love cooking, especially geeky molecular gastronomy cooking, you know, the type of cooking involving scientific knowledge, -equipment and ingredients like liquid nitrogen and similar. I already have a sous-vide setup, well, two actually (here is one of them: sousvide-o-mator), but I have none that run Clojure. So join me while I attempt to cook up some sous-vide eggs using the new transducers coming in Clojure 1.7. If you don’t know what transducers are about, take a look here before you continue.

To cook sous-vide we need to keep the temperature at a given point over time. For eggs, around 65C is pretty good. To do this we use a PID-controller.
…

egg

I was hoping that Clojure wasn’t just of academic interest and would have some application in the “real world.” Now, proof arrives of real world relevance! 😉

For those of you who don’t easily recognize humor, I know that Clojure is used in many “real world” applications and situations. Comments to that effect will be silently deleted.

Whether the toast and trimmings were also prepared using Clojure the author does not say.

Comments Off

October 2, 2014

Clojure and Emacs without Cider

Filed under: Clojure,Editor — Patrick Durusau @ 4:54 pm

Clojure and Emacs without Cider by Martin Trojer.

From the post:

I’ve been hacking Clojure for many years now, and I’ve been happy to rekindle my love for Emacs. The Clojure/Emacs tool-chain has come a long way during this time, swank-clojure, nREPL, nrepl.el and now Cider. The feature list is ever growing, and every-time you look there are some new awesome shortcut that will ‘make your day’.

However, the last couple of months have been rough for the Cider project. I’ve experienced lots of instability, crashes and hanged UIs. Cider has become very complex and is starting to feel bloated. I went from Visual Studio to the simpler & snappier Emacs for a reason, and there is a part of me that feel concerned that Cider is ‘re-inventing’ an IDE inside Emacs. If you want a full Clojure/IDE experience with all the bells and whistles, check out Cursive Clojure, its awesome.

In this post I’ll describe a simpler Emacs/Clojure setup that I’ve been using for the last couple of weeks. It’s much closer to ‘vanilla Emacs’ and thus has much less features. On the flip side, it’s very fast and super stable.
…

“…very fast and super stable.” That sounds good to me!

As Hesse would say: “Not for Everyone.”

Comments Off

September 30, 2014

Clojure Cup 2014 – Voting Ends October 06 23:59 UTC

Filed under: Clojure,ClojureScript,Functional Programming — Patrick Durusau @ 10:17 am

Clojure Cup 2014 – Voting Ends October 06 23:59 UTC

From the webpage:

Here are the apps competing in Clojure Cup 2014. You may vote for as many of them as you like, using your Twitter account. At the end of the voting period the App with the most votes will receive the Public Favorite award.

Voting ends October 06 23:59 UTC

Don’t bother trying to discern your local time from 23:59 UTC. Vote as soon as you read this post!

If you want to encourage functional programming in general and Clojure in particular, vote for your favorite.

Looking at the prizes, you will want to start working on your Clojure chops for Clojure Cup 2015!

Comments Off

September 25, 2014

Clojure in Unity 3D: Functional Video Game Development

Filed under: Clojure,Functional Programming,Games,Programming — Patrick Durusau @ 10:17 am

Clojure in Unity 3D: Functional Video Game Development by Ramsey Nasser and Tims Gardner.

I had never considered computer games from this perspective:

You have to solve every hard problem in computer science, 60 times a second. Brandon Bloom.

Great presentation, in part because of its focus on demonstrating results. Interested viewers left to consult the code for the details.

Combines Clojure with Unity (a game engine) that can export to PS4.

Is being enjoyable the primary difference between video games and most program interfaces?

A project to watch!

Useful links:

http://github.com/clojure-unity

@timsgardner , Tims Gardner

@ra , Ramsey Nasser, http://nas.sr/

@jplur_ , Joseph Parker, http://selfsamegames.com/

Unity (Game Engine) (Windows/Mac OS)

PS: I need to get a PS4 in order to track game development with Clojure. If you want to donate one to that cause, contact me for a shipping address.

I won’t spend countless hours playing games that are not Clojure related. I am juggling enough roles without adding any fantasy (computer-based anyway) ones. 😉

Comments Off

September 20, 2014

Transducers

Filed under: Clojure,Functional Programming — Patrick Durusau @ 7:06 pm

Transducers by Rich Hickey. (Strange Loop, 2014)

Rich has another go at explaining transducers at Strange Loop 2014.

You may want to look at Felienne’s Hermans live blog on the presentation: Transducers – Rich Hickey

I first saw Rich’s video in a tweet by Michael Klishin.

Comments Off

September 17, 2014

Convince your boss to use Clojure

Filed under: Clojure,Functional Programming,Marketing — Patrick Durusau @ 7:18 pm

Convince your boss to use Clojure by Eric Normand.

From the post:

Do you want to get paid to write Clojure? Let’s face it. Clojure is fun, productive, and more concise than many languages. And probably more concise than the one you’re using at work, especially if you are working in a large company. You might code on Clojure at home. Or maybe you want to get started in Clojure but don’t have time if it’s not for work.

One way to get paid for doing Clojure is to introduce Clojure into your current job. I’ve compiled a bunch of resources for getting Clojure into your company.

Take these resources and do your homework. Bringing a new language into an existing company is not easy. I’ve summarized some of the points that stood out to me, but the resources are excellent so please have a look yourself.

Great strategy and list of resources for Clojure folks.

How would you adapt this strategy to topic maps and what resources are we missing?

I first saw this in a tweet by Christophe Lalanne.

Comments Off

September 14, 2014

Clojure-Resources

Filed under: Clojure,Programming — Patrick Durusau @ 6:42 pm

Clojure-Resources by Matthias Nehlsen.

From the post:

This is a compilation of links and resources for learning about Clojure, ClojureScript, Om and more broadly, LISP. It is still in very early stages. Please feel free to add resources by issuing a pull request (preferred) or by getting in touch. For now it is mostly a dump of my bookmarks, but I intend to go through them one by one and write a quick note about each one (or delete those that I don’t find useful after all). Totally unordered at this point.

As of today, one hundred and three (103) resources listed.

Enjoy!

Comments Off

September 8, 2014

Speakers, Clojure/conj 2014 Washington, D.C. Nov 20-22

Filed under: Clojure,Conferences,Uncategorized — Patrick Durusau @ 6:39 pm

Speakers, Clojure/conj 2014 Washington, D.C. Nov 20-22

Hyperlinks for authors point to Twitter profile pages, title of paper follows:

Jeanine Adkisson Variants are Not Unions

Bozhidar Batsov The evolution of the Emacs tooling for Clojure

Lucas Cavalcanti Exploring Four Hidden Superpowers of Datomic

Colin Fleming Cursive: a different type of IDE

Julian Gamble Applying the paradigms of core.async in ClojureScript

Brian Goetz Keynote

Paul deGrandis Unlocking Data-Driven Systems

Nathan Herzing Helping voters with Pedestal, Datomic, Om and core.async

Rich Hickey Transducers

Ashton Kemerling Generative Integration Tests.

Michał Marczyk Persistent Data Structures for Special Occasions

Steve Miner Generating Generators

Zach Oakes Making Games at Runtime with Clojure

Anna Pawlicka Om nom nom nom

David Pick Building a Data Pipeline with Clojure and Kafka

Ghadi Shayban JVM Creature Comforts

Chris Shea Helping voters with Pedestal, Datomic, Om and core.async

Zach Tellman Always Be Composing

Glenn Vanderburg Cl6: The Algorithms of TeX in Clojure

Edward Wible Exploring Four Hidden Superpowers of Datomic

Steven Yi Developing Music Systems on the JVM with Pink and Score

Abstracts for the papers appear here.

Obviously a great conference to attend but at a minimum, you have a great list of twitter accounts to follow on cutting edge Clojure news!

I first saw this in a tweet by Alex Miller.

Comments Off

September 6, 2014

Green Eggs…The New “Hello, World!”?

Filed under: Clojure — Patrick Durusau @ 6:36 pm

Green Eggs and Transducers by Carin Meier.

From the post:

A quick tour of Clojure Transducers with core.async with Dr. Seuss as a guide.

A quick guide to transducers in Clojure 1.7, using strings from Green Eggs and Ham.

Using the familiar, Green Eggs, to illustrate the new, transducers, is an idea that needs to catch on!

Comments Off

« Newer Posts — Older Posts »

Another Word For It Patrick Durusau on Topic Maps and Semantic Diversity

December 12, 2014

December 6, 2014

November 29, 2014

November 25, 2014

November 24, 2014

November 22, 2014

November 21, 2014

November 19, 2014

November 17, 2014

November 13, 2014

November 11, 2014

November 9, 2014

November 8, 2014

October 28, 2014

October 23, 2014

October 15, 2014

October 9, 2014

October 7, 2014

October 2, 2014

September 30, 2014

September 25, 2014

September 20, 2014

September 17, 2014

September 14, 2014

September 8, 2014

September 6, 2014