Hallvard's Blog

Why no blogging? Alive and kicking :-)

2011-11-04T09:31:00.003+01:00

As you may have noticed (or not :), this Blog has been silent since 2008. Several people have asked me recently why I'm not blogging anymore - here is a short explanation.I was blogging quite actively for a while, but other priorities in my life (family, work, new house, exercising etc) have taken over. There is only so much time.While I've been silent on the blog for a few years now, I'm still

TDM#10: BorDebug – Return of the Giant

2008-03-30T18:37:00.003+02:00

"The Delphi linker has always had the option of including so-called Turbo Debugger (TD32) debug information (on the Linker page of the Project Options dialog). The internal IDE Debugger does not normally use this information (Delphi 4 and 5 uses it when debugging external DLLs and EXE files), but instead relies on internal compiler structures build during an interactive compile. External tools

TDM#9: Exceptional Stack Tracing (HVEST)

2008-03-15T20:02:00.001+01:00

One of the key questions you should ask yourself as a serious Delphi developer is; what kind of exception handling and logging am I using. If you're not using any custom or third party solution for tracking down exceptional incidents that occur in your production systems or at your customer sites, you're missing out big time! A proper exception handling and logging system should at least log the

TDM#8: DelayLoading Of DLLs

2008-03-11T23:04:00.001+01:00

"I don’t miss many features from Microsoft’s Visual C++ 6.0 when working in Delphi, but the new /DELAYLOAD option of the linker is one of them. This option lets you turn normal, implicit DLL import libraries into so-called delayload import libraries. This means that the DLL will not be loaded by the operating system (OS) during start-up of the EXE file, but rather on an as-needed basis when you

TDM#7: Design Patterns; Singleton

2008-03-06T22:16:00.001+01:00

"In their book Design Patterns, Gamma et al (a.k.a. the gang of four) lay the foundation for a new way of approaching software design. [...] In this article we will first look at the language elements that are unique to Object Pascal when compared to C++ and how this makes many of the problems the design patterns try to solve, non-existent, or at least much easier to solve. Then we will look at

TDM#6: Knitting Your Own Threads

2008-03-02T22:30:00.001+01:00

One of the key reasons that computers have conquered the world is that they have been following Moore's Law with faster, smaller and cheaper CPUs (and similar "laws" and improvements of memory, hard disks, graphics cards, etc) coming out every year. Until recently, all programs have just become faster and faster due to improved hardware. This has been dubbed "the free lunch" and has given sloppy

TDM#5: Slimming the Fat off Your Apps

2008-02-12T22:25:00.001+01:00

I think that the best TDM article title I've had is Slimming the Fat off Your Apps. It was published in November 1998 and we're still in the Delphi 4 era (but as always many people were still using the older versions, D2 and D3). The article intro said: "Hallvard Vassbotn wants to slim the fat off your software: tune in here if you want [your programs] to be leaner and fitter..." The core points

TDM#4: Delphi 4 Bugs and Fixes

2008-01-30T22:26:00.001+01:00

Delphi 4, released in the summer of 1998, was one of the most notorious Delphi releases ever. The initial release contained a large number of serious bugs, and it later became clear that the release date had been pushed by management and/or marketing and not sanctioned by technical and R&D. While all of this is water under the bridge, one very visible bug, the so-called TListBox ItemIndex bug,

TDM#3: The Rise and Fall of TObject

2008-01-26T21:18:00.001+01:00

"Consider yourself an Delphi expert? Here is a test question for you: Can you name the 8 methods of TObject that are part of the process of constructing and destroying objects in Object Pascal" That was the introductionary question of my The Rise and Fall of TObject article published in The Delphi Magazine, July 1998. Now we're in the era of Delphi 3, with Delphi 4 just being released. The

TDM#2: Hooking Heapcheck

2008-01-24T22:00:00.001+01:00

Inspired by the apparent popularity if my YAST article, a few months later, in July 1996, I published my second Delphi Magazine article - called Hooking HeapCheck. While the article is mainly irrelevant to 32-bit Delphis, it does show what is possible to achieve with a little hacking. The gist of the article is to expand a mostly useless, parameterless Delphi 1 memory manager callback-function,

TDM#1: Yet Another Stack Tracer

2008-01-22T22:20:00.001+01:00

