Actionable Data Structures (ADS) in CABOOSE

Team. We have been looking for ways in which we could include an actionable data structure (ADS) in CABOOSE. Considering the current design which has been somewhat organic because we are developing an evolve-able prototype, the primary goals of our use of ADSs should be easy integration with the current code-base, a reduction in the overall number of instructions, increased readability and maintainability, plus a better partitioning of the CABOOSE concerns.  

The Value of an ActionHashMap as a Request Processor
  
Each page concern whose content specification is drawn by a controller application bundle (CAB) represents an entity which is requesting a fulfillment service from the CABOOSE controller. The request is in the form of a unique user-defined identifier such as #PRODUCT_TABLE#. Such a label is a placeholder in an markup template for each concern. This placeholder also doubles as a string replacement variable within its XHTML stencil. In other words, the controller will replace this label with a markup string which provides a specification of the appropriate dynamic content. This content specification is the return value of a given method within a class that provides a bundle of one or more rendering services for the controller. An XML directory file contains a mapping between the user-defined placeholders and its associated rendering methods for each view that the application requests.

So, one can build an ActionHashMap which invokes behavior given a key versus returning only an object. An ActionHashMap can be built for each view based on the XML directory mappings, and when a web application requests that a given #PLACEHOLDER# be drawn with the appropriate markup specification, this placeholder might be used as a key for the ActionHashMap. The resulting object returned by this map's keyed behavior would the markup content string which the controller would inject in the XHTML stencil at the position of the placeholder.

Finally, a traditional HashMap could be built which holds all of the ActionHashMaps as values which are keyed by their associated view name.

It seems that we might have some slight convergence between ADSs and CABOOSE.

Hunt. Peck. Think. Happy Coding. The CABOOSE Team.

Ozark Tutorial for Netbeans 8.0.2 and the Bundled Glassfish Server + Maven

Team. The work hours are mounting on other projects. Fortunately, the roll-out for Ozark (MVC 1.0) is the Q3 of 2016. From the reading in the early draft it seems that CABOOSE would fit best as a ViewEngine for MVC 1.0 with possible support for the reflective JSP/JSF tags. Ozark has been available for review with the associated test archives since March of 2015. These with a sample Maven project archive are available at the following Google Drive locations:

Googlge Doc Shareable Links for Ozark Archives
java-ee-8-mvc-master.zip
https://drive.google.com/file/d/0B101EUHMgepNTVpGTWNZY0JuTm8/view?usp=sharing
javax.mvc-api-1.0-edr1.jar
https://drive.google.com/file/d/0B101EUHMgepNSHlrU2xaVHR2MHc/view?usp=sharing
ozark-1.0.0-m01.jar
https://drive.google.com/file/d/0B101EUHMgepNVW03RFdVem5JcVU/view?usp=sharing


The following is the first draft of a simple tutorial which shows one how he can compile and run the sample project "getting-started" contained in java-ee-8-mvc-master.zip plus create his own project called the OzarkTemplate.

The tutorial should take about 45 minutes or less:

Compiling and Testing the GettingStarted Ozark MVC Project

A. Transfer the java-ee-8-mvc-master.zip archive from the Google Docs link or GitHub
B. File>Import Project>From ZIP...
C. Browse for the above archive and select Import. Complete any remaining importing steps.
D. Right-click the "getting-started" Maven web archive and select Build with Dependencies.
E. Select Green Run Triangle on Toolbar which will run the project.
F. Select the blue link on the index page which appears and the controller should return hello.jsp.

Preparing for Creating your Own Ozark MVC Project

X. Transfer javax.mvc-api-1.0-edr1.jar and ozark-1.0.0-m01.jar from their listed Google Docs links, java.net, or the web.
Y. These will be used as package denpendencies in our project.
Z. They might be needed if your IDE does not find them automatically.

Creating an Ozark MVC "Hey" Project (Maven-Netbeans 8.0.2 IDE)

1.File>New Project>Maven>Web Application on the the Choose Project Page
2.Select Next
3.Enter OzarkTemplate for Project Name: (Everything else can use the default values) on the Name and Location Page
4.Select Next
5. Ensure that the GlassFish Server 4.1 is the chosen Server: and the Java EE Version: is Java EE 7 Web on the Settings

