Polyglot-Project Plan - [ "Hello, World!" ]

Team. The grandest of romances starts with a simple word, "Hello" or "You have an ant in your hair!". And, the most potent program from which one can build any other is just as simple. It is that canonical first program in every modern freshman computing course, "Hello, World!" It is simple and tests one of the most fundamental processes in computing, producing output. The other pair of primitive processes is accepting input and transforming that data which a program receives when producing worthwhile information for output.

Some of the skills needed for completing the project listed in this web history are not described herein. These include installing and configuring the simple, free integrated development environment, MS Visual Studio Code, for use. We use this product since it supports each of the chosen languages. If this configuration process is a mystery, one must search on-line for instructions at Microsoft or other sites with software development tutorials. Also, one simply can install interpreters or compilers for each of these languages and then use a command shell for running each script or object file.

This source archive contains all of the instances of the simple "Hello, World!" program which we will use as a starting-point for our multilingual "general-purpose" controller project. One can rewrite the scripts as he chooses becoming familiar with this process for using each language in Microsoft Visual Code.

The nine step process for developing the "general-purpose" controller components in various languages is below:

NuevoArchitect - [General-Purpose Controllers] -  07.01.2020

(9-Step) Evolutionary Development Plan for a CABOOSE Server

Step A. Hello World (on a single line)

Step B. Hello World (from a subroutine)

Step C. Hello World (in a text-file from a subroutine with exception handling)

Step D. Hello World (in an html-file from a subroutine with exception handling)

Step E. Directory.scsv (echo from a subroutine with exception handling)

Step F. Directory Dictionaries (built with a subroutine from *.scsv and echo)

Step G. Directory-Driven Hello World (with classes called CABOOSE and SCSV)

Step H. Directory-Driven Storyboard with VUE.js web-components and text-replacements.

Step I. Quality Assurance

Nothing in this project requires any advanced programming skills. The abilities used are acquired by most students who take a course in programming fundamentals as a high school or college student. We will be using the common output command used in the "Hello, World!" program that we created. We also will use subroutines. These can be called modules, functions, procedures, or methods depending upon the language used. Yet, they all perform the same basic tasks. They are subprograms. We will open and read files plus use the exception handling associated with these processes. We will echo and dynamically modify hypertext markup files based upon processing directives in the directory.scsv files. We will interact with a "novel" comma-separated values format that defines segmented sections within it. That is what a "*.scsv" file is, sectioned command separated values. And, we will integrate view components, using VUE.js, with our product showing how flexible and universal it is.

The author should note that the dates on the copyright are set in the future by a couple of weeks. It was initial intended that this project would reach this on-line venue after July 01. 2020. The dates were not rolled backwards. So, we are ahead of schedule. Ironically, the first few posts on this Rosetta Stone weblog were in 2016.

Picking UP An "Old Project"

Team. Over the course of the past few years, the author completed a software project and related book on general-purpose "web-based" controllers for MVC architectures in his spare time. The  development weblog for that project spans three months or more of regular posts. The associated book can be found on Amazon.

His primary work role is that of a college adjunct. He teaches a mixture of courses in information technology that focus on computer literacy and office productivity suites plus programming fundamentals in JAVA and Python. Designing a "simple" Rosetta Stone for modern computing languages has long been a goal of his. Others have taken on this project, but such efforts have historically been provided over-complicated descriptions of "primitive" software structures. It is his goal that he improve upon these attempts.

The experience gained from building a simple "general-purpose" controller (GPC) plus working with the fundamental computing elements found in numerous imperative languages over the past few decades has produced an "opportunity" for a "unique" convergence of his goals and ideas in the form of a "multi-language" development project that produces a GPC framework.

This polyglot-project will produce the equivalent of the JAVA servlet described in his text on "general-purpose" web-scripts, CABOOSE in JAVA. A CAB is a controller application bundle. This is a packaging of functionality that contains supporting methods and entity classes which customize a GPC for use in a particular application. The OOSE simply implies that these controllers are naturally fit for use in object-oriented software engineering. However, at least one of the GPC instances in the current multi-language project will use a non-object-oriented language, straight C.

Our development will be done in Microsoft Visual Code, since it supports the editing, compilation, and execution of many different modern languages. We will be building a component which one can integrate with a common gateway interface (CGI) process or its equivalent. It is our goal that we complete this project in at least JAVA (which has previously been done), PHP, PERL, Python, C#, C, C++, Ruby, Groovy, and other languages.

And, like an ancient builder explaining how one cast a brick from a slurry of limestone, sand, plus papyrus and other plant matter, that can withstand a load sufficient for supporting a Great Pyramid, we will complete our work in more than one "engineering" language. If one would like a "natural" language translation of any of these pages visit Google Translate.

We are picking up this web history after a few years hiatus and heading in a slightly different direction by choosing a "specific" project one which we will work.

Coding Priorites

Team. This Rosetta Stone for popular computing languages is progressing slowly. No, we are not chiseling stones in Al Gore's garage. We simply have other priorities. That is the joy of being a hobbyist. One can pick up and put down projects when comfortable and convenient.

Please, forgive the source examples on STDOUT and STDIN which were promised and have been undelivered. It is not vaporware; it is simply in a very low-priority thread. Also, we are not abandoning this effort.