"Have you ever had any really hard-to-find bugs in your code? If not, you can skip this article, otherwise you’d better keep on reading!" The above quote was the enticing introduction to my first full-feature Delphi Magazine article with the ironic title Yet Another Stack Tracer (or YAST for short). It was published in the seventh TDM issue, March 1996. The contents page said: "YAST: Yet

Republishing my old The Delphi Magazine articles

2008-01-22T22:05:00.001+01:00

As you probably know The Delphi Magazine is no longer in publication. As their web-site indicates the articles and source code repository will only be online for a short while longer, but it is still possible to order the excellent value-for-money 1GB USB stick with all magazine issues and code. TDM was generally accepted as the best source of technical articles about Delphi and development

DN4DP: The Delphi Language Chapter

2007-11-02T07:29:00.001+01:00

We have finally come to an end in the long running series of of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. All the chapter excerpts that I have posted can be seen by clicking on the DN4DP blog label. As a service to our readers, I'm also including a full list of all the post links here. Classic Delphi and .NET book in the making Come get a free

DN4DP#30: Delphi vs C#

2007-11-01T07:56:00.001+01:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we looked at .NET and Win32 constructors. This is the final post in this long running series and it covers the main differences between Delphi and C#. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for

DN4DP#29: .NET vs Win32: Constructors

2007-10-31T07:56:00.001+01:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we looked at class references. This posts covers .NET vs Win32 constructors. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "Constructors While it is a good rule in Win32 to have

DN4DP#28: .NET vs Win32: Class references

2007-10-30T08:58:00.001+01:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we looked at differences in abstract class behavior. Here we look at class references. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "Class references For the most part, the

DN4DP#27: .NET vs Win32: Abstract classes

2007-10-28T14:32:00.001+01:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we looked at initialization and finalization sections. This post covers some minor differences in abstract class behavior. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "Abstract

DN4DP#26: .NET vs Win32: Initialization and finalization

2007-10-26T23:25:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we looked at the .NET and Win32 casting issues. Here we quickly covers some potential gotchas related to initialization and finalization sections. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance

Sergey Antonov implements Yield for Delphi!

2007-10-23T21:30:00.001+02:00

The Russian Delphi programmer Sergey Antonov (or Антонов Сергей - aka. 0xffff) is a real hacker in the positive sense. He approached me with some intriguing assembly code that implements the equivalent of the C# yield statement! Yield makes it easier to implement enumerators (you know the simple classes or records with methods like GetCurrent and MoveNext that enables the for-in statement).

DN4DP#25: .NET vs Win32: Casting

2007-10-20T22:12:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we looked at the .NET and Win32 differences for untyped var and out parameters. Here we look at casting issues. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "Casting There are

More fun with Enumerators

2007-10-17T16:46:00.001+02:00

