Wednesday, October 30, 2013

Quotes and Sayings for Software Developers

I saw this today at

 They are happy men whose natures sort with their vocations. ”
— Francis Bacon

I think the above is a particularly good way of explaining why I feel very happy to be a software developer. I love what I do, and so, I find, it is a lot easier to get me to do that work, than it would be to get me to do something I did not like doing.  And in the end, not only am I happy, hopefully everyone, including the business owner that I work for, and the customers of that business, can be happy to, because they each have to get what they need too.   I think there really is a temperament that is suited to software development, and that its pretty safe to say that I have it.   

Another quote that I think is apropos for the professional software developer, which I keep quoting, without knowing where it came from, and which is similar to, or dovetails with the Francis Bacon quote is:

"Hard work becomes easy when the mind is at play"

Unfortunately I do not know the origin of the quote.  I could be quoting myself, or Benjamin Franklin, or Abraham Lincoln, or Mark Twain. Who knows.    The meaning of the quote, to me, is that if a person is unable to enter into, and enjoy the technical challenge or mastery of a skill that is required to do a job well, then not only will they hate doing the work, they'll do it badly.  This is another way of saying that temperament affects outcomes, at least in our line of work.  Incidentally google and all the quote databases come up empty when looking for quotes about a mind at play.

Please share your favorite quotes about work,  being a software developer, and anything related to the temperament or working lives of developers.

Update: Apologies for the formatting mistakes on this post, and any eyestrain caused by them!

Tuesday, October 29, 2013

Delphi Experts and IDE Plugins I Love Part 3: Model Maker Code Explorer

ModelMaker Code Explorer is one of two Delphi add-ons that is commercial that I usually buy, the other is MadExcept.   In part four, I will try Castalia, which has a loyal following as well.  But given the choice between the two, I like ModelMaker Code Explorer.

The main things I like about it are:

  • It has the best Class Browser and navigation and structure-view features of any Delphi IDE plugin.  Some of the features that I came to love in Xcode, which are also in GExperts but in less complete fashion, are built into the class browser and navigation features of MMX.
  • One feature that I use all the time is the Uses Clause formatter.  I like my uses-clauses one-per-line because it decreases the incidence of merge conflicts when people just insert units into the middle of complex uses-clause declarations.  It's also useful for when you group your units into sections, as I often do.    Once I have grouped dependencies, the structure of my system becomes clearer.  This is a precursor to making the design simpler, or easier to test, or otherwise better.  Perhaps if your uses clause takes up 300 lines of code, it might help you realize you're building a big ball of mud and that you should start cleaning it up, instead of making it worse every day you work on the code.

after (MMX + some manual work)

  • Another is a feature under "Text Tools", that will take something you paste from the clipboard and format it as a multi line string literal. For example, I often use it to take SQL that I wrote in SQL Management Studio and paste it into a .pas unit, as a multi-line string literal. Because Delphi lacks and easy "here-document" syntax (like the triple-quote syntax of Python), this is a considerable time-saver.
  • It contains a lot of good refactoring features that the base IDE cannot do, but I actually hardly use any of these. Instead, I find the "live metrics" and other "analysis" features, which shows "stuff which needs fixing or attention" is far more useful. I tend to leave a lot of TODO items around, and while Delphi contains a TODO feature, having that panel open is a waste of space. But having one panel with a comprehensive list of areas that need attention is much more useful to me.   "Metrics" is a poor name choice, in my opinion, it's more of a "Lint" feature.  Lint is a term from the C programming world that means "additional style warnings", that can help you find problems.  While nowhere near as comprehensive as the features in Pascal Analyzer, MMX's "Metrics" features are like a second level of live hints and warnings. Since the live hints and warnings in Delphi often misbehave, I often leave "Error Insight" turned off in Delphi and use MMX instead.  The Event Handler Analysis feature has found dead code for me, and event handlers which have become "unhooked" due to accidental editing, which is a bug that RAD tools like Delphi are vulnerable to.   Delphi is far behind Xcode, Visual Studio, and most Java IDEs in its Lint/Hint/Warning features, but tools like MMX really help bring it up to speed.

  • I have learned a lot from reorganizing my large classes. For example, sorting the methods and properties in a mega-class, is often a good precursor to breaking up the class into a series of smaller, much better designed classes.  Having all the methods that start with "open" sorted beside each other, for example, might lead me to consider that having five methods named "openThis", "openThat", and "openTheOther" leads me to wonder why I have another method called "makeViewForSomething".  maybe I should rename that to "openSomething", since it would make more obvious sense than what I had before. What was I thinking when I called that "makeViewForSomething"?  Or if there was some reason why "makeView" was a better name, maybe all the "open" methods should have been "makeView" methods.   Thinking about whether or not the stuff in your method names makes sense, and is consistent or inconsistent is made easier, when you organize your classes and units.
