Pragmatic Labs is pleased to announce its second product offering tentatively code named "Prometheus"

Simply stated; Prometheus is a code generation tool for .NET applications.  However, Prometheus goes a step further then most generation tools.  Most code generation tools are tier specific, meaning that they target one tier of the application.  The most common example of this is the data access layer generator.  Generators of this type usually read a database schema and generate code for CRUD operations on the database

Prometheus is a step beyond the single tier generators.  Prometheus allows an application to be defined in a tier independent schema file using XML.  From this schema Prometheus generates the database creation script, stored procedures, the data access layer, the business logic layer and the user interface.  The reason this works is there are certain common patterns that emerge when building applications.  Harnessing the experience of developers and the distilled knowledge of design patterns, a rather full skeleton of an application can be generated very rapidly. 

 Prometheus allows for code extensibility with either inheritance or region directives.  No matter how good a code generator is there is still a need for manual coding to handle business logic and special case situations.  Prometheus seeks to coexist with manual code and provides a clear separation between generated and manual coding.

 Prometheus is currently scheduled for release in the fall of 2005.

 

I found a way to “bind” objects to a web user control so that you don’t have to do this:

   Address a = new Address(….);

   This.txtLine1.Text = a.Line1;
   This.txtLine2.Text = a.Line2;

          

Instead you can just do this:

       

   UserControl.LoadData(a);

Then in the user control you have this:

   Public void LoadData(Address a) 
   {
      FormBinding.BindObjectToControls(a,this);
   }

You can also retrieve the fields once the user has made changes:

 

   FormBinding.BindControlstoObject(a,this);

 

In reference to this previous post, which was inspired by a java patterns book, Holub on Patterns: Learning Design Patterns by Looking at Code, I was again looking for the grail. 

Holub uses a builder pattern approach to avoid exposing each private field through a getter and setter.  This approach is interesting but it quickly becomes complicated in the implementation as a series of interfaces and implementations become necessary and this leaves the casual observer wondering if the getter/setter method might be much simpler to understand.

Holub's assertion is that accessors are used mostly for visual designer created UI's.  This may be true to a large extent but the alternative seems pretty convoluted.  Holub also argues that accessors are very procedural which may also be true and that object oriented progroms become procedural at the margins where they must communicate with procedural systems like UI and database access.  However, in the OO middle the program should be objects which consist of an almost service stack like service object which provides methods in which to accomplish tasks (isn't this procedural?).

Conclusion:  I have headed the warning of not to go crazy with accessors and mutators but the alternatives don't have a good smell. 

An article on OO design and CASE tools versus CRC cards and hand drawn diagrams.

I would have to agree that many times the tool causes such a disconnect from the model that it is more trouble then it is worth.  There is some fundamental mind-body link that causes the mind to be stimulated by drawing and writing. 

This is why the CRC cards, a white board and a digital camera are essentials for the SDK.

I am in the process of putting together my own SDK (Software Development Kit).  No this is not a 50 Meg download from my site but rather a portable software development toolbox that I can take on the road.
fLogViewer

Category	Name	URL
Text Editor	Crimson Editor PSPad Notepad++ Metapad	http://www.crimsoneditor.com/ www.pspad.com/ http://notepad-plus.sourceforge.net/uk/site.htm http://www.liquidninja.com/metapad/
Source Control	Subversion	http://subversion.tigris.org/
Source Control	Subversion Windows Shell Extension	http://tortoisesvn.tigris.org/
Web Browser	Firefox	http://www.mozilla.org/products/firefox/
Design	CRC Cards	http://c2.com/cgi/wiki?CrcCard
Code Generation	Code Smith	http://www.ericjsmith.net/codesmith/
Archiving	7-Zip	http://www.7-zip.org/
Various	Excel	http://office.microsoft.com/en-us/default.aspx
ftp/sftp	FileZilla	http://filezilla.sourceforge.net/
html/xml formatting	HTML Tidy	http://tidy.sourceforge.net/
Clipboard Manager	CLCL	http://www.nakka.com/soft/clcl/index_eng.html
Shortcut Manager	Winkey QLiner Hotkeys	PC World http://www.qliner.com/hotkeys/
Log File Viewer	fLogViewer	fLogViewer
Desktop Search	Copernic	http://www.copernic.com/en/products/desktop-search/

Referring to a previous post, I have been looking at the ways a business object can be represented or accessed through various tiers.  Of the ways this may be done is using the builder pattern. 

The builder pattern leaves the the representation of an object open-ended meaning that an object can have many different representations.  However, we do not need to know all of the representation at the time of construction.  Additional representations of the object can be added later. 

I have seen this pattern used extensively in java and I am actively searching for examples in C#.  Java seems to be a very pattern rich language and often strikes me as an academic language.  More on this in another post.

Welcome to the newly created blog section of Pragmatic Labs.  This is mostly for the journal of Pragmatic Labs chief engineer; Chris Weber.  This is my thought workspace, a place to list links, research and follow up items.