A Brief Timeline of History*

The following is a rough timeline of the history and evolution of AutoMathic.  It can be read on its own, but some references to program features may not make sense without some understanding of what AutoMathic is and what it can do.

The timeline also shows how computer technology has changed...  Technological advancements made my vision of AutoMathic attainable, but also changed my vision of what AutoMathic could be.

Ever since the first portable computers, I've been interested in small computers that you could have with you all the time.  I've followed their development closely because they fit my vision of having a computer be a personal, portable extension of your mental capacity.

The PDA and its descendants, with their extreme portability and ever-increasing capability, seem to be the best expression of where AutoMathic should belong.  Once handheld devices are capable of real speech-recognition (not just voice-navigation), a milestone in AutoMathic's evolution will be reached.  In the timeline, bullets six and seven for the year 2000 have a glimpse of AutoMathic's hopeful future!

Timeline

1986

• I wrote a program called "MATH" to help me do physics homework.  It used standard algebraic notation with single-letter variables, but had no equation-solving capability.  The user had to supply multiple versions of the equations, each "solved" for a different variable.  Once enough variables were defined, one of the equations would be used to automatically calculate the unknown.  Since it was really just a fancy "expression calculator", it supported a wide range of operations like exponentiation, roots, sums, products, numeric differentiation, numeric integration, etc.
• MATH was inspired by programs such as MathCAD and Mathematica which, unlike spreadsheets, were not limited to rigid, fixed calculations.
• MATH was written in BASIC on a TRS-80 Model 100.  It had 24k of memory (used for storing AND running programs), a 40x8 LCD display, a 2MHz CPU, 300 baud integrated modem, and cassette tape storage.  The Model 100 was the first true laptop computer.

1987

• I added simple symbolic equation-solving capability to MATH, but took out higher math functions due to the difficulty of handling and tracking multiple solutions.  The new program was named "SOLVER".  The equation-solving was much like it is today, using a simple, methodical approach to isolate the unknown.  Since it worked symbolically instead of using numerical techniques, each step of the process could be (and was) shown in the same "1d" format that was used to enter equations.
• SOLVER was essentially a limited expression calculator that could do some of the equation-solving work for you.  It was no longer always necessary to enter multiple versions of each equation, since SOLVER had taken over that job.  I envisioned using SOLVER to produce printouts of homework problems that would be readable enough to be turned-in!
• Most of the core equation-handling commands (list, clear, remove, solve, substitute, load, and save) were present at this time, so the program worked much like the current "Kernel Mode".
• I had done some work on Term-Rewrite Systems (TRS), and noticed that the stylized language of many word problems made them easily translated into equations.  I used my TRS to create rewrite rules that converted simple mathematical sentences into equations.
• Early versions of a full translator were a separate program (driven by my term-rewrite engine) that could translate simple statements like "area is length times width" into "a=lw".  The term-rewrite engine was controlled by a file that defined the translation rules; this file evolved into "idioms.dat" and "words.dat".  You ran the translator program and entered statements.  It would translate your input and create an output file of the translated equations and expressions.  This output file would be loaded and used by the SOLVER program...  It was clumsy, but it worked!
• The first version of what could be called WPS combined the translator with the equation-handling core of SOLVER.  The integrated program did the reading, parsing, and solving interactively.  It took over the name "SOLVER" since the expression calculator was less deserving of the name.  The main prompt's play on words, "So, what's your problem?", has been used since this first version!
• I added the ability to automatically import sentences read from a keyword-indexed file of "facts" of common mathematical knowledge.  If an entered noun phrase matched an indexed keyword, any related, stored facts (themselves, English sentences) would be added to the user's input until no more related information was found.  Prior to adding that feature, all relevant facts needed to solve a given problem had to be entered every time!

1988

• By this point, the program was essentially what it is now (minus many amenities and with MUCH smaller language and data files).
• I remember showing SOLVER to my mother (using a particularly complex word problem) but she was not overly impressed because, to a non-expert, it's common-knowledge that "computers can do math"!

1989

• That year, the Poqet PC was released.  It was a one-pound, DOS 3.3 handheld PC-XT with 512kb RAM, a 7MHz 8088 processor, CGA LCD display, two Type I PCMCIA card slots (the first device to use the new standard), and powered by a pair of AA batteries!  I imagined having that "palmtop" PC with me all the time and running SOLVER on it... Unfortunately, it cost $2000 and I was still a poor college student!

