PORTABLE SOFTWARE DEVELOPMENT

Coordinator
Jul 1, 2011 at 4:38 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

Coordinator
Jul 8, 2011 at 5:11 PM

The data that is associated with a class is a single data structure. A "Service Class" is where the data structure is contained in the data structure associated with the calling program. A "Client Class" contains its own data structure.

To render the development process strictly portable, the routines shall fall into the following three categories: The Process Category  processes the class data structure. The Status Category returns the current process status. The Data Output Category returns a specified data output.

To render the development process strictly portable, all public procedures will be implemented by a public wrapper that calls a private utility where the data associated with the class is passed as a parameter.

Coordinator
Jul 15, 2011 at 3:17 PM

SATURDAY: The software parts associated with the single point definition of any routine have been prepared. In the C++ environment, scripts for writing the associated class declaration statement have also been prepared.

MONDAY: The Class Definition Process will consist of a Class Definition Beginning Step, One or more Routine Definition Steps, and a Class Definition Completion Step.  Each Class Definition Process will be contained in one source definition sub-task; Each step will be defined by a source definition file. Integration with the data structure and include steps is next.

Coordinator
Jul 22, 2011 at 5:05 PM

SUNDAY: The Include software parts kit have successfully integrated into the Class Definition sub-task. The Typedef software parts kit is next.

MONDAY: To be able to link the class definition output source code lines to the defining source definition file line number, the class definition steps (Class Definition Beginning, Includes, Typedefs, Routines, Data Structure, and Class Definition Completion) must be defined in one source definition file.

TUESDAY: To be able to use the script software parts to facilitate the writing of the statements associated with the Includes step, the script calling capability must include using a text expression as an argument.   

THURSDAY: The script software parts library has been modified. Preliminary functional tests have been performed.

Coordinator
Jul 29, 2011 at 4:29 PM

SATURDAY: The stand-alone version of the include software parts library is operational relative to the preparation of a script needed to write the CPP #include statements.

MONDAY: In attempting to write the CPP #include statements, it has become apparent that the current script implementation is not as yet adequate. A script is still needed in as much as entries will be made throughout the class-definition sub-task.

THURSDAY: Extensive Script Modifications to the Software parts defining the Common Include library have been prepared. Hopefully, the needed flexibility in script definition and use has been achieved.

Coordinator
Aug 5, 2011 at 4:49 PM

FRIDAY: The Include Type (System, Service Class, Client Class,  Data) is not a workable identifier for organizing the *.h file.  An additional identifier must be added to include software parts kit. 

MONDAY: The additional identifier has been added to the common (the library used for all output source languages) include software parts kit. 

TUESDAY: The additional identifier has been added to the CPP include software parts kit.

THURSDAY: The revised CPP and COMMON Include software parts kits are ready for test.

Coordinator
Aug 12, 2011 at 5:38 PM

SATURDAY: The Includes software parts library is used to both create a set standard includes as well as writing them into a source file. The use of the Includes software parts library to prepare a set of standard includes has been tested.

THURSDAY: The Includes software parts library is currently being tested relative to writing the necessary statements into a C++ source file,  The proper use of the script software parts library is the primary challenge.

Coordinator
Aug 19, 2011 at 6:41 PM

FRIDAY: The script software parts library has been successfully used to
write the #include statements into the source file.  Making some minor
Format and file management modifications is next.
 
MONDAY: The format and file management modifications have been made and
tested.

Coordinator
Aug 21, 2011 at 6:07 PM

FRIDAY: A certification software parts library is used to place the comments into the output source files that facilitate testing for the absence of patches,  Upgrading the interface  between this library and the includes library is the next task.

Coordinator
Aug 26, 2011 at 5:14 PM

MONDAY: To properly update the certification software parts library, it is necessary to update the libraries that prepare the output source files.

TUESDAY: A means of updating the certification software parts library that did not require updating the libraries that prepare the output source files was found. Testing of the certification software parts library has been started.

THURSDAY: The testing of Includes software parts library has been completed. Minor changes in  the libraries that prepare the output source files were required. The certification library will need to be further modified relative to testing of the product source code. (Common Criteria, First Article Test, etc).

Coordinator
Sep 2, 2011 at 7:07 PM

SATURDAY: The modification of the software parts library associated with the data types (Typedef Library) needed to integration it with the class-base and certification library has begun. 

MONDAY: The modified typedef software parts library has been successfully tested in stand-along operation. The modifications of the class-base library needed to integrate it to the typedef software parts library will be implemented next.

Coordinator
Sep 9, 2011 at 7:26 PM

SUNDAY: The modifications of the class-base library needed to integrate it to the typedef software parts has been successfully tested relative to the service class.

Coordinator
Sep 16, 2011 at 4:02 PM

SATURDAY: To Insure that strict portability between C++, C, C#, and Visual Basic, I plan to next update the associated include and typedef libraries. 

THURSDAY: The includes software parts library for C# has been updated.  It has also been tested and found to be functional for the global includes entries.

Coordinator
Sep 23, 2011 at 6:52 PM

SATURDAY: The typedef software parts library for C# has been updated.  It has also been tested and found to be functional for the global typedef entries. The integration of these libraries into the class base library is planned next.

Coordinator
Sep 30, 2011 at 6:55 PM

SATURDAY: A major portability problem has been encountered in the Includes library.  Strict portability demands that functionally identical cpp, c, csharp, Vbasic source files from exactly the same source generations file.  Unfortunately, the inclusion of system routines requires a different number of references.  In C and C++, there are a varying number of "#include" statements.  In C#, a large number of system routines can be accessed by the "using system;". I plan to divide the system includes category into a collection of sub-categories. Multiple references to the same system statement will not result in multiple lines in the output source code.

