Delays, Delays, Delays, .... | Once Again

Team. Schoolwork is keeping this college adjunct quite busy. So, the next deliverable might become available around 11.15-30.2020 instead of 10.30.2020. His course load at the on-line university where he teaches has doubled. Plus, he is teaching a couple of "new" courses this term. And, one of these is at a "new" college. "New" courses always has an increased learning curve and require more person-hours. And, "new" work environments always require an adjustments.

The next phase is rather straightforward and many of your likely have completed it already and possibly the entire project. The end is clearly in sight.

For the next phase, we will be parsing the architectural control file and replacing the placeholder in our storyboard template with the name of the appropriate method for replacing its content.

In the final phase, we will invoke that method and replace the placeholder with the string value return from the associated method.

It likely would be wisest if the contents of the architectural control file were parsed and placed in an associative array, dictionary, hash map, or hash table. This would allow for the quick repeated access of associated method names, during the execution of the application. For web-based processing, such a "control" data structure should be placed in a session or application-level variable. As such, time would not be spent reparsing the architectural control language (ACL) file each time a server-side process runs.

These data structures already are available in most of the languages used in this development effort, except for C. And, for the sake of simplicity we likely will not roll our own hash table for this implementation. Most likely, we will simply reparse the file each time that we need a value. This will be highly inefficient, but this is a "proof of concept" prototype.

And, in the "post-final" phase, we might write a switch generator that will read the ACL file and produce a source file with the appropriate hard-coded logic for statically invoking the appropriate methods for the view that we will be returning.

The author's term at a couple of programs ends early, around the week of Thanksgiving in America. This we free up time for working on this project.

Controllers

Team. This project has manifold purpose. In other words, it is worthwhile for many different reasons. First, it is an exercise in "polyglot" programming, in that it provides fourteen functionally-equivalent software products. The author crafts each in a different high-level computer programming language. 

And, this also is a valuable exercise since it creates a general-purpose controller. This architectural software structure is very common and  found explicitly or implicitly in every interactive system. In terms of software engineering theory, it is an archetypal module for all systems that accept input and produce output. It is the locus of the system's logical processing.

For systems that are layered, usually with presentation, middle-ware, and data-entity tiers, the controller is a way of viewing the role of the middle-ware business logic.

This a fundamental structure in software engineering and system development. It is much like a compiler and interpreter. One does not write a "fresh" instance of one of these language tools each time he needs one. Unfortunately, in the "medieval" days of computing, 1970s - 1980s, a vision for the "pre-rolled" component that controlled the logic the logic of any system was not envisioned. So, the common function of the control unit was rewritten each time it was needed. This counters the principles of software reuse and write once run many (WORM).

The field of software architecture was conceived in the Spring of 1989 based upon the author's best recollection. The first conference on the topic was in the Fall of 1989 as modern records show. It was during this Spring that insight and innovation inspired the birth of the basic architectural assemblies of layered and model-view-controller systems. This was one catalyst driving the modern computing renaissance of the mid-1990s with its world-wide web and markup languages for "typesetting". 

With the advance of the discipline of software engineering during the 1990s and early millennium, the community was given various "prefabricated" controller products such as Struts, Spring, and Laravel. Yet, none of these are truly "general-purpose", nor can they as easily integrate functionality as the product under development in these fourteen languages. Plus, Struts and Spring are only compatible with JAVA and Laravel only supports PHP (the personal hypertext processor).

And, one of the most wonderful aspects of the current system implementation of this general-purpose controller is that it is very simple, a small coding effort, and one which you can build yourself and customize as needed.

Foreshadowing future software engineering practices, "general-purpose" controllers supporting dynamic invocation might soon be a standard language component much like compilers and interpreters. 

Oracle and Microsoft each have modern MVC products. The author is familiar with Oracle's Ozark product which provides a "flexible" controller product for use with RESTful web-services. Yet, outside the realm of web transactions, Ozark does not support the dynamic invocation of "user-defined" methods in other instances. At least, this is how the author understands this product. And, Ozark systems cannot be "wired-up" as easily as this "simple" products architectural control language (ACL) file. Ozark systems must have their logical flow described within the JEE controller's source file. In some sense, those logical concerns are tangled up with other source code concerns. It might be the case that this use of an ACL file provides a better partitioning of system concerns.

In short, this structure for architectural controllers might become a "de facto" standard. Primarily, because it is "simple" in design and "straightforward" in its use, much like HTML.

Phase V | Foreshadowing and Falling Action

Team. We have been working with a simple HTML template file and a CABOOSE logic file that are inconsistent and incompatible with each other. 

The architectural language instructions drawn from "directory.scsv" are from the sample website found within the pages of CABOOSE in JAVA, a text which is available on Amazon. Currently, they do not correspond with our single page site. 