A few other Rosetta Stones for coding exist online. Most have cryptic code for esoteric processes. Our goal is simple, well-documented, highly-readable, and understandable programming sources.

We will do our best at keeping these as simplistic as we can. Many of the coding samples exist in literature and on the WWW. Some would work well for this effort. Others would not. These simple samples just have not been gathered and placed in one location, yet.

This process which we are undertaking is often described by an egg-headed English word, chrestomathy. In Zhongwen (Chinesse), 讀本, this word has a much simpler and shorter representation. And, from the perspective of a native English-speaker, any word which looks simpler in Chinese than English is likely any over-complicated word describing a process which can easily become overly complexified.

We will work on simplifying the current WWW computer programming language chrestomathy approaches.

Only touching base. The Rosetta Team.

Apologies and Delays

Team. We have been rather busy wrapping up our activities with our CABOOSE project, and we have not generated all of the STDOUT and STDIN code snippets in the primary languages chosen for this code rosetta. We have a plan and goals, but we have experienced some delays. In the meantine, we have been thinking of how we can merge some of these efforts with our Ozark-CABOOSE project and reduce a duplication of coding plus documentation efforts. We appreciate any feedback or code contributions which you might be interested in making. Simply, send feedback@nuevoarchitect.com the commented code snippet. Any compressed archives sent will be discarded for fear of malicious code.

We will pick up activities on our Rosetta, when we can find a few more seconds of free time.

Enjoy your upcoming seasons,

The Rosetta Team.

Simplicity is Key!

Next Steps | STDIN | Pipe And Filter

Rosetta Team. When time allows we will provide examples which use a programs standard input stream (STDIN). Most frequently, STDIN is connected with the console input which comes from your keyboard. So, after mastering the exercises in the previous post which provide a simple example of producing output on STDOUT, we can read from the console and write on it also.

Once we understand these operations of input and out in the languages in this Rosetta, we write a program which reads input and writes output. This allows for gathering data from the user, processing it, and then producing results. One can envision this process as pushing information through a pipe, altering it as it passes through filters within the pipe, and collecting the results as it exits the pipe. This notion of conducting pipes and transformative filters is a common architectural pattern found in the everyday computer programming tasks of software engineering.

Happy Coding. Hunt. Peck. Think. We will supply the STDIN examples soon.

The Value of STDOUT in Web Development

Rosetta Team. This is a short note for those of you not familiar with the fundamentals of web development. The previous examples which describes printing data on the STDOUT stream that usually appears on the computer's console might seem very simple. One will likely notice that in more than one of the languages that he command for this is simply "print". Although seemingly trivial, this example shows the commonality among many programming languages; however, it shows some unique differences in console printing approaches when one considers the object-oriented languages JAVA and C#. These require the use an object's method when printing instead of a stand-alone procedure.

The true power in the development potency of the previous example on STDOUT is this, it is the primary stream for sending an HTTP (HyperText Transfer Protocol) response. When developing web-scripts such as servlets and CGI (Common Gateway Interfaces), one will simply structure an HTML (HyperText Markup Language) response. This is the content which the client browser will display from the "prints" on the STDOUT stream from the web-script. Subsequently, the web server with is networking software handles sending the browser this HTML content in an the form of an HTTP response. This is the Power of Print!

Keep Learning. Keep Striving. Happy Coding. The Rosetta Team.

Standard Ouput | STDOUT | Files | Hello, Rosetta!

Rosetta Team. Last month, we promised that we would start compiling and chronicle some common programming tasks in various popular modern languages. This week, we are providing the most fundamental program that any computing student has learned. This is the "Hello!" program. The goal of writing a "Hello!" is testing the most basic of computing functions, output. In every computing environment, output streams exits. A program might be supplying output and places it in numerous locations: text files, data bases, the screen, and etc. The most common of these is the screen. Most frequently, the screen is the "standard" location for all program printing commands. As such, this stream of data flow is called standard output and abbreviated as stdout.

It is worth mentioning at this time that stdout is treated like a file although the output appears on the screen. As with text files, one can place information in stdout and redirect another output stream so it fills the stdout file with data. In fact, all of the data sources and sinks on a computing device are treated like files for programming purposes. For the most part, they can all be opened, closed, read, and written.

This week we are supplying a classic "Hello!" program in a few different common modern programming languages: JAVA, C#, The LAMP Trio (PERL, PHP, and Python), plus Ruby.

The Hello, Rosetta! programs require that one has the proper compilers, interpreters, and run-time engines installed on one's computer. Otherwise, they will not function.

JAVA source file
JAVA class file
PHP source file
PERL source file
Python source file
Ruby source file
C# source file

Note: All of these languages are interpreted except for JAVA which is first compiled producing *.class files that are then interpreted by the java run-time engine and C# which produces the Microsoft Common Language Invariant (CLI) or a binary *.exe file depending upon the application.

Most of our JAVA programs will be created in NetBeans or Eclipse. The C# programs will be created with Visual Studio. The PHP, PERL, Python, and Ruby programs will be scripted in a text editor.

This Code Rosetta is not necessarily a programming tutorial, but could be possibly used as such. Its ultimate goal is providing professional engineers with samples of logically equivalent programs in various languages. This will promote polyglot programming and the porting of valuable computing solutions. The first few months of examples should be fundamental and simple.

Happy Coding!