As part of the new language syntax inherited from Delphi.NET, native Delphi now (since Delphi 2005) supports for-in loops (known as foreach in C#). The new syntax is easy to read, and it reduces the clutter of maintaining a loop index variable, checking boundary conditions (typically 0 and Count-1) and indexing into the array or list. While Delphi has special built-in support for for-in for (

DN4DP#24: .NET vs Win32: Untyped parameters

2007-10-07T13:37:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. The previous post listed the Win32 specific language and RTL features. The next few posts will focus on minor differences in implementation between Win32 and .NET - starting with differences in the detailed semantics of untyped var and out parameters. Note that I do not

DN4DP#23: .NET only: Obsolete features

2007-10-05T22:08:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. The previous post showed how to use the mysterious P/Invoke features. This time we'll list the Win32 specific features of the language and RTL that didn't make it to the .NET side. Note that I do not get any royalties from the book and I highly recommend that you get your

My article on CodeGear RAD Studio 2007

2007-10-02T13:16:00.000+02:00

As some of you may know, I've recently written an article/review on the new CodeGear RAD Studio 2007. It was originally written in Norwegian (my first technical article in Norwegian - that was hard:)) and published on the Hardware Business site hwb.no:http://www.hwb.no/test/utvikling/codegear_rad_studio_2007_/43487Due to popular demand, I've translated the article into English and sent it to Nick

DN4DP#22: .NET only: P/Invoke magic

2007-10-01T21:56:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we're explored an undocumented corner of the language. This time we'll explore the exotic (and cryptic?) world of P/Invoke. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "P/Invoke

DN4DP#21: .NET only: Undocumented corner

2007-09-30T08:45:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we're covered the differenced between classic single-cast events vs .NET-style multi-cast events. This time we'll dive into an undocumented corner of the language. Note that I do not get any royalties from the book and I highly recommend that you get your own

DN4DP#20: .NET only: Multi-cast events

2007-09-28T20:38:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we're scared by unsafe code. Here we discuss the syntax for normal Delphi events vs .NET-style multicast events. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "Multi-cast events

DN4DP#19: .NET only: Unsafe code

2007-09-26T20:46:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we looked at a new array syntax supported in .NET. This post covers the dangerous sounding concept of unsafe code. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "Unsafe code Delphi

DN4DP#18: .NET only: New array syntax

2007-09-24T21:12:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we looked at multi-unit namespace support. Now we will jump to a new array syntax supported in .NET. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "New array syntax While native

DN4DP#17: .NET only: Multi-unit namespaces

2007-09-22T23:06:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. The previous post covered platform differences for floating-point semantics. This time we'll look at namespace support. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "Multi-unit namespaces

DN4DP#16: .NET only: Floating-point semantics

2007-09-21T21:31:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. The previous post covered support for .NET Attributes. This time we will look at platform differences when it comes to floating-point operations. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon.

DN4DP#15: .NET only: Attributes support

2007-09-20T21:57:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. The previous post covered support for .NET Boxing operations. We continue with the .NET specific topic of Attributes support. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "Attributes

DN4DP#14: .NET platform support: Boxing

2007-09-18T18:33:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. The previous post covered overloaded default array properties. The next few posts will be .NET specific - starting out with support for Boxing operations. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance

DN4DP#13: Overloaded default array properties

2007-09-17T21:36:00.001+02:00

It's been a while now, but this post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. What a good time to continue this series just after the major Delphi for .NET 2.0 launch, CodeGear RAD Studio 2007! The previous post covered the exotic topic of Record Helpers. Today we'll look at another exotic-ish topic - overloaded default

RAD Studio 2007 launch in Oslo, Friday Sept 14th

2007-09-07T22:01:00.001+02:00

The largest Delphi meetup.com group in the world (121 members and counting!), Oslo Delphi Club, is arranging a launch event for the new Delphi and C++Builder version called RAD Studio 2007. This is the version that, amongst other things, introduces full support for .NET 2.0 and Generics in Delphi for .NET (as shown here). If you're in or close to Oslo, Norway make sure you're not missing this

Highlander2 Beta: Generics in Delphi for .NET

2007-08-28T21:42:00.001+02:00

CodeGear's Delphi Product Manager Nick Hodges has once again released me from an NDA - now for the beta testing of what has been dubbed Highlander2 - the version of RAD Studio 2007 (renamed from BDS 2007) that includes an updated Delphi for .NET personality, compatible with .NET 2.0. New stuff There are many new features in this version, including: Delphi for .NET now targets .NET 2.0, including

Delphi programmers wanted!

2007-07-04T21:18:00.001+02:00

Our company, Infront AS, is growing fast - both in terms of customers, revenue and employees. We're in the process of expanding our Client Development Team with one or two new persons. The Company: ~20 persons Fast growing, making profit Realtime financial information and online trading Customers: brokers, banks, institutions, day traders The Job: Tools: Delphi, Subversion, FogBugz,

Testing WLW Maps

2007-06-22T19:58:00.001+02:00

I've just updated to WLW 1.0 beta 2. It has a number of nice (new and old) features. Last time I tried the Insert Map feature crashed the application, so now I'm going to try again. To avoid attracting stalkers, I will not post a map of my home, but rather the place where I work, Infront AS: View map I can't directly upload images to my Blogger.com account, but I don't know if that is why the

Sorry about the old post flooding!

2007-06-22T19:29:00.001+02:00

Changing this blog to use a template caused most of the oldest (pre Window Live Writer authored) posts to have "interesting" formatting - with cramped text, code with no end-of-lines, bold headlines in the middle of the text, and so on. I have been cleaning up the formatting of some of these old posts and this caused the RSS and Atom feeds to include these "updated" posts. It looks there is no

Blog site transition, phase one done

2007-06-20T22:39:00.001+02:00

Welcome to a new and brighter blog! ;) I've started off with one of the standard templates. I like this one because it wastes less space at the sides, making the articles appear somewhat shorter than they are (he-he). The code syntax items should still render with the classic TP white and yellow on a blue background, but to be honest I was growing a little tired of it in the text itself. Now the

