***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 :
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.
No comments:
Post a Comment