SCM Help. The Cost and Benefits of Reflection.

Team. The leader of the local JAVA User's Group (JUG) provided us with some resources on Source Code Management (SCM). He suggested that using a Git repository might be a better choice than Subversion (SVN). Java.net offers Git as an option for the repository so we will consider this over the next couple of weeks.

We hope that this project has sparked some ideas which you might find useful in your own projects. Reflection is a very powerful feature of JAVA, and we have only used a small portion of its strength when dynamically invoking methods.
 
"Reflection is commonly used by programs which require the ability to examine or modify the run-time behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible."

     - Oracle Learning Trail on Reflection

     http://docs.oracle.com/javase/tutorial/reflect/

There is a computational overhead associated with reflection and dynamic invocation in JAVA. This is true with all compiled languages which support dynamic invocation such as C/C++, but the benefits of the CABOOSE approach is shorter development cycles, simpler application maintenance, and lesser developer learning curves. These are simply the trade-offs.

This performance penalty will also be in present in the compiled C# when we develop our .NET port. But, based upon how one dynamically invokes a method in the interpreted scripting languages: PERL, PHP, and Python, this computational overhead might not be as "great".

Remember: Hunt. Peck. Think...Enjoy This Day...La-La.

Progress on SCM - JUG Help

Team. We are making progress on placing the local source repository online at java.net. We will be getting some help from a leader of the local JAVA Users Group this weekend since we have not received any response from the java.net team yet. Our biggest concern is making a decision that limits the flexibility of the online repository in the future, results in time consuming data transfers for future builds, or requires intervention on the part of the administrators at java.net. So, we thought that we would ask someone with more experience.

If we have not received any guidance by next Saturday, we will simply do our best and learn from any mistakes that we make. We hope that you enjoy this weekend! La-La.

A KIS Approach for String Substitution Projects | Simplifying Make and JAVA's Ant

***Synopsis***

 In short, we will process all of the tile elements with an order attribute of zero first. Then those with a order of one and so on. We will let the JEE engineer determine what this order should be. This will occur if we implement the string substitution projects since such an approach simplifies the complexity of the required methods. We feel this is consistent with our Keep It Simple (KIS) design goal. In term of Lines Of Code (LOC), it is also minimizes the size of the code base.

*************

Team. One of our members has a rather active imagination and while enjoying some light exercise on Monday evening, he claims that he had a moment of inspiration. This inspiration came in the form of the remembered voice of a childhood friend who shed some light on simplifying the implementation of our string substitution projects. He was thinking of a completely different subject and considered the importance of “Keeping It Simple”. Then, the echo of the young voice of his childhood friend said “Just number them, duh!” Then he remembered that the simple things of this world shall confound the wise and a child shall lead them. 

   Immediately, he thought of the string substitution projects plus the implementation cost of creating data structures for representing graphs and determining the critical path, depth, for each node. These tasks should only be done once. We decided that these string substitution “project management computations” should be done once at design-time by the JEE engineer and “hard-coded” in the view instead of being computed by the general purpose servlet upon every view-request. This choice will simplify the design of the general-purpose web-script. In the future, we can always provide a developer’s utility which reads directory.xml  and makes these calculations. This would ease the developer’s tasks, and we would make it available sometime after the implementation of this feature.

   The notion of string substitution projects was somewhat of a “brainstorm”. We were not sure it they are absolutely necessary; however, a condition might occur that requires the processing of stencil replacement tiles in a set order. Because we are “highly-learned” individuals, we first considered the approach used in make files and building directed acyclic project graphs for resolving these dependencies. But, we also promised that we will Keep It Simple (KIS), because “educated” fools have ways of confusing ourselves and others. So, we unlearned a few things in order that we might create a simpler implementation of this concept.

  We will let the JEE engineer design the substitution project on paper in the form of a PERT chart with directed edges of length one and describe the project in the tile elements of a view using the optional attribute “order”.  All tiles without an “order” attribute will be given an order of zero. Tiles will be processed based upon their given order until all of them are exhausted. If “TILE_B” should be processed after “TILE_A” and before “TILE_C”, it should have an order greater than “TILE_A”’s and less than “TILE_C”’s. Also, for processing efficiency the maximum order should be minimized. We might still allow for the “parent” attribute which we discussed on 03.23.2015. This will document dependencies but not serve any processing purpose. Such  documentation will simplify the view’s maintenance.

  For more on PERT chart view the first section of this Adobe PDF file :