Work in progress: Blog design in flux

2007-06-19T22:27:00.001+02:00

As you may have noticed, I'm in the process of upgrading my Blogger template to get access to some new design tools they have. This means that colors and code syntax highlighting will be wrong for a little while...

DN4DP#12: Record Helpers

2007-05-30T20:59:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. The previous post explained how destructors and Free works in .NET. This one covers record helpers. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "Record Helpers Just as you can have class

DN4DP#11: The try-finally-Free pattern

2007-05-30T20:58:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we covered class helpers and why they were invented. This post looks in more detail at the TObjectHelper class helper and the Free method. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at

DN4DP#10: With a little help from your friends

2007-05-30T20:57:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we looked at how you can import identifiers that happens to conflict with Pascal keywords. This post includes the section on class helpers. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at

DN4DP#9: Escaping keywords

2007-05-19T11:50:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we covered the internationalization of Pascal identifiers. This time we will see how you can use imported identifiers that conflict with Pascal keywords. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for

Use the full FastMM! Consider donating!

2007-05-18T22:03:00.001+02:00

A few years ago, it would be interesting to ask what memory manager (MM) you are using in your Delphi projects. You had the old-in-the-tooth in-the-box 32-bit Delphi RTM MM that was the default MM in Delphi 2 through Delphi 7, simple wrappers around Win32 API HeapAlloc, freeware alternatives such as MultiMM, RecyclerMM, PSD, AAHpDeFr, Bucket, and commercial alternatives such as SmartHeap, Nexus

Hack#17: Virtual class variables, Part II

2007-05-16T22:35:00.001+02:00

In Part I of this blog post we introduced the concept of virtual class variables - a feature currently (Delphi 2007) lacking from Object Pascal (and most other languages). We also covered a potential syntax and suggested some compiler implementation details. In this post we will continue by looking at some hacks to try and implement the functionality of virtual class fields manually by using some

DN4DP#8: Unicode identifiers

2007-05-07T00:01:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we included the section on the new inlining support of the compiler. This post briefly covers the internationalization of Pascal identifiers (Klingon code, anyone?). Note that I do not get any royalties from the book and I highly recommend that you get your own

Hack#17: Virtual class variables, Part I

2007-05-04T21:27:00.001+02:00

[Note: This blog post was inspired by an email conversation I had with Patrick van Logchem - more details on this in Part II] Proper Object Pascal support for class var variables was first introduced in Delphi 8 for .NET and later in Delphi 2005 for Win32. Functionally class vars in Object Pascal (and most other languages, for that matter) work like class-scoped global variables, i.e. their

Psst, a special price for you, my friend...

2007-04-27T21:42:00.001+02:00

An item that may interest you is available at eBay now, click here. PS: I still have another Delphi 2007 licence.

DN4DP#7: Inlined routines

2007-04-17T21:46:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we covered the new for in loop and the pattern for introducing enumeration support to your own classes. This post includes the section on the inlining support of the compiler. Note that I do not get any royalties from the book and I highly recommend that you get

Subversion in Delphi's Tools menu

2007-04-11T16:17:00.000+02:00

Joe White writes about how to add Tools menu items with Subversion commands here.For some reason, the Submit button didn't work on his Comments page (running IE6), so I'll just write my comment here:Nice, thanks!I've been meaning to do the same thing for a while, but kept postponing it. Shame about the space-before-macro requirement in the Tools menu - you should probably log it in QC.I didn't

Hack#16: Published field RTTI replacement trick

2007-04-08T14:34:00.001+02:00

We're back to fixing the interesting (learning-wise) problem of the flickering TProgressBar on Windows Vista. We have already looked at two relatively dirty and intrusive hacks that either overwrites the TClass reference inside each progress bar instance or overwrites the dynamic method table pointer of the original TProgressBar VMT. There are other related code page overwrite hacks that we may

DN4DP#6: Enumerating collections

2007-04-03T23:15:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we showed how it is now possible to override the meaning of language operators. This time we'll cover the new for in loop and the pattern for introducing enumeration support to your own classes. Note that I do not get any royalties from the book and I highly

DN4DP#5: Redefining the operators

2007-03-31T23:00:00.001+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we talked about the new record syntax. This time we will look at the exciting new operator overloading capabilities. Note that I do not get any royalties from the book and I highly recommend that you get your own copy – for instance at Amazon. "Redefining the

Hack#15: Overriding message and dynamic methods at run-time

