On code health:

Now I always try to dig right down to the root cause of a bug, even if a simple, and seemingly safe, patch is available. I want my code to be healthy. If you go to the doctor and tell him “it hurts when I do this,” then you expect him to find out why it hurts, and to fix that.

Though tools like SourceMonitor can help you track your code health, the best tool is between your ears.

–jeroen

via: Dodgy Coder: Coding tricks of game developers.

Workpace (yes, it is written in Delphi) hooks itself into processes by injecting REC300.DLL into it.

That particular DLL prevents Delphi XE2 from installing in several of the systems colleagues tried, and gives you error messages like these:

'' is not a valid integer value

Followed by a bunch of access violations, and Process Monitor indicating issues reading the key HKLM\Software\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\REC300.DLL which is part of WorkPace 3.0 (an old 2007 version).

The next problem was Digital Guardian (an old 2010 version) hooking itself into all processes. Uninstalling that is a pain, as it requires a special uninstall key, but luckily the automated update script on the SCCM server’s distribution share contained that in an encrypted form. Uninstalling this solved the problem.

Maybe newer versions of WorkPace and Digital Guardian wouldn’t have interfered with the Delphi XE2 install. If so, that would be another example of technical debt.

WorkPace and Digitual Guardian are most likely there because of government induced regulations in the corporate environment.

I’m feeling a bit like Dilbert now: the corporate environment is interesting, but often they make “getting work done” so much harder than it could be.

–jeroen

O'Reilly book "Unicode Explained: Internationalize Documents, Programs, and Web Sites"

Withe the growing integration between systems, and the mismatch between those that support Unicode and that do not, I find that a lot of organisations lack basic Unicode knowledge.

So lets put down a few things, that helps as a primer and gets some confusion out of the way.

Please read the article on Unicode by Joel on Software, and the book Unicode Explained. The book is from 1996, and still very valid.

Unicode

Unicode started in the late 80s of last century as a 16-bit character model.

Somehow lots of people still thing Unicode is a 16-bit double-byte character set. It is not. It uses a variable width encoding for storage.

All encodings except the 32-bit ones are variable width. The UTF-16 encoding is a variable width encoding where each code point (not character!, see below why) takes one or more 16-bit words.

This is because – as of Unicode version 2.0 in 1996 – a surrogate character mechanism was introduced to be able to have more than 64k code points.

The architecture of Unicode is completely different than traditional single-byte character sets or double-byte character sets.

In Unicode, there is a distinction between code points (the mapping of the character to an actual IDs), storage/encoding (in Windows now uses UTF-16LE which includes the past used UCS-2) and leaves visual representation (glyphs/renderings) to fonts.

Unicode has over a million code points, logically divided into 17 planes, of which the Basic Multi-lingual Plane has code points that can be encoded into one 16-bit word.

There is no font that can display all Unicode code points. By original aim, the first 256 Unicode code points are identical to the ISO 8859-1 character set (which is Windows-29591, not Windows-1252!) for which most fonts can display most characters.

By now, you probably grasp that Unicode is not an easy thing to get right. And that can be hard, hence people love and hate Unicode at the same time. Maybe I should get the T-Shirt .

One thing that complexes things, is that Unicode allows for both composite characters and ready made composites. This is one form where different sequences can be equivalent, so there can be Unicode equivalence for which you need some knowledge on Unicode Normalization (be sure to read this StackOverflow question and this article by Michael Kaplan on Unicode Normalization).

There are many Unicode encodings, of which UTF-8 and UTF-16 are the most widely used (and are variable length). UTF-32 is fixed length. All 16-bit and 32-bit encodings can have big-endian and little-endian storage and can use a Byte Order Mark (BOM) to indicate their endinaness. Not all software uses BOMs, and there are BOMs for UTF-8 and other encodings as well (for UTF-8 it is not recommended to include a BOM).

When only parts your development environment supports Unicode strings, you need to be aware of which do and which don’t. For any interface boundary between those, you need to be aware of potential data loss, and need to decide how to cope with that.

For instance, does your database use Unicode or not for character storage? (For Microsoft SQL Server: do you use CHAR/VARCHAR or NCHAR/NVARCHAR; you should aim for NVARCHAR, yes you really should, do not use text, ntext and image). What do you do while transferring Unicode and non-Unicode text to it? Ask the same questions for Web Services, configuration files, binary storage, message queueing and various other interfaces to the outside world.

