I have no intention of starting or getting into a flame war between Ruby and Python, both are great languages but I can help with the Python tooling a bit. The Python equivalent of rvm is pyenv (https://github.com/pyenv/pyenv/blob/master/README.md) and to install dependencies and handle virtual environments after that you can use pipenv (https://github.com/pypa/pipenv). Both of them together will get you almost similar experience to the Ruby tooling example you ended the post with.
I love why the lucky stiff's writing, I love POODR (http://www.poodr.com/) and the two languages have a lot in common if you just keep an open mind about it :)
I do appreciate the effort you've put into this response, unlike parent. Well done. Next time I have to do something in python, I will try pyenv and pipenv (and maybe write about it, too)
Don't dismiss one of my favorite higher order functions so soon :)
"Recursion + memoization provides most of the benefits of dynamic programming, including usually the same running time." -- Steven Skiena
lru_cache decorator is great for people who are happy to let the language handle the caching of results for them, and often leads to code which is much more concise than the dynamic programming approach. The limitation you are referring to is that the decorator uses a dictionary to cache results and that dictionary uses the arguments as keys so the arguments need to be hashable. That limitation can be avoided by using immutable data structures (Clojure also has a higher order function called memoize which does the same thing and has no limitations because the core data structures in Clojure are immutable) and although Python not having structural sharing can mean that this approach can hurt memory and GC efficiency a bit, but that trade-off is at least worth considering :)
Still have to keep the stack depth less than sys.getrecursionlimit() so no substitute for tail recursion but surely a substitute for dynamic programming in a lot of cases.
You can only avoid the recursion limit in cases where dynamic programming would also work, as you have to explicitly call the function in reverse stack order to avoid having the stack build up. If you want fib(10000) you need to call fib(1) through fib(9999) first, as if you were implementing a dynamic programming solution.
This isn't dismissive. lru_cache is one of my favorites too, but it has limitations.
But that isn't a limitation of lru_cache, for example the same higher order function when used in Clojure i.e. memoize with recur for tail recursion will not cause stack overflow. The stack build up is because python doesn't support tail call optimization, not a limitation of lru_cache, just wanted to make it clear because you can use similar higher order functions in other languages which support tail call optimization without any limitations. Deep recursion in Python without sys.setrecursionlimit() is probably not a good idea, memoization can't help you in that. My point was geared towards presenting this pattern of memoization using a higher order function + recursion as an alternative to dynamic programming and in languages with tco and immutable data structures it works beautifully :)
The beauty of Emacs lies in how configurable it is. I use Emacs in two modes, when editing a program I use native key bindings (Cntrl-c, Cntrl-v, Cntrl-a, Cntrl-z etc.) and to execute commands I use vim key bindings. I absolutely love this setup but many people here might absolutely hate it, but what matters is that Emacs doesn't care and can be used by people with diverse muscle memories :)
Probably give Emacs Live (https://overtone.github.io/emacs-live/) or Spacemacs (http://spacemacs.org/) with the Clojure layer installed a try. Learning Emacs and Clojure both at the same time can be kinda overwhelming though and if you are just interested in Clojure and not Emacs you should probably just start with Cursive (https://cursive-ide.com/)
I'll try one of those -- might be good to have something separate. I use Emacs as my main editor and there's already a lot added onto it. Thanks for the links.
Not formal verification, but you can specify and validate application state of SPAs written in clojurescript using clojure.spec(https://clojure.org/about/spec).
The HTML export back-end includes a compact default style in each exported HTML file. To override the default style with another style, use these keywords in the Org file. They will replace the global defaults the HTML exporter uses.
Well done!
I hope things are better now :)
Quick suggestion: Include a line describing what the website does on the main page, users can go to the about page and figure it out but it would be better to have a quick intro of what the site is all about as soon as they visit it. You can probably remove it once the website is more well known but the title isn't self explanatory, so an intro would help.
Stack used? Probably Elixir+Phoenix judging from your post history, what are your impressions about that stack?
I use pinboard archival account for this use-case, but I think some readers here might find this site useful :)
Thank you for your kind words ... as for my personal life, I am still fighting to make things better.
I did think of adding a quick line on the main page, but never implemented it, thinking it will be self explanatory, but you are right, to have it until the site gets popular.
Yes the stack is Elixir + Phoenix. I was a rails and meteor guy prior to that. I like really like Elixir as a language, the excellent documentation helped quite a lot. Also the community around it is very eager to help. As for Phoenix, again its the community weight that shows its strength, being helpful and adding more open source libraries every week. I think if there was one feature where rails at the moment triumphs phoenix is in the number of open source libraries/packages/gems. Elixir + Phoenix sips on server memory.
Could you kindly explain more about how a pinboard archival account compares to summarybrew.
"Word if you learn it is just fine generating a ToC or autonumbering sections, figures, and tables." : but can it do this? -- [Common Lisp Quick Reference](http://clqr.boundp.org/clqr-a4-booklet-all.pdf)
I love why the lucky stiff's writing, I love POODR (http://www.poodr.com/) and the two languages have a lot in common if you just keep an open mind about it :)