2007-03-23T23:50:00.001+01:00

Last time we looked at a way of completely changing the class of a running object instance. As we discussed there, that hacking technique had a number of problems. But there are many ways to skin a cat (sorry, cat lovers!), and in the case of trying to fix the TProgressBar flickering issue on Windows Vista without changing the interface declaration of TProgressBar there are at least three other

Hack#14: Changing the class of an object at run-time

2007-03-22T22:53:00.001+01:00

Sometimes (such as when you for one reason or another need to stay backwards compatible with binary dcus) you may have to employ a hack or two. One such hack is to change the actual run-time class of an object instance. You might need to do this to override a virtual, dynamic or message method, for instance. Vista and ProgressBar flickering One such case; for some reason (most probably a bug fix)

Delphi 2007 ESD arrived - one gotcha

2007-03-21T22:47:00.001+01:00

We ordered Delphi 2007 ESD from the local Norwegian CodeGear distributor alfacode.no a few days ago and earlier today the email with download link and licence keys arrived (the DVD will arrive in a couple of weeks, they say). I downloaded the installer stub that then downloads and installs the required binaries - it all worked very smoothly. After the install was done Delphi 2007 ran fine. But I

Application Shutdown Changes in Windows Vista

2007-03-19T13:38:00.000+01:00

Microsoft Vista new best practices, implementation and APIs for application shutdown notification and behavior: Application Shutdown Changes in Windows Vista

The Delphi Geek: Delphi 2007 is here!

2007-03-19T12:40:00.000+01:00

Primoz Gabrijelcic has created a summary with links to all blog posts about the Delphi 2007 beta: The Delphi Geek: Delphi 2007 is here!

Vista User Account Control and Command Line Applications

2007-03-19T11:45:00.000+01:00

Fredrik Haglund has a good post on Vista and UAC: Vista User Account Control and Command Line Applications

DN4DP#4: Setting new records

2007-03-14T22:24:00.001+01:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we talked about the new capability of nesting types and constants inside other class declarations. This time we will look at the extended and OOP-like syntax and functionality for plain old record types. Note that I do not get any royalties from the book and I

Review: Delphi 2007 for Win32 (Beta) - part three

2007-03-11T21:59:00.001+01:00

Read the part one and two first. What's new in the VCL There are quite a few bugfixes in the VCL (as well as the RTL), but we'll not go into them in detail here. While remaining binary .dcu compatible, CodeGear has managed the feat of adding new functionality and even new properties on the existing TCustomForm class. The GlassFrame property hack In particular, all forms now have a GlassFrame

Review: Delphi 2007 for Win32 (Beta) - part two

2007-03-06T20:22:00.001+01:00

Read part one here first. What more is new in the compiler? New published vs $M+ behavior The new "W1055 PUBLISHED caused RTTI ($M+) to be added to type '%s' " warning is interesting. It solves one of the issues we discussed earlier. In earlier versions of the compiler, if you compiled code like this:type TMyClass = class private

Review: Delphi 2007 for Win32 (Beta) - part one

2007-03-01T23:25:00.000+01:00

Nick Hodges of CodeGear contacted me and gave me permission to talk about the upcoming Delphi 2007 for Win32 product - codenamed Spacely. Note that this review is based on a pre-release Beta build 2063 from mid February. Anything you see here is subject to change in the release version.The installerHere are a few screenshots of how the new installer looks like - click them to see them in full

The Five Things Meme

2007-01-18T21:12:00.000+01:00

