MSS Code Factory 1.9 (beta) Release History

MSS Code Factory 1.9.3325 Beta 1

As 1.10 is running code manufactured by 1.9 and is producing identical implementation code for the 1.11 CFCore and MSSBam models, it is now ready for Beta testing to exercise the PostgreSQL implementation. Once the PostgreSQL testing is complete, 1.9 will be released to production.

MSS Code Factory 1.9.3299 Corrected packaging error

The 1.9 versions of the model and xsd directories are now included in the packaging instead of the erroneously included 1.8 model and xsd directories.

MSS Code Factory 1.9.3294 Clean compiling code for new data types

This release produces clean compiling code for 1.10, although the code has not been tested yet.

I already know the Blob implementations won't persist properly because I haven't implemented the "real" PostgreSQL/JDBC insert/update code yet.

MSS Code Factory 1.9.3289 Down to 24 errors, all done but Number

All the Java code clean compiles now except for the Number attributes. I even stubbed in some temporary code for inserting and updating Blobs that treats them as Base64 strings, though that will blow up in my face as soon as I try to execute that code during testing because it is not the way you are supposed to do so.

BigDecimal is now used for Number; BigInteger is used for UInt64.

MSS Code Factory 1.9.3286 Fundamental Blob type is now byte[], 82 errors to go

Blob columns are now implemented as byte arrays. I had not been aware that the SQL Blob type was a binding buffer for JDBC, not a value wrapper like UUID.

org.apache.commons.Codec is now required by builds in order to implement Blob RFC encoding and decoding.

The PostgreSQL integration layer fetches Blobs, but I need to figure out how to do inserts and updates of Blobs yet.

MSS Code Factory 1.9.3277 Down to 90 errors in 1.10

There were 7,415 errors on Wednesday night, which is now down to 90. So 7,325 errors have been fixed since then.

CFLib wasn't on the build path for my test build of 1.10, which caused a lot of errors.

Once I added java.sql.* to the import list as well, the error count went down to 90 for the test build of 1.10.

java.sql.Blob does not implement compareTo( Blob obj ), so I'll have to figure something out for the object buffer comparators.

I need to refactor the references to getQuotedBlob() as getQuotedString().

BigDecimal colVal = resultSet.getString( idxcol )

should be

BigDecimal colVal = resultSet.getBigDecimal( idxcol );

double colVal = resultSet.getString( idxcol );

should be

double colVal = resultSet.getDouble( idxcol );

I also need to implement:

public UUID SchemaPg8Schema.convertUuidString( String value );
public String SchemaPg8Schema.getNumberString( BigDecimal value );
public String SchemaPg8Schema.getQuotedString( Blob value );
public String SchemaPg8Schema.getQuotedString( UUID value );

Finally, I need to catch and rethrow SQLException for some of the Blob accessors, like length().

MSS Code Factory 1.9.3273 New data types supported for PostgreSQL 8.4

The new data types are now defined for the database creation scripts and the Java/JDBC integration layers.

I still need to update the XSD generation rules, then all the pieces need to begin testing the 1.10 code will be in place.

The first test being how many errors there are left in the code, of course. Notes on that will appear in the 1.10 Releases log.

MSS Code Factory 1.9.3269 Clean run of enhanced Java rules

The enhanced Java rules are running cleanly.

The JEE Web Form prototypes haven't been touched yet.

The database creation scripts need attention.

After that, I'll do the Java+Pg8 integration layer.

MSS Code Factory 1.9.3267 Corrected EnumDef runtime configuration

EnumDef was incorrectly being mapped to Enum by the engine.

Two of the files that need the new data type support edits have been quick-coded. I know from test runs that more work is still required on them. There are a couple more files to go, then it's down to the JEE webform templates, and those I'll put off for now and focus on getting the core Java code running and tested instead. Plus I've only dealt with the Java code so far -- I still need to deal with the database creation scripts.

MSS Code Factory 1.9.3257 Completed testing of new BAM element parsers

The S1Bam20 and MSSBam110 models now parse successfully, but the rules have not been updated to allow for the new data types so the code is littered with rule expansion errors.

Still, much faster progress than I'd hoped for on the parser. I was expecting to spend most of today on it, not having it done before 9AM!

MSS Code Factory 1.9.3255 Implemented and tested parsing of EnumDef and EnumTag elements

You can now specify EnumDef and EnumTag elements which will eventually implement enums instead of shorts in Java and other C-like languages.

