lambdaroyal

Plug-in to your ERP System with XML-based interfaces. Use XSLT transformation to address any data structure your ERP is expecting. All this with ease, out-of-the-box, and most important for free.

Say hello to seamless and easy-to-use stock inventory from your PLANET-ROCKLOG webshops.

TL;DR

1. Create a new snapin for stock cards with ui-control

2. Attach this snapin to your webshop, that is represented by some publicdata card

We allow the user both to count the stock amount and enter the entire amount (ui-control SnapinAddStockToInventoryOrderDelta), but also to enter just the amount change (ui-control SnapinAddStockToInventoryOrder)

Say Hello to strategic supply chain management using http://www.planet-rocklog.com and https://www.log-hub.com/

Combine your daily business in PLANET-ROCKLOG, our blazing fast and easy-to-use warehouse management system with the top-notch strategic supply chain optimization toolchain of Log-hub.

Although adding some non-functional aspect (here runtime statistics) to purely functional code is a no brainer with function wrapping I will show how to add an aspect just for testing purposes without intervening your domain code by using aspect oriented programming in Clojure using robert-hooke

https://github.com/technomancy/robert-hooke allows you to extend functions after they were created.

Let’s imaging you got a bunch of function (compositions)

(defn uups [x]  (do    (Thread/sleep (rand-int 10))    (inc x)))

(defn gaga [x m]  (uups (+ x m)))

... and you wanna checkout which function is called how often and consumes how much runtime. You can end up

writing wrapper functions for each :(

writing a macro wrapper for each :(

or weave in a aspect using a simple macro and robert-hooke :)

First, we need to add the respective dependency to our project.clj file

[robert/hooke "1.3.0"]

Second we write a macro taking into account the functions to trace as well as the body to execute.

(ns ^{:doc "Performance Unittests Helper"      :author "[email protected]"}    lambdaroyal.vlic.crosscutting.timing  (:require [robert.hooke :require :all])  (:gen-class))

(defn timing [stats f-name f & args]  (let [start (System/currentTimeMillis)]    (try      (apply f args)      (finally        (let [delay (- (System/currentTimeMillis) start)]          (if-let [existing (get @stats f-name)]            (swap! stats assoc f-name (assoc existing :count (inc (:count existing)) :cum (+ (:cum existing) delay)))            (swap! stats assoc f-name {:count 1 :cum delay})))))))

(defmacro with-timing [lambdas & body]  (let [stats (gensym)        timing (gensym)        lambda (gensym)        k (gensym)        v (gensym)]    `(let [~stats (atom {})]       (try         (doseq [~lambda ~lambdas]           (robert.hooke/add-hook ~lambda (partial timing ~stats (str ~lambda))))         ~@body         (finally           (doseq [~v (reverse                       (sort-by :cum (map                                      (fn [[~k ~v]] (assoc ~v :fn ~k))                                      (deref ~stats))))]             (println ~v)))))))

Using the all new shiny with-timing we can obtain number of function calls as well as the cummulated runtime in order to get our hands dirty speeding up our domain code.

(with-timing [#'gaga #'uups]  (doall (repeatedly 1000 #(gaga (rand-int 100) (rand-int 100)))))

yields