Amazon.com Widgets All posts by nick

Using Anonymous Methods for Inversion of Control

By Nick at March 31, 2012 08:26
Filed Under: Delphi, Software Development, Unit Testing

Introduction

I’ve written an entire series of articles about Dependency Injection and the Inversion of Control.  I’ve exhorted you to decouple your code and to ask for your dependencies instead of creating them yourself.  I hope you’ve listened.

Now I’m going to discuss another way you can invert the control of your code – by using anonymous methods.

Anonymous methods were one of two major language features added in Delphi 2009 – the other being generics.  Generics are probably easier to understand and use as they have a great use case with collections.  Anonymous methods are a little harder to understand because their use and their purpose are not as easily seen.   I hope that you’ll start seeing their advantage after reading this post.

Basic Idea

The basic idea is pretty simple – anonymous methods allow you to pass code, i.e. functionality, like any other variable.  Thus, you can ask for  functionality via an anonymous method just like you can ask for a dependency via an interface.  Because you can assign code to a variable – or even pass code directly into a method – you can easily invert the control of your class by passing in code to your class instead of embedding it in the class itself.

One of the principles of Inversion of Control is “Don’t call us, we’ll call you”.  That is, if a class needs something, the class itself should ask for (call) the functionality, rather then doing that functionality itself.  If a class needs to, say, record the processing of widgets as it happens, it should ask for a widget recording class and record things using the dependency that is passed in.  A class should not create it’s own instance of a widget recording class and then use it.

Given that example, it’s not difficult to see how one could pass recording functionality into a class as an anonymous method. 

Doing it the “Normal” Way

Let’s use the above discussion in a code example.  As noted, perhaps your class needs to record the processing of widgets.  Typically, you might do something like this in order to use good dependency injection techniques:

type
  IWidgetRecorder = interface
    procedure RecordWidgets(aNumberOfWidgets: integer);
  end;

Then, you’d pass an instance of that interface into your class:

var
  MyWidgetRecorder: IWidgetRecorder;

...

MyWidgetRecorder := TWidgetRecorder.Create;
MyWidgetProcessor = TWidgetProcessor.Create(MyWidgetRecorder);

You’d store the widget recording interface and use it in your class as needed.  And that’s an excellent thing to do – your class is decoupled completely from the recorder, and you are using constructor injection to ask for your dependency. 

Again, this is a great technique, and probably preferable most of the time.  I don’t want to leave the impression that what I discuss below is always a replacement for good, sound use of interfaces. However, it may not always be what you want to do.

IOC with Anonymous Methods

As noted above, you can use anonymous methods to invert the control of your class.  Perhaps declaring an interface and instantiating a class to implement it is too heavy.  Perhaps the dependency is really simple and straightforward.  In those cases, using a simple anonymous method to inject your dependency might be a better solution for decoupling your code.

For instance, you can declare an anonymous method type:

type
  TWidgetRecorderProc = reference to procedure(const aCount: integer);

This will allow you to declare code that takes an integer – presumably the count of widgets being recorded – and does whatever you need it to without bothering the class that uses it.

From there, you can use this type in your classes:

type
  TWidgetProcessor = class
  private
    FWidgetRecorder: TWidgetRecorderProc;
  public
    constructor Create(aWidgetRecorder: TWidgetRecorderProc);
    procedure ProcessWidgets(aNumberToProcess: integer);
    property WidgetRecorder: TWidgetRecorderProc read FWidgetRecorder write FWidgetRecorder;
  end;

This simple class declaration takes an anonymous method as a parameter to its constructor, and then exposes that function as a property. That’s a bit of a commitment – you may not always want to do widget recording.  If you wanted, you could not pass the anonymous method in the constructor and simply assign it to the property as desired. In any event, the widget recording functionality is implemented externally, and your class merely depends on the anonymous method type. 

Then, you can implement the class as follows:

{ TWidgetProcessor }

constructor TWidgetProcessor.Create(aWidgetRecorder: TWidgetRecorderProc);
begin
  inherited Create;
  FWidgetRecorder := aWidgetRecorder;
end;

procedure TWidgetProcessor.ProcessWidgets(aNumberToProcess: integer);
begin
  WriteLn('Processing ', aNumberToProcess, ' widgets.');
  WidgetRecorder(aNumberToProcess);
end;

Now, you have a class that can record widgets any way you want to – to the console, to a file, to email, a database -- whatever.  And you don’t have to know anything about the implementation of how the widgets are recorded. You just have a variable that refers to the code, which you can easily call in your code. 

Using Your New Widget Recording Tool

So, now we have a TWidgetProcessor that can record widgets with an anonymous method.  Cool – but how?  Well, you simply declare an anonymous method and pass it in.  Here’s an example which just writes out to the console:

procedure ProcessSomeWidgetsAndRecordToConsole;
var
  WidgetProcessor: TWidgetProcessor;
  RecorderProc: TWidgetRecorderProc;
begin
  RecorderProc := procedure(const aCount: integer)
                  begin
                    Writeln('The Widget Recorder recorded ', aCount, ' widgets');
                  end;


  WidgetProcessor := TWidgetProcessor.Create(RecorderProc);
  try
    WidgetProcessor.ProcessWidgets(Random(100));
  finally
    WidgetProcessor.Free;
  end;
end;

All this code does is declare an anonymous method that matches the declaration of TWidgetRecorderProc and writes the information out to the console.  That’s pretty simple.  But what if you wanted to write it out to a file?  Easily done without changing the TWidgetProcessor class at all.

procedure ProcessSomeWidgetsAndRecordToFile;
var
  WidgetProcessor: TWidgetProcessor;
  RecorderProc: TWidgetRecorderProc;
const
  cFilename = 'WidgetRecord.txt';
begin
  RecorderProc := procedure(const aCount: integer)
                  var
                    SL: TStringList;
                    S: string;
                  begin
                    SL := TStringList.Create;
                    try
                      if TFile.Exists(cFilename) then
                      begin
                        SL.LoadFromFile(cFilename);
                      end;
                      S := Format('%s: %d widgets processed', [DateTimeToStr(Now), aCount]);
                      SL.Add(S);
                      SL.SaveToFile(cFilename);
                    finally
                      SL.Free;
                    end;
                  end;

  WidgetProcessor := TWidgetProcessor.Create(RecorderProc);
  try
    WidgetProcessor.ProcessWidgets(Random(100));
  finally
    WidgetProcessor.Free;
  end;
end;

Of course, you could write a similar anonymous method to record the information to a database, send an email, or any combination thereof. 

And just as importantly, if you want to test The TWidgetProcessor class, you might want to do so by passing in a TWidgetRecorderProc that does absolutely nothing:

  RecorderProc := procedure(const aCount: integer)
                  begin
                     // Do nothing, as this is a stub for testing purposes
                  end;

