turbo-django VS lisa

Indicative of how marvelously stable Django is that none of these roadmap items have to do with the software.

I came back to the old workhorse for some experimentation recently and was delighted, delighted (!), I tell you, at how familiar, comfortable, and productive it was.

Started exploring a Turbolinks/Turboframes implementation (https://github.com/hotwire-django/turbo-django) that Just Worked. Amusingly, mid-hack, the repo owner marked it as unmaintained.

But it works! Nothing needs doing! Another victim of the cult of constant improvement.

Yes Turbo is created by the team behind Ruby on Rails and it's an evolution of Turbolinks with bunch of other functionality added. But Turbo can be adapted to other languages and backend frameworks (and already has!). This Turbo thing is not Rails specific.

If you would like to try something different, there is this new thing called hotwired: https://github.com/hotwire-django/turbo-django Basically, it's about generating HTML on the backend and pushing it to the frontend. thru WebSockets. It's not production-ready yet (for Django at least) so it's more like a fun fact for now.

You might be interested in that: https://github.com/ARM-software/lisa/blob/master/lisa/monad.py

This is to replace the current flow purely based on pandas dataframe and offline trace.dat parsing used in LISA: https://github.com/ARM-software/lisa (collecting a trace.dat is nice for debugging but limits to small durations, and pandas does not allow running computations in constant memory, which is an issue for very big traces)

The module added by this PR seems to be a pretty good fit: https://github.com/ARM-software/lisa/pull/1722

I made that thing taking some vague inspiration from SML module system: https://github.com/ARM-software/lisa/pull/1722/files

import builtins from operator import add import functools # These functions can be found at: # https://github.com/ARM-software/lisa/blob/master/lisa/utils.py#L147 # Note: my implementation of curry() seems to be broken wrt named parameters (or for parameters with defaults, haven't looked at the details) for some reason but for this example it does not matter from lisa.utils import compose, curry def even(x): return x % 2 == 0 # The builtin functions don't have a signature, which will upset curry() so we # redefine it here def map(f, iterable): return builtins.map(f, iterable) def filter(f, iterable): return builtins.filter(f, iterable) # Swapped init and iterable to be curry-friendly def reduce(f, init, iterable): return functools.reduce(f, iterable, init) def pipeline(*items): # Add a currying layer so that we spare the user the need to do it return compose(*(curry(f)(*args) for (f, *args) in items)) # x = filter(even, list) |> map(lambda x: x+1) |> reduce(+) f = pipeline( (filter, even), (map, lambda x: x+1), (reduce, add, 0), ) l = [1,2,3,4] x = f(l) print(x)