SUNDAY: The C++ and C# Includes libraries have been modified and tested for stand-along use.

MONDAY: The C and VBasic Includes libraries have been modified and tested for stand-along use.

TUESDAY: The C++, C, C#, and VBasic Typedef libraries have been modified by the corresponding Includes library and tested for stand-alone use.

THURSDAY: The development of the Class Base library has been restarted. The following three class types are included: service class; client_class; and the main_class. The service class, where its client owns the data, is currently being developed. Integration with the includes library and typedef library for C++ and C# has been accomplished.

Coordinator
Oct 7, 2011 at 6:35 PM

SATURDAY: The service class base library, where its client owns the data, is currently being developed. Integration with the includes library and typedef library for C has been accomplished.

MONDAY: The service class base library, where its client owns the data, is currently being developed. Integration with the includes library and typedef library for VBasic has been accomplished.

TUESDAY: The service class base library, where its client owns the data, is currently being developed. The next step is to add the data elements to the class definition.  A problem has been encountered relative to data associated with system functions.  In C and C++, an address or integer is passed to the system functions ("* char" for example). and in C# or VBasic, a system class (not a data element) is used. In addition, in C# and VBasic, the string class can be passed as a parameter. It would appear that two forms of system classes need to be added to the mix.  This would affect the include and typdef libraries.

THURSDAY: The software parts to load the system string and system class has been been added (but not tested) to the common (not language specific) include software parts library.

For more information, please visit my web-site, "www.whatifwe.com".

Coordinator
Oct 14, 2011 at 6:59 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

MONDAY: The software parts to copy the system string and system class has been been added (but not tested) to the common (not language specific) include software parts library. The software parts to copy and load the system string and system class has been been added to the CPP include software parts library. The stand-alone include load capabilities have been tested.

For more information and free downloads, please visit my web-site, "www.whatifwe.com".

Coordinator
Oct 21, 2011 at 5:09 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: The "Copy Includes" software part of the common includes software kit library has been updated to prevent duplicate copies of the same statement from being written. This update has not been tested.

WEDNESDAY: The common and C++ typedef software parts libraries have been updated relative to the system and string includes.  These updates are currently being tested.

THURSDAY: The common and C++ typedef software parts library updates have been tested in the stand-alone mode of operation.

For more information and free downloads, please visit my web-site, "www.whatifwe.com".

Coordinator
Oct 28, 2011 at 4:46 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: The common and C, C#, and Visual Basic typedef software parts library updates have been tested in the stand-alone mode of operation.

SATURDAY: The service class base library, where its client owns the data, is currently being developed. Integration with the modified includes library for C++ has been started.

MONDAY: The service class base library where its client owns the data, is currently being developed. Integration with the modified includes library for C++ has been accomplished. Output source files have been generated. I am currently considering revising the certification parts library to render it possible to certify the output source files using the same source generation files.

For more information and free downloads, please visit my web-site, "www.whatifwe.com".

Coordinator
Nov 4, 2011 at 6:13 PM

The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.
 
FRIDAY: The service class base library, where its client owns the data,
is currently being developed. Integration with the modified includes
library for Visual Basic has been accomplished.
 
SATURDAY: The service class base library, where its client owns the
data, is currently being developed. Integration with the modified
includes library for C and C# has been accomplished.

Coordinator
Dec 16, 2011 at 6:22 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

SATURDAY: I hope that all readers had a good Thanksgiving. I have examined the software parts library associated with the definition of a routine (name, arguments, return, etc).  It does not appear to require modification.  I will proceed to integrate it to the service class base where its client owns the data.

Coordinator
Jan 20, 2012 at 7:56 PM

THURSDAY: I am continuing to modify the common routine software parts library and I have started to modify the CPP routine software parts. I have completed the declaration script up to the argument list.

Coordinator
Feb 10, 2012 at 3:41 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

My apologies for inadequacies in my blogging efforts.  I have had a non-related significant distraction from my research/development activities. These distractions have not as yet been completed.  Hopefully in a few weeks...

THURSDAY: Currently, I am struggling with the definition of a routine.  The fact that, in general, a routine is defined in one source file and used in another conflicts with a single point definition of how the associated source code is written. This is a very complex script process. One of the possibilities is a number of standard resource files for each class. Such files would contained standard automatic variables, and usage "define files" standards. I have already accepted a class data resource file. This represents a serious trade-off between serious standard methods, ease of the design process and source file self-documentation. 

Coordinator
Feb 17, 2012 at 3:41 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

During the this blog week, it became apparent that I was presenting details in my blog that required access to the associated software parts kits.  I am considering possible access for those readers who are genuinely interested.

FRIDAY: The struggle with the definition of a standard routine methodology is diminishing. The single-point definition of a routine is contained in the post office defined by the common routine software parts library. The way that it is written in the source code is contained in the routine software parts library associated with the specific programming language.

SATURDAY: The are two basic types of routine; public and private. The public routine is available to other classes and its associated class contains its data. The private routine is available only to its associated class which also contains its data. I have started rebuilding the CPP software parts for the public routine. There are three processing paths: 1) declaration path for the class definition file, 2) routine path for the definition of the routine, and 3) user path for its use in other routines.

