A Brief Timeline of History*
(*Apologies to Stephen Hawking for this title!)
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
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
- I wrote a program called "MATH" to help me do physics
It used standard algebraic notation with single-letter variables, but
had no equation-solving capability. The user had to supply
versions of the equations, each "solved" for a different
Once enough variables were defined, one of the equations would be used
to automatically calculate the unknown. Since it was really just
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
- MATH was written in BASIC on a TRS-80 Model 100. It had 24k
memory (used for storing AND running programs), a 40x8 LCD display, a
2MHz CPU, 300 baud integrated modem, and cassette tape storage.
Model 100 was the first true laptop computer.
- 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
equation-solving was much like it is today, using a simple, methodical
approach to isolate the unknown. Since it worked symbolically
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
necessary to enter multiple versions of each equation, since SOLVER had
taken over that job. I envisioned using SOLVER to produce
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
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
It would translate your input and create an output file of the
translated equations and expressions. This output file would be
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
program did the reading, parsing, and solving interactively. It
over the name "SOLVER" since the expression calculator was less
deserving of the name. The main prompt's play on words, "So,
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.
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
that feature, all relevant facts needed to solve a given problem had to
be entered every time!
- 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"!
- 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!
- 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
- 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
- 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.
- I bought an Amiga 4000 to go with my 3000. The A4000 had a
25MHz 68040, 6MB RAM, and a 120MB hard drive.
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!
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!
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...
- 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".
- 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
- 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!
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.
- 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.
- 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!
- 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!
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.
- 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!
- 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.
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.
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.
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
- 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.
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.
- 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!
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.
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.
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.
- 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
Figuring out how to load "exactly what
is needed and nothing else" took a couple of months of R&D in graph
theory. I created a (new?) technique for determining (without
using combinatorial searches) exactly what information is truly
relevant from one situation to another:
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
- 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
- This documentation of WPS' Conversational Mode was begun.
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.
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
- 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
- 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
- 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.
- Documentation continued...
- The "list" command was enhanced to allow specifying a list of
- 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.
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.
- 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.
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.
kernel command, "set", was updated to allow viewing a single option by
specifying its name as the sole parameter to the command.
- 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
- The comma was added as a group separator for numbers in some
- 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!
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
- 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.
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.
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.
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
- 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
- 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
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 difference between this
simplification and the above (even though the effect is the same) is
that reducing to lowest terms does not require that one factor divide
evenly into the other... The program tries to mimic how people
recognize and simplify fractions by finding those that divide evenly
before finding those that reduce using a different factor.
- 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").
The potentially-ambiguous terms
(biweekly, bimonthly, biyearly, and biannually) are interpreted
according to their strict definition: "for two". For "twice
each", the program recognizes the official terms "semiweekly",
"semimonthly", "semiannually", and "semiyearly".
- 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.
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
- 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.
This enhancement can streamline the
flow of "canned" calculation scripts by skipping prompts for variables
that have already been derived from previous inputs.
- The number and quality of predefined scripts was greatly
automate many common tasks for everyday use, for unit conversion, and
for topics in elementary algebra, geometry, statistics, physics, and
The new scripts take advantage of the
"input" command enhancement to minimize the amount of user input
- The breadth and depth of the knowledgebase and vocabulary was
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
creative marketing! With that in mind, a (part-creative and
part-automated) brainstorming exercise lead to changing the name from
"WPS" to "AutoMATHic".
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".
That "unnatural" ordering (used by the program's "standard form") helps with simplification, but detracted
from the overall look of some expressions. This enhancement makes
final expressions look more natural and readable.
- 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!