elixir-snippets

hah, I was actually aware of this, ironically because I side-projected an encoding/decoding that "visibled" normally unprintable ASCII characters into printable UTF-8 https://github.com/pmarreck/elixir-snippets/blob/master/prin... Maybe we should bring field and record separators back and call it "ascii-separated values" (ASV) lol (because, you know... "as originally envisioned by the makers of ASCII") The only caveat is the lack of visible printability of those (hence that project up there). It would be neat if (by default) the field separator ASCII character looked similar to a tab (maybe with some distinguishing detail such as a dotted underline) and the record separator ASCII character looked similar to a newline (again, with some extra visible difference, but also including the visible linefeed) There's probably a font feature that l

I tried to create a "printable binary" format for better visual inspection of raw binary data (and a to/from format) https://github.com/pmarreck/elixir-snippets/blob/master/prin...

None of them have tests :( I have plenty of single-file Elixir examples, many with tests included, in this elixir-snippets repo: https://github.com/pmarreck/elixir-snippets/blob/master/prin...

I just had this discussion yesterday on Slack. I think that your core test suite should be completely, 100% deterministic. Property-based testing/random input testing/chaosmonkey/profiling/etc. are all a different type of testing to me. Still useful, but separate. Still should be run, but not every time. You do not want non-deterministic tests. (And if you use random testing, ALWAYS record the seed so you can reproduce it!) If the core functionality of your code is fundamentally random (I once tested a maze generator this way https://github.com/pmarreck/elixir-snippets/blob/master/maze...), use seeded random data.

I avoid FP as much as possible precisely because of these nondeterministic (at least in the practical sense) results. I use integers almost exclusively and if I need fixed point I have view code that renders things correctly (such as for currency). When Erlang didn't have a power function that didn't use floating-point (and thus resulted in rounding errors), I wrote my own: https://github.com/pmarreck/elixir-snippets/blob/master/math...

I read Dave Thomas' book cover-to-cover like some kind of legitimate nerd :) It was very good. For understanding genservers there's The Little Elixir and OTP Guidebook, as well. In my case I experimented with it for at least a year before I decided to jump in, my "experiments" are here: https://github.com/pmarreck/elixir-snippets (I tend to use single-file dev for exploring simple ideas; this is not a general pattern used in the community or anything, it's just something I discovered I could get by doing)

Same here! https://github.com/pmarreck/elixir-snippets/blob/master/rpn_... I found it fun, and it was actually super easy to implement a stack-based language interpreter in an immutable pattern-matching language like Erlang/Elixir. It's incomplete because I haven't yet figured out how to define the defining character ":"...

I think there is a case to be made that unit tests can live inside the file under test; integration tests can live outside of it. Also, mocks are arguably a test-code-smell side effect of too little isolation: https://www.destroyallsoftware.com/blog/2014/test-isolation-... In my Elixir one-page code experiments, I put the unit test in the same file after the code under test. It makes sure the test only runs when the file is loaded a certain way: https://github.com/pmarreck/elixir-snippets/

This is interesting, but come on, man. Not a single unit test? I found TDD to be invaluable when writing a simple RPN calculator (which suddenly became a Forth interpreter that could do things like compute factorial): https://github.com/pmarreck/elixir-snippets/blob/master/rpn_... Note that I was never educated in how to write compilers or transpilers (I was a Psych major and merely a CS minor), I just looked at it as a transformation problem. :)

I have built some small projects with it and really like it... in fact, after getting atop most of the learning curve, it's hard not to want to just work IN it. Which is a pretty good endorsement, in my book. I will say that the production deployment process and tooling is not purely Elixir at this point (yet). People tend to use the Ruby Capistrano gem to deploy... which works... but to me gives sort of a cognitively dissonant experience :) Another quirk I noticed is that IEEE floating point is not completely supported, for example there is no "Infinity" value and working with large numbers will often get you rounding errors. For example, using the Math.pow function (the ONLY native power function!) ONLY works with floating point values so using it will get you large-number roundoff errors. Some libs have been written to manage numeric d