Fuller Vision for CABOOSE [ Nicknamed : SunCatcher @ IBM ] - An Iced Berg

Team. With the start of a new work-role as a full-time college instructor within the past six months, time has not permitted much of an opportunity for pursuing this project and other irons which are roasting in the furnace. In a sense, they are all resting on the back burner until this graying professor is not occasionally treading water in his daily tasks but regularly doing a leisurely backstroke, butterfly, freestyle, or free flowing combination thereof.

Yet, as a point of reference, he decided that he would record a more complete version of the vision for controller application bundles for object-orientation. Which he pitched IBM under the moniker of SunCatcher.

SunCatcher rest upon the following principles:

• Development is cognitively simpler with the use of a general-purpose controller (GPC).
• GPCs provide for better concern partitioning and organization.
• GPCs are applicable in the normal case of software creation.
• GPCs are applicable with other standard forms of concern partitioning, including traditional structured programming techniques and those which are more modern such as object- and aspect-orientation.
• GPCs are enhanced through the use of templates stored in a view model.
• GPCs should be supported with an architectural control language (ACL) file which describes the flow of information between the data model and presentation view. 
• GPCs flourish when used on "universal" language platforms seeing that this enhances portability through inherited language traits.
• GPCs fall in the category of a language translation tool in light of the ACL.
• GPCs are a overlooked "missing link" in computing that are conceptually simpler yet more advanced, flexible, and powerful than compilers and interpreters.
• GPCs can be resident in any unit of software architecture.
• GPCs are idempotent; in other words, a GPC composed with a GPC is also a GPC.
• GPCs were originally envisioned at the outset of the birth of an architectural view of software in the Spring of 1989.
• GPCs would have changed the last thirty-plus years of software development methodologies had they and their visionary not been intentionally suppressed.
• GPCs are simple enough that an elementary school student could build a worthwhile system with impressive features using them.
• GPCs follow this simple adage, "a place for everything and everything in its place."
• GPCs work well in WYSWYG environments.
• And, that is the hummock of this iceberg.

The bummock is all that one's mind can imagine and all that one's thoughts can build in the deep vortexes and eddies of one's mind.

Another CABOOSE Controller Feature - Code Generation Again

Team. Just a "short" note. While considering the future direction of this project, it was realized that a set of "rational rose-like" method stubs could be generated from the description of the middle-ware logic found in the architectural control language (ACL) file, "directory.scsv". 

This might expedite "standing-up" an web application. This would be the second-case of "simple-minded" code generation used in this software pattern for a general-purpose controller. It most likely also would be facilitated with a "batch script" generating an initial instant of the "cab.py" file in the case of a Python implementation.

Our goal was producing instances of this controller in the "fourteen" chosen web languages; however, it is most probably the case that we will fully "flesh-out" the CABOOSE pattern in Python and then render it in the other languages such as PERL, PHP, C#, C, JAVA, Node.js, TypeScript, Clojure, Ruby, Groovy, and etcetera.

Goofy Orientation

Team. Could you please help me find the right and left sides of the screen? Is the LHS and RHS, left-hand side and right-hand side, of a production in a context-free grammar inverted. In other words, what are the left and right sides of:

public static String aSimpleStringLiteral = "More backward than Aksarben."';

Could this be corrected? Or, is it the case that computing genius baffles "common sense".

When you "left-align" a paragraph in Microsoft Word or another online editor, what side of the page and screen does it align with? Are you saying, "Flush? On what side? Is that right-alignment?"

Just a reminder. Always keep this straight and remember that bolts tighten when they are turnt clockwise and loosen when they are turnt counter-clockwise. Common-sense is a nascent gift; but, it can be lost in this backwards world. Right? Or, is that Left?

And, if you think that it does not matter. Try this "natural" orientation for a year. And, see if life looks different.

Please Forgive the Rhetorical Nature of this Passage,

The Author Resolving Confusion. 

Free E-Book | A Synopsis of Programming Fundamentals

 Team. Last week the author of this weblog drafted a short book covering some the concepts in computing which he has learnt within the past three decades of learning. He has a couple of post-baccalaureates in science and engineering. One is in computer science; the other is in engineering. And, the text does contain some religious content and references from the perspective of a Protestant Christian. So, if one would not find such offensive reading while seeing another man's perspective on computing, enjoy the reading. It is a "free" (*.pdf) that you can share with your friends.

Remember Hunt, Peck, and Think. It is the "Best" Programming Approach.

The Nature of the Controller - Idempotency - Apache CABOOSE

Team. It is the case that the term "program", of which a controller is a subclass, has many synonyms. Some of those are module, routine, operation, and function. It is the case that functions have many forms. We call one of these types idempotent. This class of function remains unchanged in behavior when it is composed with itself. For instance the identity function, f(x) = x shows idempotency when it is composed with itself. 

if f(x) = x, show f(f(x)) = x.

f(f(x)) is f(x) by substitution of f(x) = x.

f(x) is x, by the antecedent.

So, f(f(x)) is x, by transitivity.

