I have placed a working example of the application
maker on my web site.
This web based application demonstrates the use of
words and word pairs to build applications. I have found that by
removing the use of HTML, and programming languages, I can build
complete applications with just a few words.
I have gone to a system of building "Adam
common knowledge" where things that I know how to do should also be
known to the Adam. I have also started a system of words and
methodology that makes the building of applications easier. I removed
the use of HTML and replaced it with a system of cells upon the screen
where content is displayed. I gave these areas names that can be easily
referenced and defined. Seven main areas; "Header", "Footer", "Body",
"Left Full Bar", "Right Full Bar", "Left Bar", "Right Bar". Each of
these can then be divided into rows and columns, and each of these can
be tabbed and un-tabbed pages.
Any application's layout can be defined in a few
minutes, then content can be added. I have created a few examples of
content robots, "title bar", "status bar", "file editor", "file
navigation" and so on. So each cell on the page can be assigned content
and the application can be built in a few minutes.
I have been able to create full applications
should be able to create any existing application in a few minutes
without the need to code the logic.
In the past we have coded just about every
combination of software possible, there just has been no way make it
accumulative. The Application Maker is my first attempt at using
words to put together logic into an application.
“The beginning of wisdom is the definition of terms.”
"Broadly speaking, short words are best, and the old
words, when short, are best of all."
-- Winston Churchill
“If the word doesn't exist, invent it; but first be sure it doesn't
-- Charles Baudelaire
The end of Software Development:
I have designed a system that is infinite in size,
has no limitations, and requires no software statements. The system is
built on the use of words and word pairs to instruct the Adam to
perform tasks. As each word is added the system becomes more powerful,
so much so that there must be a limit on the language that I build. If
this is so, then there must be a point that no more words need to be
added, and therefore the end of software development.
The system is accumulative, but also as important, is that
it is completely changeable. Words and their uses, can be changed
at any time allowing the system to be flexible. Change can be localized to
a single individual. Here context
sensitive language becomes an integral part of the system, in that it can
understand variations in the use of words by each person.
The system must be allowed to grow over time, to
perfect itself and to never cease to expand. The use of the word
"perfection" and the use of the word "variations" should be understood
here; in that we build language so that we can communicate. The more
stable the language the easier is it to communicate. Variation of a
language does not necessarily make for a better system, but this is a
trial and error period that balances these terms to make a workable
system. The system should not be engineered, but rather grown from
The software development phase is the easy part and
can be built in a few years. The language to communicate with Adams
may take far longer to perfect. So it is this language that must be
flexible until communication is well established.
I am building the system so that any given word's
actions can be altered, added, or removed in just a few seconds. What I
am finding is that as I add more words, the code behind those words is
becoming smaller. Subsystems that were thousands of lines of code are
now less than a page long, or even just a few characters. Instead of
getting bigger, the system is actually getting smaller, fewer lines of
code to perform more complex actions.
Perfection of the software development side of this
system is first for speed and security. Once these objectives are
attained the remaining work will become obvious and constructed by the
use of a word and word phrases. In a system that is accumulative, there
must be a limit on the amount of logic we need, and therefore there must
be a logical end to software development.
Removal of HTML and Computer Languages.
I have removed the direct use of HTML and any Adam language in
the creation of applications. Moving to a natural language programming
environment supports the direct use of words and word pairs to
define Adam execution. As in human communication we give everything
a name, so it seems this will also work in our
communication with Adams.
The Adam is the unconscious mind, and we communicate
general concepts in words, not specific details. We ask it to "Edit
Employee Records", the details need not be specified, this is
common knowledge that I build into the Adam as software robots.
The creation of Adam "common knowledge" is extremely easy
and accumulative. As I build more common knowledge, what seems
difficult now becomes second nature, as more facts become known, the
system becomes more powerful and easier to expand.
Do Not Reuse Code:
A continuing topic for my newsletters. As I move forward toward the
final stage of software development, the elimination of code reuse
is a key factor in the stability of the system.
I have looked hard at code reuse and its impact on testing. The reuse
of code implies multiple uses which has a huge impact on testing. For
any piece of software, absolute testing requires testing of all
permutations of its use.
Assume testing takes one hour per use of the software. We look at
code with two uses it takes two hours, code with three uses however
requires six hours. All permutations of three is 1 * 2 * 3 = 6
hours, four uses is 24 hours, five uses is 120 hours. If we ever get to
25 uses, it would take over 5 million years performing one millions
tests per second to complete.
My current thinking is to strive for one use of the code. This style
of programming matches the concept that words should have a clear