1990

• I printed out the SOLVER program and for the first time saw the code outside the confines of the Model 100's cramped, 40x8 screen...  The whole program was just seven pages of densely-packed code!

1991

• The HP 95lx was released and was almost an alternative to the still-expensive Poqet PC.  Unfortunately, it had compatibility problems with many PC applications because it did not have a standard screen resolution.

1992

• Between 1990 and 1992, several handhelds with features similar to the Poqet PC were released.  By then, the Poqet PC was down to $1000, and its clones were about $700.

1993

• I bought an Amiga 4000 to go with my 3000.  The A4000 had a 25MHz 68040, 6MB RAM, and a 120MB hard drive.
• In a two-week programming marathon (many of which were all-nighters), I rewrote SOLVER in C on the A4000 with the SAS C Compiler.  With the rewrite, it got a new name: Word Problem Solver (WPS).  Although it was primarily a direct rewrite, I eliminated most of the limitations of BASIC, and the program ran faster than you can read the output!  The source code still has some comments which are line numbers from the last BASIC version.
• I compiled WPS using VAX C, and saw it run on a powerful machine!
• I got a demo version of a C Compiler for the Macintosh (which I ran on my Amiga's Emplant Macintosh emulator) and compiled WPS for the Mac!
• Apple released the Newton and coined the phrase "Personal Digital Assistant".  It had a 20MHz ARM RISC processor, 6MB RAM, a Type II PCMCIA slot, and natural handwriting recognition, powered by 4 AAA batteries.  I imagined arming the Newton with WPS and having a kind of smart notepad where you would write your problem on the screen and the Newton would solve it!
• I bought a Newton, but rewriting WPS in its NewtonScript development language was not appealing...  A BASIC version of the program was theoretically doable using the expensive NS BASIC interpreter, but a faithful, C-to-BASIC conversion was not realistic by this point...

1994

• The HP 200lx was released, and was a truly pocketable DOS 5.0-based handheld PC with a 7MHz 80186 processor, 2MB RAM, and a Type II PCMCIA slot, powered by 2 AA batteries.  I held off buying one because the Newton was technologically superior, and I hadn't completely given up on running WPS on it.
• I created a handful of equation files for the Kernel Mode of WPS.  One group consisted of files for converting between related types of units (length, time, weight, etc.).  To do a unit problem, one would "load" the appropriate file(s) and assign values to the known unit(s).  The values of the related units were automatically calculated.  To solve problems involving compound units, multiple files would be loaded.  For example, "speed" problems would "load length_units" and "load time_units".

1995

• Six years after its release, the Poqet PC was being liquidated at the unbelievable price of $200, a tenth of its original cost!  I immediately bought one and started work on getting WPS on it...
• The PoqetPC had GWBASIC built-in and I got the last BASIC version of SOLVER running on it after a few minor compatibility changes.  Six years of patience finally paid off!
• I used the free C compiler, PCC, to compile WPS for the Poqet PC (after converting the ANSI C source to K&R C, and fleshing out PCC's standard library).  I finally had the real WPS running on a handheld computer...  but it wasn't the Newton.

1996

• WPS eventually outgrew the memory limitations of the PCC compiler, so I bought a copy of Borland Turbo C++ 3.0.  It was one of the few C compilers that still generated 8086 code, which was needed to run on the Poqet PC.  With a "real" C compiler for the PC, I maintained a single codebase for WPS that compiled on the Amiga, MAC, VAX, and PC.
• The first Windows CE handhelds were released with the promise of being powerful PDAs.  With 40MHz, 32-bit processors and 4MB of RAM, they had sufficient power.  Unfortunately, they didn't use x86-compatible CPUs, and could not run DOS applications.  WPS would require a rewrite and recompile to move it to those devices.

1997

• The Toshiba Libretto caught my eye as a powerful replacement for the Poqet PC.  As a true handheld Pentium PC with a color display, hard drive, etc. it could run Windows 95 (or any other desktop OS).  But, just like the early days of the Poqet PC, it was too expensive for my budget!

1998

• After a few half-hearted attempts at figuring out how to add pretty-printed, two-dimensional output to WPS, I forced myself to sit down, think the problem through, and "just do it"!  When my wife saw the program's new output, she recognized that it was doing real algebra (just like people do) and not using "computer math" tricks!
• Since the step-by-step algebra was a lot more understandable with 2D output, it made sense to add (optional) explanations describing each step.  I added the "detail" command with "low", "medium", and "high" options at that time.
• Sources of inspiration for WPS were PBS educational TV shows named "The Mechanical Universe", and "Project Mathematics!".  The shows brought concepts from math and physics to life by using computer animation to show the manipulation of equations, and animate diagrams as formulas or variables changed.  That level of interaction and graphics was out of reach, but the shows made me want to make WPS even more interactive and educational.

1999

• The long-standing inability to truly use units in Conversational Mode was "fixed" with a kludge that required some special keywords and syntax for specifying units.  WPS still works this way, but the current keywords, syntax, and dictionary allow much more natural phrasing.
• Decent voice recognition was becoming possible for average desktop PCs, and I imagined how great it would be to speak a word problem to WPS!  I tried a friend's copy of Dragon Dictate, and used cut-n-paste to send recognized speech to WPS...  It was clumsy, but it worked!

2000

• I was still using my Newton, but still hadn't gotten WPS running on it despite the eventual availability of C cross-compilers for it.  Its APIs would require maintaining a radically different version of WPS, and I didn't want to lose the single codebase.
• New PalmOS and Windows CE PDAs made me think about retiring the Newton.  I took a serious look at PalmOS devices from Palm, Handspring, Sony, and TRG.  There was also a variety of Windows CE handhelds with and without keyboards.  The major deciding factors were ease of use and ease of development.
• Rudimentary simplification was finally added by taking advantage of the parse trees used for the 2D output.  Basic simplification opportunities were found by looking through the parse tree for certain patterns, then manipulating the parse tree directly to get the simplified form.
• Once simplification was added as an automatic feature, I removed almost all of the (minimal) ad-hoc simplification that was being done elsewhere in the program, just to let the simplifier automatically handle (and optionally explain) it!  I also added the "verbose" and "explicit" detail options to allow viewing the simplification steps and their explanations.
• One "problem" with WPS' use of the library was that it was greedy when importing information:  It would load EVERYTHING related to everything that was entered, then immediately load everything related to that, and so on...  The result was that much more work than necessary was done in solving any problem that referenced the library.  I implemented a better strategy that loaded one "level" of related information, then tried direct solutions before loading another level...  Now, as soon as enough information had been loaded to solve the problem using direct methods, the loading would stop.  For some types of problems, a lot of (but not all) extraneous information was avoided.

• IBM released its ViaVoice voice recognition program as a free download for the Linux operating system.  I installed it on my 400MHz PC and used an open-source program, Xvoice, to send the recognized speech directly to a terminal window running WPS.  The recognition was not always perfect, but I could actually speak word problems to WPS and have it solve them!  Text-to-speech output was also possible, but untried, since most of WPS' output was not designed to be read aloud.
• ViaVoice for Linux and my successful experiment made having a Libretto even more tempting...  The Libretto could run Linux, making it at least theoretically possible to speak word problems into a handheld device and have it solve them!

• I contemplated rewriting WPS in Java so that anything with a Java Virtual Machine could run it.  This would make WPS available on a much wider variety of systems, including anything with a standard web browser.  It was not done, primarily because most handhelds were NOT be able to run Java!
• The Kernel Mode of WPS was documented.

2001

• After deciding I could not give up Newton-style, natural handwriting recognition, I decided on the PocketPC platform in general, and the Compaq iPAQ in particular.  With a 206MHz StrongARM processor, 32MB of RAM, and a 12-bit color display, this PDA was as powerful as the desktops of only a few years before!
• Using the PocketDOS PC-emulator for the PocketPC, I ran the PC version of WPS on my iPAQ.  This was definitely the most portable version of WPS ever, but execution was slow because of 8088 emulation, input was slow through its virtual keyboard, and it would not accept the PocketPC's built-in handwriting recognition.
• Using Microsoft's free Embedded Visual C++, I ported WPS to the PocketPC and gave it a simple GUI.  This version allowed natural handwriting recognition, finally realizing the vision I had for the Newton back in 1993.  Other than the additional code for the GUI, only minimal code changes were required, so maintaining a separate codebase was/is easy.
• WPS extended its use of fuzzy-matching to include determining if things mentioned in the problem match things mentioned in the library.  This optional feature is controlled with the "b_fuzzy_facts" setting.
• Fuzzy matching in the library resulted in WPS repeatedly asking if one thing meant another...  WPS got a FAQ file (faq.dat) that it checks to see if the question has ever been asked before, and it uses the file's answer automatically instead of pestering the user.  If the "b_learn_mode" option is "1", the FAQ file will be updated with the user's answer whenever WPS asks for a ruling.
• Ever since the library was added, WPS would ask the user's permission before consulting the library.  That way, if the user knew that there was already enough information to solve the problem, WPS would not waste time or effort checking the library; WPS could proceed directly to indirect methods.  The "b_auto_consult" option controls whether WPS will ask the user or automatically check the library.

2002

• Although the incremental loading of facts from the library was sometimes better than the original, "kitchen-sink" method, many problems still brought in much more information than necessary.  In fact, any problem that had to resort to indirect methods would load anything remotely related before trying an indirect solution.  Indirect methods are used as a last resort, and WPS could not know if a direct solution might be found by loading "just one more" level of related information!

Now, WPS' library has precomputed path and cluster information that captures the graph-like nature of its stored knowledge: Variables are nodes, and equations form links.  A lower-triangular matrix stores the shortest path between every pair of variables that belong to a connected graph.  An entire set of connected variables forms a graph representing related topics.  The entire set of connected graphs is the knowledge.   WPS produces near-optimal solutions by loading the minimal set of equations that form a "path" linking all active variables that can be linked.  This strategy minimizes the amount of external information to the equations needed to form whatever relationships can be formed.

• For most problems that require indirect solutions, WPS' cautious heuristics can find a variable to which to give a hypothetical value.  A few problems require a less-cautious selection, so the "b_assume_any" option lets WPS give a hypothetical value to any unknown variable that is alone in a denominator.  These variables are usually the object of a preposition, or a simple unit following a quantity.

2003

• This documentation of WPS' Conversational Mode was begun.
• The fuzzy matching algorithm was rewritten to use a left-to-right, longest matching substring algorithm.  If strings with multiple words are to be matched, the algorithm eliminates matched substrings and re-compares.  This allows multiple words or phrases to be matched regardless of differences in word order.  For single words, a recursive, ordered match is performed to measure similarity.
• The simplifier was given the ability to cancel identical-looking additive inverses that occur at the top level of expressions and equations (e.g. "n+7=5/100n+n" becomes "7=5n/100").  A more general approach (requiring the same effort applied to every subtree of the parse-tree) is possible, but computationally expensive.  A completely general approach would also require converting all terms to a canonical form for comparison...
• During an internet search, I stumbled upon a commercial product by CyberEd, Inc. named "Algebra Word Problem Solver"!  This is the first non-research product I've seen which attempts to do what my WPS does.  There are numerous research projects (e.g.  Daniel Bobrow's "Student" program from the late 1960's, and the ISAAC program which specializes in solving physics word problems), but this is evidently the only commercial product.  They believe theirs is the only such product and invite any information to the contrary...
• The kernel command, "set", was added to allow setting all configurable options at run-time.  Also, the program's initialization process was changed from reading a special, comma-delimited "config" file to executing a normal WPS "config" script (which uses the new "set" command and/or any other valid kernel commands).
• After discovering that the parser correctly handles sentences based on the verb "to do", it was obvious how to expand the vocabulary to handle many other common, generic verbs.  Constructions based on verbs other than "to be" make it possible to use active-voice sentences with WPS.
• The output for the save, list, and info commands was enhanced to show what each variable stands for when those commands are used in kernel-escapes from Conversational Mode.
• The program was given the ability to save its workspace to a save file (named "abort.eqn") whenever an unrecoverable error occurs.  This allows at least some recoverability of work that might have otherwise been lost.

2004

• Documentation continued...

2005

• The "list" command was enhanced to allow specifying a list of variables.
• Several new simplifications were added to the simplifier.
• The "append" option was added to the "openlog" command to allow non-destructive logging capability.
• The "load" command (and related usage) was changed to be silent by default unless the new "verbose" keyword is used.
• The "formulas" keyword was changed to "equations" in the "list" and "save" commands.
• Some hardcoded shortcuts were removed from the equation-solving code that maneuvers sides and isolates the variable, allowing the simplifier to automatically handle them.
• While reading a computer magazine, I saw a review of an impressive (tablet) PC program called MathJournal by xThink Corp. (www.xthink.com).  MathJournal recognizes handwritten equations, expressions, tables, etc. to solve, plot, and otherwise manipulate them like an intelligent sheet of paper.  It has no natural-language capability, but recognizes and intelligently handles a wide array of handwritten mathematical input.

2006

• The "lock" and "unlock" commands were added to allow preventing changes to some variables while allowing others to be set and unset according to the normal evaluation rules.  Locks can eliminate the need to re-define variables that should keep their values in spite of changes to other, related variables.
• The behaviors of the "clear", "list", "info", and "save" commands (as well as many behind-the-scenes routines) were updated to handle the ramifications of locked variables.
• The "_" symbol was added to allow Kernel Mode expressions and equations to refer to the most recent answer provided by WPS.
• The kernel command, "set", was updated to allow viewing a single option by specifying its name as the sole parameter to the command.

2007

• Apple announced and released its own smartphone, the iPhone.  Although not a full-featured PDA in the traditional sense, it is by far the most advanced and easy-to-use smartphone and convergence device ever.  Beneath its slick, touch-oriented interface is a version of OS X, with frameworks familiar to any Mac developer.  As a distant cousin to the Newton, and the epitome of the "always-with-you" handheld, the iPhone seemed to be a natural platform for running WPS!
• The comma was allowed as a group separator for numbers in all input.
• The comma was added as a group separator for numbers in some output.    

2008

• Apple released its official SDK for the iPhone, making native software development in Objective C on Intel-based Macintoshes available for free!  Developers could give away or sell their applications through Apple's App Store, with Apple giving 70% of all earnings directly to the developer!  Unfortunately, I had no working knowledge of Objective C, Mac frameworks, or an Intel-based Mac!
• In an unbelievable stroke of luck, I won an Intel-based 20" iMac at a tradeshow giveaway (and almost won an iPhone too in a later contest where I used WPS to calculate the answer to a tedious, non-deterministic rate problem)!

With the iMac, I registered as an Apple developer and installed the free SDK.  Using the SDK's iPhone simulator, I created a simple "Hello World" application and began the long process of learning Objective C, Cocoa, and other Macintosh/iPhone development frameworks.

• Apple released a new version of the iPhone, adding full GPS and 3G network capability.  To me, this made the iPhone a "must have" item for its capability and sheer potential for WPS.
• The simplifier was given the ability to cancel identical-looking additive inverses that occur at ANY level of expressions and equations (e.g. "1/(x+2+x-x+x)" becomes "1/(2+x+x)").  This uses the more generalized approach deemed too expensive in 2003, but not the completely general approach requiring canonical forms.
• Using the same mechanism, the simplifier was given the ability to combine identical-looking terms that appear at ANY level of expressions and equations (e.g. "1/(x+x-2+x)" becomes "1/(3x-2)").  This also uses a "visual" approach rather than canonical forms.
• The simplifier was enhanced to recognize and report instances of division by zero.  Previously, division by zero was only reported during numeric expression evaluation.  As elsewhere, it is left to the user to manually resolve inconsistent or indeterminate results as appropriate for the situation.
• The simplifier was enhanced to convert terms and subexpressions at all levels into a "standard form" (i.e. factors in terms are sorted, and terms in expressions are sorted).  Converting to a standard form gives the simplifier more opportunities to use its "visual" approach to simplify equations and expressions.  For example, "(x+1)/(1+x)" reduces to "1", and "xy-yx" reduces to "0".

A "standard form" is not as powerful as a true "canonical form", but it has been shown that there is no way to reduce arbitrary expressions to some universal canonical form.

• The simplifier was enhanced to perform arithmetic on numeric factors and numeric terms to reduce the number of numeric constants that appear.  WPS' standard form pulls numeric factors to the front of terms, and numeric terms to the front of expressions (with integers in front of floating-point numbers)...  Arithmetic on leading numeric items is performed when they can be combined in "natural" ways (i.e. involving integer results) while preserving complex constants.
• The "input" command was enhanced to process the user-defined equation as a whole instead of just numerically evaluating the right-hand-side to assign a specific variable value.  This allows the "input" command to process completely arbitrary equations, possibly even containing the input variable on the right-hand-side.
• I got an iPhone 3G for Christmas and began work to port WPS to it.

2009

• Stephen Wolfram (Wolfram Research, Mathematica, "A New Kind of Science", etc.) announces and launches the "Wolfram Alpha" web service.  Wolfram describes Alpha as a "computational knowledge engine", designed make the world's knowledge computable, and to compute the answer to nearly any quantitative question posed in a simplified, free-form language!  Alpha combines Mathematica, scientific/mathematical methods/models/algorithms, terabytes of "curated" data sources, and heuristic/algorithmic language parsing to achieve its goals.  The breadth and depth of this project is unprecedented and ambitious, even for Wolfram.
• The simplifier was enhanced to simplify division by a negative term.
• The vocabulary was experimentally enhanced to support some "syntactic sugar" to allow the "unit <unit>" construction to be expressed as "[<unit>]".  For example, "How many unit kph is 55 unit mph" could be abbreviated to "How many [kph] is 55 [mph]".  This simplifies many unit statements, but at the expense of requiring a WPS-specific, non-standard syntax.
• The display of numeric answers was enhanced to show improper fractions (e.g. "5 / 3") as mixed fractions (e.g. "1 & 2 / 3") also.
• The simplifier was enhanced to cancel integer factors in fractions that divide evenly (e.g. "6x/(3y)" reduces to "2x/y", "5x/(15y)" reduces to "x/(3y)").
• The simplifier was enhanced to reduce fractions with integer factors to lowest terms (e.g. "15y/(10x)" reduces to "3y/(2x)").

• The vocabulary was experimentally enhanced to support the use of time-frequency words such as "hourly", "daily", "weekly", "monthly", "yearly", etc.  These words MUST be used as suffixes (e.g. "cost monthly", or "2 daily"), NOT prefixes (e.g. "monthly cost").

2010

• On January 26, installed WPS on my iPhone for the first time!  This was a feature-complete version suitable for real-world testing outside the confines of the SDK's iPhone simulator.
• On the same day, Apple unveils the iPad, which could be described as a supersized iPod Touch with enhanced versions of all the built-in apps.  It runs all iPhone/iPod Touch applications unmodified (at their original size, or with pixel-doubling to use the full screen).  With the larger screen, larger on-screen keyboard, keyboard dock accessory, etc., the iPad should be an excellent (additional) platform for WPS!

With the iPad, Apple releases an updated version of the SDK so that developers can make or update apps to be iPad-specific.

• Enhanced the "input" command to include the optional parameter, "optional".  The keyword can be used to prevent prompting for a variable that already has a value.  If used, only an undefined variable would elicit a prompt...  Defined variables would silently skip the command.

• The number and quality of predefined scripts was greatly increased to automate many common tasks for everyday use, for unit conversion, and for topics in elementary algebra, geometry, statistics, physics, and chemistry.

• The breadth and depth of the knowledgebase and vocabulary was greatly enhanced to include many concepts of first-year physics and chemistry, making the program capable of solving some very complex problems at a very high level of abstraction.
• Publishing an application to Apple's App Store can be an exercise in creative marketing!  With that in mind, a (part-creative and part-automated) brainstorming exercise lead to changing the name from "WPS" to "AutoMATHic".
• With nearly all of the app's functionality and content finally complete, the html-based documentation was reworked to cover the new features and be better suited for mobile consumption.
• On June 7, Apple unveils the iPhone 4 and the latest version of the operating system, "iOS 4".  iPhone 4 has twice the horizontal and vertical resolution of previous models (but re-renders compliant apps automatically), and the new OS allows multitasking for third-party apps (with simple "suspend-and-resume" supported with just a recompile).  Since iOS 4 will be a free upgrade for all supported devices, its adoption rate should be extremely high.
  
• Tested the program on the new SDK's iPad and iPhone 4 simulators, and worked-out some minor compatibility problems with both devices.
  
• Tested the program on a borrowed iPad to see how it feels on the larger screen and how it really looks with the iPad's pixel-doubling.  Minor changes were made to convert AutoMathic into a "universal app", able to run on all devices and take advantage of each platform's screen size and resolution.
  
• Enhanced the equation-solving process to reorder negative addends into a more traditional ordering as a final step...  For example, this makes the final result of a solution look like "c=f-273" instead of the less-natural "c=-273+f".

• On August 2, "www.automathic.info" went live on the internet, introducing the product to the world!

• Submitted version 1.0 of AutoMathic to the App Store on August 8.
• AutoMathic 1.0 was approved and went live on the App Store on August 17!

• Release Notes