Abstract: Created as an ECO learning vehicle for myself, it acts as a practical example demonstrating various abilities of ECO and that, even for such a modest project, ECO is an advantage and should never be considered “overkill”.

As part of learning to use ECO, I decided to create something I need anyway. As an independent developer I work on different projects over time and often at the same time. To protect myself and my clients, I like to back up my work to an offsite location.

Now there are certainly lots of existing backup products of various capabilities, and it’s even possible to use WinZip and batch files. But I decided I wanted something easy to use and specific for my needs, and it would be a good exercise.

In developing it, I also answered for myself a frequent question I hear: Isn’t ECO overkill for small projects? My answer is no. Despite this being a very modest project, I saved a great deal of time by not having to define relationships in code, manage lists of objects, and design and manage some kind of storage mechanism.

So first let’s define the requirements.

• We want to be able to define any number of backup “projects”, typically these would be one on one for each development project, but can be anything.
• Under each project, I want to define any number of folder specifications, and for each of those, indicate whether to recurse into its sub-folders.
• Also at the project level, I want to define any number of file masks. For development projects, this is of course going to typically include *.pas, *.dfm (or *.nfm), etc. but of course a backup project can include anything at all.
• The project will also need some information about where to store the backups it generates and what to name them. And of course we’re going to want to have some visible feedback as it does its work.

Note: for the ability to zip up the selected files I used open source library called SharpZipLib available from http://www.icsharpcode.net/OpenSource/SharpZipLib/. This library is distributed under a modified GPL license that allows the library to be used by executables without requiring the executable to be GPL.

Let’s start. Create a new ECO Winform Application project. Save the project with the name ECOBackup.

We will need persistence in order to store the project definitions we create with our utility, so we will define that first. Due to the nature of this project, simple XML storage will be ideal.

In the Project Manager, find the EcoBackupEcoSpace and open it. In the tool palette, under the Enterprise Core Objects node, there is a PersistenceMapperXML component that can be dropped on our ECO Space.

Keyboard shortcut: Focus the tool palette with Ctrl-P, then just type “pe” and the palette will display the ECO persistence components. Scroll down to the PersistenceMapperXML and hit Enter.

In the Object Inspector for the PersistenceMapperXML, we need to set a file name. This can just be ECOBackup.xml. You can give it a complete path if desired. At this point take a moment to Save All and compile the project. Then open Winform1 from the Project Manager. In the set of components at the bottom will be one called rhRoot. This is a reference handle used to provide access to the model from the form. In the Object Inspector for rhRoot you will see an EcoSpaceType property and you should now be able to click on the dropdown arrow and select the EcoSpace.

Defining the Model

Defining the User Interface

var f: Folder;

    p: Project;

    dlg: FolderBrowserDialog;

begin

  dlg := FolderBrowserDialog.Create;

  try

    dlg.ShowNewFolderButton := False;

    dlg.SelectedPath := LastBrowsePath;

    if dlg.ShowDialog(Self) = System.Windows.Forms.DialogResult.OK  then

    begin

      f := Folder.Create(EcoSpace);

      f.Path := dlg.SelectedPath;

      p := ProjectsCM.CurrentElement(ProjectList).AsObject as Project;

      p.Folders.Add(f);

      LastBrowsePath := dlg.SelectedPath;

    end;

  finally

    dlg.Free;

  end;

var fm: FileMask;

    p: Project;

begin

  if MaskText.Text.Trim = ” then

  begin

    MessageBox.Show(’Please enter file mask specification’);

    Exit;

  end;

  if MaskList.FindStringExact(MaskText.Text) >= 0 then

  begin

    MessageBox.Show(’File mask already added’);

    Exit;

  end;

  fm := FileMask.Create(EcoSpace);

  fm.Mask := MaskText.Text;

  p := ProjectsCM.CurrentElement(ProjectList).AsObject as Project;

  p.FileMasks.Add(fm);

end;

var p: Project;

begin

  p := ProjectsCM.CurrentElement(ProjectList).AsObject as Project;

  p.Preview;

end;

  BuildEntryList;

procedure Project.BuildEntryList;