You probably know the drill by now. The good Dr. Bob tagged me with this infectious Five Things Meme and now I'm supposed to tell five things about myself that you probably didn't know. Oh - the excitement! ;) If you fall asleep halfway through the list - come back tomorrow. Ok - here we go: In my childhood and youth I have had part-time jobs as a paperboy, flower delivery, painter (on walls,

The history of the CodeGear name

2006-12-12T21:54:00.000+01:00

A while back, Michael Swindell (Borland CodeGear), posted the story about how the CodeGear name was picked to the delphi.nontech newsgroup. First it was established that Michael had recently bought the domain name codegear.com. Then someone asked: Can you tell us how much cost you that ? And Michael's reply was an interesting read of the story behind the name: one BILLION dollars.... heh...

Don't miss the Oslo Delphi Day, Dec 15th 2006!

2006-12-12T17:26:00.000+01:00

In a joined operation between Alfacode AS (and Thomas Fjeld), CodeGear Stockholm (represented by Fredrik Haglund) and the Oslo Delphi Club, we are arranging the Oslo Delphi Day on Friday December 15th. The key attraction is three presentations held by tech Speaker Extraordinaire, Chad Z. Hower (aka Kudzu) of Indy and IntraWeb fame. In addition there will be few sessions by Fredrik and myself.

DN4DP#3: Nesting habits

2006-11-23T22:15:00.000+01:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we learned about the new class member visibility specifiers that are available, abstract classes and final methods. This time we will look at the syntax and semantics of nested classes. Note that I do not get any royalties from the book and I highly recommend

Borland and CodeGear

2006-11-23T22:12:00.000+01:00

As most of you will already know, Borland has now moved its developer tools group into a separate company called CodeGear. CodeGear, which will still be wholly owned by Borland, will continue to develop, sell and support developer tools like Delphi, C++Builder, JBuilder and Interbase. There are also indications that they are moving into the webspace with support for languages such as PHP, Pyhon,

Hack#13: Access globals faster ($ImportedData)

2006-09-29T21:31:00.000+02:00

There is an aura of magic around Delphi packages. Packages allow you to share Delphi code at a much higher level than is possible with plain old DLLs. Writing a DLL-based library API involves writing flat non-OOP global routines and avoiding any data types more advanced than integers, doubles, static arrays, PChar and records. You cannot share or exchange classes, objects, global variables or let

Hack#12: Create smaller .EXE files ($SetPEFlags)

2006-09-24T20:46:00.000+02:00

No, this post is not about so-called EXE-compressors - I don't believe in using them. And it is not a pure hack in the sense that we're breaking any rules - its just about documenting an undocumented and unknown feature of the Delphi 2006 Win32 compiler (it is not implemented in D7 - I don't know about D2005 yet as I don't have it installed on this laptop anymore). Background infoWhen you

ODC#2: 1st Oslo Delphi Club event was great!

2006-09-21T14:33:00.000+02:00

Unbelievable, but true - only two weeks after the Oslo Delphi Club was created we have 48 members and counting! And on Wednesday September 20th we gathered not less than 21 members to the first ever meeting at the local Peppe's Pizza joint to share good food, beverages, background stories and enthusiasm of Delphi, DevCo and the Oslo Delphi Club. The room I had booked was packed to the last seat.

ODC#1: First ever Oslo Delphi Club meeting!

2006-09-14T20:40:00.000+02:00

The Oslo Delphi Meetup group has now been created and the first meeting is scheduled to be Wednesday September 20th, at a local pizza place. If you are a Delphi programmer situated in or close to Oslo, make sure you join the group and signup for the meeting. PS. IMO, the Oslo Delphi group hasn't finalized its name yet. The archetypical English name that meetup.com uses is The Oslo Delphi Meetup

DN4DP#2: Protecting your privates

2006-09-12T18:37:00.000+02:00

This post continues the series of The Delphi Language Chapter teasers from Jon Shemitz’ .NET 2.0 for Delphi Programmers book. Last time we learned about the new kinds of class members that have become available; class fields, class static methods, class properties and class constructors. This time we will look at the new class member visibility specifiers that are available, abstract classes and

Hack#11: Get the GUID of an interface reference

2006-09-11T21:57:00.000+02:00

Recently Randy Magruder approached me with a very interesting sounding project he is working on: "What I'd like to do is effectively add/remove new interfaces to a class at runtime, and invoke them. I have done enough that I can use the OTAServices model in Delphi to pass in additional interfaces, add them to an internal list, and override the QueryInterface behavior to return something in a

Oslo Delphi Meetup Group started!

2006-09-07T22:30:00.000+02:00

We have now started the Oslo Delphi Meetup Group (or "Brukergruppen for Delphi i Oslo" as it is called in Norwegian). If you have a chance to participate in upcoming meetings in Oslo and is interested in Delphi (I assume you are - why else would you be here;)) please sign up as a member here. Membership is free, but using the meetup.com site isn't (there is a monthly fee). For the time being

Extended Class RTTI

2006-09-06T22:37:00.000+02:00

As has been mentioned earlier, Delphi (since version 7) supports extended RTTI on the methods of a class - by compiling the class with $METHODINFO ON defined. This RTTI includes the signature information of the public and published methods. Delphi uses this to implement scripting of Delphi code in the WebSnap framework - see ObjAuto and friends for the details. I have now been able to write my

