Archive for the ‘ClojureScript’ Category

Cursive 1.0, Gingerbread Cuneiform Tablets, XQuery

Thursday, December 10th, 2015

Cursive 1.0

From the webpage:

Cursive 1.0 is finally here! Here’s everything you need to know about the release.

One important thing first, we’ve had to move some things around. Our website is now at cursive-ide.com, we’re on Twitter at @CursiveIDE, and our Github handle is now cursive-ide. Hopefully everything should be redirected as much as possible, but let me know if you can’t find anything or if you find anything where it shouldn’t be. The main Cursive email address is now cursive@cursive-ide.com but the previous one will continue to work. The mailing lists will continue to use the previous domain for the moment.

Cursive 1.0 is considered a stable build, and is now in the JetBrains plugin repo (here). Going forward, we’ll have a stable release channel which will have new builds every 2-3 months, and an EAP channel which will have builds more or less as they have been during the EAP program. Stable builds will be published to the JetBrains repo, and EAP builds will continue to be published to our private repo. You’ll be prompted at startup which channel you’d like to use, and Cursive will set up the new URLs for the EAP channel automatically if required. Stable builds will be numbered x.y.0, and EAP builds will use x.y.z numbering.

From https://cursive-ide.com/:

Cursive is available as an IntelliJ plugin for use with the Community or Ultimate editions, and will be available in the future as a standalone Clojure-focused IDE. It is a commercial product, with a free non-commercial licence for open-source work, personal hacking, and student work.

I’m not brave enough to install software on someone’s computer as a “surprise” holiday present. Unless you are a sysadmin, I suggest you don’t either.

Of course, you could take the UPenn instructions for making gingerbread cuneiform tablets and make a “card” for the lucky recipient of a license for the full version of Cursive 1.0.

For that matter, you could inscribe smaller gingerbread pieces with bits of XQuery syntax and play holiday games with arbitrary XML documents. Timed trials for the most imaginative XQuery, shortest, etc.

PS: Suggestions on an XQuery corpus to determine the frequency of XQuery syntax representations? “For,” “(,” and, “)” are likely the most common ones, but that’s just guessing on my part.

Parens of the Dead

Friday, August 21st, 2015

Parens of the Dead: A screencast series of zombie-themed games written with Clojure and ClojureScript.

Three episodes posted thus far:

Episode 1: Lying in the Ground

Starting with an empty folder, we’ll lay the technical groundwork for our game. We’ll get a Clojure web server up and running, compiling and sending ClojureScript to the browser.

Episode 2: Frontal Assualt

In this one, we create most of the front-end code. We take a look at the data structure that describes the game, using that to build up our UI.

Episode 3: What Lies Beneath

The player has only one action available; revealing a tile. We’ll start implementing the central ‘reveal-tile’ function on the backend, writing tests along the way.

Next episode? Follow @parensofthedead

Another innovative instruction technique!

Suggestions:

1) Have your volume control available because I found the sound in the screencasts to be very soft.

2) Be prepared to move very quickly as episode one, for example, is only eleven minutes long.

3) Download the code and walk through it at a slower pace.

Enjoy!

ClojureScript Tutorial

Friday, February 27th, 2015

ClojureScript Tutorial by Andrey Antukh.

From the webpage:

This tutorial consists on to provide an introduction to clojurescript from very basic setup, to more complex application in little incremental steps.

It includes:

  • Setup initial clojure app layout.
  • Setup initial clojurescript app layout.
  • First contact to clojurescript language.
  • Working with dom events.
  • Working with routing in the browser.
  • Working with ajax requests.
  • First contact with core.async.
  • Working with events and ajax using core.async.
  • First contact with om/reactjs.
  • Working with om and timetraveling.
  • Working with om and peristent state.
  • Little bonus: browser enabled repl.

I mention this because it will be helpful background for:

From the description:

Facebook’s React uses a virtual DOM diff implementation for high performance. It updates the view only when it’s needed. But David Nolen’s Om library (ClojureScript wrapper over React) goes even further. It stores application state in one place and passes “branches” of that state to a number of components. Data is immutable, and components are reusable. No more juggling around with JavaScript object literals. If anyone likes data as much as I do they will enjoy working with Om. It’s a great tool for building user interfaces around your data.

