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:
Functions are Bad: 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: 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 Logic Units: A logic unit has knowledge of itself and therefore is part of Jane's namespace of every application: 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: For example: Fonts, Pictures, Videos, Stock Pricing, Hardware, Communication, Your Information, All Binary Files. Conclusion: 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. ![]() |
||