We are a small house of Programmers with focus on delivering high quality software. We believe that successful software projects are made by small teams of capable individuals with high-productivity tools.

Our customers vary from large enterprises and IT service providers to lean product development organizations. We focus on solving customers' challenges together and with the best possible tools. We use lean & agile methods with modern software development tools including, but not limited to Clojure, ClojureScript, JavaScript, Scala, PostgreSQL and MongoDB.

Besides working with customer projects, we do inhouse product, service development, develop and maintain Open Source libraries, organize community events (such as ClojuTRE), give out Tech Talks, work with Universities and offer Clojure trainings in Finland. Also have had fun playing with gadgets and some nice Brews.

Our main office is located at Tampere Central Square, Aleksis Kiven katu 24 B 37, Tampere. We also work in Helsinki.

Current status: mostly Clojure & Clojurescript.


  • Consulting
  • Software development
  • Clojure training




Worked over 17 years as a programmer and hands-on architect, mostly in the telco sector. Architected large SOA, integration and self-service systems and rammed up lean development teams & processes. Into clean, lean and functional - mostly in Clojure & Clojurescript.


Programmer, CEO

Over 16 years of professional software development and consulting, headed large-scale system integration & web projects, programmed, coached development teams and knows all that Agile jazz.



When not plotting for world domination with quadrocopters he helps Finnish industry and government organisations to adopt Clojure. 20 years of professional experience in developing business-critical software.



Despite the young age, has solid attitude and awesome skills on fp, web, mobile and Linux.



A well-mannered programmer with exquisite skills in web development with JavaScript, ClojureScript and Clojure.



With background from both academia and industry, knows his applied maths, data-analysis, statistics & machine learning, but is also proficient full-stack web-app developer.


If you are looking for new challenges (Tampere or Helsinki) and programming is your thing, check out our open positions.

(defn postwalk-map
  "traverses m and applies f to all maps within"
  [f m] (postwalk (fn [x] (if (map? x) (into {} (f x)) x)) m))

(defn prewalk-map
  "traverses m and applies f to all maps within"
  [f m] (prewalk (fn [x] (if (map? x) (into {} (f x)) x)) m))

(defn strip-nils
  "removes recursively all keys from map which have value of nil"
  [m] (postwalk-map (partial filter (comp not nil? val)) m))

(defn strip-empty-maps
  "removes recursively all keys from map which have empty map as value"
  [m] (postwalk-map (partial filter (comp (partial not= {}) val)) m))

(defn translate
  "translates a value against the dictionary. return nil if cant be translated."
  [dictionary k & {:keys [nils] :or {nils false}}]
  (or (dictionary k) (and nils k) nil))

(defn translate-keys
  "translates all keys against the dictionary. loses all keys without translation."
  [dictionary m] (postwalk-map (partial map (fn [[k v]] (when-let [translation (translate dictionary k)] [translation v]))) m))

(defn as-is
  "read one element from xml with enlive selector, converts to edn and strip namespaces."
  [xml & selector] (-> (select1 xml (-> selector vector flatten)) xml->edn strip-keys))

(defn all-of
  "read one element from xml with enlive selector, converts it's val to edn and strip namespaces."
  [xml & selector] (-> xml (as-is (-> selector vector flatten)) vals first))

(defn map-index
  "transform a collection into keyord-indexed map (starting from 0)."
  [c] (into {} (map (fn [[k v]] [(keyword (str k)) v]) (map-indexed vector c))))

(defn index-maps
  "transform a form with replacing all sequential collections with keyword-indexed maps."
  [m] (postwalk-map (partial map (fn [[k v]] [k (if (sequential? v) (map-index v) v)])) m))