var fld: Folder;

    di: DirectoryInfo;

  // find requested files for passed directory

  procedure ProcessMask(d: DirectoryInfo);

  var mask: FileMask;

      fi: FileInfo;

      files: array of FileInfo;

      fe: FileEntry;

  begin

    // apply each mask in turn

    for mask in FileMasks do

    begin

      files := d.GetFiles(mask.Mask);

      for fi in files do

      begin

        fe := FileEntry.Create(self.AsIObject.ServiceProvider);

        fi.Refresh;

        fe.FileSize := fi.Length;

        fe.FilePath := fi.FullName;

        self.FileEntrys.Add(fe);

      end;

    end;

  end;
  // recurse folders from passed starting point

  procedure RecurseFolders(di: DirectoryInfo);

  var dirs: array of DirectoryInfo;

      di2: DirectoryInfo;

  begin

    dirs := di.GetDirectories;

    for di2 in dirs do

    begin

      ProcessMask(di2);

      RecurseFolders(di2);

    end;

  end;
begin

  FileEntrys.Clear;

  for fld in Folders do

  begin

    di := DirectoryInfo.Create(fld.Path);

    ProcessMask(di);

    if fld.Recurse then

    begin

      RecurseFolders(di);

    end;

  end;

end;

var p: Project;

begin

  BackupButton.Enabled := False;

  try

    p := ProjectsCM.CurrentElement(ProjectList).AsObject as Project;

    // clear the file list display

    p.FileEntrys.Clear;

    if PreviewGrid.Visible then

      PreviewGrid.Update;

    p.Backup;
  finally

    BackupButton.Enabled := True;

  end;

var fe: FileEntry;

    zip: ZipOutputStream;

    zentry: ZipEntry;

    infile: FileStream;

    memfile: MemoryStream;

    buffer: array of byte;

    ftp: TIdFtp;

begin

  BuildEntryList;

  if BackupName = ” then

    BackupName := BackupName.Format(’{0}{1}.zip’, self.Name,

      DateTime.Now.ToString(’yyyyMMddhhmmss’));
  memfile := MemoryStream.Create;

  zip := ZipOutputStream.Create(memfile);
  // now process the entries

  for fe in FileEntrys do

  begin

    zentry := ZipEntry.Create(fe.FilePath);

    infile := &File.OpenRead(fe.FilePath);

    SetLength(buffer, infile.Length);

    infile.Read(buffer, 0, infile.Length);

    zip.PutNextEntry(zentry);

    zip.Write(buffer, 0, infile.Length);

  end;

  zip.Finish;

  zip.Flush;

  memfile.Position := 0;
  // upload to a server?

  if ServerName <> ” then

  begin // yes

    ftp := TIdFtp.Create;

    try

      ftp.Host := ServerName;

      ftp.Username := ServerUserID;

      ftp.Password := ServerPassword;

      ftp.Connect();

      ftp.ChangeDir(ServerPath);

      ftp.Put(memfile, BackupName);

    finally

      ftp.Free;

    end;

  end else

  begin // save locally

    infile := &File.OpenWrite(ServerPath + ‘\’ + BackupName);

    memfile.WriteTo(infile);

    infile.Close;

  end;
  memfile.Free;

  zip.Close;

end;  

  ProgressState := ‘Preparing File List’;

procedure Project.FTPStatus(ASender: TObject; const AStatus: TIDStatus;

const AStatusText: string);

begin

  ProgressState := AStatusText;

end;

procedure Project.FTPWork(ASender: TObject; AWorkMode: TWorkMode;

AWorkCount: integer);

begin

  ProgressState := ‘Writing ‘ + AWorkCount.ToString(’N0′) + ‘ of ‘

    + BackupSize.ToString(’N0′);

end;

procedure Project.Backup;

var fe: FileEntry;

    zip: ZipOutputStream;

    zentry: ZipEntry;

    infile: FileStream;

    memfile: MemoryStream;

    buffer: array of byte;

    ftp: TIdFtp;