DN4DP#1: Getting classy

2006-08-31T16:32:00.000+02:00

As most of you will know by now, I was the tech editor of Jon Shemitz’ great .NET 2.0 for Delphi Programmers book and I wrote chapter 10 on The Delphi Language – covering what’s new in the language since Delphi 7. Jon has made one chapter available for download. To give you some extra teasers from the book, I will in the coming months post a few excerpts of The Delphi Language chapter. Note that

Nordic Delphi meetup groups

2006-08-29T22:26:00.000+02:00

Last week I had a very nice meeting and dinner with DevCo’s Nordic representatives Fredrik Haglund (Developer Relations and Evangelist) and Dan Nygren (Account Manager). We had some interesting discussions about everything from nuclear power plants to Delphi and DevCo. These guys are very dedicated and on a mission to make DevCo and Delphi succeed even better than under the Borland umbrella.One

Extended Interface RTTI

2006-08-15T21:50:00.000+02:00

To support the most basic mechanisms of its SOAP architecture, Delphi has supported extended interface RTTI since version 7. As we saw in the previous article, all interfaces support basic RTTI information such as the name of the interface, its GUID, unit, parent interface and number of methods. To enable extended RTTI on an interface, compile it with {$M+}, {$TYPINFO ON} or {$METHODINFO ON}

.NET 2.0 for Delphi programmers available now

2006-06-25T21:31:00.000+02:00

Jon Shemitz’ classic .NET 2.0 for Delphi Programmers book is now available in hardcover and shipping from Amazon and other online and old-fashioned book shops. I don’t have my own copy yet – if you already have yours, you can be the first to write an Amazon review. Read my review of it here. As I’ve mentioned before there is a sample chapter online at Jon’s site. Highly recommended!

Simple Interface RTTI

2006-06-04T22:54:00.000+02:00

Delphi supports getting RTTI for all interfaces, but it does not include method information for “normal” interfaces.type {$M-} IMyMMInterface = interface procedure Foo; end; By using the built-in TypeInfo function on the interface type, we get a pointer to the RTTI structure the compiler has generated for it, a pointer to a

Blog feed: atom2rss converter down

2006-06-04T22:28:00.000+02:00

As one of my diligent readers made me aware of, the free service I've been using to convert Blogger's Atom-only based XML feed to the more widespread RSS format has stopped working for some time now. The service I used is documented here:http://www.2rss.com/software.php?page=atom2rssWhen I initially created this blog, I included a link of the following formathttp://www.2rss.com/atom2rss.php?atom=

Digging into SOAP and WebSnap

2006-06-04T22:12:00.000+02:00

In previous articles on this blog we have dissected the internal workings of published methods, and lamented the (assumed) fact that the RTTI for them does not include signature information. We then developed a dirty (and pretty useless) hack to dig out the parameters of a published method by matching it with the RTTI of an event that references the method at runtime. As I briefly mentioned in my

David Glassborow on extended RTTI

2006-05-28T20:10:00.000+02:00

It turns out the story (part one, two and three) about getting RTTI for published method parameters isn’t over yet :-). In Delphi 7, Borland extended the RTTI capabilities in order to support SOAP and WebSnap by introducing the (then undocumented) $METHODINFO compiler directive. We’ll look at this in more detail later, but in the mean time make sure you go to David Glassborow’s blog to read his

Published fields details

2006-05-20T09:09:00.000+02:00

In the previous article we looked at how published fields are used by the IDE and VCL to make component references easy to use and to find class references from component type strings. Now we want to dig deeper down into the implementation details of published fields. Starting with analyzing the assembly code in TObject.FieldAddress I was able to reconstruct these approximate Pascal structures:

Published fields

2006-05-14T16:43:00.000+02:00

