Kyle Cordes

ClojureScript is a relatively recent addition to the list of languages which compile to JavaScript. Unlike some such languages, it does not only fix the minor difficulties with JavaScript (like syntax oddities), rather it is a wholly different language with a LISP-like syntax and very powerful semantics. Many words have been written on “why ClojureScript”, which I won’t attempt to restate here. Rather, these are the handful of reasons ClojureScript is worthy of a deep dive for projects like ours (at work).

Strengths (for us)

• It is a “programmable programming language”, especially good for building abstractions – the usual LISP strength.
• It is biased toward immutability and functional style (though many things are mutable, because of JavaScript underneath); yet can easily escape when pragmatically needed.
• Is it is possible to use the same(-ish) language on the client and server; our projects benefitted from this for years in the boring old days of desktop client-server development.
• Client side ClojureScript is built on JavaScript runtimes and libraries: proven, strong, dominant, multiplatform.
• Server side Clojure is built on Java runtimes and libraries: proven, strong, dominant, multiplatform.
• Although there are not a great number of ClojureScript developers, they tend to be good developers.

Weaknesses

• Although parentheses-first syntax does not bother me, it does bother some developers.
• ClojureScript is different enough from JavaScript that knowledge of the latter doesn’t help much with the former;
• Yet, it is still necessary to know JavaScript well.
• There are at least 100x fewer ClojureScript developers than JavaScript developers; perhaps 1000x.
• Fits well with some JS libraries, less well with others – sometimes that prevents the “shove in an hack” style of development which is JavaScript’s strength and weakness.

Tags: clojure, clojurescript

For the third year in a row, Oasis Digital will hire summer interns to build something interesting. Our program is for high school students (why? because I’m a high school student parent…). If anyone knows a St. Louis area high schooler who may be interested, please send them our way.

Tags: internship

We just went through a surprising amount of effort to import projects in to Atlassian’s JIRA OnDemand, using their CSV importer. Here are some tricky bits we hit along the way; this is accurate as of November 2012. If you are reading this well after that date, hopefully JIRA’s newer JSON-based import option is supported and documented by now.

1. JIRA CSV import can import attachments. It fetches them from URLs. Beware though that it won’t accept alternate ports. http://host/whatever is OK, http://host:nnn/whatever is broken. Moreover, is broken with a completely incorrect (403) error. (Undocumented.)
2. CSV import can import comments. The format is documented on their site, and arcane, and permanently leaves a trail of extra data in the comment text(!). But it works.
3. CSV import will import events as of date-time as imported. Only one date format is supported for comments; though it date format can be changed for  issue-level fields. The date format does not include a time zone. By trial and error we learned that the datetime is interpreted as the time zone which the JIRA server (at the OS level) is set to. (Undocumented.)
4. JIRA OnDemand servers are set to the US Central time zone, or at least they pretend to be for us. YMMV. (Undocumented.)
5. JIRA CSV import will automatically create-as-needed users if they are mentioned at the issue level (as an issue creator etc.)… but will only generate an error about missing users at the comment level.
6. CSV import can import parent-child relationships, but not other kinds of relationships.
7. The JIRA REST API is tempting – but it can’t assign correct historical date-times to anything, so it’s generally not useful for importing data.

In spite of those rough edges, we were able to get the job done, and are happy with JIRA.

Tags: JIRA

This summer, we hired three interns to build a mobile web application and learn a bunch in the process. Here is their story, in video form:

If you don’t have Flash installed (and thus don’t see the video above), you can try this direct link to the video. It plays well on most platforms (including an iPad).

It is also available on YouTube.

Tags: internship, javascript, mobile, node.js

A few weeks ago I posted about the various Github Issues export tools to prepare data for import to Atlassian JIRA. Unsurprisingly, none of them worked sufficiently well for my needs. I thought about adapting and improving one of them; I know Ruby, Python, and (barely) enough Perl. But none was all that appealing; some used an obsolete Github API version, one didn’t handle comments at all (!), and so on.

Instead I wrote a new tool, in Clojure. The following tools and documentation moved things along quickly:

• Github v3 API
• Clojure
• Clojure API wrapper for the Github v3 API: (Thank you Anthony Grimes)
• Doc for the above
• Clojure CSV library
• Clojure Date Time library
• Doc for the JIRA import format
• Doc for the JIRA comment import
• KB article for comment importing, in particular, ”settings.advanced.mapper.comment” : “com.atlassian.jira.plugins.importer.imports.csv.mappers.PvcsComment”

Download the GHI -> JIRA CSV tool now:

https://github.com/kylecordes/ghijira

A very irritating caveat is that as of June 2012, the resulting file works great with the current downloadable JIRA, but fails with JIRA OnDemand (the SaaS version). JIRA support confirmed the import problem is due to a slightly older version of the import tool used in the SaaS offering – by the time you read this, it might already have been upgraded and fixed.

Update: To help those who aren’t here for the Clojure but just to solve their GHI->JIRA problem, I added more instructions to the README file (see github project link above) explaining how to use the software.

Tags: clojure, JIRA

Today I looked for a way to import issues (including history) from Github Issues to JIRA. I was delighted and disappointed to find at least four different implementations of a Github Issues to JIRA-CSV exporter – all honestly described as rough one-off efforts.

It seems likely that I’ll adapt (add minor improvements to) one of the above to yield yet another solution for this, and perhaps publish it here, so there will then be at least four choices for the next person to find.

A lot of small problems end up in this condition: many semi-solutions, no clarity on which to use. Is that what meet users’ needs best? Certainly not. Perhaps Atlassian will step in eventually with a broad, well-tested set of issue importers for JIRA. JIRA appears to be a market leader, this is an opportunity to step up and earn that role.

UPDATE: I made a new export tool, available now.

Tags: JIRA