ABOUT US

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, Scala, ClojureScript, JavaScript, MongoDB and Riak.

Besides working in customer projects we do some product development, organize free events (such as ClojuTRE), play with gadgets and give technology trainings (mostly Clojure) to our partners and customers. And deliver some fine Brews.

Our office is located at Keskustori 7, Tampere.

Current status: mostly Clojure


SERVICES

  • Consulting
  • Contracting
  • Training

PEOPLE

TOMMI REIMAN

Programmer

I have worked 15+ years as a programmer and hands-on architect. Have built large SOA and self-service systems and been ramming up agile development teams. Into clean, lean and functional programming.

MIKKO HEIKKILÄ

Programmer, CEO

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

JARI LÄNSIÖ

Programmer

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.

JUHO TEPERI

Programmer

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

TUUKKA KATAJA

Programmer

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

MIIKA PIHLAJA

Programmer

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.

(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))