The Wiert Corner – irregular stream of stuff

Jeroen W. Pluimers on .NET, C#, Delphi, databases, and personal interests

  • My badges

  • Twitter Updates

  • My Flickr Stream

  • Pages

  • All categories

  • Enter your email address to subscribe to this blog and receive notifications of new posts by email.

    Join 2,163 other followers

Archive for the ‘History’ Category

Why is “finite” in “infinite” pronounced differently than plain “finite”?

Posted by jpluimers on 2020/12/04

December thoughts: [WayBackWhy is “finite” in “infinite” pronounced differently than plain “finite”?… – Jeroen Wiert Pluimers – Google+


Why is “finite” in “infinite” pronounced differently than plain “finite”?
As a partially word-blind person, those differences make natural languages very hard for me to grasp.
Especially because Dutch “eindig” is pronounced the same in “oneindig” (and German “endlich” the same in “unendlich“)


  • Randy Tapson's profile photo
    My guess is that it’s easier to say. They were probably pronounced the same 500 years ago but over time it became easier (lazier) to say 3 short vowels (because they are all the same sound) versus 1 short and 2 long. I’d be very interested in hearing what the old English pronunciation sounded like.
  • Wolfgang Rupprecht's profile photo
    Steven Pinker has a great talk on irregular verbs. In a nutshell certain words when put into a typical sentence are too much of a tongue twister. If the word or phrase is used enough people develop shortcuts to make them easier to say. The interesting aspect that he identified is that if some word falls out of common usage the pronunciation becomes regular again. People forget that they can say it the easier way. His talk is about irregular verbs, but the concept is much more general than that.
  • Kim Nilsson's profile photo

    Two great explanations, which both boil down to the truth and fact that people are lazy and languages adapt over time.

    English spelling is from the 15th century, but pronunciation has changed.

    Norwegian has tried to update their spelling to be closer to the actual use, and also removed duplicate “spelling” of the same sounds.

    Some languages are sponges, and fill up with words from other languages, and either keep the sounds or change them a little, even if they don’t conform to their own language. Others, like Icelandic, create brand new words for everything.


Posted in History, LifeHacker, Power User | Leave a Comment »

NOx value measurement is an indicator for much wider forms of pollution (was: Definitiv ein lesenswerter Artikel, trotz der plakativen Schlagzeile)

Posted by jpluimers on 2020/11/30


In other words (and she’ll say that later in an interview): It’s not the NO2 limit we’re talking about here, it’s all the air pollutants we inhale day after day. The discussion about diesel bans and the reduction of NO2 emissions misses the real problem, because if only the NO2 is reduced and not the other pollutants, that does not help much.

Google translated from:

Mit anderen Worten (und das sagt sie auch noch später in Interview): Es ist gar nicht der NO2-Grenzwert, um den es hier geht, es sind die gesamten Luftschadstoffe, die wir Tag für Tag einatmen. Die Diskussion um Dieselfahrverbote und Reduzierung des NO2-Ausstoßes geht am eigentlichen Problem vorbei, denn wenn nur das NO2 reduziert wird und nicht die weiteren Schadstoffe, hilft das nicht viel.

[WayBack] Definitiv ein lesenswerter Artikel, trotz der plakativen Schlagzeile: > Es geht bei dem Grenzwert nicht nur um die Gesundheitswirkung des Reizgases NO2… – Thomas Mueller (dummzeuch) – Google+


Posted in About, History | Leave a Comment »

(German): the mid 1980s stories of calling Peter Norton for free from a German phone booth, and hacking the phone lines that mobile telecom equipment sales vans connected to.

Posted by jpluimers on 2020/11/20

Two great German stories from the mid 1980s posted mid 2020.

They translate fine in Google, so enjoy!

Read the rest of this entry »

Posted in dial-up modems, History, Power User | Leave a Comment »

delphi – What are the list of all possible values for DVCLAL? – Stack Overflow

Posted by jpluimers on 2020/11/17

From a while ago, from notes even longer ago – around 1994 on DVCLAL the Delphi VCL Access License code which is actually a checking logic for determining the SKU (stock keeping unit) or Delphi license: [WayBack] delphi – What are the list of all possible values for DVCLAL? – Stack Overflow

There is no official documentation on this, so here is something from my notes of 15+ years ago:

The DVCLAL is there to check which SKU of Delphi you are using and it varies per SKU.

There are only checks for the Professional (RPR) and Client/Server (RCS) SKUs:

procedure RCS;

procedure RPR;

If they fail, they call this method:

procedure ALV;
  raise Exception.CreateRes(@SNL);


  SNL = 'Application is not licensed to use this feature';

Depending on the feature matrix and Delphi version, various components call RPR and RCS in their Create constructors to guarantee a minimum SKU.

Underneath, these RPR and RCS functions call the function  GDAL . Their names are historic and got documented around Delphi 2007:

  • [WayBack] GDAL (Get Delphi Access License)
  • [WayBack] RPR will Restrict to PRofessional license and higher
  • [WayBack] RCS will Restrict to Client/Service license and higher

Historically you had these levels of Delphi editions that could be distinguished this way:

  1. Personal
  2. Professional
  3. Client/Server (or Enterprise)

This excludes Starter and Community (which are “just” Personal), Turbo (which was “just” Professional), Architect and Ultimate, which are “just” Client/Server with extra tools.

A few years ago, another answer got added to that question explaining more details:

I am just adding another answer to this question, for all the people who search the for actual DVCLAL (Delphi Visual Component Library Access License) values, as well as some other information for all people who are curious how stuff works.

1) Like Jeroen Wiert Pluimers said, if you want to check for “Professional or higher” or “Enterprise only” inside your Delphi application/library/package/component, you can use RPR (Require Professional) or RCS (“Require Client/Server”; Client/Server was the name for the Enterprise edition in early Delphi versions) respectively. If the requirement is not met, ALV (Access License Violation) will be called which will raise an Exception with the message defined in SysConst.SNL (S Not Licensed). In English:

