thegeez blog

A bird video poker game with PicoLisp prototype for the Sensor Watch

2026-01-05T23:00:00Z

A bird video poker game with PicoLisp prototype for the Sensor Watch

The Sensor Watch is an ARM microcontroller board replacement for the Casio F-91W wristwatch. Which is the first watch I ever had. The Sensor Watch is named for the possibility to add a temperature or accelerometer sensor. I have no need for either of those, but I do want to program a game to create a smart, but not too smart, watch.

The constraints for any custom program are that the watch has 3 buttons and the LCD screen has 6 clock digits, 2 day digits and 2 weekday segments. My first idea was to make a video poker game. However I couldn't figure out a way to display 5 playing cards within the available digits, where each playing card has a rank and a suit. Luckily, I came across a blogpost about an alternate poker variant, called Bird Poker. Which uses a single suit of 13 cards, plus 4 wildcards. And creating 17 different characters within a single digit segment was more feasible.

fecs: a lisp interpreter running in wasm

2024-09-15T23:00:00Z

fecs: a lisp interpreter running in wasm

fecs is a lisp interpreter in the style of PicoLisp running in wasm.

Fecs was made as an exploration of the PicoLisp system and as an attempt to make a programming language that runs on WebAssembly (wasm). It is implemented in C, and compiled to wasm with clang/LLVM. WebAssembly can run on many platforms, including browsers. A nice advantage of running wasm in the browser is the availability of the wasm memory inspector. Because PicoLisp is an interpreter (instead of a code compiler) any running system was therefore easily inspectable and debugable during development.

Pinball with Scittle/ClojureScript

2023-03-01T23:00:00Z

Pinball with Scittle/ClojureScript

The past few months I have been on some longer train rides. These rides had plenty of time to look outside the window to the nice scenery between Dresden and Prague. Other routes were more suitable for programming.

To program on my Android phone I installed the UserLAnd app, which can run a full Ubuntu environment (or other Linux variants), without special permissions or special hacks to the phone or Android system. In this Ubuntu installation I run Emacs for coding with Paredit on Clojure code. The UserLAnd app adds the "Ctrl" and "Alt"/"Meta" key to the Android touchscreen keyboard. Together with some custom configuration in Emacs this makes nice Paredit editing available on my phone.

SpotlightBoard.com: Calendar for standup and improv

2023-01-31T23:00:00Z

SpotlightBoard.com: Calendar for standup and improv

My latest programming project is spotlightboard.com. This is a website to aggregate all the standup and improv events happening in Amsterdam. Users can add their own events and find events based on the calendar and filtering by tags. There's also a comment section for every event and a forum for discussions.

For this project I tried something different than my usual Clojure programming tools. Spotlightboard is made with Elixir and the Phoenix web framework. Because Elixir uses immutable datastructures and functional programming it is very easy to get started with for Clojure programmers. It is only a pity that its syntax is not sexp based.

Serverless search on AWS Lambda with Janet and SQLite

2022-01-11T23:00:00Z

Serverless search on AWS Lambda with Janet and SQLite

Recently I have been porting a simple app on AWS Lambda for posts and comments to use the Janet programming language. A previous post describes how Janet is a great fit to use with AWS Lambda. The web app now also supports search through the search bar in the header. An earlier version of the postings app was written in Clojure and had a search functionality backed by ElasticSearch/OpenSearch on AWS, which is described in this post.

Since postings is a demo app that is rarely used, it benefits from the serverless quality of being able to scale the compute resource usage down to zero. The storage resources are also minimal. Sadly OpenSearch does not follow this serverless model by requiring a provisioned cluster.

Web app on AWS Lambda with Janet

2021-10-28T23:00:00Z

Web app on AWS Lambda with Janet

Janet is a small functional and imperative programming language. The language has some similarities to Clojure with its Lispy syntax, its data notation, and with its proper REPL for dynamic developing within a running system. Janet also compiles its runtime and VM to C and can therefore run almost anywhere.

All of Janet's features make it a good candidate to make AWS Lambda serverless functions with. This is because Janet programs start up and compile quickly, certainly when compared to a combination of Clojure and native-image compilation. Postings is a simple forum web app on AWS Lambda behind an API Gateway and using DynamoDB as the database.