begin

  BuildEntryList;

  if BackupName = ” then

    BackupName := BackupName.Format(’{0}{1}.zip’, self.Name,

      DateTime.Now.ToString(’yyyyMMddhhmmss’));

  memfile := MemoryStream.Create;

  zip := ZipOutputStream.Create(memfile);
  ProgressState := ‘Compressing Files’;

  ProgressPoint := -1; // tell subscribers to initialize

  ProgressPoint := 0; // start
  // now process the entries

  for fe in FileEntrys do

  begin

    ProgressState := fe.FilePath;

    zentry := ZipEntry.Create(fe.FilePath);

    infile := &File.OpenRead(fe.FilePath);

    SetLength(buffer, infile.Length);

    infile.Read(buffer, 0, infile.Length);

    zip.PutNextEntry(zentry);

    zip.Write(buffer, 0, infile.Length);

    ProgressPoint := ProgressPoint + 1;

  end;

  zip.Finish;

  zip.Flush;
  BackupSize := zip.Length;

  ProgressState := ‘Writing Backup File’;
  memfile.Position := 0;

  // upload to a server?

  if ServerName <> ” then

  begin // yes

    ftp := TIdFtp.Create;

    try

      ftp.Host := ServerName;

      ftp.Username := ServerUserID;

      ftp.Password := ServerPassword;

      ftp.OnStatus := FTPStatus;

      ftp.OnWork := FTPWork;

      ftp.Connect();

      ftp.ChangeDir(ServerPath);

      ftp.Put(memfile, BackupName);

    finally

      ftp.Free;

    end;

  end else

  begin // save locally

    infile := &File.OpenWrite(ServerPath + ‘\’ + BackupName);

    memfile.WriteTo(infile);

    infile.Close;

  end;
  memfile.Free;

  zip.Close;

  ProgressState := ‘Backup complete’;

end;

TWinForm1 = class(System.Windows.Forms.Form, ISubscriber)

    p.AsIObject.Properties[’ProgressState’].SubscribeToValue(self);

    p.AsIObject.Properties[’ProgressPoint’].SubscribeToValue(self);

var o: TObject;

    p: Project;

begin

  o := (ElementChangedEventArgs(e).Element.AsObject);

  if o is string then

  begin

    ProgressLabel.Text := o.ToString;

    ProgressLabel.Refresh;

  end

  else if o is Integer then

  begin

    if Integer(o) = -1 then

    begin

      p := ProjectsCM.CurrentElement(ProjectList).AsObject as Project;

      ProgressBar.Value := 0;

      ProgressBar.Maximum := p.FileEntrys.Count;

    end else

    if Integer(o) <= ProgressBar.Maximum then

    begin

      ProgressBar.Value := Integer(o);

    end;

    ProgressBar.Refresh;

  end;

  Result := True;

end;

unit ECOSubscribe;

interface
uses

  Borland.Eco.Subscription;
type

  TECOSubscriber = class(TObject, ISubscriber)

  private

    FOnReceive: EventHandler;

  published

  public

    function IsAlive: Boolean;

    function Receive(sender: TObject; e: EventArgs): Boolean;

    procedure set_OnReceive(const Value: EventHandler);

    property OnReceive: EventHandler add FOnReceive remove set_OnReceive;

  end;
implementation
{ TECOSubscriber }
function TECOSubscriber.IsAlive: Boolean;

begin

  Result := True;

end;
function TECOSubscriber.Receive(sender: TObject; e: EventArgs): Boolean;

begin

  if Assigned(FOnReceive) then

    FOnReceive(Self, e);

end;
procedure TECOSubscriber.set_OnReceive(const Value: EventHandler);

begin

  FOnReceive := Value;

end;
end.

    FProgressState: TECOSubscriber;

    FProgressPoint: TECOSubscriber;

    procedure ProgressStateChanged(sender: TObject; e: EventArgs);

    procedure ProgressPointChanged(sender: TObject; e: EventArgs);

procedure TWinForm1.ProgressStateChanged(sender: TObject; e: EventArgs);

begin

  ProgressLabel.Text :=

    (ElementChangedEventArgs(e).Element.AsObject).ToString;

end;

procedure TWinForm1.ProgressPointChanged(sender: TObject; e: EventArgs);

var p: Project;

    point: integer;

begin

  point := Integer(ElementChangedEventArgs(e).Element.AsObject);

  if point = -1 then

  begin

    p := ProjectsCM.CurrentElement(ProjectList).AsObject as Project;

    ProgressBar.Value := 0;

    ProgressBar.Maximum := p.FileEntrys.C

Share This | Email this page to a friend

My ECO example article is now posted - click on Articles in the column at left or (better) see it on BDN here: http://bdn.borland.com/article/33669

Share This | Email this page to a friend

Obviously this is big news and a big concern to customers of Delphi, JBuilder and Interbase. Many have posted their views in the newsgroups (borland.public.delphi.non-technical) and as one would be expect, there are many ranging from complete doom to high optimism.

