March 2024

One Person's Design:
An application is made from many pieces of logic, all of which are designed for a single purpose. This purpose of logic is created, named, and designed by an individual. We get personal preferences in the design, operation, and structure of every logic unit. This makes it impossible to guess at which one of a multitude of design options was actually implemented.

Another difficulty in our understanding of logic is that most of an application's design is not original. This class of logic includes all of the System Functions, Vendor supplied API's, Compiler's built-in Functions, and Examples. System functions and API functions have an assumed use. Designing from an assumption is never a good idea. Developers, in this case, use the design of others.

A "Logic Example" is meant to demonstrate how to implement logic, never its purpose. Developers use examples as production logic without understanding the complete ramifications of the logic.

The Lost Art of Complexity
Software logic should be complex, but it is not. Developers are tasked with cost, time, and talent limitations when dealing with logic. Most of our complexity is lost due to our compilers, which have very limited text and number conventions. For example text is defined with character case. This alone is a very unnecessary simplification of a complex logic design.

The word "Clif", "clif", "CLIF", "ClIf'" requires case conversion to be searched. If we separate "case" (display characteristic) from the "character" then search logic could include all display characteristics (underline, color, bold, background, fill, ...), and reduce the time and programming issues associated with our current conventions.

The number representation is another simplification of complex logic. The current "Number" logic has been the cause of more software, limitations, compatibility, and security failures than any other of our design decisions. By changing our "number" representation would reduce 90% of all software issues.

I have mentioned just two of our failure in logic design. There are many more (Time and Date, Namespace, Fonts, Partitions, ...) that complicate development and limit the capabilities of every application.

"Simplicity is about subtracting the obvious and adding the meaningful." -- John Maeda

"Good design is obvious. Great design is transparent." -- Joe Sparano

"Documenting a design, is like trying to describe a sunset" -- Clif

"People who think they know everything are a great annoyance to those of us who do." -- Isaac Asimov

"Where there's music there can be no evil" -- Don Quixote

"Perhaps to be too practical is madness." -- Don Quixote

"Little League baseball is a very good thing because it keeps the parents off the streets." -- Yogi Berra

Software Development is Too Complex:
The task of application development far exceeds our ability. The primary reason for application complexity is that our logic is in a language that we cannot understand.

Functions are Bad:
Richard Feynman spoke of his time at Los Alamos (Manhattan Project), in which he describes running card programs on an IBM calculator. The programs were long and complex which took a long time to run and even longer to correct. So young men were hired to run the programs. The new hires soon found that when the card program failed, they could speed up the process by taking out the cards up to the point of failure, add cards with the current values, and running a smaller program. Hence the concept of functions was conceived.

The current implementation of "functions" is a complete failure. Maybe it's not the "function" but rather what a function represent that I have issues with. For a "function" is a change in flow control which benefits the developer but rarely has any benefit to the logic.

Logic Programming:
Our current software development technology has no concept of logic programming. In reality a developer is programming in logic units, but implemented as "functions" that represents a logic unit. Once the source code is complete, the logic unit's design is only known by the developer for a few days. For anyone else the source code represents nothing of the logic's design.

A change in our software development technology to have the ability to program in logic units, would speed up development, and make the source code:

1. Easy to comprehend
2. Easy to modify
3. Easy to share
4. Easy to secure
5. Remove the need for documentation
6. Reduce development time to minutes

Logic Units:
A logic unit is an action request at any level and for any purpose. The technology of a logic unit is such that all information and logic is controlled, understood, and available to the owner of the equipment.

A logic unit has knowledge of itself and therefore is part of Jane's namespace of every application:


html = Oracle.tables.employee.toHTML();

Most if not all applications come down to a few statements that qualify access and query logic units. Logic has information that the user must have access to. Natural language processor is one method to access information and actions, but so are all other methods (forms, scripts, events, ...)

Create compiler using the popup form;

No one method is any better than another, maybe just more familiar or more appropriate for the task at hand. Please let each user decide.

Logic Unit's Knowledge:

 1. Actions (add, change, delete, create, derive)
 2. Hardware Instructions (Assembler)
 3. Source Code (computer languages)
 4. Structures (used, referenced, created)
 5. Logic Subunits
 6. Dates created, modified, enhanced, released
 7. Purpose, Notes, Customers,...
 8. Edits, Authors, Issues
 9. Support Files
10. Build, Backup, Restore, and Install
11. Test cases and expected results
12. see also: "character see also: font"
Unreadable Source Code:
Our source code does not represent logic, rather it represents the actions of logic. Reading source code is like reading leg muscle instructions trying to determine where you are going.

Our computer languages only maintain the information needed to perform hardware actions. Source code statements are grouped into logic actions that the developer can understand. These logic units are called: "Functions", "Subroutines", "Events", "Interrupts", "Messages", "Entry Points", "Blocks", "Loops", "Conditions", and "Cases".

When reading source code, many of the logic units are hidden, difficult to access, in an unfamiliar language, or performed for us by the system without our knowledge.

Natural Language:
One size does not fit all. AI could expand our language syntax capabilities, which might help in the search of information. I do not believe it will be much use for enterprise operations. Custom syntax capabilities will be far more useful. Custom syntax has the same capabilities of natural language except that it controls context far better for individual users. Each organization has its own language, requirements, and responsibilities. Having the ability of every individual to create his/her own language context is critical. This does not take a lot of effort or hardware. Most information and logic come from a named list of persons, places, and things. This information is proprietary to a company and should never give absolute control, of any information, to a third party to monopolize.

For example: Fonts, Pictures, Videos, Stock Pricing, Hardware, Communication, Your Information, All Binary Files.

My vision for software is to give you absolute understanding and control of the hardware, information you create, and the applications that you own. This crap of selling you something then stealing the information you create and running processes on your hardware is my windmill to do battle with.

Like I said ten years ago, software can be reduced from man years to minutes to create.

It is my belief that every country should control, develop, and distribute software (hopefully free) to their citizens. We are being screwed by monopolies. I can only design software, politics is out of my control. Absolute-Trust, Right-to-Use, and Right-to-Repair should be a legal priviledge. You should own the things that you buy and create.

Author: Clif Collins