The Windows API is almost exclusively Unicode (see this StackOverflow question for more details)

Delphi and Unicode

Let’s focus a bit on Delphi now, as that the migration towards Unicode at clients raised a few questions over the last couple of months.

One of the key questions is why there are no conversion tools that help you migrate your existing source code to fully embrace Unicode.

The short answer is: because you can’t automate the detection of intent in your codebase.

The longer answer starts with that there are tools that detect parts of your Delphi source that potentially has problems: the compiler hints, warnings and errors that brings your attention to spots that are fishy, are likely to fail, or are plain wrong.

Delphi uses the standard Windows storage format for Unicode text: UTF-16LE.

Next to that, Delphi supports conversion to and from UTF-8 en UTF-32 (in their various forms endianness).

External storage of text is best done as UTF-8 because it doesn’t have endianness, and because of easier exchange of text in ISO-8859-1.

Marco Cantu wrote a very nice whitepaper about Delphi and Unicode, and I did a Delphi Unicode talk at CodeRage 4 and posted a lot of Delphi Unicode links at StackOverflow.

A few extra notes on Delphi and Unicode:

With Delphi string types, stick to the UnicodeString (default string as of Delphi 2009) and AnsiString (default string until Delphi 2007) as their memory management is done by Delphi. WideString management is done by COM, so only use that when you really need to. Also avoid ShortString.

For any interfaces to the external world, you need to decide which ones to keep to generic string, Char, PChar and which ones to fix to AnsiChar/PAnsiChar/AnsiString(+ accompanying codepage) or fix at UnicodeChar/PUnicodeChar/UnicodeString.

Of course remnants from the past will catch up with you: if you have Technical Debt on the past where characters were bytes, and you abused Char/PChar/array-of-char/etc you need to fix that, and use the Byte/PByte/TByteArray/PByteArray. It can be costly to pay the accrued debt on that.

–jeroen

PS:

• There is even more confusion on character set, code page, etc, which Mihai tries to set straight at the Why is the default console codepage called “OEM”? episode of “The Old New Thing“
• Getting your character set (ANSI, Windows-1252, ISO 8859-1) right is a problem of the same order of magnitude as Ben Hutchings shows.
• Notepad supports three kinds of text formats

Thanks to Randy Glasbergen for the debt image

I love this quote from Jeff Attwood on technical debt in 2009:

periodically pay down your technical debt

and the Computer Weekely article about half a year ago:

Short-term speed may come at the price of long-term delays and cost.

Lately, I find that I need to explain Debt in relation to IT and Software Development more and more often.

We now all know what happens with the financial system when we let debt get out of control.

The same holds for your IT and Software Development.

Debts get introduced by not “playing by the rules”. The quotes are there because you can not always play nicely, and the rules are not always clear or known.

Lets give a few examples of rules that – from experience at clients – are more often than not neglected. The examples are based on Windows, but could just as easily be Mac OS X, Unix, OS/400 or anything else.

• Make sure you use a recent Windows version
  I often see companies lagging more than one version behind (i.e. still use Windows XP or SQL Server 2000). That’s too far.
• Don’t run your users with too many privileges (and certainly not as Administrators)
  Especially running as Administrator will get you in trouble with User Account Control (UAC) in Windows Vista and up.
• Using directories like C:\TEMP is a no-no.
  This should be a no-brainer, but truckloads of in-company software still thinks it can write everywhere.
  I know C:\TEMP used to be the Temporary Folder some 20 years ago.
  But that was then, and this is now: Use the %TEMP% environment variable or GetTempPath function (even better: the GetTempFileName function or the .NET Path.GetTempFileName function).
  More in general for known folders, use CSIDL or KNOWNFOLDERID whenever possible. Your favourite development tool usually has a library functions for that, for instance the .NET System.Environment.GetFolderPath function.

These few were examples ranged from technically very broad to specific. There are more, but these will give you a rough idea how wide the field of debt can be. Even debt outside the realm of Technical Debt can turn out to be really expensive.

