MathInspector VS Pluto.jl

> I expect that mathematics will be rewritten to suit computing, rather than vice versa

I agree with this. I believe pure mathematics is suffering greatly because many mathematicians refuse to fully embrace the computational power of modern technology.

My belief is the age of pretty formulas is coming to an end, and that the future of mathematics will be it focuses more and more on computational aspects of the subject, and problem sets in pure math courses will be done using programs that are much more advanced than anything which exists today, and everyone will think nothing more of those programs than they we do about calculators.

Apologies for the self plug, but this has been my vision with mathinspector[1]. I've been working very hard on that, and this is why I got so interested in your statement. Thank you for clarifying your thinking here. Makes sense to me, and you could be right

[1] https://github.com/MathInspector/MathInspector

Thank you so much! Well I tried to make it work so that literally any project you have sitting on your system can be imported into the app. In principle it should work, in practice the amount of block code elements can quickly become overwhelming.

At the end of wrapping up the beta version, I was using math inspector to create math inspector, this is how I wrote the TextParser[1] class, and there is a certain beauty to the way the files were synchronized, but since everything was still in development I ended up doing a lot in Sublime instead and have not had a chance to keep working on that aspect.

I think the more the app gets dog-fooded in this way, the more clear it will become what the optimal UI/UX is. Math Inspector is not an IDE, but it does create an additional visual layer that is kind of helpful during development, especially for quick iteration.

[1] https://github.com/MathInspector/MathInspector/blob/master/m...

There is! I didn't build and codesign the linux build yet (just ran out of steam and needed a few days of rest), but I set up everything in a VM and got it working on my mac through x11.

If you follow the instructions in the Vagrantfile, it should hopefully be simple to install from the source code on your system.

https://github.com/MathInspector/MathInspector/blob/master/V...

I thought that notebook based development and package based development were diametrically opposed in the past, but Pluto.jl notebooks have changed my mind about this.

A Pluto.jl notebook is a human readable Julia source file. The Pluto.jl package is itself developed via Pluto.jl notebooks.

https://github.com/fonsp/Pluto.jl

Also, the VSCode Julia plugin tooling has really expanded in functionality and usability for me in the past year. The integrated debugging took some work to setup, but is fast enough to drop into a local frame.

https://code.visualstudio.com/docs/languages/julia

Julia is the first language I have achieved full life cycle integration between exploratory code to sharable package. It even runs quite well on my Android. 2023 is the first year I was able to solve a differential equation or render a 3D surface from a calculated mesh with the hardware in my pocket.

Re Julia there is also pluto.jl that is another notebook-like environment for julia. It's been a few years since I played with it but it looked cool, for example it handles state differently so you don't get into the same messes as with ipython notebooks. https://plutojl.org/

For this, Notebooks are often used. Julia offers a uniquely nice and interactive Pluto notebook for the web https://github.com/fonsp/Pluto.jl

I believe this is what Pluto sets out to do for Julia.

I used it as part of the “Computational Thinking” with Julia course a year or two back. Even then the beta software was very good and some of the demos the Pluto dev showed were nothing short of amazing

https://plutojl.org/

I think what you want is Pluto!

I like how Pluto.jl handles this:

> Pluto offers an environment where changed code takes effect instantly and where deleted code leaves no trace. Unlike Jupyter or Matlab, there is no mutable workspace, but rather, an important guarantee:

> At any instant, the program state is completely described by the code you see.

[1] https://github.com/fonsp/Pluto.jl