Posted by jpluimers on 2020/01/22
Dit jaar is het corso als vanouds op 25 april. Volgend jaar rijden de praalwagens op 17 april. Afgesproken is wel dat het evenement nooit tijdens Pasen zal worden georganiseerd.
[WayBack] Bloemencorso Bollenstreek vanwege warme winters voortaan een week eerder | NOS
Interferentie met mijn verjaardag (29 april!) gaat dus nooit meer gebeuren (:
–jeroen
Posted in About, Adest Musica, LifeHacker, Personal, Power User | Leave a Comment »
Posted by jpluimers on 2020/01/22
So as the author of CSS3 Animate It I have a good background in CSS animation. Before CSS3 was released you would have to resort to using JS for animation…
Even after CSS3 got introduced, I’m still not sure I’d use animation: [WayBack] CSS Animation How To Tutorial – Dev Tuts
Via:
–jeroen
Posted in CSS, Development, Software Development, Web Development | Leave a Comment »
Posted by jpluimers on 2020/01/22
A blast from the past: my 2009 answer to [WayBack] What Design Patterns do you implement in common Delphi programming? – Stack Overflow which is still very much relevant today.
TL;DR
Every Delphi programmer uses the factory pattern as it is an intrinsic part of how components at design time work.
So he were go:
Only a minority of the Delphi developers knows that every Delphi developer uses a Factory pattern (delphi.about.com has an example in “regular” Delphi), but then implemented using virtual Create constructors.
So: time to shed some light on that :-)
Virtual constructors are to classes like virtual methods are like object instances.
The whole idea of the factory pattern is that you decouple the logic that determines what kind (in this case “class”) of thing (in this case “object instance”) to create from the actual creation.
It works like this using virtual Create constructors:
TComponent has a virtual Create constructor so, which can be overridden by any descending class:
type TComponent = class(TPersistent, ...) constructor Create(AOwner: TComponent); virtual; ... end;For instance the TDirectoryListBox.Create constructor overrides it:
type TDirectoryListBox = class(...) constructor Create(AOwner: TComponent); override; ... end;You can store a class reference (the class analogy to an object instance reference) in a variable of type ‘class type’. For component classes, there is a predefined type TComponentClass in the Classes unit:
type TComponentClass = class of TComponent;When you have a variable (or parameter) of type TComponentClass, you can do polymorphic construction, which is very very similar to the factory pattern:
var ClassToCreate: TComponentClass; ... procedure SomeMethodInSomeUnit; begin ClassToCreate := TButton; end; ... procedure AnotherMethodInAnotherUnit; var CreatedComponent: TComponent; begin CreatedComponent := ClassToCreate.Create(Application); ... end;The Delphi RTL uses this for instance here:
Result := TComponentClass(FindClass(ReadStr)).Create(nil);and here:
// create another instance of this kind of grid SubGrid := TCustomDBGrid(TComponentClass(Self.ClassType).Create(Self));The first use in the Delphi RTL is how the whole creation process works of forms, datamodules, frames and components that are being read from a DFM file.
The form (datamodule/frame/…) classes actually have a (published) list of components that are on the form (datamodule/frame/…). That list includes for each component the instance name and the class reference. When reading the DFM files, the Delphi RTL then:
- finds about the components instance name,
- uses that name to find the underlying class reference,
- then uses the class reference to dynamically create the correct object
A regular Delphi developer usually never sees that happen, but without it, the whole Delphi RAD experience would not exist.
Allen Bauer (the Chief Scientist at Embarcadero), wrote a short blogarticle about this topic as well. There is also a SO question about where virtual constructors are being used.
Let me know if that was enough light on the virtual Create constructor topic :-)
This resulted in this interesting comment by Kenneth Cochran:
Factory pattern implementations in other languages use ordinary static functions (or class functions for pascalites). As such they are capable of returning null(nil). A Delphi constructor, like the nameless constructors in other languages, will always return an object reference unless you raise an exception. You are free, of course, to use a class function just as easily if the need arises.
–jeroen
Posted in Delphi, Development, Software Development | Leave a Comment »
Posted by jpluimers on 2020/01/21
[WayBack] Today’s Organizations Waste Talent. Here’s How To Change That. | Corporate Rebels
Our research into more than 100 workplace pioneers reveals an important shift –“from job descriptions to talents and mastery”. It’s a clear differentiator between traditional and pioneering organizations.
Traditional organizations focus on fixed job descriptions, and linear careers that move from one description to the next. Progressive organizations focus on “talents & mastery”– and craft jobs and development opportunities around the specific skills employees would love to exploit.
The article goes on how to get the best from your talent and talents in other people.
via [WayBack] Today’s Organizations Waste Talent. Here’s How To Change That. | Corporate Rebels – Marjan Venema – Google+
–jeroen
Posted in Agile, Development, Software Development | Leave a Comment »
Posted by jpluimers on 2020/01/21
For my link archive in case I ever need to do Delphi generic type matching on intrinsic types. This will be tricky as you can have typed types like [WayBack] type TDate = type TDateTime since the early Delphi ages.
[WayBack] Hi, by using compiler intrinsics, is it possible to check if a generic type parameter is an unsigned integer? – Malcon X Portela – Google+
It will probably come down to fast intrinsic type mapping and slower typed type mapping.
The above WayBack link contains the most important bits of the Google+ post:
Hi, by using compiler intrinsics, is it possible to check if a generic type parameter is an unsigned integer? I have the following code:
function TChecker<T>.CheckIsUnsigned: Boolean; begin if GetTypeKind(T) = tkInteger then begin if SizeOf(T) = 4 then begin // TODO: Check if it is an unsigned 32-bit integer Result := True; end else if SizeOf(T) = 2 then begin // TODO: Check if it is an unsigned 16-bit integer Result := True; end else begin // TODO: Check if it is an unsigned 8-bit integer Result := True; end; end else begin Result := False; end; end;The code should return True only if the ‘T’ generic type parameter is an unsigned integer. I remember that +Stefan Glienke posted here some code that can do this trick, however, I am not able to find that now.
Thanks!
Hi +Jeroen Wiert Pluimers, my answer can be a bit disappointing, sorry :( Some time after writing this question here, I just realized which for the things I was originally trying to do, being signed or unsigned would not change anything on the final result hehehehe :D But from this amazing project https://github.com/d-mozulyov/Rapid.Generics (entire credits goes to Dmitry Mozulyov for the magic), it is possible to write the check to the generic type parameter in order to identify if it is a 32-bit/64-bit signed or unsigned number.
LTypeData := PTypeInfo(TypeInfo(T)).TypeData; case GetTypeKind(T) of tkInteger: begin {case LTypeData.OrdType of otSLong: Writeln('32-bit signed'); otULong: Writeln('32-bit unsigned'); end;} // the above code does the same thing if LTypeData.MaxValue > LTypeData.MinValue then begin Writeln('32-bit signed'); end else begin Writeln('32-bit unsigned'); end; end; tkInt64: begin if LTypeData.MaxInt64Value > LTypeData.MinInt64Value then begin Writeln('64-bit signed'); end else begin Writeln('64-bit unsigned'); end; end; end;
The [WayBack] Rapid.Generics project is indeed cool, but unmaintained and has no unit tests. The main code is in some [Wayback] 30k lines Rapid.Generics.pas unit with some cool ideas and implementations. Hopefully people will find time to integrate some of the ideas there into basically the only well maintained Delphi generics library Spring4D.
A big limitation might be that the code is Delphi XE8 and up only, whereas Spring4D supports older Delphi versions.
–jeroen
Posted in Conference Topics, Conferences, Delphi, Development, Event, Software Development | Leave a Comment »
Posted by jpluimers on 2020/01/21
Via [WayBack] Git tips and tricks | GitLab “Handy Git commands for everyday use” I learned these:
git config --global status.submoduleSummary true~/.gitconfig:
[status]
submoduleSummary = true
–jeroen
Via: [WayBack] GitLab on Twitter: Ready to get #backtowork? Brush up on a few tips and tricks we use at GitLab everyday: https://t.co/W8zFjxnSN6
Posted in Development, DVCS - Distributed Version Control, git, Software Development, Source Code Management | Leave a Comment »
Posted by jpluimers on 2020/01/20
This procedure works for Somfy RTS motors to:
The trick is to have one remote/channel that you want to keep working as you need that one to initiate the deletion process:
Via: [WayBack] How to change the control of a Somfy RTS roller blind from 2 to 1 remote – Projectionscreen.net
Videos below the fold:
–jeroen
Posted in Hardware, LifeHacker, Power User | Leave a Comment »
Posted by jpluimers on 2020/01/20
When you look at how to find listed cron jobs, usually the answer is cron -l or cron -u username -l.
However, on OpenSuSE systems, cron jobs can be in different places, and the sysconfig settings have influence on them too.
These files and directories all influence cron:
Directories:
/etc/cron.d/
/etc/cron.daily/
/etc/cron.hourly/
/etc/cron.monthly/
/etc/cron.weekly/
Files:
/etc/sysconfig/cron
/etc/init.d/rc2.d/K01cron
/etc/init.d/rc2.d/S14cron
/etc/init.d/rc3.d/K01cron
/etc/init.d/rc3.d/S14cron
/etc/init.d/rc5.d/K01cron
/etc/init.d/rc5.d/S14cron
/etc/init.d/cron
/etc/news/crontab.sample
/etc/pam.d/crond
/etc/systemd/system/multi-user.target.wants/cron.service
/etc/omc/srvinfo.d/cron.xml
/etc/cron.deny
/etc/crontab
Most are available for other Linux distributions as well, but each one might have slightly different configurations (especially for the directories). Some background reading:
Some details:
crontab -l will only list what is in /etc/crontab./etc/sysconfig/cron, especially the DAILY_TIME variable (see below) for the daily jobs./usr/lib/cron/run-crons:/etc/cron.daily/
/etc/cron.hourly/
/etc/cron.monthly/
/etc/cron.weekly//var/spool/cron/lastrun/cron.weekly
/var/spool/cron/lastrun/cron.daily
/var/spool/cron/lastrun/cron.hourlyThe DAILY_TIME variable:
## Type: string
## Default: ""
#
# At which time cron.daily should start. Default is 15 minutes after booting
# the system. Example setting would be "14:00".
# Due to the fact that cron script runs only every 15 minutes,
# it will only run on xx:00, xx:15, xx:30, xx:45, not at the accurate time
# you set.
DAILY_TIME=""
–jeroen
Posted in *nix, *nix-tools, cron, Linux, openSuSE, Power User, SuSE Linux, Tumbleweed | Leave a Comment »
Posted by jpluimers on 2020/01/20
(thanks John!)
Posted in Uncategorized | Leave a Comment »
Posted by jpluimers on 2020/01/20
A few notes on tracking down a use-after free related issue involving interfaces.
The crash message is like this:
Project UseAfterFreeWithInterface.exe raised exception class $C0000005 with message 'access violation at 0x004106c0: read of address 0x80808088'.
Two things here:
STATUS_ACCESS_VIOLATION, which is sort of mentioned in [WayBack] Delphi 2009: EExternalException Class, but not documented in any more recent Delphi versions. It is in the code for the units System, System.SysUtils and Winapi.Windows (see below).The value is not well documented on the Microsoft documentation site either: you sort of have to connect the dots between site:docs.microsoft.com “0xC0000005” – Google Search and [WayBack] site:docs.microsoft.com “STATUS_ACCESS_VIOLATION” – Google Search to find for instance these two:
0x80808088 comes from the [WayBack] FastMM4.pas DebugFillPattern value $80808080 which is used to overwrite freed memory. Not all versions of FastMM4.pas have that value near the DebugFillPattern in the code, so I raised an issue for that: [WayBack] Document default 32-bit values of `DebugFillPattern` and `DebugReservedAddress` · Issue #67 · pleriche/FastMM4 · GitHubThe relation between
$80808088and$80808080(a difference of just$00000008) comes clear when you look at theSystem._IntClearmethod disassembly below.
$DEADBEEF, see these links on why:
Basically any memory value in an exception starting with
$8080and sometimes even$80should raise suspicion: it usually means a use-after-free case.
You see these errors with FastMM and not with the memory manager as [WayBack] delphi • View topic • Problem with FastMM and D7 explains:
Posted in Conference Topics, Conferences, Delphi, Development, Event, Software Development | 8 Comments »
The Wiert Corner - irregular stream of stuff 