Application is not licensed to use this feature

2) In case you want to check for one specific edition, you can use the output of the function GDAL (Get Delphi Access License), which is one of the following (AL1s array):

AL1s[0] = $FFFFFFF0; // Standard/Personal edition DVCLAL value
AL1s[1] = $FFFFEBF0; // Professional edition DVCLAL value
AL1s[2] = $00000000; // Enterprise/ClientServer edition DVCLAL value
AL1s[3] = $FFFFFFFF; // DVCLAL resource not existing

if the DVCLAL resource has an invalid value, GDAL will call ALVwhich will raise an Exception with message SysConst.SNL.

3) In case you want to check the DVCLAL value of a foreign EXE/DLL file (e.g. if you want to write a Resource Editor, decompiler etc), then you’ll have to query the DVCLAL resource directly.

There are only three official values:

Standard:      23 78 5D 23 B6 A5 F3 19 43 F3 40 02 26 D1 11 C7
Professional:  A2 8C DF 98 7B 3C 3A 79 26 71 3F 09 0F 2A 25 17
Enterprise:    26 3D 4F 38 C2 82 37 B8 F3 24 42 03 17 9B 3A 83

4) Just for fun: If you solve the formula 0 = (ROR(a,15) xor a) xor (ROR(b,10) xor b) xor (ROR(c,5) xor c) xor (AL1 xor AL2) you can define any DVCLAL value (tuple a, b, c, d) you want! (AL1 and AL2 are the values in the AL1s and AL2s arrays which describe the desired Delphi edition; ROR is rotate right through carry)

For example, here are alternative DVCLALs which work too:

Standard:      00 00 00 00 00 00 00 00 9B 70 0C 66 6B 8F F3 99
Professional:  00 00 00 00 00 00 00 00 9A DB 73 0F 6A 30 8C F0
Enterprise:    00 00 00 00 00 00 00 00 D8 B2 48 11 D8 B2 48 11

To validate a DVCLAL, you calculate

AL1 := DVCLAL[0] xor DVCLAL[1] xor DVCLAL[2] xor DVCLAL[3];
AL2 := ROR(DVCLAL[0],15) xor ROR(DVCLAL[1],10) xor ROR(DVCLAL[2],5) xor DVCLAL[3];

and look up AL1 and AL2 in the array AL1s and AL2s,

This way you can disguise the edition you have used a little.

5) In the meantime, an official documentation, at least for the functions GDALRPR and RCS, has been published.

6) Of course, everything works for C++ Builder, too.

In the mean time, new posts explaining bits of DVCLAL related resources (like PACKAGEINFO and CHARTABLE) and the TPF0 form/datamodule resource have appeared, of which this is a selection:


Posted in Conference Topics, Conferences, Delphi, Development, Event, History, Software Development | Leave a Comment »

Reverse engineering Delphi and Turbo Pascal unit interfaces (and maybe DCP files too)

Posted by jpluimers on 2020/10/07

Boy, I wish there was both an Embarcadero sanctioned grammar (see Delphi code completion fail with anonymous methods – Stack Overflow) and a DCU parser.

This might work for DCP files as well, since the PKX0 signature at the start of DCP files is in [WayBack] DCU32INT/DCP.pas at master · rfrezino/DCU32INT · GitHub.

Being able to dump DCP files makes it way easier to create documenting a matrix of all DCP files and units, to their interdependencies and containments become clear (including any unit scopes).

Right now that is only documented from the unit to the package on the page of the unit (see for instance [WayBack] System.SysUtils – RAD Studio API Documentation), not the other way around. This is a pain to select which packages you need in your project when building with packages.

The list at [WayBack] Unit List – RAD Studio API Documentation (which actually is an “Alphabetical list of unit scopes, along with miscellaneous units that have no unit scope.” is only partially helpful, especially as for instance the System unit page at [WayBack] System – RAD Studio API Documentation is 90% about the System unit scope, has the System unit itself about a 3rd down and does not mention it lives in the rtl.dcp package.

The list at [WayBack] Deciding Which Runtime Packages to Use – RAD Studio is even worse than the unit list, as it misses many useful packages (like dsnap)

For my link archive:

Johan wanted to create a compiler symbol table from the binary DCU files (unlike DelphiAST which does it from the Pascal source files).

From the pre-Delphi era, I found back some info from my own archive:

In the Turbo Pascal days, you had TW1UNA and TPUUNA by William L. Peavy, which I think led to INTRFC from Duncan Murdoch (or maybe vice versa) which got updated to Turbo/Borland Pascal 7 format by Milan Dadok (see Since the basic format of DCU files is very similar to that, my guess is that DCU32INT built on that.

Later I found The Programmer’s Corner » TPU60C.ZIP » Pascal Source Code also by William L. Peavy and [WayBack] Duncan Murdoch’s Programs.


Posted in Borland Pascal, Delphi, Development, History, Pascal, Software Development, Turbo Pascal | Leave a Comment »

%d bloggers like this: