By changing your style of programming to remove
internal dependencies will reduce your total project effort by 50%,
produce unbreakable code, and have code that can be changed at any time.
This is simply what software development is.
I build yoyo's does not mean I'm an expert yoyo'er. I have spent 3
years trying to learn how to remove internal decencies, it is not as
easy as it sounds. You will want to fall back on what you've done in the
past. I did this on 1 line of code that took me 3 weeks to resolve.
compiler as a part of "Jane". The compiler will run in emulation mode,
and produce executable code. To produce an executable, as a part of the
software, a linker was required. It took me two days, just to read
an object library to extract object code to be placed into the resultant
executable. This is the same amount of time it took me 30 years
ago to do the same thing.
The point is, our basic static structures separated from logic is no
better, and might even be worse, today because of the number of
versions, variations, and vendors of the same structure. If I were to do
all the different formats and logic for all these different structures,
it might take six months of work.
One of "Jane's" primary goals is to manage all information. So access
to known information structures will take seconds not man months of
work, with far greater reliability.
"The Holy Grail"
Mr. Crockford, is right for Software Engineering, as a science it
would be great. In eighty years we have yet to produce one line that
meets the code reuse criteria.
I directed my efforts to software development, which is the practical
application of creating software. So if I know that in 80 years and
billions of man-years of effort has yet produce one line of re-usable
code, maybe something is wrong.
Code reuse It like searching for and wasting time on anti-gravity, when a more
practical approach, airplanes, might hold a better solution. We can
assume that anti-gravity and code reuse could exist. I do not waste my
time on either one.
"Code reuse is the Holy Grail of Software Engineering." --
"There are no true synonyms" -- my fifth grade teacher
"Behind every great man is a woman rolling her eyes." -- Jim
"Progress might have been alright once, but it has gone on too
long." -- Ogden Nash
"The best time to plant a tree was 20 years ago. The second best
time is now." -- Chinese Proverb
Removing Internal Dependencies:
The two reasons for software failures are internal and external
dependencies. An external dependency is software that you did not write,
software that you have no control over. An Internal dependency is
software you did write and used it for more than one purpose. Getting
rid of external dependencies is easy, re-write everything yourself.
Getting rid of internal dependencies is a little more difficult.
The reason for removing external dependencies should be obvious; any
external change will break your system. The reason to remove internal
dependencies, may not be so obvious, it will improve your software in
four way: First is it makes software code unbreakable. Second it will reduce
the time to develop software. Third it will speed up the execution of the
program. Fourth it will make software changeable.
My initial thinking was to reduce the number of internal dependencies on any
piece of code to a manageable number of permutations. Three uses of a
piece of code has six permutation. So if each piece takes 1 hour to
implement, this is 6 hours. It seemed a reasonable assumption. This
assumption is wrong, we have based all of our software development on this assumption for the last 80 years. We have been spending more time designing
software for reuse without any real or practical benefits.
I now promote zero reuse of code. Whether it's one line or a million
lines, code should only be used for one purpose. This means building a
system that only has a linear forward progressive logic.
Instead of trying to collapse code to reduce size, we actually expand
code to reduce size. We also expand code to drastically reduce
development time by as much as 80%.
As an Example:
A and B both call C, this requires A and B to agree on a
calling convention and balance the logic to suit both. This can take
man years to develop properly. Future changes have risk, and there is no
A calls C1, B calls C2, now A and C1 are independent
from B and C2. This I can do in under 30 seconds.
Accountability is 100%. The size and complexity of C1 and C2 are
reduced. I can change C1 and C2 with 100% confidence.
In forty years of development, I have never seen a function called
from 2 parts of any system that had identical purposes. The few cases
that you might think are identical, is not worth the 30 seconds it takes to
isolate your code.
I can place C1 and C2 right next to where they are being called. This
gives me the ability to visualize and alter the logic at will.
Words that make no since:
Object * Abstract * Virtual * Polymorphism * Inheritance * Cloud *
Big Data * Instance * Encapsulation * Refractor * Namespace
These terms were used to describe application specific logic. The
terms are too vague and do not describe logic, rather hide 2 or 3 lines
of coded logic. I would prefer words like: Place-holder instead of
abstract, Replaceable instead of Virtual, Fix instead of Refractor, and
Intelligent Data Structures
I can probably count on my fingers
and toes all the data structures that I need access to.
Maybe 10 or 20 more. "Jane" is to build and manage data structures as an
integral part of the system. So the code to create, manage and
access them is immediate. No more days or weeks of coding just to access
something already known.
- Font Files
- Vector Graphics
- Object Code
- Database Tables
write C++ system routines to finish the compiled version of the
This means the compiler will run in all the current browsers to
produce a 64 bit windows and ARM executables.
integer, whole, and real numbers.
Diagramming Source Code
Designing and writing software is an
illusion of logic. As a part of designing Jane I diagrammed source
code, how was it written, what percentage does what part, and what
percentage is actually logic.
It turns out that logic only makes up 3% of the code. The remaining
97% is gaining access to information so the logic can be applied, and
then doing something with the production of the logic. For example "draw
a character on the screen" the logic is 60 lines, the lines of code to
get to the logic is 2,000 lines.
The production of logic is done in a very small time frame. Writing
the 60 lines of logic of the draw character example might take 30
minutes; In this 30 minutes I have complete understanding of the system,
where the data came from, where its going, what I should do, and how to
best test the logic that I am now implementing. It is also true that I
am the only person that knows this information. Once I am finished, I no
longer know this information as well as I did during the 30 minutes of
writing the code. Over time I may not even remember that I even wrote
With this information, I designed Jane to manage the data
structures, the logic, testing and every piece of knowledge when the
logic was written.