SUNDAY: The beginning software parts for the public routines have been prepared. In all cases, a script is used to write the CPP code when required. The declaration script sequence must be performed first, At this time, I do not know whether the routine script or the user scripts should be performed next.  I do know that to prepare the user scripts, the automatic storage and the parameters of the routines must have already been defined.

MONDAY: Each routine has not only a specific procedure that performs the required function but also a status reporting procedure. This requirement affects the use of a script in the definition of the routine.

TUESDAY: The principle of "Simplify and add lightness" must now be applied to the common routine parts associated with data return. Originally, the returns were specifically defined by two software parts: One for a data return and other for a status return. These two software parts will be replaced by one.

WEDNESDAY: The modifications to the common routine parts have now been prepared. Modification / creation of the data return software parts of the CPP routine software kit will proceed.

Coordinator
Feb 24, 2012 at 4:32 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

During the this blog week, it became apparent that I was presenting details in my blog that required access to the associated software parts kits.  I am considering possible access for those readers who are genuinely interested.

SATURDAY: The data return software parts for the CPP routine software part kit have been prepared. The software parts for defining and writing the routine's arguments will be prepared next.

Coordinator
Mar 2, 2012 at 2:57 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

SATURDAY: The preparation of the software parts for defining the routine's arguments has begun. The status of a routine must be monitored before and after its use. This can be accomplished either by an associated status routine with an appropriate command argument or two associated status routines with no parameters. Currently, it appears that two status routines will be easier to implement.

MONDAY: The previously developed software parts of the CPP routine definition library have been modified relative to providing two status routines for each routine.

WEDNESDAY: The software parts associated the beginning of the argument list have been prepared.  When I looked at the previously developed CPP software parts for the arguments, I recalled that in some of the cases, it was necessary to use an address.  Passing a string into a routine as an argument is a good example. A string would be returned from a routine in a similar manner. I will proceed to define a common means of communicating with a routine.

Coordinator
Mar 9, 2012 at 7:22 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: One of the challenges regarding developing a set of portable standards relative to the definition and use of the routines is the fact that an argument can be a variable containing data or a constant. I am currently considering defining variables to contain the constants and then exclusively using variables as arguments.  This, on the surface, would appear to be obsessive restrictive. On the other hand, properly done, it would help the source code to be self-documenting.

SATURDAY: I have decided to use variables to contain both numerical and string constants. It will improve the self-documenting properties of the source and will "Simplify and Add Lightness" the development and use of the associated software parts.

SUNDAY: The software parts defining the argument list of a routine has been prepared for CPP.

MONDAY: The software parts defining the end argument list of a routine has been prepared for CPP.  The next task associated with the CPP routine software parts library is the implementation of the command values.  This set of constants is important relative to the communication between the called routine and the calling routine.

TUESDAY: To properly define the variables used to define the command constants, the scripts defining a routine declaration, routine, and use must be individually defined.  It was originally thought that these three scripts were sufficiently similar that a single definition could be used.

WEDNESDAY: I have already made the decision to use a global set of basic data types. This decision has already greatly simplified the software design process and the associated software parts libraries.  I am now considering globalism the command and status values.

Coordinator
Mar 16, 2012 at 10:32 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: I have decided to globallizing the command and status values. The modification of the common routine software parts library is next. 

SATURDAY: The modification of the common routine softwae parts library has begun. 

TUESDAY: The modification of the common routine software parts library has been completed. Integration with the CPP routine software parts library will proceed.  

Coordinator
Mar 23, 2012 at 7:24 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

MONDAY: The development CPP Class Base Library which prepares the class definition *.h file has been restarted. The associated script is being updated to include those defining the declaration of routines as defined in the associated routine software parts libraries.

THURSDAY: It occurred to me that I will be using the integration process with the CPP Class Base Library as a means of testing the routine software parts libraries. This is not a good checkout/test process relative to the required "divide and conquer test philosophy".  The need for using the integration process as a test vehicle will be re-examined.

Coordinator
Mar 30, 2012 at 6:41 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: The Programmable Software Development Environment is equipped with a Test sub-system which is quite comprehensive in nature but is difficult to use. One of the most difficult steps is the use of the "Define Test Step" program generation file (See Manual) and the internal pseudo-random generator to prepare the "Test Program Step" program generation file. I believe that I have a simple method for accomplishing this task. I will try to use facility to perform a much more thorough check/test of the various routine libraries.

MONDAY: The basic Test Definition File will be a source definition file with the random generator specification presented as a comment following the source definition command. This file will be read as an input file, not a source definition file.  On a line-by-line basis, if the actual random generator string matches the specification, the line gets copied into the output file. Otherwise, it does not.

TUESDAY: The basic software parts for writing the "Test Program Step" have been prepared. These software parts can be used to define both a source definition file and a software parts file. The next step will be to build and test the associated software parts library.

WEDNESDAY: I started to prepare the test project for the common name routine software parts kit.  The test project (*.tmk) is still a difficult project to set up. I do believe that I will be capable of building a generic version that can be copied and quickly modified. The The basic software parts for writing the "Test Program Step" appears to be easy to write. I plan to make a source definition file rather than a software parts file. Some modifications of the common name routine software parts kit to render it easier to test are expected.

Coordinator
Apr 6, 2012 at 3:13 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

WEDNESDAY: The Programmable Software Development Environment is equipped with a Test sub-system which is quite comprehensive in nature but is difficult to use. The basic software parts for writing the "Test Program Step" have been checked-out and appear to be quite easy to use. The name routine library is currently being checked out using the "Test Program Step". One improper error has been detected by the TEST TASK sub-system. This error has not as yet been located.  I plan to build an additional error report library to help me to easily find and correct these kind of errors.