In general, f(f(...f(x)...)) = x. So, one might compose an idempotent function with itself an arbitrary number of times, and its results will be the same.

So, if a controller is described by a relationship, C(I) = O, where I and O are vectors of zero of more inputs and outputs, respectively, one can take advantage of its idempotence. If one combines this pattern for a general-purpose controller, CABOOSE, with a traditional web-server which is a special-purpose controller, he might produce a "structured" web server. Such a primary process would interact with a bipartite model of page templates and behaviors. And, one might use representational state transfer (REST)-style resource locator for interacting with the controller. The "caboose,py" executable would be invoked implicitly and not be part of the locator string which would list the requested view followed by the input vector.

This is the power of idempotency.

 

The Big WORM | Write-Once Run Many

Team. With the "advent" of JAVA technology plus the modern generation of "universal" virtual-machine languages and platforms during the early-1990s, the acronym "WORM" became a common computerese "buzz-word". "WORM" is a statement of one of the most obvious principles of the modern software industry and computing. 

When a software engineering team at a Microsoft or an Oracle creates a new product, they build a logical model of a real world process. This logical model is "ephemeral"; and, it is eventually rendered in the physical form of "high" and "low" electronic signals on a secondary storage device. Yet, once person-hours are spent producing the first verified and validated instance of the software, replicating it becomes rather easy. This is the first of a pair of "bi-stable" concepts in the philosophy of WORM as used in JAVA parlance. The second is the most commonly spoken concept associated with "universal" virtual machine use. One can "write" a singular instance of a program in a modern high-level language like JAVA, compile it producing a object file, and "run" duplicates of that object on numerous computing nodes, wherever the appropriate "virtual" machine is available.

So, WORM is a notion closely and intricately linked with the language translation process, compilation and interpretation. And, in a sense it is a byproduct of the "bootstrapping" of modern compilers which occurred decades ago. One compiler was produced in a "base" language that permitted the production of new language translation tools for "new" languages from that "first" compiler produced in that "primitive" computing dialect.

And, it is unthinkable in this modern era that one should "write" a compiler each time that one is need in a software development process. Such would be costly and error-prone. The use of "well-designed", "formally-verified and -validated" compilers ensures uniformity among the object files produced and helps guarantee the reliability and robustness of these files when they are generated from a "correct" source file. In other words, a language translation tool was written once and checked for fidelity. Then, it was widely used.

Contrast this with the modern era of web-development which sprouted up in the mid-1990s. The generation of software development has yet fully blossomed. Much of the "core" functionality found in common gateway processes was frequently rewritten for each instance of a web-process needed. This counters a few fundamental principles of  programming learnt by many college freshman and high school students studying computing. That "basic" rules is this, "If one writes a module once and well, he can place it in a single place within his system and reuse it often. This promotes the concept of a singular place of modification. Which enhances testability and product maintenance tasks." 

So, why rewrite the same behavioral characteristics found within the "process" control mechanism commonly used throughout web development?

Hence, the modern era of "pre-written" controllers surfaced in the late-1990s with products like Struts and Spring for the JAVA Enterprise Edition and, in recent years, Laravel for PHP. Also, Microsoft and Oracle at a couple of large software corporation that offer a standard, reusable Model-View-Controller product.

Yet, these avatars of control are found in every software product, including those "hokey toy" examples written for introductory programming fundamental courses. They are found among the "old" text-based, menu-driven systems that were commonplace from the late-1970s, throughout the 1980s, and in the early-1990s. They are found among JAVA's Swing and FX applications plus those created with packages like Tkinter found in Python and other graphical user interface (GUI) libraries.

Although simplistic, this model of development, that uses storyboard templates which represent a description of the output views and a module of behaviors that fill-in hotspots on the "stencil" which describes the view in conjunction with a "pre-written" instance of this controller pattern, provides a WORM-like component.

It is extensible through the module of "bespoke" behaviors which supports the "general-purpose" controller and is a pattern which can be used throughout computing without the need for "recreating this wheel" each time. 

Below is our diagram of interactions found among a system which uses the CABOOSE pattern and a general-purpose controller (GPC). This diagram is from the JAVA implementation which does not "currently" include an ICEMODE global with a "IceMode.java" file produced from an "Icy,java" code generator.

In our Python instance, the directory file that contains the architectural control language (ACL) does not use an eXtensible Markup Language (XML) format. Instead, it uses a sectional comma separated values file (SCSV). And, our behaviors are not part of Python classes. They are simply "user-defined" functions. 

And, of course, overseeing it all is Boonie, our mascot!

Although one can spin his own controller in a few person-hours, it is this author's sincere hope that this pattern of development becomes as ubiquitous a modern language translation tools, compiler and interpreters.

It also supports the templating of "client-side" scripts and web components which also might hold replaceable "hotspots".

Python ICE : The Reader's Digest's Version

Team. An instance of the CABOOSE System written in Python can be found on GitHub. It should be said that the version on GitHub has an simple optimization which the code found on Google Drive does not.