Although there will be runnable versions of MSS Code Factory 1.9 quite frequently, they will not produce usable code if you actually use the new data types. Enums only produce valid code right now because they inherit from Int16, so there are default rules for generating some kind of code for them.

As I add the newer types, that will no longer be the case -- the manufactured code will be littered with unresolved rule expansions, and will not compile for quite some time.

MSS Code Factory 1.9.3249 Wired EnumDef and BlobDef types to SchemaDef and Table elements

The EnumDef and BlobDef types are now properly wired in the BAM parser.

The 1.10 and 2.0 models have been updated to use the EnumDef and EnumTag elements to define the values of the DataScope, AccessSecurity, AccessFrequency, RelationType, and Primitive (2.0 only) lookup type specifications.

I've waited a long time to do this since I first realized Enum support would be necessary. It feels GREAT to have this in a model.

MSS Code Factory 1.9.3236 Added models for 1.10

The 1.10 CFCore and MSSBam models are starting out as straight-forward migrations of the 1.8 models to 1.9 syntax. You can diff the 1.10 model files with the 1.9 models from the 1.8 code base to see what you have to change to migrate your application models to use MSS Code Factory 1.9. The 1.10 runtimes will require the 1.9 CFLib and CFCore libraries. The 1.11 runtimes will use 1.11 CFLib and CFCore.