Until an actual buyer is confirmed and the details of the transaction are known, not much can be guaranteed, but Borland has made it clear that their intention is to find a good home for these products, not solely to get the highest possible bid. Obviously they need to get some reasonable price, but they are putting other critieria as high or higher. There is already some action according to one source, but only details of the successful suitor will likely become public knowledge.

Since I have the privilege of having a soap box here, I will offer my opinions. I’ve posted bits of this in various newsgroup posts, but I gather them together along with additional thoughts.

Why sell these products?

It has become more and more evident over the last few years that Borland’s focus, and where they see themselves being most successful, has changed. Clearly resources have not been sufficiently allocated to these products with the result of little marketing, no commission incentives for sales personnel, and worst of all, less than stellar quality releases with C#Builder, Delphi 8, and Delphi 2005. I won’t even attempt to describe the torment Borland’s C++ customers have endured for several years. It isn’t that Borland didn’t hear all our cries during these years, it is that they wanted to put resources where they believed their future lay, and that left little for these products.  As Allen Bauer has said, Borland is too big to act small and too small to act big - and there are too little resources to effectively pursue two different divisions that require completely different infrastructure - different kinds of sales and marketing efforts, different kinds of support. As a result the bulk of the profits have been invested in furthering their other goals.

To their credit, they did not want these products to continue dying due to lack of investment and due to the resulting loss of confidence over the quality issues with the last few versions. So for BDS2006, sufficient investment was made to allow the development team to release a quality product. That, in turn, has made a successful divestment much more likely, since it has clearly helped keep, and even get back, many customers and that helps the bottom line. That reinvestment however, from Borland’s POV, is money they would’ve preferred to spend on their other products, and thus it cannot be expected to continue indefinitely under Borland’s care.

I have also voiced my opinion previously in newsgroup postings (in response to the attempt of a particular shareholder to force sale of Delphi and middleware last year) that I would prefer to see these tools stay with Borland because the continuity of the Borland name, and the fact of their larger size, was a factor in selling customers on allowing me to develop their projects in Delphi. My own fear is that, with a much smaller company, it will be a harder sell than it already is. I still have those concerns, however I have realized that if the current state of affairs were to continue (insufficient funding), it will do more to damage the perception of Delphi in the eyes of my customers then the size of the company behind it.

The Borland Name

Many have suggested that it’s wrong for “Borland“ to go with the newer ALM tools instead of the developer’s tools that are Borland’s legacy. I fully understand their sentiment since I’ve been a Borland customer for about 18 years (starting with Turbo Pascal 5.5). It will certainly seem strange to see these products under a different name and will seem like something has been lost.

It is a simple fact that Borland has established their name in the industry for their other products (ALM, SDO) to the tune of about 70% of their revenue. For them to unstablize this part of their business by adopting a new name would not make good business sense at all. They already learned that lesson several years ago when a certain CEO decided to rename the company to Inprise instead of captializing on the still good Borland name, fortunately that mistake was eventually rectified.

I’m also now convinced that a new company name for the development tools might be exactly what the doctor ordered. “Borland“ is of sentimental value to those of us that have been using these products for a long time, but is of proportionately lesser value to people that have come to these products more recently, and of no value to the new customers that hopefully will be attracted in future. “Borland“ in fact has a lot of baggage, some of it negative - the poor quality releases of the last few years, their “dissapearance“ during the Inprise years (“Borland? Are they still around?“). A new corporate name provides a fresh slate to build on. Combined with the market recognition that does exist for the products themselves, the new company stands a chance of establishing a new and good reputation going forward.

It’s all Microsoft’s fault

I would’ve been very surprised if this hadn’t come up, and I wasn’t dissappointed. The arguments with regard to developer’s tools is identical with the general public arguments about web browsers and office suites.

The argument is that Microsoft makes and sells Windows and therefore should not be allowed to sell developer tools as this gives them an “unfair” advantage in two ways:

• They can always release developer support for their new Windows platforms (e.g. most recently, .Net 2.0 and CF) before Borland and others are able.
• They don’t need to make a profit on Visual Tools and so can sell them cheaply or even give them away

These advantages are certainly real, but are they unfair? These advantages are cited endlessly as reasons Delphi has never caught on big time against C++, and more recently, C#/VB.Net.