Rofolia: a self-hosted collaborative database/spreadsheet hybrid

2021-06-01T23:00:00Z

Rofolia: a self-hosted collaborative database/spreadsheet hybrid

My latest Clojure project is now available! Rofolia is a self-hosted collaborative database/spreadsheet hybrid. It is similar to Airtable and Google Sheets and supports links between tables, lookups, formula's and API access.

Try the demo at demo.rofolia.com and check out the documentation at Rofolia.com.

Walkthrough of a spreadsheet/database-hybrid with Clojure(Script)

2021-03-15T23:00:00Z

Walkthrough of a spreadsheet/database-hybrid with Clojure(Script)

My latest project is a spreadsheet/database hybrid called mixgrid. Mixgrid is a record based database that is editable like a spreadsheet, similar to Airtable, Stackby, Google Tables and Microsoft Lists. While mixgrid is in its early stages it already supports some nice features:

Real time collaboration
Link records between tables
Lookup values from linked records
Apply formulas per row
Undo & redo support
Sorting and nested grouping of rows

Databrowser for Crux

2020-07-16T23:00:00Z

Databrowser for Crux

Databrowser is a web app to explore the data in a Crux database. It takes a lot of inspiration from the REBL tool, with added features for Crux documents, such as an easy way to enter time and dates and to view diffs. Here's a longer list of features:

Write custom queries
Add Clojure code to your queries to shape the data
Support for collections of heterogeneous data
Group and sort the data in grids
Browse and view pane (similar to REBL)
Drill down into data through navigation
Full keyboard navigation support
Support for easy creation of time and date instances for bi-temporal queries
Support to view diffs of data

Collaborate serverless-ly on ClojureScript: crepl is back

2020-04-17T23:00:00Z

Collaborate serverless-ly on ClojureScript: crepl is back

crepl is a collaborative editor written in Clojure and ClojureScript. In the editor you can write and evaluate ClojureScript code. And you can work on the same code together, similar to Google Docs. crepl has been offline for quite some time as I did not have a place to deploy it to. Recently, I have been playing around with compiling Clojure with GraalVM's native-image and deploying on AWS Lambda. Because AWS Lambda works together with websockets via API Gateway the whole crepl infrastructure can be deployed in a serverless manner too!

Try out the serverless crepl here: crepl.thegeez.net

Serverless Clojure web app on AWS Lambda

2020-04-07T23:00:00Z

Serverless Clojure web app on AWS Lambda

The Postings app is a simple web application for posting text and comments. It is very old fashioned because it serves html pages from a server, instead of being a big ClojureScript or JavaScript application with Reagent or React. The web app does use a tiny bit of JavaScript to load certain html pages inline, following the ideas of turbolinks. Everything works without JavaScript too. To post a comment the server sends a page with a comment form in it and renders the form inline for a nice user experience. Therefore there is no client side state to manage for a nice developer experience, both of which are me.

Serverless collaboration

2019-03-03T23:00:00Z

Serverless collaboration

Previously I've worked on a collaborative tool, which worked like Google Docs. This project was called crepl. Because I stopped paying for hosting of its server, that project is now offline. That made me consider: what if a collaborative editor wouldn't need a server?

The server in crepl was needed to handle the connections between all the clients and the algorithm for collaborative editing needed a central server. For both there are alternatives that do not need a server.

Fly over Amsterdam with ClojureScript

2018-04-01T23:00:00Z

Fly over Amsterdam with ClojureScript

Probabilistic programming example with Anglican

2017-11-13T23:00:00Z

Probabilistic programming example with Anglican

At the last Amsterdam Clojure Meetup there was a great demostration by Zhenhao Li about Anglican. Anglican is a probabilistic programming language integrated with Clojure. I am a fan of the book Probabilistic Programming and Bayesian Methods for Hackers from which I solved a problem in Clojure, about which I wrote here:

Bayesian Inference with Markov Chain Monte Carlo in Clojure

Below is the solution to that problem using Anglican:

ClojureConj 2017 Baltimore: Learning Clojure and ClojureScript by Playing a Card Game video

2017-11-07T23:00:00Z

ClojureConj 2017 Baltimore: Learning Clojure and ClojureScript by Playing a Card Game video