http://www.sce.carleton.ca/faculty/chinneck/po/Chapter11.pdf

  It was likely prepared for a students of a software engineering or business management course who were learning about project management. You can ignore the section on probabilistic PERT charts and crash times. Those concepts are for managing the uncertainty of task completion in the times allotted by management.

 

  Befuddled? If so, we apologize. For those of you familiar with JavaScript, CSS, and Dynamic HTML, you have probably encountered a property of graphical user interface objects called a z-order. This is the ordering in which the objects are rendered along the z-axis which extends perpendicularly from the screen. Zeroth order objects are shown first with first order objects stacked on top at the appropriate (x,y) or (left, top) coordinate. Second order objects appear above these and so on. In the same manner that a web browser renders its visual objects, we will process the string substitutions for a view based upon a sequential ordering. Hopefully, this explanation unravels the conundrum. As said before, this feature will not be in the first release and will probably occur at the same time as keyword translation.

  

  Interestingly enough, this might enhance the speed of a make utility’s processing. But that is only speculation. We have never built make or JAVA’s ant from scratch; however, we have briefly worked in an environment where the product make took over an hour. The dependencies among files were basically stable, but there were hundreds of them.  And, they required resolving with each build.

We will keep hunting, pecking, and thinking. Please do the same. La-La.

Direct Web Remoting | JUG Presentation in May

Team. Direct Web Remoting (DWR) is another technology found at java.net that might be worth learning about. It creates a convenient connection between client-side JavaScript and server-side JAVA servlets. Its index page is at www.directwebremoting.org . We are reviewing the coding, documentation, and testing. We will do our best at deploying the source without support for keyword translation or string replacement projects in a few weeks. Our first presentation of the CABOOSE concepts are scheduled at the local JAVA User's Group in May. Happy Coding. La-La.

Long-term Goal for CABOOSE - String Substitution Projects | Housekeeping

Team. I dawned on us that the order in which one replaces the tile variables in a CABOOSE stencil might have internal dependencies. In other words, #TILE_B# must be replaced after #TILE_A# and before #TILE_C#. It seems that, in some cases, the process of string substitution will follow the pattern of a mini-project which one can describe with a PERT chart, an acyclic directed graph. We felt that the best way of addressing this condition was adding an attribute in each tile element called, parent, which list all of the tiles upon which processing in the current one depends. Of course, as with project management we will start at an initial placeholder task and then process each of it descendants in a breadth-first manner. Also, we will only attempt replacing each tile once. It would be best if one created highly cohesive tile handlers which did not effect the efforts of any other, but this might not be achievable in all instances.

Also, we will add a pair of housekeeping tiles which will expect empty-strings by contract. One will be #BEFORE# and the other will be #AFTER#. #BEFORE# will occur before the start substitution tasks and #AFTER# will occur following the finish task. This will allow for any housekeeping that one might consider doing for one or more of the application views. One could simply create a common before or after handler for more than one of the views. This lets us partition certain aspects of view processing well!

A few thoughts before the weekend which we hope that you enjoy! La-La.

03.2015 JAVA Users' Group

Team. We enjoyed a wonderful JAVA Users' Group (JUG) meeting yesterday evening. The topic was functional programming with groovy. A classic text by Michaelson on functional programming can be found at:

http://www.amazon.com/Introduction-Functional-Programming-Calculus-Mathematics/dp/0486478831/ref=sr_1_2?ie=UTF8&qid=1426684397&sr=8-2&keywords=Functional+Programming

Also, there is an O'Reilly text on functional programming with JAVA by Dean Wampler. It also has some value, but if you can only purchase one the text by Michaelson would be best since it is basically "language neutral". Besides, the Wampler text (2011) is pre-JDK 8 which has support for lambda expressions.

For those who love the notion of "free", here is an Adobe Acrobat file on functional programming for your e-reader:

http://usi-pl.github.io/lc/sp-2015/doc/Bird_Wadler.%20Introduction%20to%20Functional%20Programming.1ed.pdf

With the proliferation of the map-reduce paradigm on computing grids and JAVA, the new COBOL, having support for lambda expression in its eighth release, functional is fashion-able again. When categorized by the nature of the instructions, there are four primary paradigms for computing: imperative, functional, declarative, and logic.

Examples of imperative languages are: COBOL,FORTRAN,Algol, PL/1, Pascal, Modula, C/C++, JAVA, PERL, PHP, Python, and etc.

Examples of languages used for functional programming are: LISP, Scheme, Clojure, JAVA, Haskell, Miranda, C#, JAVA, ML, Python, and Scala.

Examples of languages for declarative programming are: JAVA Fx, Prolog, and SQL.

And, the best known logical programming language is Prolog.

You will see that some languages fall in more than one category and JAVA is in three of four.

