Myron arose out of an experience I had preparing course material with mathematical formulæ and PowerPoint. I was disappointed in how hard it was to produce simple expressions with numerical examples. That same year, my 2010 iPad having been obsoleted beyond usefulness, I purchased a Samsung Note 10.1. The Note has very good character recognition but it’s tied to fairly simplistic applications. Myron doesn’t make use of character recognition — that remains a dream yet to be realized — but somehow the creative juices started flowing and the result is an interactive symbolic algebra system.
Prior to Myron, one of my many projects was software to deal with state diagrams, finite-state machines, Boolean expressions and logic-circuit generation. Part of this included a rendering algorithm to display Boolean expressions before and after simplification. That algorithm provided a starting point for the display of algebraic expressions in Myron. In fact, the Boolean simplification algorithm was transplanted into Myron as well.
I have spent the last few decades orbiting around language systems, touching down to spend time with them, revisiting periodically, embracing each in turn as my primary means of expression in a kind of serial language monogamy. Prior to the iPad I had an iPod TouchiPod Touch and spent a while in Objective C[2] with Xcode. Just prior to the Note, I was alternating between Java with Netbeans and C# with Visual Studio and Mono. With Android, I had to make the move to Eclipse. Now, while Java is a piece of cake, Eclipse is daunting on first look and Android has a fairly steep initial learning curve. But I managed to get a rudimentary application working which became the beginnings of Myron.
At first, all I wanted to do was to manipulate equations. I tried several approaches before coming up with a usable user interface. Evaluation and the plotter were ideas that arose early on. The notion of having multiple expressions on the display came a little later and lead in turn to substitutions and a binding facility. Substitutions lead to transforms and, later, to property lists. Binding ended up with full-blown typing and overloading.
After spending a sabbatical term working on the calculus algorithms and revising the original user interface closer to what you see today, I gave a talk on Myron and used some Samsung gadgets to reproduce the tablet screen on the video projector. I wanted to give the entire talk from the tablet rather than switching back and forth to a desktop for presentation material. In preparing for the talk, I needed to create notes to summarize and present descriptive material along with a way of moving between the notes and the algebra workspace. The solution to that problem became the book reader and the notes became the beginning of this user guide.
Prior to giving the talk, I had developed a variation on integration with u-substitution by using non-trivial expressions in the integrator. This is not How Mathematicians Do It. In thinking about how the Myron approach was received by mathematicians in the audience (who were most-definitely not Computer Scientists and had little use for constraints imposed by trivial things like actual implementation or clever but non-mathematical ways of thinking about things) I was led to the use of decorations for U-substitution.
While developing the notes, I needed a way to test expressions and copy them into the notes. And as the notes grew, I needed a way to manage the many files that made up the notes. To address the first problem, I refactored the Myron source into several packages according to how much Android dependency existed. By doing this, I managed to make the expression code completely independent of Android so it could be used in other projects. I also added code to produce Tex output from the expression tree. This, combined with note-management software built to solve the second problem, lets me code the note source using abstract markup and transform it into book-reader source, Tex source, or online Web pages.
I still needed a more satisfactory way to copy expressions to the notes. I had developed an email interface for Myron so I could send myself the text of working expressions. I was also cutting and pasting screen captures of the replay screen, but what I really wanted was a way to cut and paste between the tablet, specifically the text-output area, and my desktop. It would have been really cool to be able to cut on a tablet and paste on the desktop. Since that wasn't going to happen, the clumsy techniques at hand lead to the birth of a simple desktop interface that could leverage the refactored expression code. To do this, the rendering code also had to be refactored along with much of the dispatch code (that which applies transformations in response to UI components). As a side effect, development cycle time was reduced as I was no longer bound by performance issues associated with the Android emulator. Ultimately, the desktop interface became an exact replica of the Android interface. And I had a way to test expressions and copy them into the notes.
The simplification code was getting out of hand. I had tried twice to come up with a way to abstract the simplification code and failed to achieve a satisfactory solution both times. So I went back to documenting the hard code and generating regression tests for each case. What was happening was that the comments on each branch of simplification code were taking on a notational consistency that ultimately led the way to Myron transforms and constraints. For a while, Myron had a parallel system that could switch between the original hand coded simplification code and interpreted transform-driven simplification code loaded from a file of specifications. This proved the concept, but had severe performance constraints in terms of initial load time, execution time and memory requirements. It wasn’t going to run well on a phone. Ultimately, a third branch was added to run methods whose source code was generated from the transform specifications of the second branch. This code loaded at the speed of the run time, was as fast as the hand-coded methods and required only the same amount of memory. The regressions tests showed that this branch conformed to the original code and ultimately the first two branches were dropped. The technique has since been leveraged for other parts of Myron.
I was fortunate to have a student work with me through one summer who found many limitations in the Calculus transformations. The following year, Boolean algebra was added. I was hoping to get Myron to market after that, but it just wasn’t ready. Another winter of extended development sessions resulted in a refined design of collections. I somehow also spent almost two months writing a TCL interpreter from the ground up so I could generate bubble diagrams that contain Unicode text.
Getting to market for the Fall of 2015 with version 1.0.1390 involved a great many non-Mathematical tasks: web pages, forums, code obfuscation, capability-based licensing, encrypting the book-reader version of the notes, establishing a store front and more.
Prepping for the 2015 release needed good screen shots, so I added the ability to generate scalable vector graphics (SVG) files from the algebra workspace and the plotter. And that green-board shot on Facebook and Google Play: that’s an SVG screen rendering using Chalkduster font with a green background; all Myron. The SVG support has since been revised and improved. The Chalkduster font is in an experimental part of the UI and will probably never make it to a public release.
Since that first release, I wanted to make Myron work better with Linear Algebra and ended up completely revising the support for collections. I came up with new ways to control the plotter. Along the way, techniques for binding and handoffs for non-scalar types were revisited. However, I came to the realization that I needed to get away from general-purpose data structures and go back to what Mathematicians did. Ultimately, composite types were added in the form of vector and radial types and the rather naive support for complex numbers was morphed into another composite type. And since vectors aren’t very much fun in 2 dimensions, a way to seamlessly leverage the plotter to 3 dimensions was developed.
With all that, here is the documentation for the newest release of Myron, hopefully available in early 2016. It’s based on the 2015 documentation with many revisions and additions and it describes a better Myron, more comprehensive and tighter. Until that release, this document will change frequently.
Will there be another release after that? I think you can count on it. Hopefully before you have worked your way to the present-day limits of Myron, I will have added support for more kinds of math.
In the meantime, please find your way to the Myron forum from the link on www.myronalgebra.com. Ask questions. Post interesting math problems. Make suggestions. Become part of the Myron community.