At ClojureConj 2017 I gave a talk titled: "Learning Clojure and ClojureScript by Playing a Card Game". The recording of the talk is now on youtube:

ClojureTV/ClojureConj 2017: Learning Clojure and ClojureScript by Playing a Card Game

More information for each of those Gin Rummy projects as mentioned in the talk are in the links below:

EuroClojure 2017 Berlin: crepl talk video

2017-08-17T23:00:00Z

EuroClojure 2017 Berlin: crepl talk video

At EuroClojure 2017 I gave a talk titled: "Building a collaborative web app with ClojureScript". The recording of the talk is now on youtube: crepl at EuroClojure 2017 on ClojureTV

For more background about crepl and c3e check out these blogposts:

Data wrangling with transducers for a machine learning problem

2017-04-28T23:00:00Z

Data wrangling with transducers for a machine learning problem

The transducers from the net.cgrand.xforms library are great to transform and analyze data with in Clojure. This blogpost shows how the xforms transducers can be used to do data analysis for a machine learning problem from Kaggle, which is a data science competition platform.

One of the competitions on Kaggle is the Titanic competition. For this competition you are given a dataset about passengers aboard the Titanic, with data such as their age and how much they paid for their ticket. In the training data you are also told if the passenger survived. The goal of the competition is to predict if a passenger survived or not for a test set of data.

Dutch Clojure Days 2017: crepl demo

2017-04-13T23:00:00Z

Dutch Clojure Days 2017: crepl demo

At the Dutch Clojure Days 2017 in Amsterdam I gave a lightning talk about crepl. With crepl you can write and run ClojureScript code together. I also introduced c3e, which is a collaborative editor in the browser for full projects with multiple files. The video for the talk is below:

crepl and c3e at Dutch Clojure Days 2017

2017-03-25T23:00:00Z

crepl and c3e at Dutch Clojure Days 2017

Today was the 2017 edition of Dutch Clojure Days (DCD17), the annual international gathering of Clojure enthusiasts and practitioners in the Netherlands. At DCD17 I presented a lightning talk about crepl.

crepl is a collaborative editor written in Clojure and ClojureScript. It's like Google Docs where you can also run the ClojureScript you write in the browser. And by using atom sync you can also keep state in sync with each browser running the code, which is useful when working on code with UIs. These previous blogposts have more information about crepl and its features:

Defn Podcast: Episode 18

2017-02-21T23:00:00Z

Defn Podcast: Episode 18

Last week I joined Ray and Vijay on the Defn Podcast. We talked about Clojure as well as my latest project: crepl. I had a great time talking with them. You can listen to the episode below. Enjoy!

crepl: Link to examples

2017-02-20T23:00:00Z

crepl: Link to examples

crepl is a collaborative editor where you can write and run ClojureScript together. You can now create links to new crepl pads that will be loaded with the code from an external source. Once you are in a crepl you can invite others to join you by sending them the url in the browser navigation bar. For instance try out these examples:

Solve 4Clojure problems together:
http://crepl.thegeez.net/init-pad?4clojure=23
More information about 4Clojure in crepl in this blogpost
A reagent app in crepl with SVG:
http://crepl.thegeez.net/init-pad?source=https://gist.githubusercontent.com/thegeez/d930a7d15fc166a904edeb7e816f96f5/raw/e393ca1585fc15e2ee157615475c0d54d18a19d6/crepl_svg_smiley.cljs
Using atom-sync to sync state and code in different crepls, with an example Tic Tac Toe game:
http://crepl.thegeez.net/init-pad?source=https://gist.githubusercontent.com/thegeez/15913d9fce7698738697fe58ee4e8a94/raw/98e91842b45f8f2620599e473a9e0f5d95943f7b/crepl_tic-tac-toe.clj
More about atom-sync in this blogpost

crepl: Atom sync, share code and state

2017-02-11T23:00:00Z

crepl: Atom sync, share code and state

With crepl you can write and run ClojureScript together. Any changes to the code are synced to everybody instantly. Something like Google Docs for ClojureScript. You can also use nice libraries such as Reagent to make your own UI. An example of making UI's in crepl is in this blog post. However, anything you do in the UI, such as clicking a button, would not be synced to everybody else. Because of this the collaborative features for crepl where limited to code. But crepl now has a solution for this:

Crepl now has a "Atom sync" that keeps both your code and state in sync and changes will show up instantly for everybody!

crepl: Import code, solve 4Clojure problems and use reagent

2017-02-06T23:00:00Z

crepl: Import code, solve 4Clojure problems and use reagent

There have been some upgrades to crepl. It is now possible to import code, solve 4Clojure problems and create your own UI with Reagent. It was already possible to run your code continuously and see the result of your code update instantly.

Configure crepl with code

crepl: Run continuously

2017-02-05T23:00:00Z

crepl: Run continuously

With crepl you can write and run ClojureScript code together. Everybody always sees the same code, because all the changes are updated in everyones browser simultaneously. However, everybody can only run the code in their own browser. This is why the output of "Evaluate expression" is inserted in the code. This way everybody is guaranteed to see the same output.

crepl: Write and run ClojureScript code together

2017-02-03T23:00:00Z

crepl: Write and run ClojureScript code together

crepl is a collaborative editor written in Clojure and ClojureScript. In the editor you can write and evaluate ClojureScript code. This is a fun and quick way to try out some ClojureScript code. The real fun begins when you get others to work on the same code with you by sending them the URL. When multiple people are working on the same code at the same time you will see their changes appear immediately and the output of running the code will be shared with everybody. crepl is like Google Docs that can also run ClojureScript!

Two people working on the same ClojureScript code and seeing the same output.

A wiki made with Clojure, yada and Datomic Client

2017-01-04T23:00:00Z

A wiki made with Clojure, yada and Datomic Client

At EuroClojure in Bratislava an unconference session was about Clojure and REST. At this session Liberator and yada were discussed by their authors. I have used Liberator previously, by not yada. A big difference between the two is that yada is asynchronous. This is useful when making calls to other services while handling a web request.
Datomic now has a new Client API. With the Client API a Datomic database can be accessed as a service, in a more idiomatic Clojure style than its old REST API. To play around with yada and Datomic Client I made a wiki with it. As a bonus the example yada project also uses Boot, instead of Leiningen as its build tool, which I had not played around with either.

The code for clj-wiki is on GitHub: https://github.com/thegeez/clj-wiki
An example wiki is (temporarily) running at http://wiki.thegeez.net

Parsing with clojure.spec for the Advent of Code

2016-12-09T23:00:00Z

Parsing with clojure.spec for the Advent of Code

Advent of Code is a series of code challenges in the form of an advent calender, counting down to Christmas. The challenges have inputs in the form of strings. Clojure.spec can be used to parse those inputs and turn them into useful data. The gist below works through some examples:

Trello clone clone in Clojure

2016-09-22T23:00:00Z

Trello clone clone in Clojure

The Phoenix-Trello project is a Trello clone build with Elixir, Phoenix and React. I like the dragging cards interface in Trello, so I made a Trello clone clone in Clojure.

The code for the Clojure version is on GitHub: thegeez/clj-board. The example is running on Heroku: https://clj-board.herokuapp.com

Pedestal presentation and example app

2016-09-01T23:00:00Z

Pedestal presentation and example app

At the Dutch Clojure Days 2016 in Amsterdam I gave a presentation on building user facing web applications with Pedestal. The video for it is below:

Pedestal and w3a walkthrough: Build a CRUD app with Clojure

2016-02-15T23:00:00Z

Pedestal and w3a walkthrough: Build a CRUD app with Clojure

This is a walkthrough on how to build a complete user facing web application with Clojure on top of Pedestal, with the help of the w3a library. I have made various attempts at building web applications with Pedestal and/or Clojure before. (such as here, here and here) The current version is good and useful enough to make a guide for and hopefully serve as a starting point for other Clojure web applications.

For me a complete user facing web application should have a database, templating, forms, authentication and authorization. And for development I like to get something I can click through as soon as possible, as well as having a dynamic development process from the REPL.

Gatherlist: combining Pedestal & OAuth

2015-10-12T23:00:00Z

Gatherlist: combining Pedestal & OAuth

Visiting conferences is nice. You'll find lots of new and old friends and will leave with a whole list of new interesting ideas to follow up on. It is also an opportunity to find out how much browsing websites on a mobile phone sucks. Want to find today's schedule on the conference mobile website? Sorry, the hamburger menu doesn't collapse and blocks the program table. Want to find the venue address? Sorry, the hero image of the host city's landscape is a static overlay on top of the Google maps.