It is true that Microsoft would not be seriously dented if it made no money whatever from direct sales of Visual Studio, and in fact they already give away “express“ versions of it; while Borland on the other hand must make profit from these to stay in that business. It will be even more crucial for new owners as this will be their only source of revenue, at least initially. The bottom line is that competition cannot easily compete with Microsoft on price, it must compete on other criteria, mainly features, reliability, and support.

But this is unfair only if one accepts the notion that each company has some inherent right to sufficient market share to stay in business (theory of “perfect competition”), and thus a company like Microsoft must be forced to either charge a price that allows others to compete on that criteria, or be broken up.

What gets forgotten in this “fairness” argument is the customer - the one that must pay for the product. How is it “fair” to force a customer to pay a higher than necessary price for any product? The answer is: it isn’t. Cheap and free products are good for customers and good for the economy as it frees up money to be spent on other things; it increases the standard of living. If cheap or free products were truly harmful to either customers or the economy in general, then freeware and open-source products are far more deserving of criticism than is Microsoft. It is a fact that the free availability of Eclipse has damaged Borland’s revenues far more than Microsoft ever has with its pricing or other advantages, yet very few (any?) suggest that the efforts behind Eclipse are “unfair“ and should be stopped or controlled. So there is the double standard - products like Linux, Open Office, or Eclipse are perfectly ok (apparently because they are not profit-oriented) but it is “anti-competitive” for Microsoft to offer cheap or free versions of such software and deserving of government force.

It is almost a given that if Borland and Microsoft both sold identical quality lumps of coal at the same price, more people would buy from Microsoft simply because it is Microsoft. That may seem irrational, but it is not unfair, it is the rightful free choice of customers. If Microsoft decides to bundle a coal lump with every Christmas stocking, it does not become unfair just because Borland does not produce and sell Christmas stockings. If Borland finds it is no longer profitable to produce and sell lumps of coal because not enough customers are willing to buy it from Borland (even if Borland’s coal was demonstrably better), thus giving Microsoft a coal monopoly, it does not harm the customer; they have rightfully chosen what they want.

So what should we do?

All that said, I very much hope the products find a good home with all the key personnel intact as a team, and I will be doing whatever I can to support the effort - i.e. when the time comes I will trade in my TeamB status for Team “DevCo” and continue helping in the newsgroups, I will continue to use Delphi/BDS and Interbase wherever I can, I will attend “DevCo” conferences, I will support my local User Group, and I ask all that want Delphi to continue to do similar. With our support, “DevCo” stands a good chance of not only surviving, but becoming a bigger commercial success than it has under Borland’s stewardship.

Delphi does not need to match Visual Studio in profits to be successful, it simply needs to be profitable enough to make it worthwhile for a dedicated company to continue pursuing it. So far, despite the problems in the past and cheaper alternatives from Microsoft and others, Delphi has been able to do that. There is no reason to think it cannot do even better with the right people behind it.

Share This | Email this page to a friend

Share This | Email this page to a friend

Someone in the newsgroups recently asked:

  If ASP.NET can and does cache data, why not cache the page as
  an object with all it’s glory?  And when the page is refreshed,
  refresh the native underlying HTTP object, blending it into the
  cached instance.

The answer (copied from my reply there): 

Scalability.

The whole point of being stateless is to allow a small number of resources
to serve a large number of requests. If the entire page was cached as you
suggest (making the page stateful) then, if 1000 clients connected, there
would need to be 1000 instances of each of your pages in the cache. If the
average user visits 5 of your pages, that’s 5000 cached pages. Then, how
long should they be cached for? 5 minutes, an hour? - all while more clients
are creating more instances.

With a stateless architecture, those same 1000 users can be effectively
served with just a few page instances. You can decide, for your specific
needs, just the data that actually needs to be cached.

Share This | Email this page to a friend

I have amended this post somewhat to reflect my changing view and due to clarifications made by Borland on their site, so it is not your imagination if you thought I said something a bit different before….

Borland has finally announced information for the 2005 conference. Call for papers is here.

As it stands currently, it seems this year’s conference has been scaled down over previous years. There are no specific tracks for database (Interbase, JDataStore, NDataStore), ALM (StarTeam, Caliber RM, Together, TerraQuest), or management (i.e. their SDO initiative along with other management-related topics), however it has been made clear that there will be sessions on these as part of the listed tracks. 