In our little series about reverse engineering the undocumented fields of the Delphi VMT, we have come to the FieldTable field. This field points to structures that describe the published fields of a class. In Delphi, published fields must be object references and are mainly used by forms and datamodules to store component references in logically named and easy to use fields (the alternative

Hack #10: Getting the parameters of published methods

2006-05-11T22:28:00.000+02:00

This hack is not normally very useful, but inspired by a comment on the first published methods article, I started to investigate how it could be done. Recall that the compiler currently does not encode the method signature when generating RTTI for published methods – only the code address and name string is stored.So initially, it seems impossible to obtain this information. But let’s backtrack

Come get a free sample chapter!

2006-05-11T22:08:00.000+02:00

Jon Shemitz has made a chapter called Strings and Files from his upcoming .NET 2.0 for Delphi Programmers book available for download (I was the tech editor of the book). Click this link to go to his book site and download the chapter. You can also take a look at the front matter (including a most generous acknowledgement – thanks Jon!) and the impressive index. When you have read the great

Under the hood of published methods

2006-05-02T22:16:00.000+02:00

Now that we have covered what published methods are, how the IDE and VCL uses them in .DFM streaming and how to use them polymorphically, we are ready to dive deeper to see how they are implemented under the hood.If you have been following this series of articles about the polymorphic features of the Delphi language, you will have noticed that the VMT contains a MethodTable field, currently

Pure interfaces in Delphi

2006-04-30T23:19:00.000+02:00

In a comment on the recent interface-list blog post Huseyn asks: “In Delphi we expect all interfaces be descendants of IUnknown [or IInterface - HV], but in [the] C world there are many even more basic interfaces which are not inherited from IUnknown. I came across one of them in a DLL which I need to use. But I couldn't do it using Delphi.” It is true that a Delphi interface declaration always

Getting a list of implemented interfaces

2006-04-29T13:26:00.000+02:00

Frenk asked in the non-tech newsgroup: "Is there some way to find out which interfaces (interface list) a particular component implements (I don't know [the interfaces], so querying is not possible)?" Yes, there is.Call TObject.GetInterfaceTable to get a pointer to the list of interfaces a specific class implements - see System.pas for details. Note that this does not include interfaces that you

Published methods

2006-04-27T21:37:00.000+02:00

Normally not thought of (or used as) an object-oriented features, published methods rely in RTTI to enable runtime lookup of methods by using a string with the method name. This is used extensively by the IDE and VCL when you are writing event handlers at design time. When you create a new event handler (by double-clicking on an empty event value in the Object Inspector) or when you associate an

Hack #9: Dynamic method table structure

2006-04-10T23:03:00.000+02:00

One of the compiler magic slots in a class’ virtual method table (VMT) is a pointer to that class’ dynamic method table (DMT). A class only has a DMT if it declares or overrides one or more dynamic (or message) methods. The DMT contains a 16-bit (word) Count followed by an array[0..Count-1] of Smallint indices and an array[0..Count-1] of pointers containing the code address of the dynamic method

Dynamic methods compiler implementation

2006-04-08T09:44:00.000+02:00

In a previous article, we have covered how the compiler implements non-virtual and virtual method calls. We have also discussed the rationale and semantics of dynamic methods. You’ll recall that dynamic methods works just like virtual methods, only slower. In this article we’ll dig down into the compiler magic and RTL support that is used to support dynamic methods. Note that most of the

Dynamic methods and inherited

2006-04-04T22:30:00.000+02:00

In an earlier blog post we covered how virtual methods and inherited calls work. In Delphi there is another kind of polymorphic method, the dynamic method. Note that this polymorphism series targets only the native Win32 platform, but suffice to mention that in Delphi for .NET, dynamic methods are actually identical to virtual methods. In Win32, message methods use the same underlying compiler

Book review: The Pragmatic Programmer

2006-04-01T17:46:00.000+02:00

After finishing tech editing and reviewing Jon Shemitz’ excellent upcoming .NET 2.0 for Delphi programmers, I’ve got some more spare time to write blog articles and to read. Thanks to David Cummins and Pearson Publishing Group, we at Infront now have a small library of high-quality tech books, ranging from C# and .NET, to C++, security, hacking, methodology, science and more (the Delphi side we

Hack #8: Explicit VMT calls

2006-03-24T23:25:00.000+01:00

To accommodate the COM binary protocol in the pre-interface Delphi 2 era, all user-defined virtual methods have positive VMT offsets. This also means that TObject-defined virtual methods have negative VMT offsets. In addition the VMT also contains a number of “magic” fields to support features such as parent class link, instance size, class name, dynamic method table, published methods table,

Method calls compiler implementation

2006-03-24T23:24:00.000+01:00

To support its many language features, the Delphi compiler uses a number of different data structures and machine code generation patterns. To help in understanding how the Delphi language features are implemented, to make it easier to recognize these patterns when debugging at the assembly level, and to make it possible to know what you're doing if you want to run-time patch code, I'll discuss