THURSDAY: I plan to increase the error-reporting capabilities of the Programmable Software Development Environment.  Currently, it includes the name that follows the _ERROR statement. I plan to automatically add the software library name, software part name, and the software part line number of the _ERROR statement. additional commands for reading this data will need to be added.  I believe that these changes are needed to facilitate the location of unexpected errors found during the TEST TASK.

Coordinator
Apr 13, 2012 at 5:36 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

MONDAY: I have now achieved a simple set of test software parts libraries and now the checkout of the common routines names software parts is rapidly proceeding.  The need to upgrade the Error subsystem of the Programmable Software Development Environment has now been put on the back-burner.

TUESDAY: As I am increasing the test specification and the number of Monte-Carlo tests for the common routine names software parts, I am running into the unexpected errors again.  Errors in the test specification are assumed to be the cause. I will be updating the test libraries to improve my ability to manage the test specifications

THURSDAY: I have updated the test libraries adding a space and "|" to the test specifications to help visualize the test conditions and was able as a consequence to solve the unexpected error problem.  Testing of the common routine name software parts continues.

Coordinator
Apr 20, 2012 at 8:38 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

SUNDAY: Formal testing of the common routine name software parts has been completed. The common routine software parts will be started.  Some upgrades to these parts may be necessary.

TUESDAY: The Formal testing of the common routine name software parts has emphasize the need of well-defined purposes of each of the libraries in the chain leading up to the preparation of the class-defining files. In CPP, there are two additional steps between the class-definition library and what has been accomplished. The first one is a routine common parts library and the second one is a CPP parts library. The previously developed library sets associated with this process (include and typedef libraries) must be  subjected to the same formal testing which will result in appropriated upgrades. I have learned an easy means of using the Testing capability of the Programmable Software Development Environment to checkout and thoroughly test a software parts library!

THURSDAY: The common routine software parts associated with loading one or more routines into a class has been thoroughly tested. During these test, a restriction was found; each of the arguments in the definition must have a different name. This restriction might be an inconvenience since common arguments such as an index normally have the same name. On the other hand, it will improve the resulting program from a self-documenting point of view.

Coordinator
Apr 27, 2012 at 7:08 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: The formal tests associated with the common routine software parts associated with loading one or more routines into a class has been completed. This includes all relevant error conditions.

SUNDAY: In order to minimum potential for error, every variable name must have a single point of definition. This includes the routine and argument names. The routine and argument names have been defined in the class definition development step. The routine and argument names will be re-enter during the definition of the actual routine. These names will be verified as being identical with those entered in the class definition development step.

MONDAY: The routine definition step functionality of the common routine library has been thoroughly tested.  Error response of the routine definition phase will be tested next.

TUESDAY: The formal tests of routine definition step of the common routine library is complete.  The user definition step of the common routine library is next.

WEDNESDAY: In C++, there are three different representations for each routine: 1) class declaration, routine definition, and the one used for calling the routine. A single point definition is a necessary requirement for portable error free software. This should be done in the class definition step and stored in the Programmable Software Development Environment post office where it can be read in the other steps. To rigorously implement this one step requirement, modification of the name routine library to add a second representation will be needed.

Coordinator
May 4, 2012 at 9:03 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

SATURDAY: The required modification and formal testing of the name routine library needed to add a second representation of the routine name has been accomplished.

TUESDAY: The formal tests of user definition step of the common routine library is complete.  The development and testing of the common routine library is complete.  The Language specific routine libraries are next.

Coordinator
May 11, 2012 at 7:24 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

TUESDAY: In reviewing the language specific routine libraries development process, It is necessary to note that at this point we will be writing source files. Of particular importance is the certification that these source files have not been modified after the fact. The "Patch" must be eliminated from the design process. 

THURSDAY: It is not only important to certify that a source file contains no "Patches", it is also important to certify that the source files have been prepared exclusively with the agreed-upon software parts library. This need can best achieved by the cryptographic capabilities of the Programmable Software Development Environment. The pseudo-random generator based cryptographic algorithms of the Programmable Software Development Environment can be the basis of a very accurate certification instrument.

Coordinator
May 18, 2012 at 4:34 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

THURSDAY: The development of a certification library has begun.  The certification methodology for post office communication involves implementing a certified copy of a sequence of macro-calls in the user task.  Cryptographic methods will be used to certify the communication process.

Coordinator
Jun 8, 2012 at 4:22 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

WEDNESDAY: The development of a copy certification library has been a difficult challenge.  This library enables the service task to prepare a certifiable script that can be run in the client class. Cryptographic methods are being used to certify the communication process.  The primary challenge has been implementing the optional capability for the client class to become a service class for a subsequent process.  The preparation of the  associated software parts has been accomplished.  The actual generation of the library and its subsequent test is the next step.

THURSDAY: The copy certification library has been prepared.  Its subsequent test is the next step. This test technique is different than what has been done previously.  Specifically, a software part test file and test library is prepared for each monte-carlo test condition instead of a test source file.

Coordinator
Jun 15, 2012 at 8:14 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: The Monte-Carlo checkout/testing process of the copy certification library has been started. Specifically, a software part test file and test library is prepared for each Monte-Carlo test condition instead of a test source file.

MONDAY: The functionality of the copy certification library has now been successfully tested. An upgrade to the script library was required.  The resistance of the copy certification library to errors in its use will now be tested.