Like many Delphi add-ons and tools, this one also has a free trial.  I highly recommend you download it and try it.  Perhaps the best feature of MMX, is that the guy who makes it, Gerrit Beuze, provides top-tier technical support for his products. If you find a bug, he'll generally fix it pretty fast.  I've been completely impressed with how he handles support and bug fixes.   A wonderful product, something I find it hard to live without now.

Tuesday, October 22, 2013

Embarcadero MVP list updates

Embarcadero has released a new list of MVPs. I'm very happy to be on that list, because Delphi has been my favorite language, and favorite IDE since it was first released. 

To prevent misunderstandings let me just point out that an MVP is an independent community member, not an employee of Embarcadero, I am not an employee or sub-contractor.

I believe very much in the importance of the product, and its value to the development world.   I blog about Delphi related topics, on my own time, and I don't get paid to do that.  Why?   You wouldn't see me doing that with Java or with C++, although they are good enough tools in their own ways.  

Delphi has passionate users, because it's offering something unique.  I believe in that something unique that it offers, even though there might be some tools out there that cost zero dollars.  So am I a corporate shill?  No, definitely not.  And is everything always roses around here? No.  But I've always been clearly pro Delphi, and I'm grateful for the recognition that the people who believe in and love this language, and IDE can make contributions to the future of programming, too.

How do I do that?  I think I do that by teaching, consulting, by working with other Delphi people, by building little helpers, add-ons, components, and tools that people can use.  By showing that this is a really great way to build software. 

There are some great folks on the MVP list.  Zarko Gajic, who wrote about Delphi on for many years.  Francois Piette, who has built a startling and fantastic quantity and quality of components, classes, tools, and frameworks in Delphi and made them open source.    Nick Hodges, a well known Delphi Blogger,  who did a stint as Delphi Product Manager, and has had many many other fun adventures in the community, a great guy.  Ray Konopka, Delphi component book guy, owner of Raize Software, builder of my favorite logging tool (CodeSite), and the guy who taught me to write design-time component code with his Delphi component book, back in the Delphi 3 era.  I could go on and on. Primoz Gabrijelcic... Alister Christie...  you guys rock!  Lots more people on that list deserve a shout out, but I'll keep it short. 

Anyways,  all of these people, myself included, think Delphi is awesome, and that it has a bright future ahead of it.

Friday, October 18, 2013

TurboPascal PCODE compiler implemented in JavaScript

Anybody who doubts the sincerity of my last post (the PC desktop is headed inexorably towards a  legacy technology status) and who also is into Nostalgia, should check this out.

It's a mostly-complete TurboPascal compiler written in JavaScript that compiles to a UCSD-PCODE equivalent bytecode instead of native X86.  The resulting code runs in a UCDS-PCODE vm also implemented in JavaScript.

Now that's what I call a killer Blog Post. Read the blog post and try this over here.

Oh yea, and he posted to code on GitHub.  Anybody want to implement  Pascal RAD IDE in their web browser? Should only take a few weekends here and there.  I kid, I kid.   A desktop IDE, and a real compiler do a lot more, and take a lot longer to build, than this Just For Kicks thing did.  But if this person had realized that they could just download the real DOS TurboPascal from the Embarcadero/Borland Museum, and done that, then there wouldn't be a new JavaScript pascal parser out there.  Which is inherently a cool thing. 