This talk will show how to combine core.async, liberator and om with JavaScript visualisation libraries to create interactive charts and maps. I will walk everyone through how to:

  • Generate a resource that can be used in a route and use it to pull data for visualisations
  • Use om to create reusable components out of JavaScript libraries: dimple.js and leaflet.js
  • Create core.async channels and use them communicate user clicks and selections between those components, e.g. selection on a checkbox component triggers reloading of data on a chart component.

The talk will be a practical guide to building small web applications and will be accessible to Clojurians with a basic knowledge of Clojure and HTML.

Enjoy!

Building a System in Clojure (and ClojureScript)

Monday, December 22nd, 2014

Building a System in Clojure (and ClojureScript) by Matthias Nehlsen.

From about this book:

This book is about building a complex system in Clojure and ClojureScript. It started out as a blog series about my BirdWatch application, a side project for reasoning about a live stream of tweets coming in from the Twitter Streaming API and visualized in a web application that is written in ClojureScript.

In the book, we will follow the data and watch how it is transformed in different parts of the application until it finally triggers the user interface to change within a few hundred milliseconds after a tweet has been tweeted.

For now, I have only transferred the articles from the aforementioned series, but over the holidays I will work on adapting the content to the book format and also start working on new content.

Please sign up as a reader for free if you think you might at all be interested in the topics that will be covered. Later on, you can decide if you want to pay the suggested price or not. Of course you can also pay right away if you like, but that’s entirely up to you. In either case, you want to click the Buy Now button. Then you can select an amount between zero and infinity.

Feedback during the writing process is much appreciated. There’s a Google Group for this purpose.

Now is a great time to sign up as a reader or to purchase this book!

The non-configurable push down flow of tweets in my current Twitter client is simply intolerable. I get a day or more behind in tweets and prefer to avoid attempting to accurately scroll a day or more backwards in the feed.

Searching history plus current tweets may not do everything I want but Matthias’ book may help me tweak the interface into something more to my liking.

While you are looking at this book, check out some of the other books and publishing model at Leanpub. I don’t have any personal experience with Leanpub but it sounds like a publishing venue worth pursuing.

The Ultimate Guide to Learning Clojure for Free

Saturday, December 13th, 2014

The Ultimate Guide to Learning Clojure for Free by Eric Normand.

From the post:

Are you interested in learning Clojure? Would you like to get started without risking your money on a book? Is there something that can help you even know whether you want to learn Clojure?

Well, yes.

I learned Clojure for free. In fact, I’m a bit of a cheapskate. For many years I would avoid spending money if there was a free alternative. I also keep an eye on resources that pop up around the internet.

I have assembled what I believe to be the best resources to start with if you want to get into Clojure but want to spend $0.

Eric has a focus on beginner with a few intermediate resources.

Are there any additions you would suggest?

I first saw this in a tweet by Christophe Lalanne.

Clojure/conf 2014 Videos! (Complete Set)

Friday, November 21st, 2014

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!

Results of 2014 State of Clojure and ClojureScript Survey

Thursday, October 23rd, 2014

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)

2014 State of Clojure & ClojureScript Survey

Thursday, October 9th, 2014

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:

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-22Clojure/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.

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

Tuesday, September 30th, 2014

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!

T3TROS (ClojureScript)

Thursday, September 4th, 2014

T3TROS (ClojureScript)

From the webpage:

We are re-creating Tetris™ in ClojureScript. We are mainly doing this to produce the pleasure and to celebrate the 30th anniversary of its original release in 1984. Our remake will enable us to host a small, local tournament and to share a montage of the game’s history, with each level resembling a different version from its past. (We are working on the game at least once a week):

  • DevBlog 1 – data, collision, rotation, drawing
  • DevBlog 2 – basic piece control
  • DevBlog 3 – gravity, stack, collapse, hard-drop
  • DevBlog 4 – ghost piece, flash before collapse
  • DevBlog 5 – game over animation, score
  • DevBlog 6 – level speeds, fluid drop, improve collapse animation, etc.
  • DevBlog 7 – draw next piece, tilemap for themes
  • DevBlog 8 – allow connected tiles for richer graphics
  • DevBlog 9 – live board broadcasting
  • DevBlog 10 – chat room, more tilemaps, page layouts
  • DevBlog 11 – page routing, username

What could possibly go wrong with an additive video game as the target of a programming exercise? 😉

Shaun LeBron has posted Interactive Guide to Tetrix in ClojureScript.

The interactive guide is very helpful!

Will echoes of Tetris™ tempt you into functional programming? What video classics will you produce?

Om sweet Om:…

Wednesday, June 18th, 2014

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.