Technically there are a lot more XSD basic types to add, but my focus is on the types most commonly required by business applications in my experience, so when I say "basic", I mean the subset of types that are either implemented by common machine architectures or in very common use in the industry. I may add a 1.13 release to implement the remainder (URL/AnyURI, Byte, Duration, GDay, GMonth, GMonthDay, GYear, GYearMonth, HexBinary, ID, IDREF, IDREFS, Language, Name, NCName, NegativeInteger, NonNegativeInteger, NonPositiveInteger, NormalizedString, QName, and UnsignedByte.) Most of those types can be implemented by filtering Strings or contraining the existing basic intrinsic types, and I've never seen anyone use the G* types in practice. I can't really implement "Name" unless I change its name, or things will blow up big time (maybe I'll call it XName.)

I've also increased the size of SchemaDef.DbName to 12 characters to allow for MSSBam110 for the 1.10 models.

Next I'll change the data types of the new XSD type definition attributes to use the appropriate data types. This will provide a full-spectrum test case for 1.9 supporting the new XSD data types, as by definition, all the types will be exercised as optional attributes of their own definitions.

Once 1.10 is running properly using that test data and can persist a PostgreSQL database image of MSSBam 1.10, I'll be ready to shift gears to 1.10 itself. In essence, the only thing changing between 1.9 and 1.10 is the types used to implement the attributes of the new XSD types.

Then I will finally be able to create 1.11, which is 1.10 with self-referencing manufactured code for CFLib 1.11 and CFCore 1.11 support. That will be the next and final production release for the MSS Code Factory 1.x series.

With the addition of the GEL compiler and runtimes and other performance tuning, 1.9 takes 1m25s to create MSSBam110 as of 2012-02-18.

The 1.8 release takes 3m25s to produce idential code for 1.9.

That's a 68% reduction in the execution time. Not bad. Not bad at all.

MSS Code Factory 1.9.3233 Support for new data types coded

The supporting code for the Number, Token, NmToken, NmTokens, Uuid, UuidGen, TZDate, TZTime, and TZTimestamp has been wired to the engine, though there are a few bits and pieces of "TODO" code remaining (in particular formatting and parsing of date/time values.)

The exception throws for the bindings, iterators, and references has also been updated to the new semantics.

I've decided to inject a 1.10 release built with 1.9 to incorporate the new data types, and then a 1.11 release built with 1.10 to complete the implementation of the new data types for the 1.x series.

Then I'll spin the 2.x releases, which will have radically different and incompatible rules compared to 1.x. The idea is to stick with the 1.x code base until I start using the manufactured engine components.

MSS Code Factory 1.9.3220 Initial release with 1.8 functionality

The cadence of 1.9 releases is changing. Instead of producing code for the next release of MSS Code Factory, the new cadence is to produce code for the libraries that come bundled with the installer. Thus 1.9 will manufacture code for the 1.9 versions of CFLib and CFCore.

While this will be "challenging" for development of MSS Code Factory, it is a better cadence for a production system to be used by others.

This initial release provides support for the same Java datatypes as 1.8, although it does support a richer XML parser syntax with the 1.9 MSSBam XSD. Be aware that the 1.9 MSSBam XSD is still in a state of flux as I work on the extended data type support in the code, then in the rule base. It is feasible and reasonable to migrate your 1.8 models to this version of the 1.9 code base.

MSS Code Factory 1.9.3211 Remigrated Java and XSD rules from 1.8

There were some bugs in the rules caught by the GEL compiler, so those were fixed as well as doing a straight forward migration. The resulting code has not been test compiled, though, so this is not being promoted as a default download.

MSS Code Factory 1.9.3708 S1Core and S1Bam have been coordinated

The S1Core and S1Bam models have been coordinated with the new 1.9 BAM XSD syntax. However, some of the work on S1Bam was lost because I wanted to make sure I caught everything from the 1.9 model rather than preserving what I'd done on 2.0.

MSS Code Factory 1.9.3205 New and improved 1.9 BAM XML Parser running

SecGroup contains SecGroupInclude. I don't know how I missed that typo for so long!

Removed dead code

Cleaned up exception throws in BAM Parser.

Added XML element parser for SecForm objects.

Added XML element parser for SecGroup.

Added XML element parser for SecGroupForm objects. Because the FullDomainName of a cluster includes dots, the JEEMount and the JEEServlet components of a form reference need to be of the form JEEMount/JEEServlet, not JEEMount.JEEServlet.

Added XML element parser for SecGroupInclude objects.

Added XML element parser for SecGroupMember objects.

Added XML element parser for SecSession objects.

Added XML element parser for SecUser objects.

And that's it. All the new elements now have untested parsers coded. But XML parsing is pretty straight forward, so I really only expect to possibly encounter some data instantiation errors.

Time for some regression testing...

Added ShowLines to Token, NmToken, and NmTokens definitions, defaulting to 1 as with String and Text.

There will be a fair bit of work before the S1 2.0 models are compliant with the new 1.9 XSD specification. Odds are I'll revert back to some older assumptions, as the manufactured XSD fragments I used do not automatically make attributes optional when there are initial or default values specified for the attributes. I should do that with the 1.9 rule base, though, as I want to manufacture the XML parsers now that I've got a good clean syntax template to work with.

MSS Code Factory 1.9.3193 Added more XML Element parsers

NOTE: This release does not clean compile and run. It is a work in progress.

Added XML element parser for ContactList objects.

ContactURL.URLProtocol is required, not optional.

Added XML element parser for ContactURL objects.

Added XML element parsers for EnumDef and EnumTag.

Added XML element parser for HostNode objects.

Corrected XML element parser for License objects.

Added XML element parser for Memo objects.

Added XML element parser for MimeType objects.

Added XML element parser for Phone objects.

Added XML element parser for SecApp objects.

Cleaned up some dead code in MSSBamMssCF.

Service.ContainerHost is a mandatory relationship, not optional.

Added XML element parser for Service objects.

Added XML element parser for Tag objects.

Tenant.Cluster relationship is mandatory, not optional.

Added XML element parser for Tenant objects.

Added XML element parser for URLProtocol objects.

That leaves the Sec objects to be implemented yet.

MSS Code Factory 1.9.3178 Added more XML Element parsers

Added XML element parse for Chain objects.

Added XML Element parse for Cluster objects.

Added attribute Contact.MiddleName.

Added missing relation Contact.ISOTimezone.

Added XML Element parse for Contact objects.

MSS Code Factory 1.9.3175 Use new UnrecognizedAttributeException

NOTE: This release does not clean compile and run. It is a work in progress.

Switched the XML duplicate attribute assertions over to CFLib default exception factory throws.

Updated Author references to use new exception form.

Replaced unrecognized exception RuntimeException throws with CFLib default exception factory syntax.

Replace CFLibRuntimeException throws for unrecognized attributes with CFLibUnrecognizedAttributeException throws.

Finished converting to new CFLib default exception factory syntax.

MSS Code Factory CFCore 1.9.3075 Rebuilt with CFLib 1.9.3070

MSS Code Factory CFLib 1.9.3070 Added UnrecognizedAttributeException for XML Parsers

MSS Code Factory 1.9.3160 Work on consistent XML parsing model continues

Refactor Address.Zip as PostalCode. Only the US calls it a Zip code; the rest of the English speaking world calls it a Postal code. Majority rules.

Coded the XML parser fragment for the Address object.

Added AttachmentTag XML parser support. Propagated AttachmentTag implementation for XxxTag parsers for the different objects.

Started a bit of work on shifting over from assertions to proper CFLib default exception factory throws instead. There is a lot of old-style code to be fixed, but the existing code works, so this change is not a high priority and will be done when I feel like spending some time on grunt code.

MSS Code Factory 1.9.3154 BAM object model and XML parser enhanced

This still isn't a clean-compiling subversion release, so there is nothing to download from the SourceForge "Files" page. But things are coming along nicely, and by Monday 2012-02-13 I should have a clean compiling and testable version of 1.9 again.

There are still about two dozen objects that need to be properly parsed, but the BAM XML parser is finally fleshed out to the point where all the XML elements have at least a stub of a parser coded for them. I'm guessing it will take about another 2-3 days to finish implementing the element parsers and have a clean, testable compile again.

UuidDef and UuidGenDef element parsers have been fully implemented -- I've been waiting to learn how to use UUIDs in Java, and I must admit it's very easy to do so. It only took me about 15 minutes to implement the UUID attribute parsers.

EnumTags need to have their order explicitly specified by the user, so Prev/Next links have been added.

The Prev/Next links I've been adding to data that needs to be ordered by the sequence specified by the user or business application model is the reason I've decided to add a Chain definition to 1.9. My intent is to automate the production of container getXxxHead() and getXxxTail() methods that rely on the fact that a null value for Prev/Next indicates the ends of the ordered list.

I had considered using sequence numbers, but my experience has been that although sequence numbers make for easy order-by queries for custom SQL reporting, they have horrible performance when the user is resequencing data through a user interface. So I opted to maintain the quality of the user interface experience over the lesser need for simple, easy reporting.

MSS Code Factory 1.9.3145 Only the new atom types aren't stubbed yet

Stubs have been added for the SME objects in the model, but they have compile errors and are just placeholders at this point. I need to map their attributes to value setters next; right now I just wired the parser framework for the SME objects.

MSS Code Factory 1.9.3142 A little bit further now

Much has changed. Much more will also change.

MSS Code Factory 1.9.3136 MSSBam parse structure corrected

The parse structure is fixed, but that has exposed a whole host of attribute mismatches between the XSD and the defined models, so they're going to have to synchronized.

MSS Code Factory 1.9.3132 Non-functional release uses mssbam-1.9.xsd

This release is NON-FUNCTIONAL. It does not run properly at all.

However, it does now properly wire in mssbam-1.9.xsd to replace the old RepoModel with a Business Application Model instead.

I need to update the various 1.9 models to not just reference the new XSD, but to migrate all the altered object names.

MSS Code Factory 1.9.3130 Refactored Value, Schema Atom, and Table Atom containers

Refactored the SchemaDef and TableDef containers as a VContainer that gets specialized as a CSchema or CTable in the Schema Atom and Table Atom instances.

java/msscodedfactory19/xsd/mssbam-1.9.xsd now passes validation, though it's far from a correct and parsable XML schema as of yet. But it's coming along nicely.

This is an UNTESTED release.

MSS Code Factory 1.9.3110 Refactoring to new exception semantics complete

The code produced by 1.8 now uses the new exception semantics as implemented by CFLib 1.9.3110 and has been applied to the 1.9 code base.

MSS Code Factory 1.9.3105 Refactored more source files to use new exception semantics

Test build compiled and runs. Regression testing by manufacturing 2.0 code delayed for now.

MSS Code Factory 1.9.3095 Partial conversion to new exception implementation

Regression testing passed -- the manufactured 2.0 code is unchanged except for the new build stamp for MSS Code Factory 1.9.3095.

MSS Code Factory CFLib 1.9.3090 In tribute to old times

I never programmed one, but respect for the venerable IBM 3090 is due.

In actuality, you'll find an almost-complete implementation of the ExceptionFactory architectural performance tuning of the Java exception programming model that I prefer.

MSS Code Factory CFLib 1.9.3078 Added non-wrapping exception interfaces

The version with the Throwable last argument is very necessary in some cases, but far more common are the interfaces I just added without the Throwable.

MSS Code Factory CFLib 1.9.3076 Made factory instances more specific

By making the factory instances more specific, it should be easier for programmers to know what the manufactured code is doing and what exceptions it's throwing around.

MSS Code Factory CFLib 1.9.3074 Added initial exception framework

CFLib now has a default ICFLibExceptionFactory member, which is to be used by application code to instantiate thrown exceptions. This is an alternative to the more common use of NLS string resource support, and just as powerful.

All you do to set the language of the server is set the default exception factory in CFLib to the language-specific implementation you desire.

Note that exceptions only adapt to the SERVER language, not any user session attributes. However, because each exception carries its attributes and provides accessors for them, you CAN implement session exceptions that are NLS-adaptive in the business logic and application layers.

MSS Code Factory 1.9.3065 Packaging error corrected

1.9.3062 included the wrong version of CFCore jars. The build itself has not changed, only the packaging. It ran fine under the debugger. Details, details, details. *sigh*

*runlog removed from website*

The gritty tidbits are at the end of the logs.

MSS Code Factory 1.9.3062 Severity 1 defect corrected

Although the runtimes were largely correct, the way they were being wired together after instatiation by the compiler was far from correct. The affected defects have been corrected.

GelInstruction.CallerId and its associated were synchronized as optional attributes; they were inconsistent.

Performance has not been compared with 1.8. Runs to produce CFCore 1.9 using 1.8 and S1Core 2.0 using 1.9 are the only valid performance comparison set available.

MSS Code Factory 1.9.3055 Update Copyright notices

Update to "Copyright (c) 2012" for notices.

This highlighted the need to add a CopyrightPeriod attribute to the SchemaDefs for 1.9. I still haven't finished the PostgreSQL DELETE testing. Sorry. I've been busy with other things.

MSS Code Factory 1.9.3035 Wired CFLib LGPL library to system

The Xml core components have been moved to the LGPL CFLib jar.

MSS Code Factory 1.9.3030 2011-12-31 GEL Compiler and runtime testing complete

The GEL compiler highlighted some unterminated expansions in the knowledge base that hadn't been detected by the GEL interpreter. There was also inconsistent use of naming for To/From relation column info probes.

Now to do some test runs and see how much of a performance boost all this work actually bought me in the end.

MSS Code Factory 1.9.3026 2011-12-31 GEL Compiler and runtime largely work

The runtime produced by the GEL compiler is running. I am getting error messages reported, but I need to look into whether that's some knowledge base configuration that got messed up or which wasn't transferred, or if it's an actual issue with the way the runtime is implemented.

While this version runs, I still wouldn't bother downloading it yet.

CFLib is still unused at this point.

MSS Code Factory CFLib 1.9.3014 2011-12-29 Introducing the LGPLv3 Core Library

CFLib is released under the LGPLv3, not the GPLv3 as is the rest of the MSS Code Factory 1.x series.

I've decided that it would be unreasonable and unfair to leverage common code to try to force people to pay for manufacturing and maintenance. I'd rather win their business through a unique service and quality delivery of those services than try to strongarm them by abusing the ideals of software freedom. People who know me already know the names of companies using tactics in the marketplace that I consider to be oppressive, repressive, and anti-competitive. They're within the bounds of law -- technically. That depends where business and personal ethics fit into your definition of "law."

I will therefore be shifting fragments of the Pg8 SchemaObj to this library. I've already shifted the XML base classes, though I'm not using them anywhere just yet.

Over time, I'll also add a custom exception framework to replace all the relatively useless RuntimeExceptions I throw with the code right now. The custom exceptions will mostly derive from RuntimeException, but they'll be enhanced to make it easy to get diagnostic information about the error from the custom methods of the exceptions.

This will also enable a shift from hard-coded English messages to parameterized exceptions that can be enhanced to use NLS translations. Ideally, you should present enough information in an exception to give even the most naive user some clue as to what went wrong.

MSS Code Factory 1.9.3011 2011-12-29 Added net-sourceforge-MSSCodeFactory-CFLib-1-9

CFLib is going to be released under the LGPLv3.

I've decided that it would be unreasonable and unfair to leverage common code to try to force people to pay for manufacturing and maintenance.

I will therefore be shifting fragments of the Pg8 SchemaObj to this library, as well as moving the CFCore XML base classes here.

Over time, I'll also add a custom exception framework to replace all the relatively useless RuntimeExceptions I throw with the code right now. The custom exceptions will mostly derive from RuntimeException, but they'll be enhanced to make it easy to get diagnostic information about the error from the custom methods of the exceptions.

This will also enable a shift from hard-coded English messages to parameterized exceptions that can be enhanced to use NLS translations. Ideally, you should present enough information in an exception to give even the most naive user some clue as to what went wrong.

MSS Code Factory 1.9.3010 2011-12-29 Added BlobDef to Business Application Models

Going through the data types 1.9 will support, I realized I still hadn't gotten off my butt and defined a Blob. While they're not critical to business applications, they've become more important lately due to web applications that want to incorporate media such as images, videos, etc. in their applications.

To be honest, I've never used a BLOB in my life, so I'm going to have to learn as I go and will probably be producing buggy support for the feature for some time.

MSS Code Factory 1.9.3000 2011-12-28 Correction to the way optional reference attributes are considered

There was a bad assumption in the way that a decision was made at runtime whether to try to resolve a reference or not. Previously, if any of the columns involved were not null, the reference resolution was attempted.

The corrected implementation no longer attempts to resolve a reference if any of the optional columns correlate to a required target column have not been specified.

A 1.8 release has been issued and the 1.9 code has been remanufactured to implement the correction.

Note that 1.9 is still not running due to errors in the way I tie together the compiled GEL instructions. They're supposed to establish a prev-next chain, but apparently I missed a few links. The 1.8 correction has fixed the DbIO invocation problem that was causing a more serious but unrelated crash at runtime.

MSS Code Factory 1.9.2996 2011-12-28 Finished wiring to use the GEL compilet and runtime

I've finished wiring the CFCore implementation to use the GEL compiler and runtime instead of the GenContext interpreter.

Unfortunately it's highlighted a subtle bug in the way that I produce code to resolve foreign keys. If any of the reference attributes are mandatory, I currently treat the relationship as mandatory, and that's incorrect.

Instead of checking of any of the attributes used by a reference are null and attempting to resolve the reference if they aren't, what I need to do is determine if ANY of them are null and ONLY try to resolve the reference if ALL the attributes used are non-null.

I'll have to update the 1.8 and 1.9 rules to correct the problem, and remanufacture the code to implement the correction.

I don't recommend bothering to download this checkpoint release because it flat out doesn't work.

MSS Code Factory 1.9.2977 2011-12-28 GEL Compiler and Runtime Coded

It's been a busy couple of days, but I've coded the GEL Compiler and runtime implementations. It clean compiles, but is completely untested and has not been wired to actually run yet.

The GEL Compiler and Runtime were originally written for 2.0, then back-ported to 1.9.

The extra Builtin expansions have been implemented by the specializing MSSBamCFGelCompiler.

MSS Code Factory 1.9.2930 2011-12-18 Update to merge latest 1.9 CFCore work

Disable manufacturing of PostgreSQL and JEE support for S1CFCore customization. The knowledge base will never be residing in a database, only XML files, so why bloat the library with unnecessary code?

The embedded copy of the s1core 2.0 model has seen the 1.9 GEL runtime objects brought forward as well.

MSS Code Factory CFCore 1.9.2923 2011-12-18 Added initial GEL compile objects

The initial set of GEL compile objects has been modelled and manufactured. Once the set is complete, I'll implement the runtimes by customizing the BLObj layer, and work on a compiler for what is currently the GEL interpreter.

I look forward to substantial performance improvements when it's done. I should have it done before I leave for Christmas holidays.

MSS Code Factory 1.9.2917 2011-12-18 Shifts knowledge base from genkb-1.8 to s1genkb-1.9

The core engine now defines and uses the 1.9 XSDs for the s1genkb component files, so the referencing knowledge base files in the main 1.9 project have been updated accordingly.

MSS Code Factory 1.9.2915 2011-12-17 genkb-1.8 mapped to s1genkb-1.9.

Step one to a 1.9 model was documentation.
Step two is the XSD files.
Step three will be updating the rule cartridges to reference the new XSDs.

Then I can update the parser code for the knowledge base and do another 1.9 release. Yeah, yeah, I should be testing PostgreSQL. No hurry. No one wants to beta PostgreSQL so far, and in the meantime it lets you create, update and read data from a PostgreSQL database. That's enough of a "proof of concept" demo from 1.8 for now. My focus is 1.9, not testing the output of 1.8. I really don't want to go back to modifying the 1.8 rules unless I find actual bugs in the manufactured code while working with it for 1.9.

MSS Code Factory 1.9.2888 2011-12-16 First cut of formatters implemented

When manufacturing the S1CFEngine customizations, the rules need to check whether the ToIndex of a sub-object relationship is unique, producing a Reference if it is or an Iterator if it's not.

The 1.9 rule base has been extended and fixed so that it properly manufactures the S1Core customization extensions.

The first cut of supporting the new S1Core Formatter objects has also been implemented, producing skeletons of the $SchemaName$S1CFFormatter$TableName$ValueOf$ColumnName$ objects which extend the base formatter implementations in CFCore.

MSS Code Factory 1.9.2869 2011-12-16 Split out S1Eng from S1Bam

I decided that although I'd like to do some intelligent parsing of the English language at some point, it does not make sense to merge that model with S1Bam. I need to stay focused on business application models and code with S1Bam, not get distracted. So I split out an S1Eng model.

MSS Code Factory 1.9.2860 2011-12-15 Finished wiring DataScope, View/Edit AccessSecurity/AccessFrequency

The DataScope, ViewAccessSecurity, EditAccessSecurity, ViewAccessFrequency, and EditAccessFrequency attributes have been wired to each of the SchemaDef, Table, and Value. If an attribute is null at a detail level, it defaults to the value of the next higher scope. Value defaults to Table which defaults to SchemaDef.

I don't intend to use the new attributes any time soon, but they're important enough that I wanted to get them defined at least as advisory/documentary attributes for now.

With the resulting extra object references to coordinate and bind, MSSBam for 1.9 now weighs in at 1,519,925 lines of code.

I also added some of the object names for parsing the English language. English has such a challenging structure of words, never mind meaning. But it's something I want to play with during the 2.x series, I have some ideas on how to make it parse and structure the sentences properly to provide hints for dictionary word meaning lookups. As it turns out, I remember very little of my Canadian High School English classes, even though they hammered grammar rules at us for three years running.

MSS Code Factory 1.9.2847 2011-12-14 Refreshed by latest 1.8 release

This release also incorporates the backporting of the new DataScope, AccessSecurity, and AccessFrequency attributes for Value objects.

This will need to be propagated to the Table and SchemaObj objects so that schema and table defaults can be checked for the columns if the attributes aren't specified at the more detailed levels.

See the 2.0 Release History page at the project website for details about the new model attribute values.

MSS Code Factory 1.9.2811 2011-12-13 Clean build of manufactured 2.0 code

The msscf references have all been refactored as s1cf references, including the names of the rule cartridges and their directories. All MssCF references have also been refactored as S1CF references.

If you enable CFCore support, you will actually get support for S1Core 2.0, and will need to download the latest version of that library seperately from the 1.9 installer in order to use the manufactured expert system implementation.

The net-sourceforge-msscodefactory-2.0-s1bam.xml model has also been updated to resolve duplicate naming and clean up the definitions of the Parse objects overall. The Parse objects now have their own ParseObjId generator rather than bloating the DbObj generator values.

In the future, I want to be able to segment a schema into persistent object hierarchies and volatile Ram-based hierarchies. The Parse objects really should be volatile, not persistent, as they'll be getting produced by compiling a Method body and aren't intended to be stored as raw XML objects. However, they do have to be part of the main S1Bam schema so that the engine will be able to translate the Parse objects into native language implementation code.

MSS Code Factory 1.9.2800 2011-12-13 Initial migration of rule cartridges from 1.8 to 1.9 complete

There is a lot of work yet to be done as I copy over the 1.8 XSDs and update the 1.9 parsers to reference the 1.9 XSDs instead of 1.8's. That will allow me to start enhancing the XSD and parsers to finish implementing the new modelling attributes in the 1.9 code base.

The 1.9 rules are being used to drive the production of 2.0 code, so if you enable CFCore support with 1.9, what you'll actually get is support for S1Core 2.0. It's just a refactoring of the technology implementation; the functionality of the core expert system is quite stable and has been for several months.

MSS Code Factory 1.9.2750 2011-12-10 MssCF layer is complete

The MssCF manufactured bindings, iterators, and references with their consolidating MssCFEngine instance are now properly constructed, populated, and ready for testing.

This means the engine can now produce an adaptation of itself tuned to storing knowledge about a new business application model and processing that knowledge into generic text files of transformed information. It's not a mere artificial intelligence, but a genetic life form with its DNA defined by the business application model.

MSS Code Factory 1.9.2750 2011-12-10 MssCF layer is complete

The MssCF manufactured bindings, iterators, and references with their consolidating MssCFEngine instance are now properly constructed, populated, and ready for testing.

This means the engine can now produce an adaptation of itself tuned to storing knowledge about a new business application model and processing that knowledge into generic text files of transformed information. It's not a mere artificial intelligence, but a genetic life form with its DNA defined by the business application model.

I still haven't tested PostgreSQL deletes and multi-object reads; I let myself have some fun being distracted with the automatic MssCFEngine binding to an abstract business application model.

MSS Code Factory 1.9.2704 2011-12-08 We have aluminum!

I wouldn't call this a "gold" release, but it's aluminum! The manufactured code for 1.9 successfully populates an empty PostgreSQL database. It does take a few minutes to do so, but it works! I'll be updating the run logs with this one -- it's a MAJOR milestone in PostgreSQL testing.

All that remains is testing of the deletes, which will be done by re-running the 1.9 test client after the initial load. A second run should recursively delete all the elements of the schema and recreate it using the loaded XML file as one big transaction.

There are probably bugs in the client code, however, so I don't expect that to work for a few hours yet.

MSS Code Factory 1.9.2689 2011-12-07 Significant segments of PostgreSQL persistence now work

I spent the night debugging and fixing the PostgreSQL and object layers until I finally got to the point where most of net-sourceforge-msscodefactory-1.9-mssbam-model loads into PostgreSQL. It currently dies on a TimestampDef insert, but I just don't feel like working any further right now. It's 10 AM and I've been up all night.

There was a slight error in the 1.9 MSSBam model, as I forgot to specify that the Dictionary's DictTenant relationship narrows the inherited Tenant relationship from AnyObj. Subtle runtime errors resulted when the debugger was showing the AnyObj version being set but the Dictionary entry invalid/0 on a database insert.

MSS Code Factory 1.9.2659 2011-12-06 BAM Parser initializes prev/next links

I upgraded the BAM parser to initialize the prev/next links while it parses the atoms and table columns owned by a table. I replicated that behaviour to the IndexCol and RelationCol population as well.

I believe this will exercise all the core data types for the PostgreSQL layer, which I want to get done before I do further development and extensions of the engine.

MSS Code Factory 1.9.2658 2011-12-06 Added Chain definitions to BAM

Chain definitions specify the Prev/Next relationships they use to implement the chain of sub-objects. Accessors to manipulate the chain will be provided, as well as chain iterators.

Note that because chains have multiple entries with a null subkey during the relinking process, the chaining relations cannot be based on unique indexes.

MSS Code Factory 1.9.2652 2011-12-05 Add prev/next lookups to table, index, and relation columns.

These lookups will be used by the GUI and by the engine to support user-specified sequencing of the affected columns

Someday I'll implement a proper "Chain" construct that stitches together TableObj.$ChainName$Prev and TableObj.$ChainName$Next, to provide an OrderedList<TableObj> accessor that is dynamically managed by the client.

For now I can manually code the three cases of chains that I need for the GUI and repository models to be valid when loaded from a database that doesn't impose an artificial sequence like XML documents do.

After I modify the XML import parser to update the prev/next links, I can recreate the PostgreSQL database and test the updated code. I don't need the prev/next links just yet, but thought I should get them out of the way.

1,333,048 lines of code in 1.9.2652.

MSS Code Factory MSSBamCFClient 1.9.2634 2011-12-05 Bootstrap data now merges with repository properly

The client now merges state with the PostgreSQL database repository as it should. Remember the client will be used primarily to provide a "white board" shared editing environment for the design team, not a model revisioning history, so export to XML often and save that away in a software versioning tool.

MSS Code Factory MSSBamCFClient 1.9.2631 2011-12-05 Initial PostgreSQL test cases passed

MSSBamCFClient is being used to test the PostgreSQL database IO implementation by initializing and merging the initial object state with an MSSBam19 repository schema.

This version tests read by unique index and create/insert for basic tables that do not implement object inheritance. This version of the 1.9 client code inserts a significant chunk of data to initialize the lookups of an empty PostgreSQL database, not just a record or two.

I'm comfortable that both test cases are covered, and thereby the foundation of object inheritance creation code is implicitly tested as well. OIC is just a sequence of SQL inserts, one table at a time, with the base table initializing the Id of the object and the subclass inserts using that same Id for their own inserts, forming explicit inheritance relationship links in the database.

Next I need to update the way the engine initializes its lookup data so that it merges state with the repository rather than always doing a create/insert on the assumption it's starting with an empty repository.

1.9.2588 2011-11-21 CFCore MssCFTestCli passed

The minimal changes needed to get CFCore 1.9's testbench code to run have been done and the tests have passed.

1.9.2586 2011-11-21 Initial port of 1.8 code to 1.9

I've completed an initial port of the 1.8 code to 1.9

This provides me with a test framework to exercise the PostgreSQL DbIOs with.