Every time you  postpone or skip a Windows version, you collect some debt in the hope (often wrongfully called expectation) that you earn more on the money/resource you just didn’t invest and putting that money/resource to use otherwise. The same holds for any other kind of debt.

The main problem with debt is not the total of the debt, it is the interest rate that makes the accrued debt grows faster than most people and organizations realize.

This is actually one of the main causes of the current world wide financial crisis, the same holds for many IT debts.

And for all kinds of debts, you often don’t know how high the interest rate will be, so the accrued value can be way beyond what you expect.

I’ve regularly seen projects collecting so much debt, that migration costs raised to thousands of hours because of it, resulting into management taking another very bad decision: rewriting the stuff from scratch. Don’t do that: Joel on Software excellently describes what happens when you do that.

What to do about it?

You might say “don’t collect debt”, but you can’t always avoid debt.

So you need to build periods where you pay off accrued debt. And you need to do that regularly, in order to avoid the interest pitfall.

This does not limit itself to software development (though that’s what I normally focus at). It covers a wide range of IT topics.

Sometimes, you can even pay your debt in advance. For instance, I was among the first to switch from Windows XP to the x64 of Windows Vista. I knew it would cause pain, but it immediately payed back by being able to use much more memory, and run more Virtual Machines at the same time. That made me more flexible and productive.

–jeroen

via: Coding Horror: Paying Down Your Technical Debt.

Not so: just like with the & in Delphi, you can use @ for identifiers too.

The prefix “@” enables the use of keywords as identifiers, which is useful when interfacing with other programming languages. The character @ is not actually part of the identifier, so the identifier might be seen in other languages as a normal identifier, without the prefix. An identifier with an @ prefix is called a verbatim identifier.

–jeroen

via: naming – What’s the use/meaning of the @ character in variable names in C#? – Stack Overflow.

Use cases:

1. double click on a word to select it
2. press Ctrl-C to copy the selected text
3. result is either of these two dialogs:
   

   ---------------------------
Microsoft Visual Studio
---------------------------
Cannot navigate to definition.
---------------------------
OK
---------------------------

   or

   ---------------------------
Microsoft Visual Studio
---------------------------
Cannot navigate to definition. The cursor is not on a symbol.
---------------------------
OK
---------------------------

The reason is that Visual Studio 2010 still thinks I am clicking the identifier (which I’m not, I just released the mouse button) while pressing the Ctrl key.

Actually I never realized that Visual Studio 2010 incorporated the same form of Ctrl-Click code browsing that I got accustomed to since Delphi 4 in 1998 :)

Whereas the Delphi code browsing keyboard shortcuts are the same as for web browser keyboard shortcuts (like Alt-Left/Alt-Right and Browse-Left/Browse-Right), I have gotten accustomed to the odd Visual Studio keyboard shortcuts F12 (go to definition of symbol), Ctrl-Minus (navigate to previous editor position) and Ctrl-Shift-Minus (navigate to last cursor location).
That is fine with me. When switching between Visual Studio, Delphi, Xcode, etc, I mentally switch to different sets of keyboard/mouse usage anyway.

But did Visual Studio implement this natural way of code browsing?

No, it didn’t, and it took the  “Cannot navigate to definition” annoyance in Visual Studio 2010 question on Stack Overflow for me to realize that.

The code browsing is actually provided by the Productivity Power Tools for Visual Studio by Microsoft:

Ctrl + Click Go To Definition
This extension gives the editor a web browser by adding clickable hyperlinks to symbols in your code as you hold down the Ctrl key.

And that extension is buggy

But: since you can individually disable extensions in the Productivity Power Tools, it is easy to workaround: go to “Tools Options>Productivity Power Tools” and you will see a dialog similar to the image on the right (click to enlarge). Then turn off the Ctrl + Click Go to Definition and press the OK button, and restart Visual Studio.

–jeroen

via: “Cannot navigate to definition” annoyance in Visual Studio 2010 – Stack Overflow.

Is there anyone that has a C#, Delphi or FreePascal implementation with unit tests?

–jeroen

In short, pass CharSet.Auto unless you P/Invoke a function that is specific to CharSet.Ansi or CharSet.Unicode. The default is CharSet.Ansi, which you usually don’t want:

when Char or String data is part of the equation, set the CharSet property to CharSet.Auto. This causes the CLR to use the appropriate character set based on the host OS. If you don’t explicitly set the CharSet property, then its default is CharSet.Ansi. This default is unfortunate because it negatively affects the performance of text parameter marshaling for interop calls made on Windows 2000, Windows XP, and Windows NT®.

The only time you should explicitly select a CharSet value of CharSet.Ansi or CharSet.Unicode, rather than going with CharSet.Auto, is when you are explicitly naming an exported function that is specific to one or the other of the two flavors of Win32 OS. An example of this is the ReadDirectoryChangesW API function, which exists only in Windows NT-based operating systems and supports Unicode only; in this case you should use CharSet.Unicode explicitly.

–jeroen

via: .NET Column: Calling Win32 DLLs in C# with P/Invoke.

• Jed Software on a Select Directory method on OS X (they have an OS X category)
• iOS demos applications by Anders Ohlsson shown on CodeRage 6
• Russian FireMonkey sample app submissions that won prizes
• 3D interactive FireMonkey app for displaying models imported from COLLADA files using Delphi IDE build-events to automatically compile HLSL shaders with a custom camera class, and example how to export COLLADA models from 3D Studio Max
• Changing style colors on the fly
• The MonkeyStyler blog
• Visualizing Math Functions in 3D and Visualizing Interference in 3D

–jeroen

Jason Southwell (from arcana) just published DuckDuckDelphi: a unit to do Duck typing in Delphi XE2 (not XE):

Duck Duck Delphi

DuckDuckDelphi is an Open Source (MIT License) unit for Delphi XE2 which adds duck typing functionality to a normally strongly typed language.

Great stuff that makes a truckload of my code so much easier to maintain.

–jeroen

via arcana – DuckDuckDelphi.

(Edit: 1400 UTC+1 Sorry, wrong boolean; wrote “and” but should be “not” XE).

Like Apple’s iOS Human Interface Guidelines and Microsoft’s User Experience Design Guidelines for Windows Phone they are a must for any mobile developer.

Together with sites like Android UI Design Patterns, and mockup stencil tools, more Android UI mockup sketch tools and stencils allow you to give prospective users an impression on how an app might be looking like when developed.

What is lacking is a set of real Android GUI design tools. The kind of tools like the Xcode Interface Builder for iOS, or Expression Blend for Windows Phone that – together with iOS PSD templates or Windows Phone design templates (and more templates) – give you a killer start.

Also note Delphi XE2 that has a great UI designer which has consistently covered Windows UI design for 15+ years, including multi-touch and gesture support, and now covers Mac OS X and iOS for HD and 3D apps (but not yet with multi-touch or gesture support).

The only design tool for Android I could find is DroidDraw that emits the XML needed for Android UIs. It is painfully slow and lacks basic things like a property window to edit properties of UI elements.

Given the number of Android app developers, there is much room for improvement.

• Am I missing something here?
• What kind of tools are you using?

–jeroen

via: Android Design – UI Overview.

This one is by Remy Lebeau, who is part of TeamB:

You don’t need to enumerate running explorer.exe processes, you can use WTSGetActiveConsoleSessionId() instead, and then pass that SessionId to WTSQueryUserToken(). Note that WTSQueryUserToken() returns an impersonation token but CreateProcessAsUser() needs a primary token, so use DuplicateTokenEx() for that conversion.

You should also use CreateEnvironmentBlock() so the spawned process has a proper environment that is suited to the user account that is being used.

Lastly, set the STARTUPINFO.lpDesktop field to ‘WinSta0\Default’ instead of nil so the spawned UI can be made visible correctly.

I have been using this approach for several years now and have not had any problems with it. For example:

… code sample is in the answer …

–jeroen

via: windows – CreateProcessAsUser doesn’t work when “change user” – Stack Overflow.

Here is a quote from Cosmin Prund describing on how Delphi implements anonymous methods using a TInterfacedObject descendant:

When you have a function like the one in the question, where you have an anonymous method accessing a local variable, Delphi appears to create one TInterfacedObject descendant that captures all the stack based variables as it’s own public variables. Using Barry’s trick to get to the implementing TObject and a bit of RTTI we can see this whole thing in action.