At conferences it is equally complicated to arrange an impromptu meeting or eating arrangement between a larger group of people. It's a hassle to exchange contact details with all of them, because not everybody is on the same platform. The most common place for these types of ad-hoc organizing that I have seen is on Twitter. But it's almost impossible to follow a conversation between a lot of people on Twitter, especially through the mobile website.

Web application with Pedestal

2015-05-16T23:00:00Z

Web application with Pedestal

As Frankie said, for web development in Clojure we should give Pedestal another chance. So I set out to build a user facing web application with Pedestal. To me a minimally useful user facing web application should have a database, templating, forms, authentication and authorization. And for development I like to get something I can click through as soon as possible, as well as having a dynamic development process from the REPL. The w3a library and w3a-example try to provide this, using Pedestal as foundation.

w3a-example

Turned off gin.thegeez.net

2014-07-08T23:00:00Z

Turned off gin.thegeez.net

The server for Gin Rummy with Datomic has been shut down. Playing over the network against a human or AI opponent through the Datomic database is no longer available. See the blog post and code at github.com/thegeez/gin to run the code yourself.

A ClojureScript-only version to play against the CLJS AI is available here: Gin Rummy

Gin Rummy with Datomic

2014-06-12T23:00:00Z

Gin Rummy with Datomic

When I began to learn Clojure I found the Gin Rummy game in the PLT Racket/Scheme programming environment. Gin is a simple card game and it includes a simple AI for an opponent. This game has been the basis for some previous hobby projects, specifically a ClojureScript implementation and a software robot to play the game. But the project I always wanted to make was a way to play Gin over the internet. Some 5 years later it is finally done:

At gin.thegeez.net you can play the Gin card game against a ClojureScript AI, a remote Clojure AI or a remote human opponent.

Datascript and Quiescent TodoMVC stand-alone

2014-05-01T23:00:00Z

Datascript and Quiescent TodoMVC stand-alone

Yesterday I wrote about clj-crud and its TodoMVC implementation with Datascript and React.js/Quiescent. Below is the same implementation, but this time in advanced compilation and without using a back-end. Now you don't have to log in to see the demo, but of course your todo list won't be saved in a database either.

Datascript and React.js for a Clojure web app

2014-04-30T23:00:00Z

Datascript and React.js for a Clojure web app

When building a web application with Clojure there are a lot of building blocks to choose from. For ClojureScript there has been a particularly interesting new offer with the release of Datascript. Datascript is a way to manage application state in ClojureScript following the database properties of Datomic (although not related to that project in any way). Together with React.js to handle the rendering of the user interface, this is a nice way to build dynamic, data-driven browser front-ends. It also fits in nicely with an example todo list application I have been working on.

Datascript

Using SendGrid with Clojure in The Next Web HackBattle

2014-04-24T23:00:00Z

Using SendGrid with Clojure in The Next Web HackBattle

This week is The Next Web conference in Amsterdam, where I participated in the HackBattle. Like I did two years ago, I took a project I am currently working on and tried to use one of the HackBattle API partners. Last time I used BrowserChannel and the Rijksmuseum API. The current project I am working on is to complete the Clojure web application story by building a back-end for a TodoMVC ClojureScript front-end. I've integrated SendGrid's Inbound Parse Webhook API to be able to add todos via email.

Using SendGrid you can send an email with your todo to add it to your todo list, when you use your profile name in the subject line. On the server side this was easily implemented by adding a POST handler and setting some DNS settings properly.

Bayesian Inference with Markov Chain Monte Carlo in Clojure

2014-03-12T23:00:00Z

Bayesian Inference with Markov Chain Monte Carlo in Clojure

I've been working through the book Probabilistic Programming and Bayesian Methods for Hackers (ProbHack) by Cam Davidson-Pilon. This online book is an introduction to bayesian methods and probabilistic programming for programmers. Its main focus is Bayesian Inference with Markov Chain Monte Carlo (BI-MCMC). The ProbHack book uses Python and the PyMC library. For my own understanding of the inner-workings of BI-MCMC I ported the code to Clojure in the bi-mcmc (bi-mcmc) project on github.

