abhirag

Would you prefer I use serif for both or sans serif for both?

Thanks :)

Interesting, @bede @v3gas I would love to hear your thoughts on my plots -- http://abhirag.in/articles/price_data_present.html

Too fancy? Too plain? Kinda ok? Kinda new to matplotlib, so your feedback would help :)

Matplotlib also allows xkcd style plots [1] if that is something you fancy :)

[1] -- http://jakevdp.github.io/blog/2013/07/10/XKCD-plots-in-matpl...

Well, I have already put some extra work in making jupyter notebooks look good when exported as html (for example - http://abhirag.in/articles/train_of_thought_1.html). I am planning to use Idyll for d3 plots and such, but thanks for the idea, exporting to markdown and then using Idyll was something I hadn't thought about.

Thanks for making this :) As of now I just export Jupyter Notebooks to html, throw them on my site and call it a day but have been meaning to try Idyll for some data visualization.

I see that you use python and hence I recommend Folium (https://github.com/python-visualization/folium). For example I made this (http://abhirag.in/articles/train_of_thought_1.html) using it and though it's not this cool, it's a start I suppose :) Also Idyll (https://idyll-lang.github.io/) might be of interest.

Kindly don't shoot the messenger(i.e. me) but pipenv does the work of pip + virtualenv + requirements.txt so packaging tool seems like a good name for it. Virtual environments aren't a lot of fun without local packages and reproducibility I assume.

The discussion here has quickly gotten out of hand and at the risk of causing more confusion I would like to point out that pipenv(http://docs.pipenv.org/en/latest/) seems to be the officially recommended Python packaging tool now[1], though venv and pip work too.

[1] -- (https://packaging.python.org/new-tutorials/installing-and-us...)

In addition to the points flavio81 made, checking at runtime because unless the language is dependently typed i.e. has types as first class citizens(for example Idris) a lot of the information about your code you want to prove to be correct is not available at compile time(for example, you have an integer but is it a non-negative integer, a list but is it sorted). It is not about being reliable, it is about being possible.

Agree with the advice of taking inspiration from algorithm visualizations and would like to add the work of Mike Bostock to the list above --

[1] Article -- https://bost.ocks.org/mike/algorithms/ [2] Talk -- https://vimeo.com/112319901

We are in complete agreement then :) GameMaker without GML is an extremely constrained environment to make games in.

I bought Pico-8 and forgot about it, after your glowing recommendation I think I need to give it a try :)

"For certain things it's very, very good (moving a character around on a screen and attacking enemies and collecting things, it's great at that)." -- I think I was lucky in my limited experience with it then, you seem to be much more experienced in gamedev so I am surely not going to argue against your experience with GML + GameMaker, it must have its limitations :)

I was never really interested in making/playing video games but Hotline Miami changed that so I decided to play around with GameMaker and GML and had a lot of fun, didn't have a particular game design in mind so I just made my resume in the form of a platformer, exported it for web, threw it on my website and that was that( https://abhirag.in/interactive_resume/ ) [doesn't work on small screens] I loved the experience and plan to work more with it in future, but will keep your advice in mind and try out Unity too :)

Sounds like an interesting analysis, would love to know where Erlang stands. Terseness definitely is a factor in play but I think at the end of the day it is all about where the priorities lie in language design, some languages really take errors and fault tolerance seriously, Erlang is famous for that and it is dynamically typed, same with Clojure, being a lisp the language design is much less rigid which allows for improvements like core.typed and Clojure.spec

"the idea that dynamic languages are more productive than static languages are laughable." -- being statically typed or dynamically typed comes with its own set of tradeoffs and what a person is more productive in is a highly subjective matter. Lispers are more productive in Lisp than Haskell and vice versa.

"Statically type languages prevent a lot of bugs and allow for a lot of automated provably correct refactorings that simple cannot be done with a statically typed languages." -- not true, Clojure is trying to do that with Clojure.spec and specifications being checked at runtime can get you closer to things you could have automatically proved correct only with languages with dependent types, nothing against statically typed languages but I feel that your sweeping generalizations hurt the point you are trying to make.

I think GameMaker doesn't fall in the "super easy to do something basic, but very restrictive at the upper end" group at all, and though I definitely fall in the newbie spectrum when it comes to gamedev but I feel that games like Hyper Light Drifter, Hotline Miami, Undertale, Risk of Rain, Spelunky should be proof enough that it is a great tool for the job, if the job is making 2d games.