Over the next few weeks, we will don our creativity caps and alleviate this problem. Once we have an HTML storyboard with a compatible controller logic file, Phase V will consist of replacing each placeholder in the HTML file with the name of the method or procedure that will eventually supply the appropriate string for that position within the markup file.

We are planning on the construction of a very simple system with a few pages, no more than five. We will settle on a theme over the next few days. It will be a "meaningful" solution that does not require database access. Plan on an October 31 deliverable.

It is envisioned that we will have a single phase after this one, when we utilize the features of dynamic invocation available in each of these language. The tentative deliverable date for that phase is December 31, 2020.

Phase IV Deliverable

 Team. We completed the deliverable for the fourth phase of this project over the weekend. Of the last few implementations, the only one which was troublesome was the one done in Ruby. The output from this language version during the current phase of our general-purpose controller's development is somewhat different than the others in this deliverable. A current archive with work from all of the phases is available on-line.

Hunt, Peck, and Think. The "perfect" solution will come more quickly, if you do.

Phase IV : Progress Report [ 08.31.2020 @ 7:45 A.M. PST ]

 Team. This past weekend saw a couple of four-hour "bird-brained" coding sprints. During this time, the first eight language instances of our general-purpose controller were constructed ( C, C# [.NET], C++, Clojure, Go, Groovy, JAVA[ JME, JSE, & JEE ], and Node.js ). 

The most time consuming was the Clojure instance. It required the fewest instructions; however, the author only has limited experiences with LISP-like languages and has not coded Clojure programs before this effort. The Clojure controller for Phase IV required about 1.5 PH. 

The remaining language instances ( PHP, PERL, Python, Ruby, Rust, and TypeScript ) will be coded this afternoon or during this week or weekend. So, we might provide this deliverable after is initial proposed date of availability, 08.31.2020. It should be here by the American holiday, Labor Day, Monday, September 7, 2020.

Road Running

Team. With the beginning of the university semester comes a flurry of activity. This is compounded by accepting a teaching assignment at a new college. New computing systems, administrative procedures, and a completely new pool of students with its own unique community culture. 

This coincides with the end of a term at the on-line program where the author teaches a programming fundamentals course in Python. Grading must be done and he must prepare for the next term before 08.31.2020. 

These are his deliverable items which coincide with the delivery of the next phase of this project. So, although he is working like a bird brain while coding (hunt-peck-think), he is running at light-speed between coding sessions. It is his goal that he can set aside a focused 16.0 PH for coding up the scripts. And, average of 1.0 PH per code snippet should be sufficient for the nature of the required enhancements for the phase.

In this step we are:

• we are reading the "directory.scsv" file 
• we are removing the blank lines in the file
• we are parsing the individual lines around commas
• we are ignoring lines which start question marks
• we are removing all of the white space around the line's tokens
• we are echoing this content along with the markup template file

In the next phase, we will process this "directory" file based upon the mappings that it describes. This will require the use of an associative array, dictionary, hash table, hash map, or similar structure. And, we will output the HTML markup with the placeholders replaced by the name of the method which will fill in that spot.

The last phase will involve using "dynamic" invocation for providing the proper content for the markup placeholder.

Hopefully, we can elude Wile E. Coyote and his proverbial ACME contraptions of doom which will scuttle our efforts.

Phase Completion - Extension [ 08.31.2020 ] : Course Preparation

Team. The next season of teaching offers four "lecture" courses. This includes a programming fundamentals course in Python for an international on-line distance education program, a couple of remote delivery courses for a local community college, which likely will include an information literacy course, and a freshman computing elective at a local Jesuit university. Over the next few weeks, the author must prepare himself for this upcoming term. A couple of these "specific" courses the author has not taught previously, although he has given many similar lectures. He could enter each class session and "wing it", but that does make for the occasional "poor" performance.

The long and the short of it is this, he must postpone work on the fourth phase of this project. Which is about a 16.0 PH coding effort. It also requires refreshing some "long-forgotten" programming skills in C. Many of the modern languages, such a JAVA, C#, and etc., provide memory management under the hood and automatically allocates space as needed plus comes bundled with many useful data structures.

And, although this effort's goal is providing a "proof of concept" prototype for the CABOOSE controller pattern and not an "optimized", "professional-grade" solution, each language's object file should handle a reasonably-sized input. This includes the one created in C, whose language features for dynamically resizing data structures is "messier" than many other "more modern" languages.

So, we will plan on delivery of this phase by 08.31.2020, and the final multilingual project in fourteen "unique" languages well-before 01.01.2021.

Keep Coding Like a Bird-Brain. Hunt...Peck...Think...And, Let HIM Provide.

[Mat 6:26 KJV] 26 Behold the fowls of the air: for they sow not, neither do they reap, nor gather into barns; yet your heavenly Father feedeth them. Are ye not much better than they?