Thursday, October 17, 2013

Windows as a Legacy System

I have been seeing charts like this one all over the place, but I think this one is telling.  It's from a presentation by a firm called KPCB.

First there's this technology cycles graphic:

Finally, here's the visual chart that goes with the above infographic:

So the WinTel era starts with MS-DOS in about 1982, and if you plot the line at the left side, with some kind of long tail, a gaussian distribution, which I think makes sense, you get this:

If that happens, here's what you'll see:

  • PC shipments will continue to decline, and the PC will become a tiny niche that represents about 10% or less of the overall computing world's annual sales.
  • Microsoft will continue to control the WinTel/PC desktop world, but the significance of that will shift almost entirely upstream to the Enterprise and large Corporate markets.

Yesterday, when I was having trouble sleeping, I did a search on a few Legacy Technologies that you might not remember.  Does anyone remember the HP e3000 family of computers, and its accompanying MPE/iX operating system?

Imagine your business ran on these boxes:

Then imagine you got a letter from HP saying that they're ceasing production of this hardware you rely on, and the software that runs your entire business on it.  They politely suggest you transition onto Something Else.   Your compilers are no more good. Your source code is no good.  Your tools and your skills are no good.

Okay enough fear mongering.    Such a thing is very unlikely to happen in the WinTel PC world, at least not before 2099, which is long after I've left this planet, and you too, probably.    

But we're creeping ever closer to the era in which Windows applications on a Windows PC are a niche object, something not everyone wants anymore.  Businesses will continue to use them until there are no more bits of hardware left that run them.  But the days of PCs getting twice as fast are already hard up against the nanoscale physical limits of the universe, and the days when the R&D budgets that drive this Moore's Law growth are going away too.

Soon, very soon, within ten years, Windows will be a shadow of its former self.  This, my friends, is why Microsoft is scared, and is reacting with Windows 8.0 and 8.1. You and me, ordinary developers who target Windows are going to be fine, just fine.    In 2200, there will probably still be virtual machines running some of the Windows software that you and I are building now.

Saturday, October 5, 2013

Delphi Experts and IDE Plugins I Love - Part 2: CNPack

In Part 1 of this series, I covered GExperts, and now I am moving on to what is arguably the most powerful, and most useful open-source expert plugin for Delphi.

It works with very old versions of Delphi (including Delphi 7 and Delphi 2007) which are still widely used out there, it adds some features to Delphi 7 and 2007 that became standard in later versions of Delphi, such as line numbering, and adds features like structure highlighting that are also available in one of the very high quality commercial IDE Expert tools like Castalia, which I'll be covering in a separate article.

I don't believe very many delphi Developers start out with any of the following goals:

  • I would like to write units that are over 50,000 lines in length.
  • I would like to write methods with Cyclomatic Complexities over 1000.
  • I would like to nest begin and end blocks more than 20 levels deep.
  • I would like to write units that have methods that are over 5000 lines long.
But if very few of us start out wanting to do the above, it is still kind of scary how many of us manage to unlock the above dubious achievements. And even if we do not manage to unlock them ourselves, some of us get to work on codebases where the previous people working on the system made things less tidy, less sane, and less easy to follow.  When you can't go in and rewrite every line in a 2 million line application, sometimes a tool can help you not to get lost in the forest.   This is one of the reasons why structure highlighting and context indicators are so useful in your editor.

Imagine you have some code like this, I'm going to construct an artificial example, because I can't really show you the commercial source code I work on, as it's proprietary and may contain trade secrets of my employer.

  object1 := TSomeObject.Create(param1,param2,param3);
    if  CustomerFlags.EnterpriseEdition then
         // 80 lines of code, including several WITH
         // blocks.
    else if CustomerFlags.ProfessionalEdition then
        // 200 lines of code, more WITH statements.
    else begin
       // 300 lines of code, yet more WITH statements.
  // exception  handling. 