Currently the way I share my notebooks is that I export them to html and put them on my site, for example -- [http://abhirag.in/articles/train_of_thought_1.html] but sometimes I wish I could share a notebook backed by a running environment which others could edit and run, that is my use case. Right step towards reproducibility of results I would say.

I have realized that Difference Equations i.e. the discrete variant of Differential Equations are much more common in Computer Science/Data Science(recurrence relations etc.) and it would have been great if they were atleast given half as much attention as Differential Equations get in universities.

This seems the best place to plug one of my favorite musicians, 24192(https://m.soundcloud.com/x24192)

Fair enough, I think I am having difficulty in understanding your views because firstly I have never worked with Java, closest language I have worked with is C# and I don't particularly dislike its REPL, its nothing to write home about but I don't particularly hate it either.

Secondly the image we two have in mind of a REPL seems to be different. When I am thinking about a REPL the image I have in mind is of Jupyter Notebook and Clojure, Elixir, Idris, Haskell REPLs in Emacs. The image you have in mind seems to be a basic console, so having spent my day working in a Jupyter Notebook I sit here thinking what you mean by Python's significant whitespace being an issue(Haskell and Idris have significant whitespace too). But now I do understand your views :)

P.S. I didn't get your point about python having nominal types, duck typing seems closer to structural typing to me and mypy seems to support both, but maybe I misunderstood you. Thanks for the thought provoking discussion though :)

You sir, seem to be hell-bent against REPLs :P

I agree with your point that IDEs are getting better but REPLs are getting better too, why should they be relegated to be mere artifacts of the past. Your java REPL will mostly have autocomplete, give it a chance, it really might turnout to be fun :P

And typing python in a REPL is fun for me, but fun is subjective, no point arguing about it :)

Definitely start with the book I mentioned, it is by Edwin Brady, he leads the development of Idris. I am reading it right now and it is an enjoyable read :)

The interactive development workflow in Idris is best described as type driven development and the focus seems to be on making the REPL an interface where an intelligent dialog can happen in between the programmer and the compiler, with the compiler trying to nudge you in the right direction. It is kinda fun, you should definitely check it out[1].

And regarding your point about the modern IDE workflow, I personally think that the sweet spot is somewhere in between, I personally prefer having a REPL process in the background I can interact with while still writing code in my source file and a REPL kept open as a scratch space where I can experiment freely without messing up my source code, I feel much better experimenting in a REPL, but to each his own I suppose :)

Jupyter Notebook is a completely different beast though, modern REPL + literate programming, what's not to love.

[1] -- (https://www.manning.com/books/type-driven-development-with-i...)

REPLs don't necessarily have to be ephemral, this is my REPL session(Jupyter Notebook) exported as HTML -- (http://abhirag.in/articles/train_of_thought_1.html), and also great REPLs can help in interactive static analysis, as a case in point consider the Idris REPL (http://docs.idris-lang.org/en/latest/reference/repl.html).

The only debugging experience I find enjoyable in Emacs is debugging Clojure using cider[1] and I think it comes close to what you are describing but I think you might already be aware of that :)

[1] -- (https://github.com/clojure-emacs/cider/blob/master/doc/debug...)

I have never used a Lisp Machine so forgive my naivety but I saw the demo and you seem to be referring to the ability of displaying images inline in a buffer. Emacs can definitely do that, I have used Emacs IPython Notebook[1] which is a REPL supporting this. I could fire up a jupyter notebook and use pillow[2] to recreate the image manipulation part of the demo.

[1] -- (https://github.com/millejoh/emacs-ipython-notebook/blob/mast...) [2] -- (https://python-pillow.org/)

Although LINQpad is awesome, the newer versions of Visual Studio have a C# REPL built in -- (https://github.com/dotnet/roslyn/wiki/C%23-Interactive-Walkt...)

Hydrogen seems nice, I also occasionally get tired of the default jupyter notebook interface and use Emacs[1] to edit my notebooks, this way I can have all the niceties of jupyter notebooks without working in the browser :D

[1] -- (https://github.com/millejoh/emacs-ipython-notebook/blob/mast...)

C# and F# do too.