BI-MCMC Algorithm

Solving 4clojure problems in an editor

2014-01-10T23:00:00Z

Solving 4clojure problems in an editor

On Twitter xeqixeqi asked for a leiningen template to be able to solve to the problems from 4clojure in an editor rather than the browser. He then solved this problem himself by building a lein template for 4clojure.

I did most of the problems in emacs by copy-pasting the test cases from each problem page. To turn the text on 4clojure into a runnable test I used this utility: gist: 4clojure in editor.

Vintage JavaScript game restoration

2013-12-30T23:00:00Z

Vintage JavaScript game restoration

At a recent Amsterdam Clojurians meetup the topic was game development. Some of the first code I played around with in high school were games in JavaScript. These games were great as an introduction to programming because all that is needed to play around with them is a browser, 'view source' and notepad. My favorite JavaScript games then were made by K. Moriyama. His site from 1996 is still available online today in its original form: K. Moriyama's Home Page, including a matrix led visitor counter and gradient word-art like header.

Mr. Moriyama took great care to make sure his games were playable on most browsers, including Internet Explorer 4 and Netscape Navigator 3. Sadly, current browsers cannot run the JavaScript anymore. The game I like most is JS Falcon. To be able to play this game again I have dusted of the old JavaScript. All that needed changing were some DOM traversal paths and the main loop's update interval. The server-side high score bookkeeping has been removed from this version.

Testing RxJava with executable marble diagrams

2013-03-25T23:00:00Z

Testing RxJava with executable marble diagrams

Reactive Extensions (Rx) from the .Net world are observable sequences. In particular they are push based sequences, in contrast to the pull based seq api in Clojure. Furthermore you can subscribe to and unsubscribe from observable sequences. This also makes observable sequences a nice candidate to replace futures and callbacks in asynchronous code.

For more information see any of the following resources:

Rx (Reactive Extensions) .Net Source
Erik Meijer (Rx creator) explains Rx video
Intro to Rx Free html ebook

In particular the "Intro to Rx" book is a great resource. Every other example will have you wishing to be able to use Rx in Clojure. Luckily Netflix recently open sourced their Java variation of Rx called RxJava.

Haskell Picnic

2013-01-20T23:00:00Z

Haskell Picnic

PicnicMob is a Haskell tutorial for beginners. It is different from many other introductory tutorials as it has an interesting, non-trivial algorithm as the subject and it produces pictures at every step. Also you can't go wrong by reading something by Conrad Barski, author of Land of Lisp.

I worked through the tutorial when I was still at university. The picnic placement pictures I first generated are from 2009. I revisited the tutorial to read up on the simulated annealing algorithm that is used. Along the way I ported the code to Clojure and this code is on GitHub here. The Clojure code follows the Haskell code quite closely. As with the original tutorial the Clojure code is inefficient with its use of datastructures and its algorithmic complexity.

October Amsterdam Clojure Presentation

2012-10-28T23:00:00Z

October Amsterdam Clojure Presentation

The slides from my presentation at #OctAmsClj are in the ams-clj repo: Simpler webapps with Clojure.

The code for the example in the presentation is here: amscljoct-example.

Count aggregator in Cascalog

2012-08-26T23:00:00Z

Count aggregator in Cascalog

At my current job we use the excellent Cascalog library. Cascalog is a declarative query language for "Big Data" processing on top of Hadoop. Cascalog queries get compiled into MapReduce tasks (through the underlying Cascading library). This approach is a huge win over writing MapReduce tasks yourself. The "Hello World" of MapReduce tasks is the word-count example. However this example is a bit deceptive as it consists of only one Map task and one Reduce task. Most queries that we run require multiple MapReduce tasks chained together. With Cascalog we write a query declaratively while the underlying libraries take care to create (efficient!) chains of MapReduce tasks.

In the beginning I struggled with writing Cascalog queries with aggregators. The best example of this is the count aggregator. The following code uses "count" in Cascalog and SQL.

Testing clj-browserchannel

2012-07-10T23:00:00Z

Testing clj-browserchannel

The clj-browserchannel project now also contains a test project. The test project contains a small executable test that tests the whole browserchannel stack, by using the chat-demo application. The test project is meant to test the server-side component of the BrowserChannel protocol in clj-browserchannel. Together with the client-side implementation as part of the Google Closure library this provides real-time bi-directional communication for web apps.