TUESDAY: The copy certification library has now been successfully tested. It will now be applied to the portable software development process. I am very pleased with the TEST_PROJECT capabilities of the Programmable Software Development Environment. It has greatly increased my capabilities in bringing a library under development to a released status.

Coordinator
Jun 29, 2012 at 7:31 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

SATURDAY: The role of the common includes library has been significantly simplified. Specifically, it will define the certified copy process, define the sequence of includes command, and simplify the source code writing process. A quick revision and test process is anticipated.

SUNDAY: The preparation of the common include library has begun. Those software parts that are associated with system files have been tentatively prepared. To implement the potentially required multiple certified reproductions, a minor revision to the certified copy library will be required.  This revision will be the next task.

TUESDAY: The needed revisions to the certified copy library have been made and tested. The next task is the preparation of the common include software parts associated with the data files.

THURSDAY: The modified software parts associated with the common include library has been prepared. Preparation of the common include library is the next task.

Coordinator
Jul 7, 2012 at 6:00 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

SATURDAY: The modified common include library has been prepared. Preparing its Monte-Carlo checkout/testing process is next.

Coordinator
Jul 13, 2012 at 5:51 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

SATURDAY: The modified common include library has been prepared. Preparing its Monte-Carlo checkout/testing process is next.

TUESDAY: The Monte-Carlo checkout/testing process has been prepared. Checkout of the first level operation of the common include library is next.

THURSDAY: First level operation of the common include library has been checked out. Checkout of the second level operation of the common include library is next.

Coordinator
Jul 20, 2012 at 4:53 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

SATURDAY: Testing the second level operation of the common include library has been started. A problem in the script library has been encountered. The script library has not ever been formally tested.  It is probably time to consider this effort.

THURSDAY: The problem in the script library has been identified. It can be fixed by a simple patch. A patch would be a violation of my design philosophy and would be seriously inconsistent with my testing philosophy.  As a consequence, I have decided to formally test the script library. The formal testing of the common include library will be put on hold.

Coordinator
Jul 27, 2012 at 5:57 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

MONDAY: The formal test of the script library has begun.  Improvements in the comment documentation is required and has begun. The Minor modifications required to render the software parts formally testable are being identified and implemented. 

Coordinator
Aug 3, 2012 at 8:02 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: Please look at the formal test topic for the progress reports on the upgrade and formal test efforts of the script software parts library.

Coordinator
Aug 10, 2012 at 10:13 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: The script library has been sufficiently tested that the testing of the second level operation of the common include library can continue.

TUESDAY: The testing of the second level operation of the common include library has been completed. The tests include the copying of the system includes and the definition of class and data includes. Testing the third level of operation is next.

Coordinator
Aug 24, 2012 at 6:50 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: Modifications to the common includes software parts library are needed. Specifically, the ability to receive a copy of a set of include commands without preparing them for copy to a subsequent task (the end of the copy sequence) has not been prepared.  The additional software parts will now be prepared.

TUESDAY: Modifications to the common includes software parts library have been made and tested.  Specifically, the ability to receive a copy of a set of include commands without preparing them for copy to a subsequent task (the end of the copy sequence) is now provided.  A review of the permissible use of this library now needs to be made.  Also, an untested feature of the script library was encountered and checked out. The formal tests of the script library must be upgraded.  

WEDNESDAY: We can use the C++ #include statement to identify the rules associated with the use of the includes software parts library.  Specifically, we have three types of include statements: system, data and class include statements. The system include statements are written in all source files. The data include is written in the class header file and the the class include statement is written in the source files. There appear to be no certification chains required for the #include statements. We also need to consider a common name that will allow us to bring in not only the #include statements but also the other command sequences associated with the referenced file.

Coordinator
Aug 31, 2012 at 7:37 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: Currently, I believe that the common name problem can be resolved using the script calling capability of the script software parts library. This require a different form of certification chain capabilities which will probably require upgrading the certified copy library. This will be examined after I upgrade the associated software parts of the script software parts library.

Coordinator
Oct 12, 2012 at 6:01 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

THURSDAY: Currently, I believe that the common name problem can be resolved using the script calling capability of the script software parts library. This require a different form of certification chain capabilities which will probably require upgrading the certified copy library. The script software parts library has been sufficiently upgraded that I should be able to restart this development activity.

Coordinator
Oct 19, 2012 at 3:24 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY:  The certification / common name issues of the includes software parts library will be reexamined and the development process re-planned.

MONDAY: A re-examination of the common class base software parts revealed the basic challenge. The act of referring to a class another class (sub-class) involves a number of sets of commands; i.e., the sub-class includes, sub-class typedefs, and sub-class data structure. The basic problem is that all of the include instructions must be executed first, then all of the typedef instructions next, and so forth. A script call instruction can satisfy this requirement. The next task will be to implement and test an appropriate certification command. This effort will be reported in the utility blog.

Coordinator
Nov 9, 2012 at 4:20 PM

The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

MONDAY: Having upgraded both the script and certification software parts library, I reexamined the software parts associated with the common includes software parts library to determine the need of script software parts library. Specifically in the preparation of a source or header file, all of the system includes must written first, the data includes must be written second, and the class includes must be written last. The script is not needed to accomplish this task. The next step is to complete the formal testing of the common includes library.

TUESDAY: The formal testing of the common includes software parts library has been completed. The certification process will only be complete when we are able to perform a certification test on the generated source product. To meet this goal, the software parts library associated with the generation of output source files must be examined, upgraded as necessary and formally tested.  This will be the next task and the associated research / development activities will be reported in the utility blog.