Read his full answer for the complete description including sample code.

I stumbled on this great answer trough the question Is it possible for a managed local variable to transparently “travel to” another local scope? which might sound like an odd question, but it is not: StackOverflow is about learning, and some people do that by asking questions on solving problems in a very uncommon way, just to learn there are far better ways of obtaining what they want.

–jeroen

via: How and when are variables referenced in Delphi’s anonymous methods captured? – Stack Overflow.

I was right, this posting on perlmonks direct me to a /. posting in 2003 pointing me to the research paper on low-bandwidth attacks based on hash collisions (pdf version) that I had seen before. Perl 5.8.1 fixed it September 2003 (search for “hash” in that link).

The attack can be used for DoS because a normal distributed hash table insert of n elements will be running O(n), but a carefully crafted insert of those elements will run O(n^2).

Carefully crafting a worst case scenario depends on how well you can predict collisions in the underlying hash table implementation, which - apparently - is not too difficult, and requires little bandwidth.

Many platforms and languages are vulnerable, including those based on Java, Tomcat, .NET, Ruby, PHP and more in greater or lesser extent. I have the impression that the list only includes big names, but presume platforms based on smaller names (ASP, Delphi, Objective C) are equally vulnerable.

Just read the articles on CERT 903934, oCERT 2011-003, Arstechnica, Cryptanalysis.eu, Heise (German), Hackillusion and the research paper published at 28C3.

a few quotes:

“This attack is mostly independent of the underlying Web application and just relies on a common fact of how Web application servers typically work,” the team wrote, noting that such attacks would force Web application servers “to use 99% of CPU for several minutes to hours for a single HTTP request.”

“Prior to going public, Klink and Wälde contacted vendors and developer groups such as PHP, Oracle, Python, Ruby, Google, and Microsoft. The researchers noted that the Ruby security team and Tomcat have already released fixes, and that “Oracle has decided there is nothing that needs to be fixed within Java itself, but will release an updated version of Glassfish in a future CPU (critical patch update).”

“The algorithmic complexity of inserting n elements into the
table then goes to O(n**2), making it possible to exhaust hours of CPU time using a single HTTP request”

“We show that PHP 5, Java, ASP.NET as well as v8 are fully vulnerable to this issue and PHP 4,
Python and Ruby are partially vulnerable, depending on version or whether the server
running the code is a 32 bit or 64 bit machine.”

Microsoft seems to have been notified pretty late in the cycle, I presume because the researchers started with a some platforms and finally realized the breath of platforms involved.

The ultimate solution is to patch/fix the platforms using for instance a randomized hash function a.k.a. universal hashing.

Microsoft will provide a patch for ASP.NET later today, Ruby already patched and other vendors will soon or have already (please comment if you know of other platforms and patches).

The links this morning indicated there were no known attacks. That is (maybe was) true for ASP.NET, but for PHP a public proof of concept of such a DoS is has been published by Krzysztof Kotowicz (blog) with sources at github and a demo html page.

Temporary workarounds (based on the some of the links in this and the prior blog post, and the workarounds mentioned here and here):

1. If you can: replace hash tables by more applicable data structures
   (I know this falls in the for-if anti-pattern category, but lots of people still use a hammer when a different tool works much better)
2. Limit the request size
3. Limit the maximum number of entries in the hash table
4. Limit form requests only for sites/servers/etc that need it.
5. Limit the CPU time that a request can use
6. Filter out requests with large number of form entries

Some platforms already have applied temporary workarounds (I know of Tomcat (default max 10000 parameters), and PHP (default max_input_vars = 1000) did, and looks like the ASP.NET fix will do too).

Other platforms (like JRuby 1.6.5.1, CRuby 1.8.7 (comments) and Perl 5.8.1 in September 2003 ) fixed it the proper way.

Note: workarounds are temporary measures that will also deny legitimate requests. The only solution is to apply a fix or patch.

A major lesson learned today for a few people around me: when vendors start publishing “out of band” updates, do not trust a single 3rd party assessment with state “initial investigation”, but be diligent and do some further research.

–jeroen

PS: Just found out that most Azure users won’t need to manually apply a fix: just make sure your Hosted Service OS servicing policy is set to “Auto”.