Page of the New Web Applciation Widget
6. Select Finish

Adding Dependencies

7. In the Project Explorer, right-click the Dependencies Folder under the OzarkTempalte Maven Web Application>Add

Dependency.
8. Enter the following values:
    groupId:     com.oracle.ozark
    artifactId:    ozark
    version:    1.0.0-m01
9. Select a scope of compile.
10. The jar files, ozark-1.0.0-m01.jar and javax.mvc-api-1.0-edr1.jar, are added in the project dependencies.

Adding RESTful web-service

11. In the Project Explorer, right-click the OzarkTemplates Maven Web Application >New>RESTFul WebServices from Patterns
12. Select Simple Root Resource>Next
13. Enter the following value:
    path:         ozark
    Class Name:    OzarkController
14. Select Finish

Editing OzarkController.java

12. In the generated OzarkContoller.java source add the following imports:

import javax.mvc.Controller;
import javax.mvc.View;

13. The annotate the class as a Controller:

...

@Controller
@Path("ozark")
public class OzarkResource {

....

14. The add the following resource method:

...

    @GET
    @Controller
    public String ozarkString(){
        return("/WEB-INF/jsp/hey.jsp");
    }

...

Creating "hey.jsp"

15. In the Project Explorer, right-click the OzarkTemplates Maven Web Application >New>JSP
16. Enter the following value:
    FileName:     hey
17. Select Finish.
18. Place the following content in hey.jsp:
...
<title>Ozarkian HEY</title>
...
<h1>Hey! From the Ozarks</h1>
...

19. Right-click the WEB-INF folder>New>Folder
20. Enter the following value:
    FolderName:     jsp
21. Select Finish.
22. Drag hey.jsp and drop it on the newly created jsp folder.

Creating a link which activates the controller.

23. Place the following content in the body of the index.html file:
...
<a href="ozarkHey/ozark">Ozark</a>
...

Testing WebApp

19. In the Project Explorer, right-click the OzarkTemplates Maven Web Application >Set As Main Project
20. Select Green Run Triangle on Toolbar which will build and run the project.
21. Select the Ozark link on the index page which appears. The hey.jsp page content should appear.


Hope it was fun! The CABOOSE Team... Hunt...Peck...Think...!

Loopy Fiasco | Do No Harm | Social Responsibility | Earning an Education | Good Neighbor Day (01.15.nnnn) Proposal

Team. This morning upon awakening an old college experience occurred. It is a rather natural event that occurs in the life of many. Whether it is a divine action as some believe in historical religious accounts, the result of an overactive mind taxed with many new concepts or ideas, or the hypersensitive nature of hearing upon falling asleep or awaking, modern medicine classifies it as mundane. Those who are neurotic become scared when it occurs; however, hypnogogic and hypnopompic hallucinations do not indicate any form of psychological, psychiatric, or neurological disorder.

Loopy Fiasco

Upon waking this morning, a crowd of happy, excited voices where talking about the possibility of extremely tight loops which actionable data structures. A queue with a length that exceeds that of the CPU's pipeline might have a dequeue which results in a node action followed by an immediate enqueue of the same (dequeued) node. If the action, enqueue, and dequeue source lack any conditional branches, these would prevent any pipeline stalls in an iterative structure. This might produce a very quick loop, possibly faster than doing the same in a while(true),for(;;),or do...while(true). This might be worth benchmarking. Might not. This would produce an infinite loop, and some say infinite loops are "bad". But, they have uses in computing. Remember, one can spawn new threads with any given action. Also, forgive the grogginess; this might require at least a pair of cooperating action-able structures who request dequeues from each other after an initial operation on the start structure.

Do No Harm 

If this barrage of audible ideas this morning was reliable and this does produce a faster iterative structure (loop), please do not create any malware with it. It would be worse than a worm; it would be a venomous centipede (VC) since such a structure could mount a URL request attack that might overtax a server. This would be compounded if it asexually reproduced with any of the action nodes stored in its queue. This would definitely be a "bad" modern computing version of the 80's video game.

Social Responsibility    .....    Earning an Education

Please, be socially responsible with the information which you glean during this life's experience. One earns his education with the way in which he handles it after getting the degree. If one harm others with the knowledge that one has for any reason, he really never merited having an education since there are an abundance of other "positive" things one can do with an education.

Good Neighbor Day (01.15.nnnn) Proposal

In the spirit of "do no harm", we suggest that those who read javacaboose promote the idea of an international "Good Neighbor" day. There have been many wonderful teachers throughout history who have promoted harmony among the various groups of the human people for the ant is a people, the coney is a people, and the locust are a people. A united, peaceful society is much better that the fragmented, warring one which we currently have. We will probably perform a deliberate act of social kindness for someone in an opposing social group on 01.15.nnnn; however, in honor of all the great teachers through history, chose any day of the year which you see fit and be a Good Samaritan.

Forgive the recent tangential nature of this weblog, more Ozark and CABOOSE is coming soon. Everything which converges must rise.

Have a Peaceful Week. The CABOOSE Team.

Reflection versus Interfaces in CABOOSE

Team. We have been thinking and doing less hunting and pecking recently. One thought which has made itself apparent is the use of interfaces for realizing the "dynamic nature" of reflection when invoking page concern handlers in CABOOSE and the action-able data structures which we mentioned in the last few web-post. As with many design decisions in computing, trade-off exist. Using an interface requires that not only is the method signature of the behavior under a contract, but also its identifier likewise is fixed. This might be a non-issue in some implementations, but in some development environments identifier names must follow an "organization-dependent" standard. So, simply calling the method "render" or "draw" might not be acceptable in all cases. Also, a developer might decide that the identifier for the method which fills-in the page content should reflect the purpose of the content which it is drawing in the form of page markup. This would increase the readability and maintainability of the source.

Interfaces for Actionable Data-Structures

The use of interfaces in the creation of action-able data structure nodes might be worthwhile since an informal form of name standardization exists among the behaviors found in these structures. So, an ActionableNode interface with an "action" method which bundles the methods which it should invoke in the before or after events of a push, pop, peek,enqueue, dequeue, and etc. would be acceptable. This is only true if the design permits a constant set of behaviors for a node with each data structure action. If this set of behaviors is variable, then using reflection might be the best choice.

A few simple notes for this day. Since we lost our text files of the second chapter summary, we will deliver the summary of the Ozark 1.0 early draft specification which we promised weeks ago when we find time for recompiling it.

Enjoy This Week....

The CABOOSE Team

Continued Aside: Actionable Data Structures, Object Machines of Various Types, Implementation, and CABOOSE

Actionable Data Structures

As mentioned before in the last couple of post, an actionable data structure can perform zero or more specified tasks when one of the standard operations of that abstract data type (sort) occurs. Each one of these tasks is a method contained within the object node stored in the abstract data type (ADT).

Object Machines of Various Types

Computing machines are modeled using various data types. For instance, a queue of instructions might simulated a pipe-lined processor. Another popular sort for computation is the stack ADT. Stack machines are quite common and are at the heart of many programmable calculators such as the HP 11-C. They are useful in the evaluations of expressions and conversion between prefix and postfix notation. With this in mind, if one constructed and actionable object stack machine, then he could evaluate a language of object expressions based upon the available libraries of a modern object-oriented language.

Implementation

More than one approach exist for creating actionable data structures as with traditional ADTs whose physical structure might be realized with fixed length arrays or dynamic link lists. One might produce the "actionable" behavior of these sorts using reflection, aspect-orientations, or an event-driven programming model like that found in Visual Basic.

CABOOSE

How will CABOOSE use actionable data structures? This is a great question. This dynamic behavior should be available within the model data structure which provides the views which automatically render the specification (HTML, XHTML, DHTML or XML) of the browser's requested content.
We will be revising our implementation of CABOOSE in light of these thoughts on actionable data structures.

Have a Great Week. We are still working on the summaries which we promised.
Hunt... Peck...Think....Please pardon any typos.

The CABOOSE Team

Another CABOOSE MVC Aside : Actionable Data Structures and Object Machines

Team. We promise simplicity, but for brevity we often omit supporting facts which will make the content of these post more accessible for new computing students and other experienced professionals who do not work with these specific concepts. As we said in an earlier post, we have very limited skills with the functional programming paradigm. This is because the use of command (imperative) lists is more common in traditional high level languages used for computing such as COBOL, FORTRAN, C, C++, JAVA, Ada, and etc. Other computing professionals learned functional programming as freshman at certain colleges. So, please search for more web-based information on the terms which seem uncommon. This is what we usually do when we meet unfamiliar terms. Once you supply this missing content, these pages will seem more sensible.

Over the last few post, we have been discussing actionable data structures. This arose from comments on our efforts at learning functional programming in JAVA 8 with its lambda expressions. We mentioned how these lambda expressions which are unnamed (anonymous) functions might be useful for implementing actionable data structures such as a map of behavior (actions). We also discussed how, for decades, data and behavior resided in the same program space but were not grouped (encapsulated) in bundles of related data and behavior. We also discussed how the creation of objects in the late 1980s was the realization of this concepts. Objects are not a final resting place, but a naif -like step toward more expressive ways of describing software modules when they model real-world entities. 

Shortly, after the development of the first object-oriented language, C++, many started discussing the notion of an object machine. Such a device would likely be purely virtual; however, instead of processing individual low-level commands such as those found in processor microcode or assembly instructions, these (non-physical) virtual processors would process streams of objects or commands which manipulated various class instances(objects) which one found stored in the virtual machine's memory.

With a dab of imagination, one can envision an actionable data structure such as a processing queue that functions as a virtual processor for such a non-physical machine. Being a queue, it would be naturally pipe-lined, and, being non-physical, it could do branch-prediction on the enqueue operation. This would alleviate pipeline stalls when a branching instruction decides that it must redirect the program's flow of control. The only constraint is that any object between the head and tail of the queue could not modify the state of the branching condition. This might restrict the length of the queue by not permitting any future enqueues until the next "object" for processing can be definitively identified. This is a stall of sorts for a processing queue, but does not require a flushing (ignoring) of instructions currently in a processor pipeline which are unusable.

All physical computer's use what one calls a Von Neumann architecture. The processing capacity and the memory exist in differing physical spaces. Since objects represent a bundling of related behavior and data, an object machine implemented with an actionable queue is a slight departure from this logically. Ultimately, the computing work is done on a Von Neumann machine, but it might be possible that one can reason about the processing differently when using an object machine. Since one inevitably is solving some sort of problem with each computing task, reasoning with more powerful, higher order paradigms might produce simpler solutions for difficult tasks.

For more information, search the web for notes on object-based virtual machines or object machines.
Please pardon the typos. This was a "fun" post as the German descendants in this area say. We did not properly implement our bird foraging procedure..Hunt.. Peck...Think..........
Enjoy your week, The CABOOSE Team.

CABOOSE Aside: Actionable Data Structures - Stacks, Queues, Maps, etc.

Team. This posting is simply a side note in the CABOOSE pages about a concept which might benefit its development. For those of us who were computing majors and studied data structures, we learned about various abstract data types such as Stacks, Queues, Trees, HashTables, and etc. It might have been a few semesters later when we discovered the dynamic invocation behavior available in most high-level languages. With this span between learning these concepts, it would be highly unlikely that one would consider combining them unless one was regularly working on projects which used both.

    Traditionally, abstract data types (ADTs) held data only and had rules for creating, reading, updating, and deleting the values within them. These ADTs were an extension of the primitive types found in high-level languages such as integers and floating-point numbers of various sizes plus characters. Being the precursor of modern objects, they represented a grouping of state and related behaviors; however, their purpose was storing state and providing methods for the creation, reading, updating, and deletion of this same state based upon the the rules of their interface. Early ADTs might store individual primitive types or a grouping of such types in a "record of data". When objects became available, they were the entities stored in these structures, such as Queues. Yet, presently, most of the implementations of these common data structures do not support the dynamic invocation of the methods contained within the objects that they store upon pop, dequeue, get, or etc. An interesting class of modern data types would be the actionable data structure. Upon the pop, dequeue, get, visit, or etc. of the object stored within the structure, the atomic action of a specified method would occur. There might also be value in associating behavior with the "insert" operations of these data structures. The dynamic behavior of these actionable data structures also might be toggle-able.  

Just a note before the sheep start flying overhead. Enjoy this upcoming week.
Hunt.... Peck... Think.....

The CABOOSE Team.