Coordinator
Dec 7, 2012 at 7:45 PM

It is planned to upgrade the Programmable Software Development Environment to include the capability of reading the paste-in text files where the each paragraph is one very long line.

Currently, the Programmable Software Development Environment has the capability of reading a standard ASCII text file where the TAB character is replaced with a suitable number of blanks. Each line of the text file cannot be longer than 256 characters. On the other hand, the Programmable Software Development Environment has the capability of writing a paste-in text file where each paragraph is one very long line. This capability includes the ability to include special characters such the TAB.

The ability to read the paste-in text file is needed to certify that the file has not been changed, was developed using the agree-upon standard libraries, or has not been illegally copied.

SATURDAY: Modifications to the instructions associated with the writing a paste-in file has begun. Currently, there is the capability of inserting an eight-bit numeric value into the line being prepared. This makes it possible to insert a TAB character. Currently, this eight-bit numeric value can include ASCII characters. To provide a rigorously consistent read paste-file capability, the ability to insert an eight-bit numeric value must be restricted to values less than 32 or greater than 126. The required modifications have been implemented. Handling the end of line will be considered next.

Coordinator
Feb 9, 2013 at 10:46 PM
The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

SATURDAY: 2013/02/09 ************************************************

STATUS: The basic challenge is to develop a basic output format that can be equally applicable to the five output source languages.

DETAIL: Visual Basic provides us with the greatest challenge. It has a continuation flag for a statement that continues to the next line. Also a comment or continuation flag can follow that portion of the statement on a line but not both. The other source languages do not have this restrictions.

RESULTS: I think that the basic format would consist of a set of comment statements that minimally would contain the source definition statement (*.src file) as well as the source definition file line number, associated dates, and a longitudinal parity byte that includes not only all the comment statements but also the generated source code statement.

NEXT TASK: The next step is to define a set of commands which will accomplish the above basic format
Coordinator
Feb 11, 2013 at 10:12 PM
The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

MONDAY: 2013/02/11 ************************************************

STATUS: The two sets of commands that define the source file writing / certification library are the initialization set and the writing set.

DETAIL: The initialization command set enables the specification of the line-size, the initial indentation, the indentation increment, the comment flag, and a longitudinal parity key. The writing command set enables writing comments, the source generation statement as a comment, and the actual source statement.

NEXT TASK: Prepare the directory needed to contain the necessary library generation files.
Coordinator
Feb 12, 2013 at 9:32 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

TUESDAY: 2013/02/12

STATUS: The directory needed to contain the necessary library
generation files has been prepared along with the first two
initialization software parts.

DETAIL: _SOURCE_OUTPUT_CONSTRUCT which initializes the control stack,
initializes the basic_output library which will be used to perform the
basic write / certification process, and initializes the pseudo random
parity sub-system has been prepared. _SOURCE_OUTPUT_DESTROY which
tears down the libraries and pseudo-random parity sub-system has also
been prepared.

NEXT TASK: The setup software parts which define the comment flag, page
size, initial indentation and the indentation increment will be
prepared next.
Coordinator
Feb 14, 2013 at 9:51 PM
The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

THURSDAY: 2013/02/14 ************************************************

STATUS: The setup software parts which define the comment flag, page size, initial indentation and the indentation increment have been prepared.

NEXT TASK: The software parts which write/certify the output source code files will be prepared next.
Coordinator
Feb 16, 2013 at 10:35 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

SATURDAY: 2013/02/16 ************************************************

STATUS: The basic function of this software parts library is to
facilitate the preparation of source code files according to computer
language-specific formats.

DETAIL: Its function is roughly equivalent to the format definition of
a CPP printf command. Each format would have a specific name and would
be implemented by a script.

NEXT TASK: The script library will next be examined to see if 1) it
is functionally adequate and 2) it has been adequately tested.
Coordinator
Feb 17, 2013 at 5:41 PM
The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

SUNDAY: 2013/02/17 ************************************************

STATUS: The software parts of the script library have been examined. The software part needed to define one or more parameters at the _RUN_SCRIPT level have yet to be designed.

DETAIL: The capability of passing parameters from a calling script to a called script has already been implemented. The additional software part for implementing this feature from the _RUN_SCRIPT level can be implemented from code associated with these previously developed software parts.

NEXT TASK: The script library will be upgraded next. The activity report will be presented in the Utility Development blog sub-directory. Although it is possible to "Walk and Chew Gum At The Same Time", the development of this library will probably be delayed until the script upgrade has been completed.
Coordinator
Feb 20, 2013 at 5:43 PM
The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

WEDNESDAY: 2013/02/20 ************************************************

STATUS: The upgrade and testing of the script software parts library has progressed sufficiently that this development activity can be restarted.

NEXT TASK: The development of the format commands of the common source output library will begin.
Coordinator
Feb 21, 2013 at 5:03 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

THURSDAY: 2013/02/21

STATUS: Each format will be represented by a script which can either be
executed from a _RUN_SCRIPT command or called from another script.

DETAIL: One of the format statement requirements will be the ability of
specifying columns.

NEXT TASK: The software parts which associate a column with a specific
column name will be defined next. These names can be used in the
definition of a format statement.
Coordinator
Feb 22, 2013 at 9:42 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

FRIDAY: 2013/02/22

STATUS: The preparation of the script that implements a specific line
format requires that the basic routines that writes the line be
prepared first.

DETAIL: There are four basic routines: 1) Initiates the line writing
process; 2) Writes a text segment; 3) Moves to a specified column; and
4) Completes the line writing process.