And of course if your classes are easy to test, then they are very likely well designed.  The ability to stub out functionality as above is a hallmark of well designed classes.

Conclusion

So now you have another tool in your Dependency Injection/Inversion of Control tool box.  The power here is in the ability to decouple functionality from the class that needs that functionality. Anonymous methods provide a nice way to wrap up functionality in a single variable.   Instead of injecting an implementation of an interface, with anonymous methods you can inject a specific chunk of code that will provide the functionality.  Either way, you end up with testable code that will be more maintainable in the future.

(I have included the full source for this demo, as well as other demos, available on my Demo Projects repository on BitBucket.org)

Flotsam and Jetsam #58

By Nick at March 24, 2012 11:59
Filed Under: Delphi, Flotsam and Jetsam
  • The annual RAD Studio survey is out. (UPDATE:  Apparently the link I gave was unique to me, so I've removed it.) I strongly recommend you take it if you are a Delphi/C++Builder/Prism kind of guy.  I can assure you from first hand experience that the results of this survey are very valuable and are used by Embarcadero to make decisions.  So please fill it out and let Embarcadero know what you think.
  • Awesome Quote by Nick of the Week: “The real cool part of it is that proper unit testing is a "virtuous circle". The more you write unit tests, the more you see how to write testable code. The more you write testable code, the more you tend to remove dependencies. The more you remove dependencies, the more decoupled your code is. The more decoupled your code is, the easier it is to test, and thus you write more unit tests, and start it all over again.”   I wrote that in a conversation about unit testing in the Delphi newsgroups.
  • Awesome Follow-up Quote by Dalija Prasnikar of the Week: After someone claims that unit testing can become “wheel-spinning”:  "Exactly opposite. It is quite hard to start the process rolling at the beginning. But once you get going it gets easier and easier, and you write new code faster and with less bugs and when you do write bugs, you find them in matter of seconds instead hours. And you end up with code that is easy to maintain and change. What more could you want?"
  • Sure enough, the denizens of Wikipedia have determined that this blog is “not notable”.   “Notability” is the magic word for Wikipedians, though often I think the definition that they use for it “Stuff I’m not interested in” or “a word I can use to control my little fifedom of the web’.  I will note, though, that my entry has appeared to prompt a complete reworking of the disambiguation page for “Flotsam and Jetsam”, so I’ve got that going for me, which is nice.  I can understand the need for Wikipedia to maintain a level of neutrality and objectivity, but I do think that it can get out of hand, with small-minded people enjoying their power a bit too much.  In any event, I do love Wikipedia, and use it probably more than any other site on the web.  One could even make the argument that it is mankind’s greatest achievement.  Perhaps I will in a future blog post.  Winking smile

Authoring Generics: A Simple First Step

By Nick at March 19, 2012 15:39
Filed Under: Delphi, Software Development

Consumer or Producer?

By now I suspect that most of you have heard of generics.  Perhaps you have started using them via the Generics.Collections unit, where you can find TList<T>TStack<T>, etc.  The Delphi Spring Framework contains an even more sophisticated set of collections and interfaces to those collections, including the very powerful IEnumerable<T>

These are all very useful classes, and our code is made much simpler, easier to maintain, and more type-safe because of them.  But using them merely makes us consumers of generics.  If we want to truly take advantage of generics, we need to become producers of generic classes.  It’s a big step to see the benefit of generic collections, but the truly big step is to start seeing opportunities for the use of generics in your own code.

A Contrived, Simple Example

This past weekend, some of my team members and I attended the C-Sharpen event here in Philly.  It was a valuable day, made particularly so by the presentations given by Steve Bohlen.  He gave an excellent presentation on the topic I discussed above – how we need to start thinking as producers of generics and not merely consumers.  In that presentation, he gave a simple example of how generics are powerful and can make your code simpler, more effective, and more powerful.  So, I’m going to show that example here.  It’s a bit contrived, but very illustrative of how to think about generics.

First, consider the following code:

type

  TOrderItem = class
    ID: integer;
  end;

  TOrder = class
    ID: integer;
  end;

  TCustomer = class
    ID: TGUID;
  end;

Now this code is very simple – a set of classes that might represent a simple order entry system.  But right away, something should occur to you.  All three have something in common – they are entities in your system. Down the road, you may want to act upon all the entities in your system, so you might create a superclass like so:

type

  TEntity = class  
  end;

  TOrderItem = class(TEntity)
    ID: integer;
  end;

  TOrder = class(TEntity)
    ID: integer;
  end;

  TCustomer = class(TEntity)
    ID: TGUID;
  end;

But you might be frustrated because you want your TEntity class to have an ID field that is in use by all descendants, but that pesky TCustomer class can’t oblige – it needs a GUID for its ID tag instead of an integer like the other classes.

Instead of fretting about the different types of ID tags, how about just create one that doesn’t care what type it is?  Well, this is where the power of generics comes in.   How about you give the TEntity class a parameterized type – a generic – as  it’s ID, and then just tell all the classes what type their ID tag will be?

type

  TEntity<T> = class
    ID: T; 
  end;

  TOrderItem = class(TEntity<integer>)
  end;

  TOrder = class(TEntity<integer>)
  end; 

  TCustomer = class(TEntity<TGUID>)
  end;

Now, given the above, your entities can all have ID’s, but you don’t have to have the same type for all of them.  If a TEntity descendant needs an ID of a different type, you can just descend from TEntity and pass the correct ID type in the class declaration.  

Again, the example is quite contrived, but I think it does a nice job of showing how you can starting “thinking generically” and not just accept a rigid type structure. 

In addition, it illustrates why the more formal name for generics is “parameterized types”.  The type in the brackets is passed in to the type declaration, and then used within the class, just as method parameters are passed in to functions and procedures. 

A simple, contrived example, sure.  But hopefully it illustrates how generics can be used to turn you from a consumer of generic classes to making them a common tool in your code.

 

Update:

As a number of commenters have pointed out, my original example was sub-optimal.  Rather than post a "correction" post, I've taken the liberty of updating and improving the original article.

New Blog Theme

By Nick at March 17, 2012 15:41
Filed Under: General

As you  have no doubt noticed, I updated the theme to my blog.  I was never really happy with the one I've had for about a year now, so I tweeked and existing BlogEngine.Net theme to my liking. It appears to be working and looking fine, but l can't test it on all the browsers you people have, so please let me know if you encounter any problems or oddities.  

One problem I am having is getting the lists, especially nested unordered lists, to work right.  Not sure what is going on yet, but I'm learning.  

Flotsam and Jetsam #57

By Nick at March 16, 2012 09:23
Filed Under: Flotsam and Jetsam, Delphi

How Not to Code: Passing function results directly as parameters

By Nick at March 11, 2012 12:27
Filed Under: Delphi, How Not To Code

I think I’ll start a new series, and a new blog category, called “How Not To Code”.  In it, I’ll try to highlight those little things that we’ve tended to do over the years that, well, are tempting for expediency, but probably not something we should be doing.  There are a lot of “Here’s the right way to do things”, so this series will concentrate on the “what not to do”.  That will inevitably lead, of course, to a discussion of “What to do”, but that’s ultimately the point, I suppose.

Today’s topic is “Don’t directly passing function results as parameters to other functions and procedures”. 

For instance, consider the following code:

type
  TData = record
    a, b: integer;
  end;

  TMoreData = record
    c, d: string
  end;

function GetSomeData(aInteger: integer; aString: string): TData;
function GetMoreData(aBoolean: Boolean; aInteger: integer): TMoreData;

procedure ProcessData(aData: TData; aMoreData: TMoreData);

Then, imagine that you wanted to call ProcessData with the result of  calls to GetSomeData  and GetMoreData.   It would be mighty tempting to simply call:

ProcessData(GetSomeData(aIntVariable, 'ocelot'), GetMoreData(True, AnotherIntVariable));

After all, think of all the typing you’ll save!

You should avoid that temptation, because this way of doing things presents a few problems:

  • It’s really hard to read.
    • A line of code that does more than one thing requires more brain power to read that does code where each line does one thing.  In this case, you have to convince your brain to parse all those parentheses.  Before you can figure out what the code is really doing, you have to parse two function calls inside of a procedure call.  Using your brain to parse unnecessarily complex semantics is a waste of effort.
    • You can’t be sure by merely reading the code what the types of the parameters are that are being passed to ProcessData.  This means that you have to look up the parameter types to gain full understanding.  If the variables were declared locally, then it would be easy to see their types.
  • It’s really hard to debug
    • There are no intermediate results to check in the debugger.
    • Stepping into the code requires that you step into the calls to GetSomeData and GetMoreData, when that might be something that you don’t want to have to do.

Instead of trying to compress everything into a single line of code, you probably would do something like this, instead:

var
  TempData: TData;
  TempMoreData: TMoreData;
begin
  TempData := GetSomeData(aIntVariable, 'ocelot');
  TempMoreData := GetMoreData(True, AnotherIntVariable);
  ProcessData(TempData, TempMoreData);
end;

The above code solves the aforementioned problems – it is easier to parse in your head and you can easily see the data values in the debugger before they are passed to ProcessData

Some good heuristics that fall out of this:

  • If you have to stare at the code for a moment just to parse it in your head before you even figure out what is going on, then you have a problem.
  • If you have a hard time figuring out where to put a breakpoint to get at the debugging information that you really want, then you have a problem.
  • If you feel the need to create intermediate variables to improve your ability to debug code, then you probably should have put the intermediate variables there in the first place. 
  • All sorts of bad things happen when you try to be clever and save a few keystrokes by taking a code shortcut.  Remember, the future maintainer is the person you should be writing code for, not the compiler.
  • A line of code should do one thing and one thing only – if the explanation of what a single line of code does needs the word “and” to describe it, then it probably ought to be two lines of code.

Lesson for the Day:  Always pass variables, never direct function calls, as parameters to another procedure or function. 

On Why I Think Twitter is Awesome

By Nick at March 04, 2012 11:57
Filed Under: TechBiz, General, Tech Stuff, Software Development, Delphi

I have this friend who totally doesn’t get Twitter.  He doesn’t get it so much that it actually kind of makes him angry that anyone does get – and like – Twitter.  To him, it is a total waste of time in every way. He can’t imagine why anyone would spend any time at all having anything to do with Twitter.  And that’s fine – to each his own. But I do find it amusing that someone would feel that way about a service used and enjoyed by millions of people. 

I’m a Twitter lover.  I find it entertaining, amusing, interesting, and good for my brain.  I really enjoy reading it, and I really enjoy posting tweets.  I get good news, good development information, and a good laugh when I read twitter.  I get to express my self in short bursts that  help me formulate my thoughts.  What’s not to like?

The common impression is that Twitter is for “letting you know what your friends are doing” – or at least that is how it was originally marketed.  The common misconception is that Twitter is just a bunch of people posting “Now I’m eating lunch.  Yum!”, and perhaps it was that in the very beginning.  But in the spirit of “Let a thousand flowers bloom”, Twitter became a lot more than that.  Twitter is a forum for expressing not only what you are doing, but what you are thinking, what you are watching, what you are reading, and anything things that you are up to.  It is many things.  It is a means of conducting a conversation across the world.  It is a means of sharing information with like minded people .  It can help you track your customers are thinking.  It can be a source of entertainment.  It can ensure you are up to date on the latest news, and it can even help foment a real live revolutions.  Not bad for a site that posts things  140 characters at a time.

Short and Sweet

Here’s the main reason why I like Twitter:  It forces us to express ourselves in short, concise sentences.  140 characters isn’t a lot, but it’s not nothing.  It is sort of real-world application of Strunk & White’s exhortation of “Use fewer words”.   It’s really quite amazing the amount of humor, wisdom, and pith people can cram into that little chunk of text.  Anyone who cruises around the internets knows that, while it allows people to publish openly without the barrier of a publishing house, folks – this blog included – don’t get the benefit of an editor.  Twitter is the one place where you can know that if you read it, you’ll get things in short, concise, crisp chunks.  (And I should add that I pride myself on never using ‘4’ and ‘2’ and other similar shortcuts….)

I find that pleasing as a reader, and valuable as a writer. If I can express my thought in 140 characters, then I know that I’ve really distilled it to the essence of the thought.  For instance, it took a while for me to get Hodges Law down to 140 characters but I did.  (And I also now have the added advantage of it being in a single place that I refer to my awesome idea – as well as showing that I was the first to think of it.  Winking smile  )

The other big reason I like Twitter is that it is an “easy read”.  If I have a few minutes to kill, I can pull out my Kindle and flip through the latest on my Twitter feed. I’ve knocked out more than a few pages of Twitter feeds at the Doctor’s office.  It also is perfect for solving that First World Problem of being bored while, ahem, “indisposed”.

Third reason?  It’s a wealth of information about Delphi and software development.  Many great developers tweet, and point to articles and blog posts that teach and explain about development.  Want to know what the latest Delphi articles are?  Follow DelphiFeeds.   You can’t say it is impossible to know what is going on with Embarcadero – they have a Twitter feed that updates with just about everything going on with the company.  You can tailor your feed to bring you whatever you are interested in.  I’m interested in Software Development, the NBA, specifically the Timberwolves, certain American Idol contestants, and generally funny stuff.  That’s exactly what my feed brings me. 

HashTags

Another feature that is both fun and powerful are hashtags.  As far as I know, the power and coolness of hashtags was actually an invention of the Twitter community and not an original part of the “spec” for Twitter.  According to this article – which is a great history and summary of hashtags -- the idea actually came from a guy named Chris Messina, and his idea has become part of the power of Twitter.  Hashtags are used to create groups or topics.  Sometimes they are fleeting – like a hashtag for the Superbowl – or sometimes they are ongoing, with people constantly adding to them, like the “#overheardathome” tag.  Want to see what others are saying while American Idol is on?  There’s a hashtag for that.  They have even made a difference in world events.  The valiant folks fighting for freedom in the Arab Spring used twitter hashtags to inform the world and each other about important, world-changing events.  Businesses are event starting to include hashtags in their advertisements (and of course, folks aren’t always respectful of those tags…..)  There’s even a website dedicated to tracking the use of hashtags.  From the humble beginnings of an idea from a single users, hashtags have made twitter into a useful and powerful communications medium.

Comedy

It may have started out as a site to tell your friends that you are eating lunch, but Twitter has become a great place for some quick-witted comedy and entertainment.  Heck, I tweet a lot about technology and programming, but I try hard to make a witty, funny comment every once and a while.   Some people’s sense of humor is just made for Twitter.  One of my favorites is Josh Hara.  If you are looking for a series of laugh-out-loud funny, but off-color tweets, look no further than Pauly Peligroso.    There are tons of lists of (allegedly) funny people on Twitter.  I should add that in my experience, the people that are “supposed” to be funny – that is, comedians whose names you know – aren’t really that funny. But hands down, bar none, the funniest feed on Twitter is Sh*tmydadsays.   In any event, Twitter can definitely make you LOL.  (I only use “LOL” when I, well, actually do laugh out loud. You should follow the same rule.)

Parody and History Sites

Another feature that dovetails on the straight comedy sites are some of the excellent parody sites.  There’s a whole slew of Star Wars characters on TwitterLord Voldemort of Harry Potter fame is enormously popular, on topic, and very funny.  He and Severus Snape often exchange barbs.  (Actually, there are quite a few folks tweeting as Severus Snape on Twitter….)  You can keep track of Batman, Drunk Superman, Aquaman  (Warning: he’s a little….”salty”), Spiderman, Drunk Hulk, and just (presumably sober Hulk. (Apparently there are many facets to Hulk’s personality). Want some history? You can follow Henry VIII, Calvin Coolidge,   You can follow the history of the Byzantine Empire, the first 1000 days of the JFK administration, and real-time events of World War II.  And that is just scratching the surface.  Believe me.  There is no end to the inanity, craziness, and imaginativeness of the folks on Twitter. 

In The End

Yes, Twitter would be boring if it were nothing more than people telling you what they were doing.  It may have been that at one point, but it’s become way more than that.  Shoot, a recent cover of Sports Illustrated had a hashtag for the cover article about Jeremy Lin. In the end, Twitter can me what you want it to be.  You can follow technologists, pop stars, actors, authors, characters from books and movies, business, news sites, newspapers, bloggers, family members, humorists, athletes, historical characters, and more.  You can keep up with technology, world events, politics, all manner of news and events, what your favorite authors/actors/singers are up to.  It’s really a huge, fascinating party that you can control to your heart’s content. 

Why anyone wouldn’t be interested in that, I have no idea.

Three Sentence Movie Review: Drive

By Nick at March 03, 2012 06:32
Filed Under: Three Sentence Movie Review

Drive: Hey, I’m as big a Ryan Gosling fan as the next guy, but holy cow is this movie ever boring, filled with lots of silent, forlorn staring and longing. In addition, I can’t stand a movie where the “hero” drives away, leaving a bag with a million dollars in it lying on the pavement.  Seriously?

I don’t want to hear another frackin' negative word about Embarcadero Marketing.

By Nick at February 26, 2012 09:19
Filed Under: Delphi, TechBiz

Not one more word.

For many years, it has been very fashionable to say how “[Borland|CodeGear|Embarcadero] sucks at marketing”.  You could very easily establish your bona fides by bashing Delphi marketing.  Everyone knows that Borland always sucked at it, and all the cool kids say so, right?

Well, I think those days are over.

What is Marketing, Anyway?

First of all, I’m guessing that about 99% of the people saying this didn’t understand the difference between “marketing” and “advertising”.  They aren’t the same, just so you know.  They overlap, but they aren’t synonymous.  The Wikipedia page for marketing starts out with "Marketing is defined by the AMA as ‘the activity, set of institutions, and processes for creating, communicating, delivering, and exchanging offerings that have value for customers, clients, partners, and society at large.’"  My personal definition is “whatever you do to make people aware that your product is for sale and what the reasons are that they should buy it”. 

Sales and marketing are related, but very different.  In general, marketing’s job is to create leads for sales to act upon. 

I think that the root of much of the complaining over the years has been the result of a lack of advertising.  People who don’t see advertising think that there’s no marketing going on.  Marketing is much more than just running ads.  Marketing activities include, but are very much not limited to, advertising. In fact, some of the most effective marketing is that which requires zero advertising.

For instance, Dropbox has a brilliant marketing strategy that has been amazingly successful and requires exactly zero budget for marketing or advertising. What do they do? They get people like me to try to get people like you to sign up. The more people sign up, the more potential paying customers they have. They give away 2GB of space (which probably costs them something like $0.000001….) and then induce those folks to do their marketing for them. They have been enormously successful doing this. They spend zero money on advertising, but they have a fantastic marketing plan that makes millions of people aware of what they have to sell. Awesome.

Delphi Marketing in the Past

I’ll concede that the marketing of Delphi has been historically “limited” or “hard to find” . I’ll not concede that it has been “bad” or “terrible”. The marketing itself has been good – there just hasn’t been enough of it.  Marketing success is largely a function of budget, and over the years, and the budget for marketing Delphi has not always been huge. As noted above, there isn’t a direct relationship between marketing and money, but certainly money is a big boost.  Limited budgets have made it harder to market Delphi, but that doesn’t mean that the marketing that was done was done poorly.

Despite limited budgets, here has always been marketing going on around Delphi.  Every new release resulted in many activities, a “world tour”, webinars, etc.  And here’s a key point to remember:  if you are an existing customer, then marketing to you is fairly easy. You already know the products and benefits.   To a large degree, efforts spent on marketing that you see is wasted effort.  The perfect marketing plan would be visible only to non-customers and invisible to existing customers.  And here’s the second thing to remember -- if you know that Delphi is on version XE2, and even the basics of the current feature set, then you have been successfully marketed to, whether you want to admit it or not! That’s always been the case – if you knew about the latest release and it’s features, you were successfully marketed to. 

Delphi Marketing Today

However, over the last few years, things have been getting better.  And over the last year or so, things have gotten, well, really good.  In that time, I’ve seen a marked and obvious increase in marketing activity and an rise in the quality of things done for Delphi and Embarcadero products in general.  Clearly someone has decided to spend some money and make it a point of emphasis. 

I now see the following on a regular basis:

  • First, the overall outbound communication in general has steadily picked up.  I now see people who for years didn’t hear a peep from the Delphi marketing team now complaining that they are getting too many emails.  Some are even upset that their sales representative has called them.  Yeah, that’s terrible!  I myself had a very nice chat with our sales person last week --  they were pleasant, knowledgeable, and helpful.  We probably won’t be upgrading our licenses until next year, but they were happy to know that, and interested in hearing my feedback on a wide variety of things, including the product, the marketing efforts, and other things of concern.  I appreciate a vendor that takes the time to hear me out.
  • A steady stream of webinars on a wide range  of topics.  It seems that at least once a month, they are conducting a webinar of some sort, on topics ranging from Delphi to database design and enterprise architectures.  I get very professionally done emails, I sign up, they remind me about the event, and they follow up with emails after.  If I miss it, they send an email saying “Sorry we missed you, here’s the replay”.  As a result, you see their products in action, you learn the new features, and you are steadily reminded that the product is there.  Excellent work.
  • When they aren’t doing webinars, they are letting me know about White Papers that well known Delphi community members have written.  There a lot of them available, and a steady stream of new ones coming online.  Nice.
  • I haven’t seen them recently, but for the last few years, Embarcadero has had a full page advertisement in every issue of SDTimes.  I’ve also seen banner ads on the SDTimes website. 
  • And while on the subject of ads, I see Delphi banner ads all over the place.  They clearly have paid Google for the adwords, and since Google knows I’m a Delphi user, I see ads for Delphi and RAD Studio all over the web.  Nice.
  • They also appear to have bought keywords on StackOverflow.  Try this – log out of StackOverflow and go the Delphi tag page and see what you get on the right side.  (If you don’t any reputation at StackOverflow, you don’t have to log out – they stop showing ads after a certain reputation score).
  • For a long time, the Borland/CodeGear/Embarcadero website was….less than helpful.  However, now, it is really well done.  Checkout the Delphi page.  It’s visually appealing with a  good highlight of the product. Easy to find links take you to the Product Edition page, a page showing cool third-party stuff, and free resources out on the web, among other information  And of course the page has a clear “call to action”, either buy or download a trial.  This is a very nicely done web page.
  • And if the webinars were not enough, the Developer Relations team did an excellent (and well attended, I might add…) series of live seminars all over the world.  These were well advertised and well run.  They included user group events during week nights, and for the first time. some day long events on Saturday.  In talking with the DevRel folks, I know that these were particularly successful.  I had the honor of being the guest speaker at two of them, in Washington, DC and in Newark, NJ.  Over the last year, the team has also put on a CodeRage event, the 24 Hours of Delphi, and a Delphi Birthday Party.  The hits just keep on rolling.
  • The marketing department even has a blog – The Delphi Insider – run my by friend Tim Del Chiaro.  If you want to  know everything that is going on, that is a good place to start. And of course, there are a number of active (an inactive, sadly) blogs on the Embarcadero servers.

The folks marketing Delphi are doing some really good work, and we should appreciate and recognize it.  Embarcadero has clearly stepped up its game, and we should all give credit where credit is due.

Flotsam and Jetsam #56

By Nick at February 24, 2012 17:24
Filed Under: Delphi, Flotsam and Jetsam, Personal

On the Proper Design of Exception Hierarchies

By Nick at February 19, 2012 13:13
Filed Under: Delphi

Introduction

Exceptions are all over the place in Delphi.  Introduced way back in Delphi 1.0, they totally changed the way that folks looked at error handling.  Previously, we’d do things like:

ErrorCode := DoSomething;
if ErrorCode > 0 then 
begin
  DoNormalStuff;
end else
begin
  UhOh;
end;

We had to constantly interrupt the flow of our code in order to make sure that all is well.  Exceptions changed all that by letting you put all the error handling at the end, in a try…except block – out of the way of the flow of your code -- where you could handle things separately, leaving you to worry about how things should go, and not how they might go wrong.

Way back for Borcon 2004, I wrote a paper on exception handling called “Exception Handling for Fun and Profit”.  You can read that and get a good idea on the proper way to handle exceptions.  It is eight years old, but it’s still all good advice.

What I want to talk about here, though, is the best way to write your own exception classes and exception class hierarchies.  The Runtime Library gives you a number of Exception types, and it uses most of them.    You are, of course, free to use any of those exceptions declared in SysUtils.pas and elsewhere, and of course you can simply create an exception from the base class Exception. But most often when writing your own library code, the standard exception classes are not enough.  So I’m going to try to give you some ideas on how you can and why you might create your own exception classes.

A note before I start: Exception hierarchies should be part of library code; that is, code you write for use by other applications. As noted in my aforementioned article on exceptions, application developers should trap exceptions, and library code writers should raise exceptions. Exception hierarchies are part of developing library code, so this article really only pertains to that side of the fence.

The Basics

The first thing I’ll tell you is that you should never raise a plain exception:

raise Exception.Create(‘An error occurred’);

I can’t think of any reason for ever doing that.  It provides no useful information about the type of exception and why the exception being raised, leaving consumers of your code with little helpful information.

So, as you’ve probably noticed,  I like to say “You should never do <this>”.  And of course, when I do that, it’s incumbent on me to say what you should do instead.  So here goes.

First, you should always raise a specific exception for a specific exceptional situation.  If it’s a “normal” exception, use on of the standard Exception classes that are part of the RTL.  For instance, if you are dealing with streams, and you have an error, you might raise an EStreamError

Most often, though, you want your exception to be as precise and exact as possible.  This way, it will be easier to pinpoint exactly what went wrong when the exception is captured and displayed.  And in order to do that, you should create your own exception hierarchy.  If an existing exception type isn’t perfect for the situation, then don’t be afraid to define one that is.

And when you do that, the hierarchy you create should be flat and wide.  Flat and wide exception hierarchies allow for the simple organization of similarly purposed exceptions.   Here’s what I mean by that.

Flat and Wide

I’ll use my class library THTMLWriter as an example.  It it, there is a unit called HTMLWriterUtils.pas that contains the following code:

type
  EHTMLWriterException = class(Exception);
    EEmptyTagHTMLWriterException = class(EHTMLWriterException); // Tested
    EOpenTagRequiredHTMLWriterException = class(EHTMLWriterException); //Tested
    EHeadTagRequiredHTMLException = class(EHTMLWriterException); // Tested
    ETryingToCloseClosedTag = class(EHTMLWriterException); // Tested
    ENotInListTagException = class(EHTMLWriterException); // Tested
    ENotInTableTagException = class(EHTMLWriterException); // Tested
    ENotInCommentTagException = class(EHTMLWriterException); // Tested
    ENotInFieldsetTagException = class(EHTMLWriterException); // Tested
    ENoClosingTagHTMLWriterException = class(EHTMLWriterException);
    ENotInFrameSetHTMLException = class(EHTMLWriterException); // Tested
    ENotInMapTagHTMLException = class(EHTMLWriterException); // Tested
    ENotInFormTagHTMLException = class(EHTMLWriterException); // Tested
    ENotInObjectTagException = class(EHTMLWriterException); // Tested
    EClosingDocumentWithOpenTagsHTMLException = class(EHTMLWriterException); // Tested.
    ETableTagNotOpenHTMLWriterException = class(EHTMLWriterException); // Tested
    EParamNameRequiredHTMLWriterException = class(EHTMLWriterException); // Tested
    ETagIsDeprecatedHTMLWriterException = class(EHTMLWriterException); // Tested
    ENotInSelectTextHTMLWriterException = class(EHTMLWriterException); // Tested
    ECaptionMustBeFirstHTMLWriterException = class(EHTMLWriterException); // Tested
    EBadTagAfterTableContentHTMLWriter = class(EHTMLWriterException); // Tested
    ENotInDefinitionListHTMLError = class(EHTMLWriterException); // Tested
    ECannotNestDefinitionListsHTMLWriterException = class(EHTMLWriterException); // Tested
    ECannotAddDefItemWithoutDefTermHTMLWriterException = class(EHTMLWriterException); //Tested

This is an example of a “flat and wide” exception hierarchy.  The hierarchy is “flat” because there are only two levels of inheritance – the base class and a large number of descendants.  A class diagram of these classes would be “flat” because there isn’t much distance from the top to the bottom of the inheritance.  It’s “wide” because there are a lot of sibling classes on the second level of inheritance.  The class diagram would take a lot of horizontal space if it were laid out on paper.

How does this all work?  First, I declared a base type, EHTMLWriterException.  All the exceptions raised in the THTMLWriter library will be a descendant of this type.  As a result, you can easily check the type of an exception, and if the type is EHTMLWriterException, then you know what library raised the exception.  When you are using the THTMLWriter library, you can easily trap all the exceptions raised by the library within your exception handling code by simply calling:

try
  //code that raises an exception in THTMLWriter....
except
  on E: EHTMLWriterException do
    //you know that the exception came from THTMLWriter
end;

Second, I declare a large number of very specific descendants that are raised in very specific situations.  Their names are very descriptive, and they are usually raised only in one place – the exact place that the error occurred.  This makes locating the cause of the exception much easier.   Precisely named exceptions can be easily searched for in code.

An Example

For instance, here’s an example of some code calling a very specific exception:

function THTMLWriter.OpenParam(aName: string; aValue: string = cEmptyString): IHTMLWriter;
begin
  CheckInObjectTag;
  if TStringDecorator.StringIsEmpty(aName) then
  begin
    raise EParamNameRequiredHTMLWriterException.Create(strParamNameRequired);
  end;
  Result := AddTag(cParam)[cName, aName];
  if TStringDecorator.StringIsNotEmpty(aValue) then
  begin
    Result := Result[cValue, aValue];
  end;
end;

Here you can see that the code raises an exception named EParamNameRequiredHTMLWriterException.  The class name alone tells you that it is an error from the THTMLWriter library, and that it was raised because a parameter name was required but not found when the call was made.  Just the exception’s class name has a lot of information.  In addition, you’ll note that when I raise these specific exceptions, I include a very specific, detailed error string explaining what happened.  In my view, you can’t have enough information in an error message. 

Thus, if you end up raising this exception, you’ll get this:

image

Given all that, if you can’t figure out exactly what the problem is and exactly where it occurred, well, then I’m not sure you are in the right business.  Winking smile

Lots and Lots of Exception Types

Since it is fine – and even desirable – for exception hierarchies to be wide, you shouldn’t be shy about declaring many exception classes as direct descendants of your one main exception class.  You’ll note above that even in a small library of code like THTMLWriter, I’ve declared 23 exception types.  I see nothing wrong with having a large, very specific set of exceptions that you can raise throughout your code library.  As I said before, if your exception type is only raised once, that’s fine – it’s very easy to find the location of an exception that is only raised in one place. 

Conclusion

So there it is – make your exception class hierarchies flat and wide, use good exception messages when raising them, and you’ll enable the consumers of your code to easily see where problems are arising and to quickly deal with them when they do.

My Amazon Kindle So Far

By Nick at February 11, 2012 21:59
Filed Under: General, Tech Stuff, TechBiz

A while back I wrote about why I got my Amazon Kindle Fire, and in that post I promised you that I’d write about my thoughts about owning the Kindle.  And since I’d rather rub shredded fiberglass in my eyes than break a promise to you fine people, here are my thoughts on owning an Amazon Kindle

  • First, I want to say that I also am an Amazon Prime customer, so what I talk about below may include benefits of being in Amazon Prime.  Those benefits are actually quite numerous considering the $79 annual price tag.  If you are at all involved with Amazon, I’d give the Prime membership a good look.   You can save a lot of postage – and a lot of time and gas – with Amazon Prime.  “Gas, you say? How?”  Well, I’m glad you asked.  Here’s an example:  I don’t drive to the Pet Store anymore, because I just have Amazon ship me – at no charge and with no sales tax – my dog food.  And cat food .  And that is just the beginning of what Prime offers.  I’ll leave it now to say that it’s a pathetically good deal if you have even the remotest notion of buying things from Amazon, and point out some more specific things as I go along.
  • The second point to make is that at $200, the Kindle Fire is pretty much a loss leader for Amazon.  I don’t know for sure what it costs to make the Kindle Fire, but I’m guessing that Amazon is selling them at a loss or very close to it.  And the reason is that the Fire is, in Amazon’s eyes, merely an Amazon content delivery device.  They want to get this device – a Kindle – into your hands. At $200, it’s an attractive tablet that runs Android apps, had a dual core processor, a color screen and has all the advantages of a Kindle.  Sure, any tablet can run Kindle software, but as a Kindle, I  can do things like borrow a free book a month from the Kindle Owners' Lending Library (another Prime perk….) as well as watch Amazon Video (another Prime benefit…) on the device.  I can store all my Kindle content (another Prime benefit….) with unlimited space on the cloud, including magazines, books, and music. 
  • The Kindle Fire is pretty impressive hardware. It is a dual core processor, and a very nice seven inch IPS screen. I haven’t really ever thought that it was slow because of processor power. It seems plenty powerful to me.
  • Things I like to do with a tablet (and that don’t really matter that it’s a Kindle Fire….)
    • Read Twitter.  I’ve taken twitter off my phone because now I can….
    • …actually read the web article on a link from Twitter instead of putting it in Instapaper because my phone makes it too hard to read the link. 
    • Watch movies and TV in bed with a nice, crisp seven inch screen. The Fire is really easy to hold however I like.
    • Play games. The screen is big enough to actually see the cool graphics on some cool games. I’ve taken all games off my phone, and the Fire has become a nice little tool for wasting some time.
  • Things I like to do with my Kindle fire (because it is a Kindle…)

Miscellanea:

  • Nice: One thing I like is the “Lock screen” feature which locks in screen orientation.  Sometimes you want to lie on your side and still read in portrait mode even though you are holding the device in landscape mode.  I like that. I suppose that  other tablets have that – I don’t know – but I do like it’s easy access.
  • Nice: Amazon's Android AppStore gives away a paid app every day.  Mostly it is cheesy games, but every once and a while you can get a nice paid app.  While not the Android Market, you can get many of the apps you want from the Amazon AppStore, including things like NetFlix, Pandora, Evernote, etc. 
  • No Google apps, though.  I guess I’m not 100% clear while Amazon blocks Google apps. I guess they view them as a competitor. I sure would like to be able to run Google Mail and Google Calendar on it. I also prefer Google Music, but Amazon’s music is workable. It is a bummer not to have the Google/Tablet connection.
  • To add insult to injury regarding the above note, there really isn’t even a decent third-party calendar app in Amazon’s store. Alas.
  • Bummer: The device has no camera, no microphone,  and no GPS.  This is okay, because the GPS on my phone works much better when I’m driving.  The camera on my phone is as good as any they’d put on the tablet.  I pretty much have my phone with me all the time, so those missing features in the Fire aren’t a problem. 
  • Bummer:  The Kindle Fire runs Android, but it is a very customized and restricted version of Android.  As a result, the device has no Google apps, including no access to the Google Market.    However, if you want, you can root it (though if you do, you lose the ability to watch free Amazon Prime videos).  You can then sideload the Google apps.   You can sideload apps without root access, but it is a bit of a crap shoot whether any given app will work.  (Here’s a good open letter to Jeff Bezos on this topic, the general sentiment of which I support.  I don’t’ regret my Kindle purchase, but it would be a really, really awesome tool if I had the Google stuff on it.)
  • A Bit Strange: There is only one physical button on the whole device:  the power switch on the bottom.  This means no volume rockers, which Android users are kind of used to, I guess.  It hasn’t bothered me too much, but I know that it is something that bothers other users.
  • Bummer:  Amazon advertises their custom Android Silk browser as “lightening fast”, but my experience has been, uhm, different.
  • Nice to Know: I have kept my device “Kindle-ized”, but if I wanted to, there are Android ROM’s available for the Kindle Fire if I wanted to move the device to be a “pure” tablet.  But again, I’d lose the advantages in Amazon Prime of the device being a Kindle.

Final verdict:  I’m happy with my Kindle Fire – I like using and having a tablet – but I’m going to save up an buy a “real” tablet in the fall.  I’m interested in the Google Nexus Tablet – or at least in concept.  I like having a Nexus phone, and I’d like to have the same thing in a tablet.

Flotsam and Jetsam #55

By Nick at February 08, 2012 09:02
Filed Under: Flotsam and Jetsam, Delphi
  • Marco notes that Embarcadero has put out a press release announcing a 54% increase in revenue in 2011 over 2010.  This is unequivocal, clear, unassailable good news.  No amount of Chicken Little whining will take away from the fact that this is very, very good news.  (It didn’t take long for Marco’s commenters and the Nattering Nabobs of Negativity in the non-tech newsgroups to try to find a way to make this something other than great news.)  The most important thing that the EMBT Executives care about is the bottom line – and that is how it should be.  And the bottom line for Delphi apparently looks pretty darn good – good enough for them to brag about it.  When the bottom line of Delphi looks good, that is good for Delphi developers. 
  • Hey, I noticed that I’ve gone over 1000 comments here on my blog (actually it’s more like 3000  if you count spam that I’ve deleted.….).  Thanks to everyone who posts comments.  I appreciate you reading this stuff I write, especially when you go to the trouble of writing something up and adding to the conversation.  Lately some of the discussions on my technical posts have been really good – I’m grateful.
  • I am not myself able to go this year, but I’m quite happy that three of my team here at Gateway Ticketing will be attending Delphi Developer Days this April in Baltimore/Washington, DC.  I was there last year, and I can tell you that it was a really valuable experience, and I recommend that you attend this year if you can.
  • Jason Southwell’s ApeSuite for FireMonkey has a new beta out with a bunch of new features.
  • More FireMonkey components are now coming from TMS Software as well – they have a cool set of instrumentation components as well as a TableView control that will be popular for folks writing mobile apps in particular.
  • And Even More FireMonkey: As previously noted, I haven’t played with FireMonkey  much, but I have to confess, it is cool to think that this demo app – as described by Anders Ohlsson in his EDN article – is written in Delphi and will run on the Mac (and even iOS I guess…?) as well as on Windows.  Pretty slick.  And while you are at it, check this one out as well.

…Wherein I Rant Vigorously About Mobile Twitter Clients

By Nick at February 04, 2012 15:23
Filed Under: TechBiz, Tech Stuff, General, Delphi

I am now going to go on a rant about Twitter clients – mobile Twitter clients in particular (though some desktop clients are rant-worthy as well).  I am going to do this because I can’t understand why they are such a pain in the ass and work so badly, when they could so easily work so well.

Okay, first, don’t get me wrong.  I really like Twitter.  (If you want, you can follow me, I’m @nickhodges --  no surprise in that handle, eh?)  I like it because it’s a great place to keep up on news, find interesting articles, read funny stuff, and to post your thoughts in short, pithy statements of 140 characters or less.  It’s also a great time killer.  If you are waiting at the doctors office, it’s a much better way to pass the wait than looking at a two and a half year old copy of People Magazine.  It’s interesting, fun, never the same thing twice, and frankly, I’m a little addicted.  I do almost all of my twitter reading on my phone or on my wonderful Amazon Kindle

But yet reading Twitter on my mobile devices drives. me. crazy.  When it comes to mobile Twitter clients, I’m not addicted -- I’m inflamed with a rage that burns like the heat of a thousand suns.

I’ve tried just about every one out there. They all drive me insane.  And so here is  my rant:

  • A twitter client should never, ever, ever, under any circumstances, for any reason, at any time, ever, ever, EVER move my “cursor”.  EVER. And by “cursor” I mean my location in my Twitter stream.  I determine where my cursor goes, not you, you blasted twitter client that thinks you can just show me whatever you want when you want to.  If I am reading Twitter on my phone, leave off on a funny Pauly Peligroso post, go away to another app, and then I come back, you darn well better have my twitter client looking right at that same stinking Pauly Peligroso post when I come back.  I don’t care if I’ve been gone for five minutes, five hours or five years, you flipping better have your cursor right there where I Ieft it. Not anywhere else.  Where. I. left. it.  Leave a gap if you have to. I don’t care, just leave it. Don’t try to do me a favor and “catch me up”.  If I need catching up, I’ll get myself caught up. Give me an option to get caught up, fine.  But for the love of Adam Sandler, DON’T MOVE MY POSITION IN MY TWITTER STREAM.   Ever,  ever, ever, never, ever, ever. 
  • Second, if you tell me that there are “143 new tweets”, and I say “Great, some new tweets”, put me at the freaking START of the 143 new tweets, not at the current time!!!!   Why in the name of sweet baby Dick Van Dyke would I ever, ever, ever what to start at the most recent tweet out of those 143 new tweets? Why would you tell me that there are 143 new tweets and then start me out at the point where there are zero new tweets? Why do I open up the fracking client and see some tweet from three seconds ago, when I want to read the 143 new tweets?  Why do I have to manually scroll down and try to figure out where the new tweets start?  What is that, some kind of sick, twisted joke?  Really?  I have to scroll?  Seriously?   I mean this is basically a variation of the “Never move my cursor spot”, but come on, this is ridiculous.
  • Third – stop trying to shorten my shortened URL’s.  I’m smart – I can shorten my URL’s myself.  It’s nice you want to do that for me, but at least let me opt out of it.  Nothing says “wasted time and resources” as a link that is a Twitter shortened version of a bit.ly link that started out as a tinyurl.com link.  I mean, come on, I can keep my twitter posts under 140 characters myself.  I don’t want your help.  I don’t need your help.  Stop it.

Bottom line: Mobile twitter clients stink and they make me want to bash public monuments with a sledgehammer. (I’d never do that, really, but I want to when I go back from checking my mail and the stupid TweetCaster moves me to  a tweet that was posted 23 seconds ago.)

Phew, okay, I feel better now.

An Interface Implementation Pattern for Consideration

By Nick at February 03, 2012 14:42
Filed Under: Delphi, Software Development

So I’ve been writing about Interfaces, and mostly talking about how you should use them.  But as important as designing and using the interfaces themselves is how you implement those interfaces.  I talked about the basics in the previous article, but there are some things that you can do to make implementing an interface a little easier.

I’d like to show one way that you might go about it for the purpose of starting a discussion about the technique.  I’ve seen the method I’m going to describe below used in a number of places, most notably back in WebSnap. (Remember that?  WebSnap was actually a pretty cool library of code, doing a lot of things in a somewhat MVC fashion  before MVC and web development was in, well, fashion.)

Anyway, here is how the implementation pattern I’m talking about here works:  You create a “base” class that implements each member and property of the interface. Then, you add a virtual, abstract method that corresponds to each interface method with a naming convention of DoMethod.  You then call that virtual, abstract method inside the implementation of the interface methods. 

This base class then becomes the parent for any class that implements the interface.  In essence, you create an easy-to-inherit class that easy implements the interface so you don’t actually have to worry about implementing the interface over and over again. 

Naturally, this is hard to explain, so a code example is in order.

Consider the following simple interface:

type
  IDemoInterface = interface
    procedure ProcessSomething;
    function ProcessData(aString: string; aInteger: integer): Boolean;  
  end;

Nothing fancy, and obviously illustrative. 

To do what I’m talking about, you’d implement this interface as follows:

type

  TBaseDemoInterfaceImplementor = class abstract(TInterfacedObject, IDemoInterface)
  protected
    procedure DoProcessSomething; virtual; abstract;
    function DoProcessData(aString: string; aInteger: integer): Boolean; virtual; abstract;
  public
    procedure ProcessSomething;
    function ProcessData(aString: string; aInteger: integer): Boolean;
  end;

procedure TBaseDemoInterfaceImplementor .ProcessSomething;
begin
  DoProcessSomething;
end;

function TBaseDemoInterfaceImplementor .ProcessData(aString: string; aInteger: integer): Boolean;
begin
  Result := DoProcessData(aString, aInteger);
end;

So, what you have now is a class – TBaseDemoInterfaceImplementor – that can be used to really implement the functionality of the IDemoInterface.  You have an abstract class to inherit from, and two methods to override to implement the functionality. 

So, of course, the class that you’ll actually use would look something like this:

type
  TRealDemoInterfaceImplementor = class(TBaseDemoInterfaceImplementor)
  protected
    procedure DoProcessSomething; override;
    function DoProcessData(aString: string; aInteger: integer): Boolean; override;
  end;

function TRealDemoInterfaceImplementor.DoProcessData(aString: string; aInteger: integer): Boolean;
begin
  ShowMessage(Format('I am processing the following data: %s and %d', [aString, aInteger]));
  Result := Random(2) = 1;
end;

procedure TRealDemoInterfaceImplementor.DoProcessSomething;
begin
  ShowMessage('I am processing something!');
end;

What happens is that the implementation becomes much less painful once you have the base class defined with the details of implementing the interface neatly tucked away.  You are doing simple class inheritance at that point. 

Now I’ve thought about this pattern for a while, but I’m not sure about it.  I’m very interested in hearing what you all think.  I guess one downside is that the class doesn’t clearly declare that it implements a given interface.  Perhaps a naming convention would do that? 

On the one hand, it seems a nice way to create a class library that implements an interface.  To me, it seems like a good use of polymorphism. There may be times when you want a large chunk of your library to implement a “basic” interface, and using this inheritance trick can make that easy.  Once you create a base class, you can now build a class hierarchy based on that class, with all the classes implementing the interface with much less hassle and more cleanly.  In addition, it makes it easier to create any number of descendants  from the base class if you want to have a number of different implementations for the interface.  For instance, if you had ICreditCard, you might create TBaseCreditCardImplementor, making it easy to descend from and create TVisa and TMastercard, etc. 

Pattern? Anti-pattern?  Maybe I’m crazy and this is a really silly idea.  Maybe this is a known pattern already and I’m just ignorant.  Maybe this is the coolest idea ever. 

What do you guys think?

My Book

A Pithy Quote for You

"Of all tyrannies a tyranny sincerely exercised for the good of its victims may be the most oppressive."    –  C. S. Lewis

Amazon Gift Cards

General Disclaimer

The views I express here are entirely my own and not necessarily those of any other rational person or organization.  However, I strongly recommend that you agree with pretty much everything I say because, well, I'm right.  Most of the time. Except when I'm not, in which case, you shouldn't agree with me.