Remember, JAVA has a dual goal of universality, being ubiquitous and applicable for every computing need. This is quite a daunting task. If the custodian of JAVA, currently Oracle Corporation, achieves this, JAVA will be the first "universal" high -level language in history. This is something which many claim is impossible, but JAVA is gradually approaching its goal as the JAVA Virtual Machine (JVM) proliferates.

If you are interested in learning more about the various types of languages, visit this Wikipedia article:

http://en.wikipedia.org/wiki/List_of_programming_languages_by_type   

We will keep you abreast of our progress. La-La.

Draft Verification Document

Team. We found a couple of hours this morning for quickly sketching a draft verification document.

Verification Document
It can be found on Google Drive at:

https://drive.google.com/file/d/0B101EUHMgepNNElETnZVaTB3ZW8/view?usp=sharing

This is only a quick draft and will be revised in the future.

Subversion Repository
We are still waiting on a response from the java.net team about how we can properly place the repository online without putting limits on future revisions.

Enjoy This Day. Hunt-Peck-Think.La-La.

Revised Posting Schedule

Team. As we move forward. There likely will be new post on Monday and Friday of each week. Many of the ideas which we have related with general-purposeness, concern partitioning, and web services have been presented in the earlier notes. Also, only posting twice per week will free up some time for other pursuits. This ultimately will result in more hours for the CABOOSE project.

For the outstanding tasks, the test cases are on the way, and we have not heard a response from java.net about properly transferring the repository. We will try dumping our local repository and the loading the online repository with the output "dump" file. We will compare our activities with our last plan and forecast what we will be doing for the next few week in a future post. Enjoy This Day. La-La.

Notes on Prototyping. Apologies

Team. There is an interesting paper on prototyping available from some folks at Apple. It can be found at : https://courses.cs.washington.edu/courses/cse440/12au/readings_files/Houde-Prototypes.pdf . The video went well this weekend, and, besides the papers, we are wrapping up a short non-technical book which has been delayed for three or four months, so bear with us on those test cases. They are coming. Hunt. Peck. Think. and Enjoy Your Day. La-La.

Interesting JAVA User's Group - Talk by Venkat S. on Reactive Programming

Team. We had an enjoyable and informative talk by Venkat S. of www.agiledeveloper.com on 03.02.2015 at our local JAVA User's Group. He spoke of agile development and the new derivative paradigm called reactive programming. You can visit his website for more details. If he speaks in your area, do not miss his great talk.

Also, there might be another week's delay in the test cases. It looks as if our Saturday person-hours will be allotted for creating a memento video for a family whose near relative received NFL Team Hall of Fame honors last Fall. We simply must take this iron out of the fire and cannot postpone this effort past this weekend. It probably will take about all of our weekly eight hours in the creation and editing of this multimedia photo montage. We will do our best at politely saying "no" when asked if we can help with projects that will compromise our time on this CABOOSE effort in the future.

We are waiting on a response from JAVA.net about the proper method we should for placing our local repository online. Should we dump and load, mirror with svnsync, or do something different. We do not have a resource with much experience in SCM repository management  and administration.

Enjoy this weekend. Hunt. Peck. Think. La-La.

Test Cases Delayed | Unrelated Papers Pending

Team. The test cases will be delayed for about a week. Events arose that wiped out our Saturday's work effort. This is the only day during the week in which we can get much done. Also, the message posting this week will be sporadic. It should resume with regularity next week. A couple of paper deliverable dates are pressing and taking time away from CABOOSE.

In the meantime, here are some documents outlining coding conventions in various languages:

JAVA
http://www.oracle.com/technetwork/java/codeconventions-150003.pdf

NET
https://msdn.microsoft.com/en-us/library/ff926074.aspx

PERL
http://perldoc.perl.org/perlstyle.html

PHP (Pear)
http://pear.php.net/manual/en/standards.php

Python
https://www.python.org/dev/peps/pep-0008/

Following coding standards is important, and it is likely that the current CABOOSE codes deviates from the JAVA style guide above. We will revise the instructions as necessary so they are consistent with what Oracle expects. This is a project for future weeks.

Also, we have contacted the java.net staff with questions about creating the online Subversion repository. We are not well-versed in Subversion and Source Code Management (SCM) repositories and are hoping that we can avoid making an irreversible choice that will limit the CABOOSE project in the future.

We also are quite excited about the upcoming local JAVA User's Group which discusses reactive programming. If you have not attend such a meeting, you have missed out on a very informative and enjoyable time. We will keep you abreast of our progress on CABOOSE. Have aWonderful Week. La-La.