dash

adopted a similar style for my own work: - https://github.com/geocar/dash/blob/master/d.c#L63 - https://github.com/geocar/con/blob/master/con.c I don't let it bother me though. Occasionally you meet people who can be convinced to take a certain leap of faith, and then you get to have very interesting conversations about making software that you can't have otherwise. Perhaps you've heard this said of other things as well: That learning lisp makes you a better programmer even if you do not use lisp. This thing here, is kind of like that.

, I'd say posix_spawn() is as well. † https://github.com/geocar/dash/blob/master/README.techempowe... †† https://github.com/geocar/dash/blob/master/README.md

about it). I am telling you I can only do this because the code is small. [3]: https://github.com/geocar/dash/blob/master/d.c#L63 [4]: https://github.com/geocar/dash#performance

://www.nsl.com/papers/origins.htm [3]: https://github.com/geocar/dash/blob/master/d.c#L62

pace, not binary size. Then I compose my application out of a few small programs. I sat on the plane recently next to a guy proofreading a manuscript. He had five phones out next to his laptop, all with various parts of his document open on them, scrolling on each. I didn't want to disturb him to ask him what he was thinking, but was nonetheless fascinated by his process. I intend to try experimenting with a lot of little displays for my programs next. [1]: https://github.com/geocar/dash/blob/master/d.c#L61 > One of my favourite examples of this is APL, where those experienced can read and write programs in it as easily as they can a human language; programs which are completely incomprehensible to anyone who doesn't know the language. APL has got anywhere from 30-70 or so builtins (depending on how you count and the specific flavour of APL) and a very simple syntax. I think a lot of their "incomprehensibility" comes from how strange they look. If a literate approach can be useful for training a mathematician uncomfortable with programming Java and C# to use Java and C# effectively, then perhaps it can be used for teaching APL. Assuming you have a dictionary of your alphabet: A←'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789' and a way to collect the contiguous "words" from some input: words←{1↓¨(~x∊A)⊂x←' ',⍵}input which is easy to understand if you break it up; the key part is `x∊A` which generates a bitmap of the locations where our input is a member(∊) of our alphabet. We negate(~) it since we want the breaks, and then we then take that bitmap and pick(⊃) out the breaks. Note I put something not in the alphabet at the beginning of the input so that `x` will begin with a break. Next we'll want the unique words without an empty word (likely if we have multiple breaks in a row): unique←(∪words)~⊂'' and to know how many there are: counts←+/unique∘.≡words By doing a match on each word against the unique word `∘.≡` we build a 2d bitmap which is as wide as length of the unique words, and as tall as the number of words - each cell denoting whether the word was the unique word we were comparing. You might try `unique∘.≡words` for yourself. Lastly, we want the indices of the top (3) counts: i←3↑⍒counts so that we can draw a nice table of the results: (⍪unique[i]),⍪counts[i] You can try this at http://tryapl.com/ K/Q has a slightly simpler solution since it has a builtin "group" operator and more data types (like dictionaries), if you have something that makes words words:{"<"vs ssr[x;"[\000-@\133-`\173-~]";"<"]} it's a simple matter to take some number (3) of the descending count of each group or: 3#desc count each group words input or in k: a!x a:3#>x:#:'=words input which you can try by downloading the free version at https://kx.com