Why is it that so many program generators generate code that is virtually unreadable.  Granted, one of the main advantages of a program generator is that you don't often need to read the generated code, just execute it.  But is really that hard to generate code that maintains indentation and some semblance of a coding standard and naming convention?  Actually, I already know the answer.  I have written code generators, and you can have them create code that can be maintained outside the generator.  Most generators can only get you to 80- or 90% of the way to the final solution (many, no even that far).  Since the generated code is un-maintainable, you end up designing the solution around the tools at hand.  Frequently, this is good enough, and well worth the productivity gains.  You only need one or two people who really understand the tool to design the solution, and then a bunch of people who understand the language involved well enough the write the code snippets at all the exit points that the designer pointed out.  When the user requirements change, or it is discovered that a key business concept was misinterpreted, you simply toss out that section of the design, re-design it and introduce new code snippets.  Most people aren't even aware that they are using a code generator, and often the organizations that create the tools purposely make the generated code un-maintainable without their tools.  Again, if the life expectancy of your application is a few years, then no problem.  This is a great approach.  If you expect your application to be in service for many years or decades, then this lock-in poses a problem.  The tool needs to be at least a year ahead of the technology, so that you can spend that year adjusting your application to the upcoming technology.  If the tools needs to be a year ahead, and it takes them a year to revamp the tool, then they need to know the future technology 2 years before it is required.  Do you know the API's and the platforms that will be in demand 2 years from now?  What you end up with is an application that is always a year or two out of date.

Sometimes the problem at hand is one that cannot be resolved with the tools as published.  The tools can get you very close to the solution, but then you want to abandon the tool and work with the generated code to finish up.  Yes, this means that you can no longer leverage the tool for maintenance.  This is why it is critical that the tool generate maintainable code.  Too often I have been burned by using an application framework with no source code available to me.  Then some great new technology comes out, and there is demand for my application to leverage the technology.  The tool was written before the technology was known about, so it did not consider this.  Now I'm stuck.  How do I get my generated application designed for the blackberry to leverage the Android or iPhone?  How do I leverage some of the features coming in HTML 5 when my generator didn't have this in mind.  My solution is to pick an open framework, where I can see the source and stray from the tools if I want or need to.  When the tools catch up, I can then go back into the fold and pick up the productivity gains.  I'm happy and my user base is happy.