Widgets Nick Hodges | A man's got to know his limitations


By Nick at November 22, 2014 08:24
Filed Under: Delphi, General

I've decided to start blogging at a new location:

I've grown dissatisfied with and want to move to WordPress.  

I'm going to leave this blog in place, as I don't want all the links to get broken.  

But going forward, I'll be blogging at the above link

Another Gem from the VSoft Guys: TCommandLineParser

By Nick at November 16, 2014 02:02
Filed Under: Delphi, Software Development, Tech Stuff

You know, the gang at VSoft, led by Vince Parrett, have really contributed a lot to the Delphi and the Developer community.  First, they built FinalBuilder – probably one of the best known apps built with Delphi -- and now ContinuaCI for all developers.  And being Delphi developers, they have contributed the DelphiMocks and DUnitX frameworks to the Delphi community.  Recently, they added another little gem to that list – TCommandLineParser.

It’s seems less common than it used to be with “regular” applications, but command line switches certain remain popular and common with console applications.  They are used to pass filenames, boolean values, and other information on the command line. Handling those switches can be a bother, and it’s seems silly to repeat similar code for each application.  This is where TCommandLineParser comes in. 

TCommandLineParser is a library that makes it really easy to add and read command line parameters to your applications. Sure, the RTL provide the ParamStr/ParamCount functionality, but they don’t provide some of the features that TCommandLineParser does.  For instance, with TCommandLineParser you can:

  • Set switches to contain specific value types
  • Easily retrieve those switch values in your application in a simple class
  • Pass strings, boolean values, and numbers and other types

To get started using it, you can pull the code using Git from the following endpoint (You do have Git installed on your machine, right?) :

The project comes with a simple demo application, but let’s build one ourselves so that we can step through the process and really see how it works.  So, let’s take the following steps:


  1. 1.  Create a new Console application by selecting File|New|Other|Delphi Applications|Console Application.
  2. 2.  Make sure that the directory where you put TCommandLineParser is on your path, either for the application you just created or as part of your library path for Delphi.
  3. 3.  In the uses clause of the project file, add the following two units: VSoft.CommandLine.Parser and VSoft.CommandLIne.Options.

4.  Now, add a new, blank unit to the file and call it CLPOptions.pas. This is the file that will hold the class that will end up with all of the command line parameter values.  In that file we’ll have an interesting class – one with nothing but class variables.  Put the following code into the unit.

  TSampleOptions = class
    class var
      FileToProcess: string;
      OutputInUpperCase: Boolean; 
      NumberOfIterations: integer;

This class contains a string, a Boolean and an integer.  Other types that can be passed on the command line include enumerated types, sets, and floating point numbers.  Again, this class will end up holding the values passed on the command line, and since the variables are all class variables, they can be accessed directly without having to instantiate the class. 

5.  Next, we’ll register these items with the TOptionsRegistry class.  This class is the one that translates the command line parameters into options usable by your application.  You can define options as having a long name, a short name, and whether the parameter is optional or required.  The TOptionsRegistry.Parse method will then parse out the command line and fill in the values of the class we defined above.  In order to do that, create a new, empty unit, add it to the project, and call it CLPConfig.pas.  Then, add VSoft.CommandLine.Options and CLPOptions to the uses clause of your new unit.  Then, add the following code to the implementation part of the unit (you can leave the interface section empty):