NEXT TASK: These four routines will be prepared next.
Coordinator
Feb 25, 2013 at 7:53 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

MONDAY: 2013/02/25 ************************************************

STATUS: The basic routines that writes the line from the script have
been prepared.

DETAIL: The five basic routines were prepared: 1) Initiates the line
writing process; 2) Writes a text segment; 3) Moves to a position which
is the sum of a specific column and the initial starting column; 4)
Moves to a specified column; and 5) Completes the line writing process.

NEXT TASK: The routines for writing the associated script will be
prepared next.
Coordinator
Mar 1, 2013 at 9:53 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

FRIDAY: 2013/03/01

STATUS: The preparation of the software parts for defining a format has
begun.

DETAIL: These routines will define a script that when run will define
the script that defines the format. This is required because the format
is defined in a different sequence that required for its execution.

RESULTS: Using a script to define a script is a difficult effort. To
facilitate its checkout, software parts that contain calls to the
required script definition software parts is required. This will make
the full debugging capabilities to be enabled during checkout.

NEXT TASK: The development of the format definition software parts will
continue.
Coordinator
Mar 2, 2013 at 6:37 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

SATURDAY: 2013/03/02

STATUS: The most important characteristic of this software parts
library is its ability to write/certify an output using previously
defined formats. This will, of course, be used in the preparations of
source code files. The preparation of source code files will not be its
only use.

NEXT TASK: The library and macro names will be renamed appropriately
to reflect its more general application. Its development will continue
to be reported in this post.
Coordinator
Mar 5, 2013 at 10:12 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

TUESDAY: 2013/03/05

STATUS: The software parts of the common source output library for
defining the formats have been prepared.

DETAIL: These software parts use a script to prepare the format
scripts. The format scripts will be run to write / certify the output
files.

NEXT TASK: The software parts of the common source output library that
write / certify the output file according to a specified format will be
prepared next.
Coordinator
Mar 6, 2013 at 5:41 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

WEDNESDAY: 2013/03/06

STATUS: It became obvious to me that a separate format needs to be
created for each file even though it may be identical for every file.

DETAIL: This is an unnecessary inconvenience. In most cases, its
definition is independent of the file.

NEXT TASK: The format definition software parts will be modified so
that the output file can be specified in the format script or as a
parameter of the format script.
Coordinator
Mar 7, 2013 at 11:44 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

THURSDAY: 2013/03/07

STATUS: The modifications to the source output software parts library
needed for the optional parametric specification of the output file
alias have been made. In addition, the software parts needed to run
the format scripts have been prepared.

NEXT TASK: The next task is to prepare the software parts needed to
call a format script from another script.
Coordinator
Mar 19, 2013 at 6:19 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

TUESDAY: 2013/03/19

STATUS: The software parts for generating and running the format
scripts has been modified to use a post office rather than a local
dictionary.

DETAIL: This will render it possible to define a standard format set
separately from its use.

NEXT TASK: I have not forgotten about the software parts associated
with calling a format. The next task will be to prepare format
commands associated with adding a pseudo-random string of blanks. This
will be used as a means of protecting proprietary information. A
varying number of blanks at the end of each line is hard to visually
detect and is a very good means of making the source files detectably
unique.
Coordinator
Mar 20, 2013 at 6:41 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

WEDNESDAY: 2013/03/20

STATUS: The software parts associated with adding a pseudo-random
string of blanks to a format have been prepared.

DETAIL: These software parts will be used as a means of protecting
proprietary information. A varying number of blanks at the end of each
line is hard to visually detect and is a very good means of making the
source files detectably unique.

NEXT TASK: Calling a format script from a client script will be
considered next.
Coordinator
Mar 22, 2013 at 10:47 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

FRIDAY: 2013/03/22

STATUS: The preparation of the software parts for calling a format from
a script has been completed.

DETAIL: During this activity, I discovered that there were two
additional software parts required to complete the preparation of the
required software parts. Specifically, the ability to manage the
beginning indentation of a line for each file.

NEXT TASK: The line indentation software parts will be the next effort.
Coordinator
Mar 30, 2013 at 11:31 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

SATURDAY: 2013/03/30

STATUS: I reconsidered the line indentation requirements and found that
my original conception was sadly lacking.

DETAIL: My apologies, It has been over a week since I have looked at
this project. There is only one of me. It appears that an alias must
be assigned to an indentation in a similar manner as has been done for
a column number. These indentation aliases would be included in the
definition of a format. This would probably be done at the beginning
of the format definition. These indentations would be incremented /
decremented during the execution phase.

NEXT TASK: The software part for associating an alias with a specific
indentation and setting the indentation at a beginning value is the
first step. This will be accomplished in the setup phase of this
library at the same time as the columns are defined.
Coordinator
Jun 12, 2015 at 10:23 PM
The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

FRIDAY: 2015/06/12

STATUS: This development effort has been backlogged for several years.

RESULTS: The basic output library developed for document and web-site development is a good starting point for this project. This library has the capability of certifying that the output source code has been developed exclusively with the approved software libraries and has not been modified by any patches.

NEXT TASK: I will restart this project by preparing output libraries for C, C++, Visual Basic, and C##. A common set of a commands will be defined first.
Coordinator
Jul 27, 2015 at 11:50 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

MONDAY: 2015/07/27

STATUS: This project has been restarted by preparing a common program
output library.

DETAIL: This common output library will be capable of 1) making a
comment line, indenting a program line, and making lines of any length.

