vnlog VS RecordStream

For simple analyses (i.e. what most people do most of the time) doing this on the commandline gets you there faster. I use vnlog (https://github.com/dkogan/vnlog/). By the time you fired up your editor to write your Python code, I already have analyses and plots ready.

Alternative very appropriate for some uses cases: `vnl-join` from the vnlog toolkit (https://github.com/dkogan/vnlog). Uses the `join` tool from coreutils (works well, has been around forever), and `vnlog` for nice column labelling

There's also https://github.com/dkogan/vnlog/ which is a wrapper around the existing coreutils, so all the options work, and there's nothing to learn

And to improve the ergonomics, the vnlog wrappers are available to operate on field names, while retaining the internals of the core tools:

  https://github.com/dkogan/vnlog/

I sorta, kinda agree. Tools written in AWK (and friends) are indeed somewhat unmaintainable, but they're really close to being just right for a LOT of applications. The vnlog toolkit (https://github.com/dkogan/vnlog) adds just a little bit of syntactic sugar to the usual commandline tools to make processing scripts robust and easy to read and write. This was not my intent initially, but I now do most of my data processing with the shell and vnl-wrapped awk (and sort and join, ...) It's really nice. If you write stuff in awk, you should check it out. (Disclaimer: I'm the author)

It's interesting watching these types of tools get re-invented periodically:

https://github.com/benbernard/RecordStream

It shows the unix model of many small, composable tools is very powerful, but also shows that POSIX is missing some essential pieces that everyone keeps trying to add/reinvent.

I don't know about MillerCLI's portability, but RecordStream (https://github.com/benbernard/RecordStream) is my go to swiss army knife.

That record/field parsing library would be a tool to handle a broad category of command-line programs. Once the library has broken the input stream into a collection of records and fields, another layer would then turn them into internal representations. The JSON-based RecordStream tools are illustrative here: there are some tools that parse based on a delimiter or a regular expression, some that parse documented generic non-JSON formats like XML, and some that parse application-specific files like tcpdump outputs. In a Lisp world, all of the dedicated stream manipulation tools are redundant, and you avoid parsing and printing at every step in the chain.