The days of the conference have also been shifted, they are Sunday to Thursday. In North America at least, it is a standard in the airline industry to charge just about double for flights that do not span a Saturday. It has been normal for many attendees  to fly into the conference Friday night, thus taking advantage of cheaper fares (at least if they are attending the preconference tutorials). But to do that this year, it will cost them an extra day away from home and work and an extra night of hotel charges.

It is clear that Borland is focusing more on developers at this conference with apparent plans to offer a separate conference that focuses more on management levels (where they will highlight their SDO initiative more than development tools).

I have conflicting thoughts on this presently. There are many who think this is a positive move - more purely a developer’s conference concentrating on the tools we love along with some attention on the ALM tools.

However, I also have interest in learning about SDO and how it might help me or my customers, but I will not be able to afford to go to a separate conference just for that.

I also think that there is a lot of value in different levels intermixing at a conference - one gets to meet people besides their direct peers, possibly “networking” with others that may pay future benefits, as well as promoting some degree of learning across those boundaries. I think separating customers (and thus emphasizing such boundaries) might not be the best way to go.

But we’ll see.

Share This | Email this page to a friend

There has been a discussion taking place in the Delphi non-tech newsgroup on the merits of refactoring with a few participants suggesting that refactoring is only needed if one designs or writes poor code in the first place - i.e. that refactoring is only useful for fixing bad code, not for writing new code. In an effort to prevent this developing myth from spreading too far I responded there with the following examples showing this is not true (a couple of typos have been corrected):

1. Enhancing existing code, even when originally well designed and written,
in order to allow it to be more easily reused for a new feature being added.
This can take the form of extracting methods or abstracting out a baser
class, or delegating some functionality, originally built into a class, to
an interface (e.g. a plug-in).

Unless you’re omniscient, you cannnot blame anyone for being shortsighted
for not foreseeing every possible future enhancement that could be asked
for, and even if one could, it still does not justify coding for every
possible enhancement in advance of actually needing it.

2. During original development, realizing that something you are doing now could be reused by another part of the application. Such realizations do not always happen during design no matter how thorough one tries to be or how well modelled it was.

3. During development, flaws in the design may come to light - as above, this can happen no matter how much care was taken in design. In this case, one should, of course, go back to the design with that new knowledge, but then the code does indeed need to be refactored at that point.

4. Finally, we all (hopefully) improve our practices with time and experience (and if we stop doing so then, IMO, it is time to quit and do something else). So it is not at all unusual that one writes code a certain way and then, looking at it again later, realizes a better way to do it -
even in the course of a single project.

I’ve often written code where I was not really satisfied with my solution but did not yet know a better way to do it, or where time constraints forced me to allow a solution I knew was not the best I could do, had I more time. When a future opportunity allows, it’s nice to be able to go back to that code and refactor it. The existing code is not necessarily wrong - i.e. no bug exists, it could just be better!

Bottom line is that refactoring is as useful during original development as it is for fixing/improving/extending older code, and makes writing correct code the first time a whole lot more likely!

Share This | Email this page to a friend

Falafel’s conference in Toronto wrapped up today. It was excellent - of course it couldn’t be anything but, with Lino, Danny, and Allen presenting (Steve had to bow out this time). They of course covered Delphi 2005 features in the compiler and IDE for both .Net and Win32, ASP.Net, Security, and lots of other things. Lino finished the day with some coverage of what to expect in ASP.Net 2.0 once Microsoft releases it next year.

If you were anywhere within driving distance of Toronto and didn’t come, well…  One lucky attendee left with a copy of Delphi 2005 Architect, and Lino also gave away other products from Falafel and swag supplied by Borland.

We would very much like to make this an annual event, so please consider attending - the more the merrier.

Share This | Email this page to a friend

One of the sessions I attended was on color modeling. I first read about this only a few months ago and have gradually been warming up to it as a result of trying it on various example problems derived from projects I’ve done in the past. The session was good and cleared up a couple of gray areas for me and now I like it even more and intend to actively use it.

There are a number of articles available on BDN, here are a couple to get you started:

• The Coad Letter: Modeling and Design Edition, Issue 68, a New Beginning
• Whole-Part Relationships in Color Modeling

The results of this technique is it makes diagrams a lot more readable and easy to follow, but most importantly, at least for me, is I found it really makes a difference in how I think about the classes and the responsibilities and relationships each class should have. My class diagrams most definitely change from what I would’ve done previously and I can clearly see it as a change for the better.

Share This | Email this page to a friend

Share This | Email this page to a friend