RESULTS: The Certification process has been prepared and the Setup has
been started,

NEXT TASK: The Indentation Variable has been defined. Incrementing and
Decrementing a specific Indentation is next
Coordinator
Aug 10, 2015 at 10:54 PM
The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

MONDAY: 2015/08/10

STATUS: The software parts associated with a common program output library has been prepared.

DETAIL: The software parts include _BASIC_PROG_OUT_INDENT_NAME, _BASIC_PROG_OUT_INDENT_INCR, _BASIC_PROG_OUT_INDENT_DECR, _BASIC_PROG_OUT_WRITE_COMMENT,_BASIC_PROG_OUT_WRITE_CERTIFY, _BASIC_PROG_OUT_WRITE_INDENT, and _BASIC_PROG_OUT_WRITE_EXTEND.

NEXT TASK: The next task is to prepare the associated software parts library.
Coordinator
Aug 14, 2015 at 12:00 AM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

THURSDAY: 2013/08/13

STATUS: The common program output library has been prepared.

DETAIL: common program output library contains software parts
_BASIC_PROG_OUT_INDENT_NAME, _BASIC_PROG_OUT_INDENT_INCR,
_BASIC_PROG_OUT_INDENT_DECR, _BASIC_PROG_OUT_WRITE_COMMENT,
_BASIC_PROG_OUT_WRITE_CERTIFY, _BASIC_PROG_OUT_WRITE_INDENT, and
_BASIC_PROG_OUT_WRITE_EXTEND.

NEXT TASK: The next task will be to prepare the associated test task.
Coordinator
Sep 18, 2015 at 12:07 AM
The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, C#, and Visual Basic; and Linux based C and C++.

THURSDAY: 2013/09/17

STATUS: The write and verification test files have been prepare and are ready to be used to both check out and thoroughly test the common program output library.

DETAIL: This library has both the capability of writing an output file and verifying that a previously created file has not been modified.

RESULTS: The need to thoroughly test the library has resulted in test files that were much larger and more complicated than expected. The conditional test library needs to be upgraded.

NEXT TASK: The next task will be to prepare the test task definition files and start performing the tests.
Coordinator
Feb 8, 2016 at 11:55 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

MONDAY: 2016/02/08

STATUS: I have started developing the C++ program output software parts
using the common program output library. I found that I was missing the
capability of preparing a header comment section on all of the files
being written.

DETAIL: The header comment section is required to present copyright and
other legal statements. These statements need to be at the beginning at
each of the files being written by common program output library.

NEXT TASK: The next task will be to add a header comment command to the
common program output library.
Coordinator
Feb 16, 2016 at 10:56 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

TUESDAY: 2016/02/16

STATUS: A header comment command has been successfully added to common
program output library.

DETAIL: Header Comments are required for each of the files being
produced. These comments contain pertanent legal data such as a
copyright statement.

NEXT TASK: The task will be to continue developing the C++ output
library.
Coordinator
May 3, 2016 at 9:38 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

TUESDAY: 2016/05/3

STATUS: The CPP output library has been prepared and is ready for
test. This library has the required header commant instruction.

NEXT TASK: The test tasks will now be developed for the C++ output
library.
Coordinator
Jun 14, 2016 at 9:19 PM
The activity associated with development of strictly portable methods
of software development will be presented here. Included in this
Portability effort will be Windows based C, C++, C#, and Visual Basic;
and Linux based C and C++.

TUESDAY: 2016/06/14

STATUS: The CPP output library has been successfully tested. It is
ready for use.

NEXT TASK: The next task will be to examine previously CPP development
activities to determine the next step.
Coordinator
Oct 1, 2016 at 11:07 PM
The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, and Java; and Linux based C and C++, and Java.

SATURDAY: 2016/10/01

STATUS: The classcommonnames library has been developed and fully tested.

DETAIL: All of the development language have collections of name. They specify data types, data names, structures, class names, subroutines and arguments. Most of these names require the definition of other names. For example, data name needs a data type. This library provides the capability of defining a name in terms of the other required names. The postoffice capabilities of the Programmable Software Development Environment define the communication between libraries.

RESULTS: It is ready for use.

NEXT TASK: The next library will define the data types. Four libraries being considered. One will be a common library and the other three will be for C, C++, and Java.
Coordinator
Nov 2, 2016 at 12:05 AM
The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, and Java; and Linux based C and C++, and Java.

TUESDAY: 2016/11/01

STATUS: The software parts for the common data type library (typedef) has been started and the first definition level has been prepared.

DETAIL: Currently, there are two definition levels. The first one loads language specific keyword such as float which will then be used to prepare commaon aliases. The second level defines these aliases and places the pertainent data in a postoffice.

NEXT TASK: The next step will be to start preparing the second level parts.
Coordinator
Nov 7, 2016 at 9:57 PM
The activity associated with development of strictly portable methods of software development will be presented here. Included in this Portability effort will be Windows based C, C++, and Java; and Linux based C and C++, and Java.

MONDAY: 2016/11/07

STATUS: Preparing the second level parts of the typedef software parts library has been started. I found the need to identify and compare (less, equal, and greater) float decimal numbers

DETAIL: Currently, the Programmable Software Development Environment has no float decimal commands. Either the Programmable Software Development Environment would have to be updated or a special float decimal library would have to be developed.

RESULTS: I believe that developing a special float decimal library would take less time than updating the Programmable Software Development Environment.

NEXT TASK: I am suspending the development activity on the typedef software parts library and starting the development of the special float decimal library.