• Delphi tools
  ModelMaker Code Explorer
  GExperts with experimental find extension
• CodeRush
• Visual Studio 2010 Power Tools (all from the VS2010 tools gallery):
  - Productivity Power Tools (download)
  - Spec Explorer 2010 Visual Studio Power Tool (download)
  - Team Foundation Server Power Tools (download)
• Visual Studio 2008 Power Tools:
  - VSTS 2008 TFS Power Tools(download)
  - Visual Studio 2008 PowerCommands (download)
• Team Foundation Server Sidekicks (download 2.4 for TFS 2008, and 3.0 for TFS 2010)
• SourcePad

–jeroen

In this case, the below quote from the Release Notes for XE2 Update 3 was very important for me, as I use the IDE Fix Pack:

IDE Fix Pack Is Not Compatible with Update 3

The IDE Fix Pack for XE2 is incompatible with XE2 Update 3. If you have the IDE Fix Pack for XE2, you should uninstall the IDE Fix Pack for XE2 before installing Update 3. A revised version of the IDE Fix Pack for XE2 will be made available at http://andy.jgknet.de/fixpack/ .

The cool thing is, on the same day that Delphi XE2 Update 3 got released, Andy also released the new FixPack 4.6 last week and also explained the cause of the incompatibility.

Note that because of the same reason, more products will need to be updated. EurekaLog also released an update, and I expect more vendors to release updates soon.

Update 3 breaks the monthly release cycle, but for a reason. This update contains way more fixes than the previous ones, in a much wider area and with short turnarounds between reporting and fixing (yes, it does pay to report bugs through QualityCentral). Just read the list of fixes. It is similar to the big updates we used to have for previous Delphi versions.

It also requires a lot more disk space, so make sure you have at least 5 gigabytes of free disk space.

Not related to Update 3, but still nice is that Thomas Müller made available for download the Expertimental GExperts version 1.35-2011-12-18 that is compatible with Delphi XE2. It includes a code formatter that has different bugs than the Delphi XE2 one, but for me usually works better.

–jeroen

via: Release Notes for XE2 Update 3 – RAD Studio XE2.

That results in a few things you should take into account when developing iOS applications:

• Do not use Unit scope identifiers (that’s why for instance the FireMonkey unit FMX.Dialogs is called FMX_Dialogs when building an iOS application)
  So don’t do a “uses System.SysUtils”, but “uses SysUtils” and don’t name your units using Unit scope identifiers for now.
  It would be so nice if Embarcadero shipped the tool that made all the FMX_* units out of the FMX.* units; that alone would make code sharing between non-iOS and iOS applications in Delphi a lot easier.
• Do not use Generics (though FPC supports them, the FPC mode that Delphi XE2 uses for iOS compatibility does not)
• Do not use new style RTTI or TValue (they are not supported by FPC)
• Do not use any other dataset than the ones directly descending from TDataSet (so anything TClientDataSet or IBX like is out) mostly because those depend on external C obj files, Unit scope identifiers or new style RTTI
• Do not spread your application sources over multiple directories
• Do not use the TMyDynamicArray.Create shortcut of initializing dynamic arrays, but use a wrapper function that uses Open Array parameters as Rob Kennedy explains on StackOverflow.
• Do not run dpr2xcode after you have changed any files it generated (believe me, you will change those). This basically makes you have to reinvent most of the dpr2xcode logic, which is a real pain, as I’m still in that process and not completed.
  These are the things you usually want to manually keep track of:
  - most of the manual changes are keeping the “YourProject.dpr” and dpr2xcode generated “YourProject.pas” in sync
  - altering the PNG files to show different splash graphics / application icons

I will extend this list over time.

Note that this detour should be gone in a future Delphi version, but for now you need to take the above into account.

It means that you might feel like programming with one hand behind your back. Well, the Objective C and Xcode way feels very similar, but from a different perspective

–jeroen

It is based on FireMonkey supports Delphi XE2 Update 1 and up, and FPC (and yes: it supports on iOS too).

Interesting stuff!

–jeroen

Via: Asphyre Sphinx 2.

Funny, as I remember being late to report GExperts 1.35 for Delphi XE2 was released a while a go

It reminded me to ask Thomas to publish the XE2 version of his Experimental GExperts build though.

