What is the advantage of using Spec over simply having the first few lines of the function declare the types of its arguments and assert some things about parameters?
Also, are these checks integrated with the compiler at all? If I specify an integer between -100 and 100 in Spec, can the compiler use the info to create an unboxed type or anything like that?
Rich Hickey explains it much better than me in the Rationale of clojure.spec http://clojure.org/about/rationale , but in short writing specs gives you: validation, error reporting, destructuring, instrumentation, test-data generation, generative test generation As far as I’m aware, the checks are not integrated with the compiler. They are focused to aid development and run-time validation.
I was wondering almost exactly the same thing. For me it was “I wonder which algorithms would light up the ‘this is beautiful’ part of the brain.” I can think of several algorithms that blew me away with their beauty when I first saw them, and several that while useful are like, “Ugh…”
Also applies to open source work -> “George RR Martin is not your b*tch” http://journal.neilgaiman.com/2009/05/entitlement-issues.html
I was thinking of something similar the other day. My idea was in the form of a “botlandia”, where people could have up to say 5 “bots” which would be open source modules that would consume, follow, filter, etc the underlying data. You could then share these bots with others and create more. The nice thing about it would be that it is totally customizable for what you want, yet you could use common and shared building blocks for ease.
Also, if you are using the page for jobs/ consulting - you might want to put in your linkedin profile or equivalent
The other issue I could see is that small changes, like a bandaid on a finger, would totally whack it out.
I worked in a lot of chemical reaction simulation code and there is an interesting similarity between those concrete simulations and this sort of logic. You end up having to still take account of how many electrons a given (real) atom has or at least how many electrons your set of C atoms vs H atoms have, and at the same time make sure they never go beyond the limits of their orbitals. In the end, what this seems to be doing is creating functions that act the same regardless of the order of their inputs (f a b) = (f b a) which is fine for addition, but probably becomes a major pain once you have to do any serious entity level accounting. Still an interesting thought if you encapsulated state properly. In essence all reducer functions act this way ideally, right?
Cool. An idea if to explore if you are interested in the order of inputs, is to use function molecules that could curry the argument (like in Clojure’s partial), and became another new function molecule.
Awesome! This is the most interesting thing I’ve seen in a while - I’m also interested in visualizing programs and learning from models from other domains. Current software / programming language models don’t really seem to capture the right problems.
A quick demo of startup speed https://www.youtube.com/watch?v=LlDQTLRrcZI
With great power comes great responsibility. Something all of us with the power of technology at our fingertips should remember.
biking, reading books, writing books, experimenting with slime mold