(I moved this from the “welcome page” cause it is not really “up to date” anymore.)

I’ve started to choose emacs as the editor for my clojure project development. Overall vim was the big fit for the last years, but the VimClojure REPL is really not that much powerful (regarding usability, …). I’ve installed emacs as a debian package, following the rules from the emacs website nad installed the emacs starter kit from technomancy which ships with nearly everything you need.

I’ve added a few entries to my emacs init to get it up and working. See:
$ emacs ~/.emacs.d/init.el

(require 'package)
(add-to-list 'package-archives
             '("marmalade" . "http://marmalade-repo.org/packages/") t)
(package-initialize)

(when (not package-archive-contents)
  (package-refresh-contents))

;; Add in your own as you wish:
(defvar my-packages '(starter-kit starter-kit-lisp starter-kit-bindings clojure-mode)
  "A list of packages to ensure are installed at launch.")

(dolist (p my-packages)
  (when (not (package-installed-p p))
        (package-install p)))

(global-set-key (kbd "C-x <up>") 'windmove-up)
(global-set-key (kbd "C-x <down>") 'windmove-down)
(global-set-key (kbd "C-x <right>") 'windmove-right)
(global-set-key (kbd "C-x <left>") 'windmove-left)

(fset 'cljinit
   "\C-xo\C-x1\C-x2\C-x^\C-x^\C-x^\C-x^\C-x^\C-x^\C-x^\C-x^\C-x^\C-x^\C-xo\C-xbslime-r\C-m")

(global-set-key (kbd "C-c i") 'cljinit)

The global key bindings make geometric movement with the specified hotkeys possible. After viewing a file and M-x clojure-jack-in the REPL is opened at the right side with 50% size. The shortcut C-c i moves it to the bottom with only ~30% size.

Short keys are for example:
C-c C-k (compile the file)
C-x e (compile last sexp)
(ns x.y) << switching namespace in REPL.

Es stank, es funkte, kaputt. So leise war es noch nie!

Von Kulanz auf Seiten der Firma nichts zu erwarten, nur Forenbeiträge von einigen Leuten denen das Netzteil auch abgequalmt ist. Da die Garantie eh um war und ich bekanntlich vor nichts zurückschrecke, habe ich das Teil auseinander gebaut.

Bunt gemischt: Kabel ohne Zugentlastung direkt auf die Platine gelötet, andere mit Steckern. Auf einer Spule war der Kabelbinder geschmolzen, andere Stellen schwarz von der Hitze. Teils wurden Drähte auf Lötstellen nur “aufgepappt”. Ich werde in Zukunft davon absehen dort noch einmal etwas zu kaufen.

First Results can be found here: https://github.com/kremers/Clojure-Memcached-Connector

Clojure + Sandbar + Enlive + Stencil spymemcached on membase server + MongoDB

Membase vs. other K,V Stores

• Not Master,Slave! Peer Replication
• Fastest, Supported and Tested Platform
• Also available at Heroku (5mb for free)

But no tested support for collections, missing query api, …
Mongodb will also get a chance. (With monger instead of congomongo).

Enlive vs Hiccup

• Pure DRY code should be separated from the page markup.
• HTML should be semantic markup. CSS should work for the design.

Stencil vs. Enlive

• Templates free of logic
• Same API works in other languages for years
• No CSS selector and modifier hell

• Sandbar creates stateful sessions in memory, but we want to scale. Let’s store the sessions in our k,v store. So we need an implementation of ring / ring-core / src / ring / middleware / session / store.clj for memcached

If I choose to go on with mongodb, there are already existing ring session adapters.

Logging

• Finally: Simple logging (Category, Message) to memcached, quota with flush to file

I had problems installing the Heroku CLI on Debian (lenny) because of SSL Certificate problems. Heroku CLI developers commented out the “error” line with the important message, explaining what caused the error.

~> export RESTCLIENT_LOG=stdout
~> heroku create --stack cedar
Enter your Heroku credentials.
Email: xxx
Password:
RestClient.post "https://api.heroku.com/login", "password=hidden&username=kremers%40act-online.de", "Accept"=>"application/json", "Accept-Encoding"=>"gzip, deflate", "Content-Length"=>"50", "Content-Type"=>"application/x-www-form-urlencoded", "User-Agent"=>"heroku-gem/2.15.1", "X-Heroku-API-Version"=>"2", "X-Ruby-Platform"=>"i486-linux", "X-Ruby-Version"=>"1.8.7"
/usr/lib/ruby/gems/1.8/gems/heroku-2.15.1/lib/heroku/auth.rb:96:in `ask_for_credentials': undefined method `[]' for nil:NilClass (NoMethodError)
from /usr/lib/ruby/gems/1.8/gems/heroku-2.15.1/lib/heroku/auth.rb:133:in `ask_for_and_save_credentials'
from /usr/lib/ruby/gems/1.8/gems/heroku-2.15.1/lib/heroku/auth.rb:71:in `get_credentials'
from /usr/lib/ruby/gems/1.8/gems/heroku-2.15.1/lib/heroku/auth.rb:51:in `user'
from /usr/lib/ruby/gems/1.8/gems/heroku-2.15.1/lib/heroku/auth.rb:11:in `client'
from /usr/lib/ruby/gems/1.8/gems/heroku-2.15.1/lib/heroku/command/base.rb:22:in `heroku'
from /usr/lib/ruby/gems/1.8/gems/heroku-2.15.1/lib/heroku/command/apps.rb:122:in `create'
from /usr/lib/ruby/gems/1.8/gems/heroku-2.15.1/lib/heroku/command.rb:114:in `send'
from /usr/lib/ruby/gems/1.8/gems/heroku-2.15.1/lib/heroku/command.rb:114:in `run'
from /usr/lib/ruby/gems/1.8/gems/heroku-2.15.1/bin/heroku:14
from /usr/bin/heroku:19:in `load'
from /usr/bin/heroku:19

After uncommenting the following Line (564 in /usr/lib/ruby/gems/1.8/gems/heroku-2.15.3/lib/heroku/client.rb):

error "WARNING: Unable to verify SSL certificate for #{host}\nTo disable SSL verification, run with HEROKU_SSL_VERIFY=disable"

After executing “export HEROKU_SSL_VERIFY=disable” everything worked.

Why I have not choosen Scala 

I tried Scala because I excepted it to be more academic and exact. A major reason was that I have been impressed by Martin Odersky working on Scala. My first functional attempts at Scala were unsuccessful, due to the lack of JVM TCO. It may be due to my lack of experience that the Scala code seemed to look like “write only” Perl code. Programming Scala felt more like writing in Java, but with a lot more capabilities and primarily more complexity. The language is really hard to understand, even the complexity of its type system  is astounding. I’ve been quite happy using this blog post from Stephen Colebourne to help me. I had some of the same issues after some experiments with Scala. After seeing the answer from Martin Odersky I was a bit disappointed by how he deals with criticism. Blaming people who are investing time to point out weaknesses of a language and its problems to spread FUD.

How I started learning Clojure

Getting into a complete new environment with its own paradigms is hard. Especially if you can not reuse your knowledge from imperative / procedural and object oriented programming languages. Having seen a few real world Clojure applications, I was able to get an understanding of its Java interoparability. With the help of tools like “leiningen” it was easy to build my first applications.

Why I except it to be worth a try

Clojures built-in functionality to deal with the lack of TCO in the JVM (“recur, lazy sequences, …”). I searched a long time in the Scala API for such a feature. It’s not just a wide mix of object orientation with a few functional concepts, which feels like an advantage to me. The community is also adopting good libraries like these for website templates  (Enlive, …).

Where to go from here

I will check out the samples for Heroku and Clojure, since Heroku is one of the most popular cloud providers and all of the infrastructure management is done for you. And now they are properly supporting Clojure. There are also goals to play around with the language such as the “petshop” and examples with database / NoSQL connectivity. Once I have tried writing these things myself, I’ll write another blog entry on it. One of my goals is to ensure that Clojure can be used in bigger web projects. I’m not sure Clojure should be recommended for such business projects yet.

[0] http://clojure.org/

[1] http://stackoverflow.com/questions/310974/what-is-tail-call-optimization

[2] http://blog.joda.org/2011/11/scala-feels-like-ejb-2-and-other.html

[3] http://entwickler.com/itr/news/psecom,id,58955,nodeid,82.html

[4] http://en.wikipedia.org/wiki/Write-only_language

[5] http://de.wikipedia.org/wiki/Fear,_Uncertainty_and_Doubt

[6] https://github.com/technomancy/leiningen

[7] https://github.com/cgrand/enlive/wiki/

[8] http://blog.heroku.com/archives/2011/7/5/clojure_on_heroku/

[9] http://thecomputersarewinning.com/post/clojure-heroku-noir-mongo

JSF only feels good, if it is used as it’s meant to be. I.e. for Internet Applications which behave like desktop applications. 

Most poeple, companies or software architects choose JSF because it is part of the JEE standard. They assume that it is the industry standard and that it cannot be wrong to use it, regardless of the functional and non-functional requirements. There are several non-technically-related shaky arguments for such a decision. Like “enterprise support, a ‘proven’ solution, included in standard” which sometimes leads to self-protection of decision makers in case of a project failure. This does not minimize the project risk. Quite the opposite, it leads to shift the liability onto the software developers, by forcing them to think in paradigms that don’t fit the customer requirements. Other circumstances can also lead to similar sub-optimal decisions. For example lack of experience, fear of getting in touch with new technology or third-party regulations when choosing a framework. Also, having experience and expertise with a single product or technology can result in the assumption that this is the “silver-bullet”, meaning comparisons between the different frameworks and technologies are skipped. Result: The aim is the ability to deliver something, rather than aiming for quality and maintainability.

Decisions based solely on self-protection are really risky. 

What else is omitted from the rose tinted articles about JSF? One thing is the Post-Back Pattern: JSF is based on the so called “post back architecture”. This is how it works: 1. A page is loaded. 2. All requests are now sent with HTTP-POST. 3. The client recieves the result and processes it with javascript. Steps 2 & 3 are repeated until the client leaves the page. After the client leaves, the session is still available until the JSF session timeout (and longer if resources are bound to the JSF session). This has several disadvantages:

A lot of sub-optimal design decisions have been made in the JSF architecture.

JSF is a really complex framework, because a lot of things are affected under the hood. The complex six step phase-model is an example of how to handle states (see: step diagram). The complexity is not the only issue; cpu-time for processing the steps for every request and the RAM which holds the user sessions for each synch in the component tree must also be considered. Java-Script was a must have in JSF 1.0. After JSF 2 many things changed, for example graceful degradation was implemented to be more fault tolerant to users with java script limitations. Due to JSF’s complexity and because it is so expensive to fulfill simple requirements, frameworks like JBoss Seam are getting more and more popular. The goal of such frameworks is to eliminate complexity at architecture and API levels. If you are forced to work with JSF, JBoss Seam is one of the best solutions to get out of the complexity, though JSF is still running behind the scenes, which affects application speed and scalability.

Compared to other frameworks JSF is complex, CPU and RAM intensive.

Many business applications can be classified as “data capture / store and modify / CRUD” software. High Performance is not an issue here and a large part of the user interface consists of reusable components like input forms & text fields. Component Libraries such as IceFaces and MyFaces come into play. In this context the concept of a “plug and play” component solution works. Such applications can have complex data input tables and validation rules, resulting in large, complex calculations, but the design of the page is simple. On the other side are websites with a lot of design and content. If you are forced to implement such things with JSF you’ll end up with a bloated codebase, which is hard to maintain.

There are domains where JSF adds value.

However other people say that JSF is the silver-bullet and that all problems can be solved with JSF?! You should not trust these people! Most of the stuff that you can find (online articles, java-magazine, …) are from people who clearly recommend JSF. Most of them are biased because they work with JSF every day and their company advises customers to use it. So why lower their own worth on the market? They will not write about the workarounds in their software solutions, the bad experiences they had once JSF was in place and all the scalability problems. A long time ago I bought the “Java Magazine”, which is mostly full of articles from consultants to boost their own value. The quality varies a lot from article to article. The main article was called “Web Frameworks, Struts, JSF and ZK compared”. The author talks about JSF as a more modern framework than Struts. I think the paradigms of event-driven and request-response driven architectures are incomparable. Problems with the component tree or real world experience with big projects were not mentioned. I know from projects where custom JSF user-session recycle services have been developed to prevent memory overflows with only a few hundred concurrent users.

Trust yourself! Evaluate different frameworks. Read about technical details and do not trust the hype a technology is given.

So, what is the next big thing for the future? After the growing market impact of javascript due to application development for Apple IOS and Android, architectures like SOFEA have good chances in the future. The biggest problem is that there is no standard stack defined which brings all of the necessary javascript frameworks together. Until then it is better to stick with the Spring (MVC) stack or Grails.

MphasiS, an HP Company, has also done evaluations of JSF for big, complex projects. The results reflect my experience. Check out this excellent article by Mohan Borwankar. Click here to read the Article of Mohan Borwankar. 

You shold also check out this presentation from reliabledesigns.

1. The Interface / XML structure changes
2. Output enriched with rule results in additional nodes
3. Non-redundant template code is a must-have

Example of a XSLT2 Identity Transform template:

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="@*|*|processing-instruction()|comment()">
<xsl:copy>
<xsl:apply-templates
select="*|@*|text()|processing-instruction()|comment()"/>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>

From now on, other templates can match nodes which should be modified. For example we wish to remove all nodes with the name “Bill”:

<xsl:template match="Bill"/>

Because the template is empty, the node is removed in the output.

If multiple transformations are applied, XML pipelines are better (XProc, …). Projects under active development include QuiXProc and Tabular.