Lets hope he is faster than me catching up

–jeroen

via: Google Reader feed for GExperts.org.

Many modern applications seem to put less and less emphasis on the most efficient user input device: the keyboard.

You should: it makes your application much more pleasant to use.

I wrote about CUA before, but the Windows and Mac shortcuts are just as important.

A small table (please post a comment if you know additions):

Note that many Linux programs follow both the CUA and Windows settings.

References:

• CUA: SAA Common User Access Bookshelf
• Windows: Guidelines for Keyboard User Interface Design
• HIG: Keyboard Shortcuts

–jeroen

Now there are many more extensions involved, so it is harder to choose what to put in your version control system and what not.

The File Extensions of Files Generated by RAD Studio page helps you with that: it lists most of the Delphi file extensions (.local is a noticeable exception) that are used today.

–jeroen

via: File Extensions of Files Generated by RAD Studio – RAD Studio XE2.

a matrix library including some advanced operations like singular value or LU decomposition, pseudo inversion and others as well as a large set of assembler hand optimized matrix primitive functions. The assembler version are available for x64 code as well by the way. Quite a few of these matrix primitives are also available as multi threaded versions.  All functions are encapsulated in an easy to handle matrix class or interface.The library is released under the apache licence meaning that it may also be integrated into commercial products.

So it has lots of features, and optimizations. When browsing the source code, there are also some tests, I presume there will be more in the future.

The library has both a web site with download and a Google Code respository with source browsing.

–jeroen

via: Matrix Library by Michael Rabatscher.

It encapsulates the MQTT protocol, which – being a telemetry transport protocol – is extremely light weight, but also versatile.

–jeroen

Via: Jamie’s Blog | MQTT Client Library for Delphi.

In Delphi the SHR is always a SHR operation: it never takes into account the sign.

• SAR is the artithmetic shift right.
• SHR is the binary/logical shift right.

–jeroen

via: Shift Right: Delphi vs C | Galfars Lair.

Below is a batch file that generates a CSV file with scopes and units. The file does not only contain the VCL, RTL and FMX units, but all units in the C:\Program Files (x86)\Embarcadero\RAD Studio\9.0\source\ directory tree.

From the CSV, I generated two tables at the end: one with only the scope prefixes, one with all the units and the scopes they belong to.

The tables are based on Delphi XE2 Update 1.

I hope the batch file survives the WordPress syntax highlighter.

@echo off
  echo ScopePrefix
  call :outer 0
  echo ScopePrefix;UnitName;FileName;ParentDirectory
  call :outer 1
goto :end

:outer
:: recursively walk the directory for .pas file having a unit scope
:: http://osix.net/modules/article/?id=755
for /F "tokens=*" %%f in ('dir /s /b "C:\Program Files (x86)\Embarcadero\RAD Studio\9.0\source\*.pas"') do call :inner %1%%f
goto :end

:inner
setlocal
::http://stackoverflow.com/questions/636381/what-is-the-best-way-to-do-a-substring-in-a-batch-file
  set Parameter=%*
  :: strip the first character: copy from 1 till the end
  set FullFileName=%Parameter:~1%
  set Mode=%Parameter:~0,1%
  shift
::  ~dp does not work for regular environment variables
::  ~dp only works for batch file parameters and loop indexes
  for %%d in ("%FullFileName%") do set ParentDirectory=%%~dpd
  for %%f in ("%FullFileName%") do set FileName=%%~nf
  for %%f in ("%FileName%") do set ScopePrefix=%%~nf
  for %%f in ("%FileName%") do set UnitName=%%~xf
  :: strip the first character: copy from 1 till the end
  if !%UnitName%!==!! goto :noscope
  goto :scope
:noscope
  set UnitName=%ScopePrefix%
  set ScopePrefix=
  goto :display
:scope
  set UnitName=%UnitName:~1%
:display
  if !%Mode%!==!0! if not !%ScopePrefix%!==!! echo %ScopePrefix%
  if !%Mode%!==!1! echo %ScopePrefix%;%UnitName%;%FileName%.pas;%ParentDirectory%
endlocal
  goto :end

:end

–jeroen

Table: Scope prefixes

Table: Units and their Scope prefixes