If anyone comes up to me and says, "you shouldn't write large blocks of unreadable code that have many nested levels of begin, end, and you should definitely not be using WITH", I'd say, "fine, you're right, now go away,  I'm trying to teach you how to read messy Delphi code, not how to write good code".

If the amount of code inside the blocks is small enough that the code fits entirely on the screen, and the person doing the indentation made it line up, it's probably easy enough to visualize the above scopes.

However, because I dare not show you a 1500 meter tall bitmap here, I'll just show you a method that barely fits on the screen, and you can judge for yourself whether or not methods 100x and 1500x larger than this would also benefit from the following highlighting improvements, and lines connecting the begin and end statements:

As  you can see above, each set of scopes (the begin and end of the procedure, the finally that goes with the try, the begin and ends that go with the if statements) has a different color, and there are lines connecting the begin and end statements now.

If Delphi's code formatter supported reformatting single methods, I'd say, use it on each method,
as you modify it, because reformatting entire modules causes too much difficulty with version control systems.  But the combination of highlighting as above, and completely rigid formatting in the One True Delphi Indentation Style (shown above) will lead you into the Holy Land where Programmers, Customers, and Bosses all Dwell in Peace and Prosperity. 

Just to be contrary, I think I'll start using an Egyptian Braces style, a-la the K&R C book, every now and then.  Just to rile up certain people. You know who you are. Everybody loves a holy war. Anyways, onwards.

What else does CN Pack have?

Too much stuff, frankly. Here's where I show you how to turn everything off and then turn on the bits you like. Click CnPack > Options, then click Advanced, which opens a new window, with two tabs, go to the Advanced tab, and then click this button, to Deselect All Wizards. Then Restart Delphi.
Now you have a CNPack menu that is empty, and basically no features. Now you can add the features you want, one at a time, and learn them, and then add another. I find this a much easier way to learn the CNPack features than being thrown into a virtual labrean tar-pit of options.

Okay now let's turn some stuff on.

The stuff you probably want to turn on first is Source Highlight Enhancements, that's what does the pretty lines and colors for begin and end, that  I showed you above.  If that's all CNWizard did, it would be a great thing.  But wait, there's more.    Try out the Form Designer Enhancements. If you turn them on and then go into the form designer, you'll see new stuff and it will be easier to associate in your brain what feature does what, if you turn them on, try them out, and if you don't absolutely LOVE it, turn it off again, until you need them.

Here's what I have turned on, note how spare my selections are:

If you are overwhelmed with the decision set you face, try my settings.  You might find the Uses Units Cleaner a life saver, I know I do. It's basically magic. If you have a disgusting Uses Clause, that uses 100 units in the interface uses clause, and 100 units in the implementation uses clause, are you certain that all of those are necessary?  This expert will find and remove units that could be removed, speeding up compilation, decreasing the number of namespace pollution and making code-completion in the IDE more accurate, among other things.  Bad Uses-Clauses Hygiene is an epidemic, because most Delphi developers are scared to touch a Uses clause.  Most people just go in and add an item to it, and then hope for the best.  Understanding, grouping and organizing your dependencies, once CNPack has minimized them to the real minimal set that you need to build that unit, is a good step towards understanding the ball-of-mud that your application is becoming, and start turning it around to the point where it is a clean, and well architected piece of software.

The tab-order wizard is another one that I'll recommend you check out.  It's the best tab-ordering helper for Delphi forms I've seen. First it shows you the tab order visually while you are in the form designer at all times:

If you don't keep your application's tab order sane and how users would expect it, your users hate you. I'm telling you this straight.   Many Windows application users navigate their forms with the Tab key and like keyboard shortcuts, tabbing, and keyboard accessibility to work properly.  Tab ordering, a good set of keyboard hotkeys, and so on, are key to expert users loving your system.  Give them some love, test your application's tab ordering before you ship it, and when you have a grotesque mess of a form with 1500 controls, and you use the IDE Tab ordering dialog, it only shows you one level of your form at a time. In the example above, that's fine, but what if your form looked more like this:

At least the out of order problem is now visible. Now let's fix it:

A little warning message comes up, which you can ignore or read, and as all it does is normalize your tab orders, I really think it's pretty safe. But you are using Version Control right? If you don't like what any of the CNPack wizards does, just revert your code instead of committing, right? If you're not using version control, please go get Mercurial and learn it, and then come back, before you go any farther.   Thank me later.

Anyways, here it is, all done:

Wait you say, that's not how I would have ordered it.   Well, I did the above as an example so you can see what it does.   It starts at the top left most pixel of the screen, and orders the tabs from top to bottom, left to right.  Since the button on TabSheet2 is slightly ABOVE the other, it gets the first tab position inside that tab sheet.    So many you'll want to make sure you have all the alignments and positions on your form set properly first, and then try this wizard out.

You can even turn on "Auto Update Tab Orders" in the CNPack menu, but I think that's overkill, as you may want to manually update tab orders at some point, then review them, then save and check in your work.  A much saner workflow than leaving the whole thing on Automatic at all times.

GExperts has a very nice dialog that is better than the single-layer dialog in the base IDE, but I like CNPack's dialog-box-free way of working right in the form designer.  (You can use Delphi's WYSIWYG form designer as your tab order verification screen.)

Anyways there's more, but I think this is a long enough blog post. Next time, part 3, Model Maker Code Explorer, a commercial tool, and worth every penny, just like Delphi is a commercial product, and worth every penny.  If only Delphi was cheap like Borscht, like Code Explorer.  

A reply to Verity Stob

Imagine my pleasure to be mentioned by the one, the only, the legend, Verity Stob.   If you are not familiar with the work of this renowned pundit, journalist, and composer of postmodern satirical brilliance, since 1988, you can find her writing these days over at The Register.  She mentioned me, and my somewhat vitriolic C++ post, back in June, when I said that the great thing about Delphi is that it is not C++.  Harsh? Yes.  Rediculous? Maybe.  Truth underneath? I believe so.

As with most of my more hyperbolic statements, I wonder if I must clarify further exactly what  ridiculous position I was taking, though.  I should very much dislike to be heard to be saying any more or any less than I meant to say by that. And as happens, time goes by and my position moderates or moves, as more information, and more thoughts pass through my gray matter.

What was my "most ridiculous position"? My assertion that what is great about Delphi is that it is not C++.  I still maintain that this is true, but the ire with which my original statement was made is something that I have come to regret.  My apology in this post is to C++, though as I don't think I offended Verity, rather I suspect my C++ slam was amusing.

Verity speaketh verities, yea verily. For indeed, Shared Memory is an intrinsically tricky proposition, and I am not aware of a Shared Memory library for Delphi that is free of accidental complexity, nor of any library of the scope and feature set that Boost has.  So far, Verity, thou hast said rightly.

Further, there are in fact multiple options in the C++ world.  The Boost shared memory library is among the most complex, and most difficult to understand libraries within the boost framework, and there are several simpler non-template-laden C++ library options for shared memory.

But still, I see a general pattern that in C++ everything is more complex than it had to be, and yet, I do not blame C++ anymore, nor the developers.  Have I changed my mind that both higher levels of essential and accidental complexity are baked right in there?  No.