The test is done by mimicking people chatting in the chat-demo application. Testing the server component in clj-browserchannel by itself is nearly impossible. This is because the server-side is fully dependent on cooperation with the client-side to comply to the BrowserChannel protocol. However both the protocol and the client-side implementation are very sparsely documented. The client-side implementation is a black box that can not easily be mocked or stubbed. Therefore the approach is to do simulation testing.

My understanding of reducers after EuroClojure

2012-06-12T23:00:00Z

My understanding of reducers after EuroClojure

At EuroClojure Rich Hickey gave a second, unscheduled talk about the new reducers library. The talk clarified a few points for me, that I didn't initially get from the explaining blogposts on clojure.com/blog. For the Amsterdam Clojure Meetup I wrote down these notes:

Reducers vs seq/lazy-seq api

Playing "Racket Gin Rummy in ClojureScript" with Clojure

2012-06-01T23:00:00Z

Playing "Racket Gin Rummy in ClojureScript" with Clojure

In 2010 I built my first real Clojure application. It was a tool to execute semantic specifications of modeling languages and was part of my master thesis. Before I decided to use Clojure for this tool I built a little program to test the waters. This program was GinBot.

Whilst dabbling with functional programming languages I tried PLT Scheme (now PLT Racket). As part of the DrScheme editor came a couple of example games. My favorite is the Gin Rummy card game. The object of this game is to make a hand of 10 cards, consisting of a set of four cards and two sets of three cards. Players take turns and can choose to pick the top card of the discard pile or a face down card from the deck. For more information see the rules for Gin Rummy in the Racket documentation.

BrowserChannel and the Rijksmuseum API at The Next Web HackBattle

2012-05-16T23:00:00Z

BrowserChannel and the Rijksmuseum API at The Next Web HackBattle

The last The Next Web conference in Amsterdam on the 23rd to 25th of April 2012 included a two day HackBattle. During this HackBattle I built a website combining the API from the Rijksmuseum with my clj-browserchannel library.

The Rijksmuseum API contains all the works from the museum in digital format, with loads of metadata. The website I build displays a selection from these works and allows people to add 'notes' to the paintings. When a note is placed, everybody looking at that painting will see the note pop-up on the site. The idea behind this was that this could be used in a group tour setting through the museum. Of course the real-time aspect of the website is provided by clj-browserchannel. This group tour aspect is also the motivation behind the simple design of the website, which makes it usable on at least Android smartphones.

Why BrowserChannel?

2012-04-03T23:00:00Z

Why BrowserChannel?

After the release of clj-browserchannel-demo, I have been asked what BrowserChannel is exactly. This post will hopefully clarify what BrowserChannel is and why it is a great fit for ClojureScript and Clojure web applications.

BrowserChannel is a protocol developed by Google. It provides cross-browser compatible, real-time, bi-directional communication for various Google web apps, including Google Docs and GMail.

Racket Gin Rummy in ClojureScript

2012-03-20T23:00:00Z

Racket Gin Rummy in ClojureScript

A ClojureScript implementation of a simple card game. The game can be played here.

The Racket programming environment comes with a couple of example games written in Scheme. My favorite of these games is Gin Rummy. The object of this game is to make a hand of 10 cards, consisting of a set of four cards and two sets of three cards. A set of cards are cards of the same rank (i.e. three Jacks) or subsequent cards of the same suit (i.e. 8,9,10,J of hearts). An ace can be low or high. The game has two players with ten cards each. In the middle are the deck of cards faced down and a discard pile, with cards face up. Players take turns and can choose to pick to top card of the discard pile or a face down card from the deck. The chosen card has to be exchanged for a card in the players hand, which is placed on top of the discard pile. For more information see the Racket documentation.

Simple static blog with Clojure

2012-03-15T23:00:00Z

Simple static blog with Clojure

This inaugural post for this Clojure blog describes how it is created. This blog is hosted by GitHub Pages and the static pages are generated by a minimal clone for Jekyll written in Clojure and using Enlive. The code is by no means a replacement for Jekyll, but can serve as a starting point for people wanting to do the same.

The code for the static pages generator is in the clj-static-blog project.