Posted by jpluimers on 2021/06/30
Sometimes your development stack is not fully ready to handle signed 64-bit BIGINT values across all layers, which is when [WayBack] A How-to Guide for Resolving Database Record Limitations | Distillery comes in handy.
For data type ranges: [WayBack] int, bigint, smallint, and tinyint (Transact-SQL) – SQL Server | Microsoft Docs
–jeroen
Posted in Database Development, Development, Software Development, SQL Server | Leave a Comment »
Posted by jpluimers on 2021/06/30
For me this unaccepted answer from [WayBack] Regex for a file name without an extension – Stack Overflow by [WayBack] Bohemian worked best:
Assuming the extensions are up to 4 chars in length (so filenames like
mr.smitharen’t considered as having an extension, butmr.smith.docandmr.smith.htmlare considered as having extensions):^.*[^.]{5}$No need to capture a group, as the whole expression is what you want – ie group 0.
Depending on the extension length, increase 5 to like 7 for 6 character extensions (it’s always N+1 when you want to match extensions of N characters).
--jeroen
Posted in Development, RegEx, Software Development | Leave a Comment »
Posted by jpluimers on 2021/06/30
The documentation simply states “no”, without explaining why.
Luckily, there is [WayBack] David Heffernan at [WayBack] Delphi interface generic function – Is there a work around? – Stack Overflow
Interfaces do not support generic parameterized methods, as the compiler says.
There is no workaround because it’s a fundamental limitation. Parameterized methods in classes are implemented by adding one method per instantiation to the class. That works for classes since they are concrete, but is not viable for interfaces. That’s because interfaces are a table of functions and the size of that table cannot vary depending on which generic method instantiations happen to be present elsewhere in the code. For similar reasons, generic methods cannot be virtual or dynamic.
…
In any case, it’s not possible. One option is to use a class instead. I agree that this is a bind.
If you want to do it in an interface, the best you can do is:
function CastAs(const IID: TGUID): IInterface;But you’d have to call it like this:
MyIntf := ProxyIntf.CastAs(IMyIntf) as IMyIntf;which feels somewhat foul.
Choose your poison!
In the background, for every distinct use of generic method parameters, the compiler generates an overloaded concrete version of the method. That is possible for classes and records, but not for interfaces.
In practice, I either go for the last option, or have the interface expose a record or class type that can have the required generic method (so the compiler can generate the overloads at run-time).
All options feel somewhat ugly, so I like the comment by [WayBack] Jason:
Wish I could “Program into Your Language, Not in it” programmers.stackexchange.com/questions/2777/…
[WayBack] What are the key points of Code Complete? – Software Engineering Stack Exchange answer by [WayBack] limist:
Code Complete is about software craftsmanship; it is an advanced-beginner/intermediate-level book, written for the working programmer, but it would still be very useful to someone who’s been programming for at least a year.
Thus the key points of Code Complete (2nd ed.) are nicely summarized in its Chapter 34, Themes in Software Craftsmanship. As paraphrased from my notes:
- Conquer Complexity: reduce the cognitive load on your mind via discipline, conventions, and abstraction.
- Pick Your Process: be conscious of quality from start (requirements) to finish (deployment) and beyond (maintenance).
- Write Programs for People First, Computers Second: code readability is hugely important for comprehensibility, review-ability, error-rate, error-correction, modifiability, and the consequent development time and quality.
- Program into Your Language, Not in it: think of the What? and Why? before the How?
- Focus Your Attention with the Help of Conventions: conventions manage complexity by providing structure where it’s needed, so that the ultimate resource – your attention – can be effectively used.
- Program in Terms of the Problem Domain: work at the highest level of abstraction possible; top-level code should describe the problem being solved. Distinguish OS level, programming language level, low-level implementation structures, low-level problem domain terms, and finally, high-level problem-domain terms that would make total sense to the (non-coder) user.
- Watch for Falling Rocks: as programming merges art and science, good judgement is vital, including heeding warning signs.
- Iterate, Repeatedly, Again and Again: iterate requirements, design, estimates, code, code tuning.
- Thou Shalt Render Software and Religion Asunder: be eclectic and willing to experiment. Don’t be an inflexible zealot, it precludes curiosity and learning. Go beyond having just a hammer in your toolbox.
But the most important take-aways are in Chapter 33, Personal Character: once you consciously seek to improve as a coder, you can and will. The fastest way to do so is to take on the the attitudes of master coders(humility, curiosity, intellectual honesty, discipline, creativity), while also practicing their habits (many good habits are listed in the book, e.g. choosing good variable/value names).
Also, the book makes clear that the gap between average and excellent in software is immense; that fact alone should drive the conscientious coder to better himself.
That’s the short of it; the long version is in the book. :) I can also send you my not-so-long, not-so-short notes if you want more details. But the book is certainly money and time well-spent, even if the writing style is tiresome at times.
Beyond Code Complete, I’d highly recommend The Pragmatic Programmer. It’s for intermediate-level programmers, nicely-written and a great mix of high, medium, and low-level advice.
The documentation on limitations has not changed much since Delphi 2009.
[WayBack] Overview of Generics: Platform Requirements and Differences
Generics are supported by the Delphi for Win32 compiler.
Runtime type identification (RTTI)
In Win32, generics and methods do not have RTTI, but instantiated types do have RTTI. An instantiated type is the combination of a generic with a set of parameters.
Interface GUID
In Win32, an instantiated interface type does not have an interface GUID.
Parameterized method in interface
A parameterized method (method declared with type parameters) cannot be declared in an interface.
Instantiation timing
Instantiation is processed by the compiler. All instantiated objects are emitted into .obj files.
Dynamic instantiation
Dynamic instantiation at runtime is not supported.
Interface constraints
The Win32 interface is not a “light” interface. This means all type parameters with interface constraints always support the COM IUnknown methods _AddRef, _Release and QueryInterface or inherit from TInterfacedObject. Record types cannot specify an interface constraint parameter.
[WayBack] Overview of Generics – RAD Studio: Platform Requirements and Differences
Generics are supported by the Delphi compilers.
Run-time type identification
In Win32, generics and methods do not have run-time type information (RTTI), but instantiated types do have RTTI. An instantiated type is the combination of a generic with a set of parameters. The RTTI for methods of a class is a subset of the RTTI for that class as a whole. If a non-generic class has a generic method, that method will not be included in the RTTI generated for the class because generics are instantiated at compile time, not at run time.
Interface GUID
In Win32, an instantiated interface type does not have an interface GUID.
Parameterized method in interface
A parameterized method (method declared with type parameters) cannot be declared in an interface.
Instantiation timing
Generic types are instantiated at compile time and emitted into executables and relocatable files. Instance variables of a generic type are instantiated at run time for classes and at compile time for generic records. The RTTI for generic classes is only generated when the classes are instantiated. RTTI for instantiated classes follows just as for non-generic classes. If the generic class has a generic method, then the instantiated generic class will not have RTTI for that generic method.
Dynamic instantiation
Dynamic instantiation at run time is not supported.
Interface constraints
The Win32 interface is not a “light” interface. This means all type parameters with interface constraints always support the COM IUnknown methods _AddRef, _Release, and QueryInterface or inherit from TInterfacedObject. Record types cannot specify an interface constraint parameter.
–jeroen
Posted in Conference Topics, Conferences, Delphi, Development, Event, Software Development | Leave a Comment »
Posted by jpluimers on 2021/06/29
A few statements go get database names and IDs based on these functions or system tables:
DB_NAME() function (Transact-SQL) – SQL Server | Microsoft Docs: This function returns the name of a specified database.DB_ID() function (Transact-SQL) – SQL Server | Microsoft Docs: This function returns the database identification (ID) number of a specified database.sys.sysdatabases view (Transact-SQL) – SQL Server | Microsoft Docs: Contains one row for each database in an instance of Microsoft SQL Server. When SQL Server is first installed, sysdatabases contains entries for the master, model, msdb, and tempdb databases.Part of it has the assumption that a master database always exists.
-- gets current database name select db_name() as name ; name -------------------------------------------------------------------------------------------------------------------------------- acc (1 row affected)
-- gets current database ID select db_id() as dbid ; dbid ------ 5 (1 row affected)
-- gets all database IDs and names select dbid,name from sys.sysdatabases ; dbid name ------ -------------------------------------------------------------------------------------------------------------------------------- 1 master 5 acc (2 rows affected)
-- gets current database name by ID select db_name(db_id()) as name ; name -------------------------------------------------------------------------------------------------------------------------------- acc (1 row affected)
-- gets case corrected database name for sys.sysdatabases.name having a case insensitive collation sequence select dbid,name from sys.sysdatabases where name='Master' ; dbid name ------ -------------------------------------------------------------------------------------------------------------------------------- 1 master (1 row affected)
-- gets case corrected database name for sys.sysdatabases.name having a case sensitive collation sequence select dbid,name from sys.sysdatabases where name = 'Master' collate Latin1_General_100_CI_AI ; dbid name ------ -------------------------------------------------------------------------------------------------------------------------------- 1 master (1 row affected)
Note that:
- even though by default the SQL server collation sequence is case insensitive, it can make sense to do a case insensitive search, for example by using the
upperfunction, specifying a collation, or casting to binary. I likeupperthe most, because – though less efficient – it is a more neutral SQL idiom.- the most neutral case insensitive collation seems to be
Latin1_General_100_CI_AI
Related:
- Do not use
upperasupperwithlowerdoes not always round-trip.- Do not use
varbinaryas it is not case insensitive.- Neither the
=orlikeoperators are case sensitive by default: both need acollateclause.- Find the collation of the column(s) involved; if it contains
_CI, then you are done (it is already case insensitive); if it contains_CS, then replace that with_CI(case insensitive) and add that in acollateclause.- Collations are per
predicate, so notper query,per table,per columnnorper database. This means you have to specify them if you want to use a different one than the default.
Latin1_General_100_CI_AILatin1-General-100, case-insensitive, accent-insensitive, kanatype-insensitive, width-insensitive
I recommend using
Latin1_General_100_CI_AI. I recommend this because:…
- If
Latin1_General_CI_AIis supported, then there’s almost no chance thatLatin1_General_100_CI_AI(which is a far better choice) isn’t also supported. The version 100 collation has about 15,400 more sort weight definitions, plus 438 more uppercase/lowercase mappings. Not having those sort weights means that 15,400 more characters in the non-100 version equate to space, an empty string, and to each other. Not having those case mappings means that 438 more characters in the non-100 version return the character passed in (i.e. no change) for theUPPER()andLOWER()functions. There is no reason at all to wantLatin1_General_CI_AIinstead ofLatin1_General_100_CI_AI. There might be a need if code was put into place to work around these deficiencies, and that code would behave incorrectly under the newer, better version of that collation. However, it’s highly unlikely that code was put into place to account for this, and extremely unlikely that if such code did exist, that it would error or doing things incorrectly due to the newer collation.
By using collation or casting to binary, like this:
SELECT * FROM Users WHERE Username = @Username COLLATE SQL_Latin1_General_CP1_CS_AS AND Password = @Password COLLATE SQL_Latin1_General_CP1_CS_AS AND Username = @Username AND Password = @PasswordThe duplication of username/password exists to give the engine the possibility of using indexes. The collation above is a Case Sensitive collation, change to the one you need if necessary.
The second, casting to binary, could be done like this:
SELECT * FROM Users WHERE CAST(Username as varbinary(100)) = CAST(@Username as varbinary)) AND CAST(Password as varbinary(100)) = CAST(@Password as varbinary(100)) AND Username = @Username AND Password = @Password
–jeroen
Posted in Database Development, Development, Encoding, internatiolanization (i18n) and localization (l10), SQL Server | Leave a Comment »
Posted by jpluimers on 2021/06/29
At the bottom a few examples on on how not do do user experience.
Most of them are related to public traffic ticket vending machines, which seem to have a common pattern of having very low usability.
There is one example I know that has quite a good user experience, because taking usability into account aspart of the design was done at the start of the project.
This is contrary to most machines: they are built by engineers just taking into account their needs and challenges: build from existing parts, allowing for easier serviceability, aiming for ease of manufacturing.
Dutch GVB did it differently: they hired Dutch design agency [WayBack] Fabrique to design and test the user experience before the whole machine went into production.
This resulted in a machine that combines easy usability, good servicing, and straightforward manufacturing process. In addition, an “extended” version that allows for non-electronic payment was designed and manufactured in the same go.
Fabrique is a strategic design agency, specialised in service design, app development, e-commerce and website design. Discover Fabrique!
(Note I am not affiliated, nor endorsed by Fabrique. I just think they did a very good job)
Here are some pictures of the designed and manufactured machines; the vertical stripes light up the place where the next user interaction takes place:
Posted in Development, Software Development, Usability, User Experience (ux) | Leave a Comment »
The Wiert Corner - irregular stream of stuff 