My recent epiphany, thanks mostly to Chandler Carruth, is that it's not C++'s fault.

 I will try to explain what I now think, and why I now think it, in a series of linked logical propositions, each of which is open to attack, but I only ask that my propositions be considered in detail. If they are ridiculous, you would do me a favour by pointing it out as I value logic and reason above ego and dogma.

  1. Because template meta-programming (in C++) and generic programming (in Delphi, C#, and Java) is higher order work, it is harder to understand, harder to learn, and harder to maintain. As a language's powers grow, so do the scope and number of ways you can abuse them.  The very things that make both C++ and Delphi powerful and useful are also the source of the greatest problems that arise from both their use.
  2. C++ is more powerful than Delphi, and is thus, harder to use. Because C++'s power comes along with a history and a series of now-unchangeable-decisions, this accidental complexity is already higher than the accidental complexity of a less convoluted, less powerful language like Delphi. You can dig deeper holes in C++ than you can in Delphi, and you can build higher towers. Most of us are building apartment flats, though, not the Burj Dubai.
  3. If you don't need that much complexity, you're better off leaving it off the table.  C++ programmers often reach this point themselves, when they start advocating subsets of C++ that are "allowable".  By being a non-templated, non-multiple inheritance modern OOP language, Delphi (and Objective-C) have some advantages (as well as some limitations) with respect to C++.  Delphi is not C++, and is both better, and more limited than C++, depending on what you want to do. For most of what I want to do, Delphi is better than C++.
My evidence for the above propositions is as follows.

A. Watch this illuminating talk  The Care and Feeding of C++ Dragons by the very talented Chandler Carruth, a Google employee, who works on CLANG/LLVM, giving a talk at Microsoft's Native 2012 summit.    If you are a Delphi-centric developer and you haven't encountered the terms "Undefined Behaviour" or "Almost-Strong Memory Model" before, you might want to google those and have their meanings fresh in your mind before watching. Ask yourself,  if C++ really is as "expert friendly" as Bjarne says it is, is that a good thing? The C++ community is aware of this problem, and is trying to avoid framing it as frankly as it could be framed.  The talk spends a while on whitespace and formatting.  Then it goes on to explore the other tools that Chandler's colleagues have been building, and why.  It's fascinating.  Chandler makes an aside about C++'s complexity not being C++s fault.  In the context of that talk, I was enlightened.  He's right. I forgive you C++. But you're still harboring lots of Dragons.

B.  Bjarne Stroustrup, father of C++, a guy I admire very much, and ask yourself what he means when he says C is a gun you can shoot yourself in the foot with, but C++ is a machine gun that can blow your leg off.  I have his new book, and I'm really enjoying C++ 11 so far, but the in-the-field reality is that the life of a C++ programmer is one of working in the trenches of ugly C++98 code.  

C. The allowable-subsets-of-C++ that I have seen so far, and the efforts I have seen to improve the accidental complexity of C++ include, but are not limited to:

Ironclad C++  - A paper and proposition on a subset of C++

Embedded C++ - A subset of C++ that removes exceptions, multiple inheritance, and more.

MISRA C++  - Advisory rule system (static) to try to help you write safer C++

Clang Analyzer - A fantastic looking static analysis tool that adds more warnings when it detects you may be shooting yourself in the foot.  A bit of a demo is included in the Chandler Carruth demo above.

The Java Language and the C# Language   -  The complexity of manual memory management (a fault C++ shares with Delphi, but to a greater extent) and the other perceived or real flaws of C++ were a key motivation in the creation of Java, and the later creation of C#, which was itself a Microsoft reaction to its feeling miffed about being told it could not Embrace, Extend, and Extinguish Java by making its own proprietary JVM extensions.   C# is in many ways, the most beautiful language I have ever seen, with most of the warts of the other Curly Brace Languages (including Java)  fixed in a lovely way.   I do not have a lot of love for non-native-runtimes (JVM, .NET runtime) but as a language, C# is surely one of the most beautiful Statically Typed Languages ever designed or built.

C++ Holy Wars - If I might be allowed one mostly personal, anecdotal addition, it's that every time I've worked with other C++ developers, the usual holy wars about indentation and library use are usually usurped and over-arched by conversations about which C++ features are allowed in this codebase, and which are not.   Some developers in some places hate the ternary ( a ? b : c) operator, some hate template metaprogramming (I'm getting close to that point myself),  some hate smart-pointers and shared-pointers and avoid them, except as a last resort. This includes Bjarne Stroustrup.

Now let me knock a few obvious holes in the above evidence, so you won't think I'm a complete Delphi-loving idiot. 

  • There are more tools, libraries and attempts to improve C++ than there are for Delphi because more people use C++, not because Delphi is less complex.  I know this.   I am not arguing on the existence of some cardinal number of different tools that any link should be made between the complexity of C++ and Delphi.   That, frankly, is easy to do. Compare the complexity of the grammar of Object-Pascal and the grammar of C++, be sure to include the vast differences between the C family language style (separate compiler and linker and preprocessor stages) and the Delphi/Pascal language's simpler compiler and linker.

  • By complexity in C++ I do not mean only accidental complexity, but also essential complexity. These two types of complexity are both going to add to the cost of software development.  But as Chandler Carruth points out, it's unfair of me to target C++ as being the cause of most of the complexity that I deal with. Nevertheless, due to the real nature of the problem (the essential complexity that C++ was designed to help you deal with), you still are going to have that weight on your shoulders.  Just please, let's not villainize the wonderful, smart, and amazing people who have designed, and built C++. They were not out to get you. They have the same universe to live in that you and I have to live in.  They do not wake up in the morning and dream of new ways to terrorize the rank and file programmers of the world with their new language misfeatures.  If anything, they got into this work (designing languages, implementing compilers, working on ISO language standards) to tame the very dragons of complexity that I curse, when I bemoan my ill-luck debugging template issues. 
  • The context in which I made my original blog post, was while trying to modernize an old C++ codebase, and bring it up from Visual C++ 6, with it's well known standard library bugs and ancient no-standard-but -itself status, to a modern Visual C++ version.    This codebase included a very old and very sad shared memory implementation that was based around mapping a block of shared memory, and resizing it when it caught access violations happening. This code had no unit tests, this code was based on libraries for which not all the source was present (some LIB files for Visual C++ 6 contained classes that no source code was present for), and a host of additional issues.   In the ensuing attempts to rescue this project from obsolescence, I was learning Boost, learning modern C++, and (as is usual for me), assuming the fault lay with other people, and other things (like C++) instead of with myself.    The bugs I found in the Boost Shared Memory library were mostly a result of me misusing the library, and the result of mixing that library with a quite insane and crusty codebase.   I ranted, and I raved, I even posted a message to the Boost mailing list that I am now ashamed of.   The author of the Boost Shared Memory library is a better developer than me, better, smarter, and more humble. Mea culpa. I'm an idiot sometimes.   But even with that admission (that casts some serious doubts upon my original assertion about C++), I still maintain that the job of working in C++ is harder than the job of working in ObjectPascal, and that part of Delphi's advantage as a "Force Multiplier" for Developers, would actually be eroded, if Delphi ever achieved feature parity with C++.

 And in conclusion I'd like to say that Delphi basically allows someone of mere mortal capabilities, to get a job done that would require a Ph.D.-like grasp of compiler and language semantics, in C++.   This is the key challenge that C++ faces in the next 20 years. It is not going away, C++ is far more important and far more powerful than Delphi.  In a way, I admire the beautiful new language that C++ 11 and C++ 13 are trying to become.  But the legacy of C, the ill-advised choices in C++98, and even, the odd codebase still stuck on Visual C++ 6.0 are part of the panoply of things that a  "C++ Programmer" today, and in 2023, will still be stuck dealing with.  I for one, am very sad that Delphi jobs are drying up.  Because any Delphi developer's next job just might be a C++ job, or a mix of C++ and Delphi, I think it's wise if Delphi geeks know both.  I'm not saying I'm a Big C++ fan now.  But I'll try to grin and bear it with better humor than I had previously managed.  Because I'm still learning and growing as a human being, I ask anyone who is offended by my C++ trolling to please forgive me.  Including Verity Stob, who I hope, might see that I'm not quite making as many ridiculous claims now that I have had a bit of time to reflect.  Because, hey, Verity, you were right.   I was being a bit ridiculous.  If I have erred in my analysis above, I trust the mighty internet to correct me in the comment box below.

TLDR?  There's no such thing as a free lunch.