procedure ConfigureOptions;
  Option : IOptionDefintion;
  Option := TOptionsRegistry.RegisterUnNamedOption<string>('The file to be processed',
    procedure(value : string)
        TSampleOptions.FileToProcess:= value;
  Option.Required := true;

  Option := TOptionsRegistry.RegisterOption<Boolean>('OutputInUpperCase','o', 'The output should be in upper case',
    procedure(value : Boolean)
        TSampleOptions.OutputInUpperCase:= value;
  Option.Required := true;
  Option.HasValue := False;

  Option := TOptionsRegistry.RegisterOption<integer>('NumberOfIterations','n','The number of times the file should be processed',
    procedure(value : integer)
        TSampleOptions.NumberofIterations := value;
  Option.Required := False;   
  Option.HasValue := True;

Here’s what is important to note about the following code:

  • The first thing to note is that each of the calls that registers a parameter takes a parameterized type of the type that should be received as part of the command line parameter. 
  • The first Option registered is an “unnamed” option, meaning that there is no switch or name associated with it.  Normally, a parameter will have a switch (for example “/d”)associated with it.  This option, however, will just be the filename.  The first parameter of RegisterUnNamedOption is a description of the option that will be shown to the user when “help” is displayed.  (We’ll discuss that in a bit).  The second parameter is an anonymous method that lets you do what you want with the value passed in the parameter.  It’s a TFunc<string> and in this case, we assign the string to the TSampleOptions.FileToProcess class variable.  Note that this option is also set to Required, meaning that unless the parameter is present, the application run and the “help” will be shown.
  • The second Option registered is a “regular” parameter, in that it is a switch.  That switch can two values – “/OutputInUpperCase” or “/o”.  These are defined by the first two parameters of the call to RegisterOption.  The third parameter is the help string, and the fourth is an anonymous method taking a single Boolean value that defines the presence or absence of the switch.  Because the Option.HasValue property is set to False, the switch will stand alone, and its presence means the value is True, and its absence means it is False.  In other words, the parameter has no value passed along with it. 
  • The third Option is yet another variation. This one has a switch, but it takes a value, because the Option.HasValue property is set to True.  This means that the parameter will appear as “/o:42”, using a colon to separate the switch from the passed value.  Note that this parameter is set to be optional, because the Required property is set to False.

Of course this procedure needs to be called very early in the executable timeline, so you should add an initialization section to the unit that looks like this:



Switches are key to passing command line parameters, and TCommandLineParser will accept the following to define a switch:

  • A forward slash: /d:aValue
  • A single dash: -d:aValue
  • Double dashes: --d:aValue

Note that for options that have HasValue set to False, there is no need to pass a value. 

Of course, once you have set all these options, you need to write some code to retrieve them, and handle the situation when things aren’t right – required parameters are missing, or switches requiring values don’t have them. 

Go to the DPR file and add this code:

  ParseResult :  ICommandLineParseResult;
    //parse the command line options
    ParseResult := TOptionsRegistry.Parse;
    if ParseResult.HasErrors then
      Writeln('Usage :');
        procedure(value : string)
    end else
      Writeln('FileToProcess : ', TSampleOptions.FileToProcess);
      Writeln('OutputInUpperCase : ', TSampleOptions.OutputInUpperCase);
      Writeln('Iterations : ', TSampleOptions.NumberOfIterations);
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);

Note the following about the above code:

  • It declares ParseResult with is of type ICommandLineParseResult.  It will contain the results of parsing the command line when TOptionsRegistry.Parse is called.  The names make that pretty obvious, eh? 
  • If the result of the parsing HasErrors, then the “Usage” of the application is output.  It can be output anyway you like, as you pass the PrintUsage method an anonymous method that does the output in any way you want.  In this case, it simply prints out the value passed in to it.  This is where the “help” parameters above come in.  The PrintUsage method parses out all the registered parameters, grabs all the switch and parameter values, as well as the help string you passed in, and creates a string that shows the proper usage of the parameters.  Before printing that out, the code prints out the actual problem with the usage.
  • If all is well, and all the required parameters are present and properly formed, then the code will simply print out the values passed on the command line.

That’s it for code.  Now for using the application.  First, let’s get a look at what happens when you pass no parameters at all.  Press F9 and you should see something like this:



Note that you receive error messages, and a description of how the command line parameters work.

Then, go to Run|Parameters and in the Parameters box enter:

somefile.dat -o -n:42

Running the app should result in the following:


Which shows that the parameters were correctly passed. 

And that is about it.  It takes a bit of work to get going, but not much, and you get a lot of functionality for the little input that you have to make.

Like I said in the title – another gem from the folks at VSoft Technologies.

Write a Twitter Client with Delphi XE7

By Nick at September 27, 2014 22:00
Filed Under: Delphi

I just wrote a Twitter client with Delphi XE7.  It took about thirty minutes, and most of that was spent trying to figure things out on the Twitter side of things.  Here’s the first tweet from my app:

It was surprisingly easy once you figure out the Twitter security. Here's how I did it.

First, I read the DocWiki on the REST client components.  It showed me where to go to create an application on the Twitter site.  Twitter uses OAuth1, and they have a page about it on their website.  Don’t worry, though.  Delphi includes a component that does all the work of OAuth 1.1 for you. 

The first thing you have to do is to create an app on the Twitter side.  I created an app called “DelphiDemo” and received a Consumer Key and a Consumer Secret.  I then went to the “Keys and Access Tokens” tab and generated an Access Token and and Access Token Secret.  Keep that page handy, because you are going to need the information on it in a minute.  And protect those keys – you shouldn’t distribute them.  I’ve blanked mine out in the shot below.



Next, you need the assistance of the large REST Demo that comes with Delphi. It does the heavy lifting of communicating with Twitter to get all the information that you need to create a client. It can be found here:

C:\Users\Public\Documents\Embarcadero\Studio\15.0\Samples\Object Pascal\Database\RESTDemo

Open it up, run it, and click on the “Twitter” tab.  You should see this:



The memo on the upper has the basic information on what to do.  You should have already created an app on the Twitter site.  Here is how it should go:


1.  Enter your Consumer Key, Consumer Secret, Access Token, and Access Token Secret from the Twitter web site into the appropriate edit boxes.

2.  Press the top button labeled “#1: Get Request-Token and Auth-Code”.  You’ll be asked to authorize your application for use on your account.  Do so. 

3.  Next, you should receive a second window with a number in it.  This number is a graphic and can’t be cut from the window.  Write this number down, as it is your “PIN” number to authenticate yourself.  Keep that number, you’ll need it to post to Twitter later.  You’ll also need it now, so put it in the “Auth-Verifier (“PIN’')” edit box. 

4.  Press “#2 Get Access-Token”.  That should fill out the Request-Token boxes and clear the Access-Token boxes.

5.  Now you should be ready to post a tweet.  If all has gone right, enter something in the Status edit box and press “#3 Send a tweet”. Check your timeline, and the tweet should be there.  Cool!

Okay, that is only half the battle. Now to create your own application.  Here’s the steps I took.

First, I created a new VCL application, and put an Edit Box, a Label, and Button on the form. 

Then, I went to the main form in the RESTDemo application and copied the OAuth1_Twitter component and pasted it on my new form. 

From there, I filled out all the properties on the component that I could.  The API endpoints should all be filled out – all you have to do is to enter your personal information from the app’s Twitter page into the component.



Be sure to include the VerifierPIN value that you write down earlier. Now, the rest is all Delphi. 

1.  Drop a TRestClient, a TRestRequest, and a TRestResponse on your form.

2.  Add the following method to your form:

procedure TForm42.ResetRESTComponentsToDefaults;


  /// reset all of the rest-components for a complete

  /// new request


  /// --> we do not clear the private data from the

  /// individual authenticators.






2.  Double click on the button on your form and add the following:

procedure TForm42.Button1Click(Sender: TObject);



  RESTClient.BaseURL := '';

  RESTClient.Authenticator := OAuth1_Twitter;

  RESTRequest.Resource := '1.1/statuses/update.json';

  RESTRequest.Method := TRESTRequestMethod.rmPOST;

  RESTRequest.Params.AddItem('status', Edit1.Text, TRESTRequestParameterKind.pkGETorPOST);



3.  Put the following code in the OnChange event for Edit1:

procedure TForm42.Edit1Change(Sender: TObject);


  Label1.Caption := Length(Edit1.Text).toString;


4.  You’ll need to add REST.Types to your uses clause as well.

And there you go.  Run it, type in a tweet (Keep it 140 characters or less!) and press the button, and you should have posted your first tweet from your very own Delphi application. 

The RESTDemo application has a bunch of good demos in it that show you how to connect to Facebook, DropBox and others.  As usual, Delphi wraps up the functionality in a set of components, making it pretty easy for you to get the job done in a jiffy. 

Flotsam and Jetsam #85

By Nick at September 21, 2014 04:50
Filed Under: Delphi, Flotsam and Jetsam, Software Development
  • I have been spending a lot of time with XE7 lately, mainly working on presentations for EKON18.  I’m speaking on a number of topics, and thus have been running XE7 through the paces pretty well.  Impressions so far:
      • Having Castalia as a free add-on is fantastic.  I’m currently only using about 10% of it, but I love it already and am looking forward to learning more.  You can get it absolutely free – the full edition – until 30 September as long as you are a registered XE7 owner.  Highly recommended.
      • One of the talks I’m doing is on REST services, and so I’ve been working with the Enterprise Mobility Server (EMS) in XE7.  This is a seriously very cool thing.  It makes building REST Servers as easy as falling off a log. It automatically provides support for users and groups.  You can building your own extensions as easily as building a Delphi package, and the server will scale no problem by running inside of IIS as an ISAPI extension.  It also makes it really easy to build clients to consume the services.  This is some really amazing and powerful stuff.  Seriously.  Not just mindless promotion here – this is really powerful and easy. Want to get started with it?  The documentation is terrific.
      • I know that some people get upset with me when I say this, but the IDE is really fast and stable.  I don’t know if it is just the way that I use it, but I really haven’t had any trouble with it at all.  It just works. 
      • Similar to the EMS stuff is the Backend as a Service (BaaS) support. If you want to build a mobile application that a million people will use, you can do it with the BaaS stuff via either Kinvey or Parse.  These back-ends take care of storing everything, including users, logins, data storage, and everything.  Much like the EMS Server.  So if you want a hosted solution, or want to host your own, then XE7 has you covered.
      • You can even use it to build apps for things like the new Moto 360 watch.  Cool.
      • Bottom Line:  It’s a seriously cool time to be a Delphi developer.  If you haven’t looked at XE7, do it now
  • I want to mention yet again how much I appreciate all of you who have bought my book.  The whole experience has been humbling as the sales have exceeded my wildest expectations.  Thank you.  In fact, it’s been such a good experience that I’m already thinking about writing another one.
  • I’ll be doing a Developer Skill Sprint this Tuesday on Aspect Oriented Programming with DSharp.  I’d be honored if you attend and ask questions.  These Skill Sprints have been really cool.  They are nice and short, but not too short. They happen at three times during the day, so no matter where you are, you should be able to tune in.  This is my second one, and they’ve been fun to do. 

Where to Get Delphi Help

By Nick at September 06, 2014 07:48
Filed Under: Delphi, Software Development, Tech Stuff

Sadly, the good old Embarcadero newsgroups NNTP Feed appear to have come to an end.  Alas.  I’ve been a member of those groups in one form or another for over 20 years, starting with the Compuserve forums and ending up with the wonderful and grossly underappreciated NNTP newsgroups.  I believe that Embarcadero is trying to get the newsgroups back up in a read-only status.  Nevertheless, it appears to be time to move on.

So where can we migrate to?  I see three places where the community can communicate and get questions answered.

    • The official solution is  This is the place that Embarcadero is bringing everything together that formerly was EDN, the Blog server, and the newsgroup server.  This new community has blogs, articles, and Forums.  The Forums are organized by topics rather than products and languages. It takes a bit of getting used to, but we can work with it that way, right?  In addition, there is the Answers section, which has a StackOverflow-like way of asking and answering questions. Overall, it looks like a pretty nice web site, though I know many of us will miss the NNTP forums.  This will take some getting used to, but things move forward, and this is the way that things are going.  I’m on board
    • StackOverflow has a very active Delphi sub-group where you can get excellent, fast answers to your questions.  If David Heffernan doesn’t answer your question, Ken White, Rob Kennedy, Mason Wheeler, Remy Lebeau or some other very active Delphi community member will jump on it.  StackOverflow is a fantastic resource, and if you have a Delphi question, it’s a great place to get an answer. Most often, someone has already asked your question, and the archives have the answer already. I for one will always choose the StackOverflow answer in a Google search as my first choice. 
    • Another place to ask questions and generally hang out is the Delphi Community on Google Plus.  There are almost 3500 of us there, and there is usually some lively discussion, questions being answered, interesting open source projects announced and discussed, and generally a good place for Delphi folks to be.  If you aren’t a member and aren’t participating, you should be.

So for now, those are the places to gather and get help.  Times are changing for the Delphi community, both in terms of what the tool can do and where we will communicate online.  I encourage folks to move on from the newsgroups and try out the newer places to hang out and get help.

Flotsam and Jetsam #84

By Nick at June 07, 2014 11:29
Filed Under: Delphi
  • I am currently working on two things:
    • First, I’m working to provide general documentation for the Spring4D project.   The documentation can be found in the project’s wiki, and you are more than welcome to contribute to what I’ve started there.  Interestingly, the wiki can be managed as a Git project consisting of *.md (markdown) files.  That’s the way I’m doing it, though if you want, you can edit the wiki directly in the browser.  Pull requests are gladly accepted.
    • Second, I’m getting back into the Delphi Unit Test project.  Things have slowed down there, and I’ve decided to try to continue adding tests.  Thanks should go to Jeroen Pluimers for putting a lot of effort into the infrastructure of the project.  Of course, pull requests are gladly accepted here as well.
  • You wouldn’t build a fence into your neighbor’s yard.  Why would you allow an object to escape the scope in which it is used?
  • The BOGO offer is back.  That’s “Buy one get one free” for those of you not familiar with the marketing lingo.
  • My book continues to sell pretty well, even after a few months.  Thanks.  The book’s Google Group reached 600 members this week.  Thanks again. 
  • I was having a conversation with a friend this week and we came to the conclusion that you can’t really call yourself a developer if you don’t have Git, Mercurial, and Subversion installed on  your development machine.  You should also be proficient in at least one of them.  What do you think?
  • If you aren’t reading Mark Seamann’s blog, you should be.  This site is solid gold.  Mark wrote the excellent Dependency Injection in .NET which you should read immediately if you haven’t already done so.  For instance, his series on Poka-yoke Design is just fantastic.  Clearly written and illustrated.  I’ve probably raved about his blog before, but it’s just so worth reading.  I’d love to be directed to a better blog on software development.
  • And while you are at it, read this great article – Speed in Software Development.  It was pointed out to me by the inestimable Mark Edington.  I particularly enjoyed it being a former sprinter and a former marathoner – with a strong emphasis on “former”. 

Flotsam and Jetsam #83

By Nick at May 25, 2014 22:23
Filed Under: Delphi, TechBiz
  • Del Yocam is a former Borland CEO, a purchaser of $30,000 couches, the creator of the immortal “Inprise”, a lover of pizza, and apparently a check kiter.
  • I have decided to take the advice of some commenters and leave the site pretty much alone.  I removed a bunch of the ads that weren’t generating much if any revenue and removed some of the little boxes on the side that I didn’t think were very useful or that anyone paid any attention to.  Hopefully it is a bit cleaner that way. 
  • So I have a “Bleg” – a blog beg.  I’m not pleased with the code formatter used by this blog.  It’s hard to set up, seems to keep breaking, and feels old and outdated.  Anyone have any better ideas?
  • I’d like to personally thank each and every one of you that have purchased my book.  I also really appreciate the kind words I’ve received.  I’m really very grateful.  It’s really cool to know that you have written a book that actually has a listing on Amazon.  And I won’t lie – the extra money has been very timely.  And a quick word about that – I have made far, far, far more money having self-published than I would have had I worked through an established publishing house.  The publishing industry is changing rapidly, and my excellent experience with self-publishing is a testimony to that.  Thanks should go to LeanPub and CreateSpace for making it possible.  If you are thinking about writing a book – any kind of book – I’d strongly recommend that route.
  • I’m going to be giving my Unit Testing talk at the Philly.Net Code Camp next month.  If you are in the Philadelphia area, you might consider coming to the event.  It is a much bigger conference this year, spanning two days and happening at the Valley Forge Convention Center.  Typically there are 700 or more folks there – it’s usually a big event.  The talks are generally aimed at .Net developers, but there is a lot of Javascript and other topics.  I’ll be there both days.
  • I had a great time at the Delphi Developer Days in Baltimore earlier in the month.  It was great to see Cary and Loy, as well as Dr. Bob.  The classes were good, Jim McKeeth was there, and it was nice to meet new folks as well.   I highly recommend these events.  There are DDD’s in London and Amsterdam still left.  I don’t know if there is space available, but if you can attend, I think you should.

Coding in Delphi Website

By Nick at May 19, 2014 01:04
Filed Under: Delphi

Coding in Delphi now has its own website.   Visit and be amazed.

I’m not happy with this blog design.

By Nick at May 10, 2014 08:07
Filed Under: Delphi, General

I’m not happy with my blog design.  Frankly, I think it kind of looks terrible. 

But here’s the problem.  I don’t really know what to do about it. 

I’m currently using BlogEngine.Net, and a theme for it that I kind of cobbled together to do things that I wanted it to do.  I wonder if I should switch to WordPress where the plugins and themes are endless, or stick with which has much less support. BEN has continued to be updated – I just recently updated this blog to the 2.99 version – but the overall support level isn’t what WordPress is.   I could work on it myself – it is open source – but as you can probably tell, I’m no graphic designer.

A switch now would break all my links.  I don’t want to do that.

My hosting service is DiscountASP.NET, which is very good, but very .NET focused.  If I want to use a different engine, I may have to switch providers.  Not fun. 

I guess my best choice is to just try to somehow improve what I have. 

What do you think?

Delphi XE6 is Here

By Nick at April 15, 2014 02:17
Filed Under: Delphi, Tech Stuff

Delphi XE6 has been released.  There are reportedly over 2500 bug fixes in it, which is quite a few and quite in keeping with the QPS (Quality, Performance, Stability) plan they’ve discussed.  Probably the best place to find out what is in the release is in the DocWiki’s What’s New Page


And if you are ready to make the move, you can click on the banner below and purchase:

Thank you ADUG

By Nick at March 30, 2014 07:43
Filed Under: Delphi

I had a great time at ADUG 2014 this year.  I'm grateful to the group for their gracious hospitality.  They took very good care of me, and I'm thankful.  I was honored to sign all of the copies of Coding in Delphi that I did, and was pleased to see so many of them there. :-)  I presented on Dependency Injection and Patterns in Delphi both in Melbourne and Brisbane.  I think that talks were well received.  Overall, I love going to Australia and was honored to be asked.  Thanks, ADUG. 

Flotsam and Jetsam #82

By Nick at March 18, 2014 08:26
Filed Under: Delphi, Flotsam and Jetsam
  • Yay!  Flotsam and Jetsam is back!  Did you miss it?
  • Okay, some really interesting things going on with Appmethod.  Appmethod is Embarcadero’s new cross-platform development tool.  For you Delphi/RADStudio types, it appears to be a FireMonkey only IDE with some new connectivity that will be of interest only to mobile developers.  In other words, it is a new aimed squarely at new customers and not “us”.  Anyway, David I has a bunch of links on his blog, including a bunch of nice press coverage.  This new offering appears to me to be aimed squarely at the Xamarin space, as the pricing is very similar.  Should be fun to see how this plays out. 
    • As a side note – if you are a Delphi/RAD Studio person, this product is not for you, and so you need not be upset if the offering and the pricing is not to your liking.  Stick with RAD Studio and cheer on the product as Embarcadero expands into a new market.  This is a good thing – Embarcadero is branching out to reach into the very hot, growing, and important mobile development market.  This is a new, exciting entry into that nascent market.  I for one am hoping for great success for Appmethod, because that can only be good for Embarcadero and thus Delphi.  It represents a whole new revenue stream for the company, and what is good for Appmethod will be good for Delphi. 
  • Some interesting things to note that are going on with Appmethod:
    • You can report bugs not in QualityCentral, but in a public JIRA repository.  That is very interesting.
    • In addition, there appears to be a completely new Embarcadero Community website.  Appmethod is the only app represented there so far, but the rest of the products can be far away.
    • Part of the new community site are public forums. Looks like you can earn points and rank for being an active participant.  I wonder what will happen to the existing ones that support NNTP. I know many folks over there will give up their NNTP readers when you pry them from their cold, dead fingers.  Again, should be interesting.
    • Here’s the Appmethod EULA online for everyone to read.
  • Book Update: As I hope you know, my book is available two ways – in electronic form to people who purchase XE5, and in paperback form from CreateSpace and Amazon.  Many of you have purchased – more than I had hoped, in fact, and I’m really greatful.  Thanks very much, really.  It’s really an honor to have someone buy your book.  If you have purchased the book, I sure would appreciate a review on Amazon – good or bad! – as that really helps other people decide whether to buy.  Thanks to David Schwartz who was the first to do a review on Amazon.
  • Kind of lost in the shuffle a bit with Appmethod and all is the fact that Embarcadero purchased Erwin From CA Technologies. I find this to be a really interesting move, because when I was at Embarcadero, Erwin was “the enemy” – the product that ER Studio competed most strongly with.  Embarcadero now has two tools that basically do the same thing. I guess they won’t need this page and whitepaper anymoreWinking smile It will be interesting to see how that plays out. 

Nick in Australia

By Nick at March 10, 2014 01:23
Filed Under: Delphi

I’m really excited to return to Australia and speak at the Australian Delphi Users Group.  They were kind enough to invite me, and so off I go next week to Melbourne and Brisbane to talk about Dependency Injection and Design Patterns.  If you are in Australia and not going, I’m guessing that it’s not too late to sign up. If you are going, I’m looking forward to seeing you again or meeting you for the first time.  I’m also looking forward to a little summer weather after this crazy winter in Pennsylvania.  Winking smile

Coding in Delphi Now Available in Print

By Nick at February 22, 2014 01:54
Filed Under: Delphi, Software Development

My book, "Coding in Delphi" is now available in print.  This is pretty cool. You can get it from CreateSpace or Amazon.  I'm grateful for every order. 

It seems very strange to have my own entry for sale on Amazon.  Writing a book is a lot of work, but I will say, it's quite satisfying to hold the book in your hand and see your name on  :-)

I'd also be very grateful for book reviews on Amazon.  If you like the book, please let people know.  And if you don't like it, write a review and say why.  Either way, I'll appreciate your honest assessment.  You can write the review right from the Amazon order page.  

And again, I'm grateful to all of you who have had so many nice things to say, who helped edit the book, and who make the Delphi community so great.

I’m Speaking at EKON 17

By Nick at September 05, 2013 03:07
Filed Under: Delphi, Personal

Hey, I’d be delighted if you came to see me speak at the EKON 17 conference in Cologne, Germany the first week in November.


I’ll be giving two regular talks on Unit Testing and Dependency Injection, as well as an all day tutorial on advanced programming topics such as Generics, Anonymous Methods, RTTI, Virtual Interfaces, and more.  The conference will be a great time with such well-known and respected names as Ray Konopka, Cary Jensen, Jeroen Pluimers, Daniel Wischnewski and more.  Marco Cantu from Embarcadero will also be there.

I’m really looking forward to going.  You should go, too.

My Book

A Pithy Quote for You

"A people that values its privileges above its principles soon loses both."    –  Dwight D. Eisenhower

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.