Today I read the documentation for how Dependency Injection is done in MediaWiki.
I had a few small nits to pick (such as their statement that services should be stateless) but… fair enough.
For myself I don’t usually use Dependency Injection and a Service Container, instead I prefer the Service Locator pattern which I find is simpler and more economical to use, especially in PHP where there is a single process per request.
There’s a famous quote from Alan Kay that you will see bandied about:
OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things.
I think I agree with him, but I often find myself wondering quite what he meant by “extreme late-binding”. I suspect he means that object instances can redefine stuff they inherited from their concrete class. If your OOP platform doesn’t support that, you can emulate it with data and API.
Here is something I would like to demo regarding foreign key constraints.
This regards what type of errors foreign key constraints can (and can’t!) save you from.
Occasionally you hear developers say how important foreign key constraints are and how foreign key constraints saved them from some bug. That might all seem well and good but when you think it through if a foreign key constraint saved you from a bug it also might very well just have been luck that saved you and the thing that went wrong might have gone wrong another way and have gone undetected as database corruption and potential accidental data disclosure to an incorrect entity.
To set the scene let’s use some schema/data from what we were talking about earlier:
create table t_skinny_customer ( customer_id bigint not null primary key, customer_name varchar(255) not null, customer_record_created_on timestamp default current_timestamp, customer_record_updated_on timestamp default current_timestamp on update current_timestamp ); create table t_skinny_customer_phone ( customer_phone_id bigint not null primary key, customer_id bigint not null references t_skinny_customer( customer_id ) on delete cascade, phone_number varchar(255) not null, phone_type enum( 'phone', 'tollfree', 'mobile' ) not null default 'phone', phone_type_order tinyint unsigned not null default 0, phone_record_created_on timestamp default current_timestamp, phone_record_updated_on timestamp default current_timestamp on update current_timestamp ); insert into t_skinny_customer ( customer_id, customer_name ) values ( 1, 'John Doe' ), ( 2, 'Jane Doe' ); insert into t_skinny_customer_phone ( customer_phone_id, customer_id, phone_number, phone_type, phone_type_order ) values ( 11, 1, '123-456-7890', 'phone', 1 ), ( 21, 2, '123-456-7894', 'phone', 1 );
Then let’s run this code:
$stmt = $pdo->prepare("
update
t_skinny_customer_phone
set
customer_id = :customer_id
where
customer_phone_id = :phone_id
");
try {
$stmt->execute([
'customer_id' => 3,
'phone_id' => 11,
]);
assert( false );
}
catch ( PDOException $ex ) {
// 2024-02-13 jj5 - foreign key constraint saved the day!
assert(
0 === strpos(
$ex->getMessage(),
'SQLSTATE[23000]: Integrity constraint violation: 1452 Cannot add or update a child row: a foreign key constraint fails'
)
);
}
$stmt->execute([
'customer_id' => 2,
'phone_id' => 11,
]);
// 2024-02-13 jj5 - ... whoops! what we've done here is switch
// one of John Doe's phone numbers to be one of Jane Doe's
// phone numbers. The foreign key constraint is of no value in
// detecting this type of data corruption.
Now I’m not saying that you shouldn’t have foreign key constraints. I’m just pointing out that if you do have foreign key constraints and you’re relying on them for “referential integrity” your door may be open for all manner of bugs (and exploits).
That your foreign key points to an actual record doesn’t necessarily imply that your foreign key points to a correct record.
I would like to compare and contrast two options for the design of customer contact information for a relational database.
This is the first option, a “fat” customer table.
create table t_fat_customer ( customer_id bigint not null primary key, customer_name varchar(255) not null, customer_phone_1 varchar(255) not null default '', customer_phone_2 varchar(255) not null default '', customer_tollfree_1 varchar(255) not null default '', customer_tollfree_2 varchar(255) not null default '', customer_mobile_1 varchar(255) not null default '', customer_mobile_2 varchar(255) not null default '', customer_record_created_on timestamp default current_timestamp, customer_record_updated_on timestamp default current_timestamp on update current_timestamp ); insert into t_fat_customer ( customer_id, customer_name, customer_phone_1, customer_phone_2, customer_tollfree_1, customer_tollfree_2, customer_mobile_1, customer_mobile_2 ) values ( 1, 'John Doe', '123-456-7890', '123-456-7891', '800-123-4567', '', '123-456-7892', '' ), ( 2, 'Jane Doe', '123-456-7894', '123-456-7895', '800-123-4569', '', '123-456-7896', '' );
This is the second option, a “skinny” and “properly normalized” option. It has lots of skinny tables, which some will claim are the hallmarks of “good design”.
create table t_skinny_customer ( customer_id bigint not null primary key, customer_name varchar(255) not null, customer_record_created_on timestamp default current_timestamp, customer_record_updated_on timestamp default current_timestamp on update current_timestamp ); create table t_skinny_customer_phone ( customer_phone_id bigint not null primary key, customer_id bigint not null references t_skinny_customer( customer_id ) on delete cascade, phone_number varchar(255) not null, phone_type enum( 'phone', 'tollfree', 'mobile' ) not null default 'phone', phone_type_order tinyint unsigned not null default 0, phone_record_created_on timestamp default current_timestamp, phone_record_updated_on timestamp default current_timestamp on update current_timestamp ); insert into t_skinny_customer ( customer_id, customer_name ) values ( 1, 'John Doe' ), ( 2, 'Jane Doe' ); insert into t_skinny_customer_phone ( customer_phone_id, customer_id, phone_number, phone_type, phone_type_order ) values ( 11, 1, '123-456-7890', 'phone', 1 ), ( 12, 1, '123-456-7891', 'phone', 2 ), ( 13, 1, '800-123-4567', 'tollfree', 1 ), ( 14, 1, '123-456-7892', 'mobile', 1 ), ( 21, 2, '123-456-7894', 'phone', 1 ), ( 22, 2, '123-456-7895', 'phone', 2 ), ( 23, 2, '800-123-4569', 'tollfree', 1 ), ( 24, 2, '123-456-7896', 'mobile', 1 );
Here are some stats from the design options:
| Fat option | Skinny option | |
|---|---|---|
| Lines of code: | 42 | 85 |
| Tables: | 1 | 2 |
| Columns: | 10 | 11 |
| Records: | 2 | 10 |
The first option is simpler than the second option by every measure.
I know, you want to create a more general solution. I know, they say a hallmark of good database design and “proper normalization” is lots of skinny tables. I remind you: the first option is simpler than the second option by every measure.
My advice is don’t rush toward general solutions in an effort to solve problems you don’t have.
The UI isn’t coupled to the database design in any way. You could implement any type of UI on top of either database design alternative, such as:
| Primary | Secondary | Operations | |
|---|---|---|---|
| Phone: | |||
| Tollfree: | |||
| Mobile: |
Or:
| Phone Type | Phone Number | Operations |
|---|---|---|
(My opinion is that the first UI option above is superior to the second UI option, it’s also exceedingly easy to implement with the “fat” customer table.)
Here are some implementation exercises to compare the difficulty of working with the database options:
User: explain profundity
ChatGPT:
Profundity refers to a state of being deep in thought or insight. It’s often associated with ideas, thoughts, or expressions that have significant depth of meaning, understanding, or insight. Profundity can apply to various contexts, including intellectual discussions, philosophical concepts, artistic works, and emotional experiences. When something is described as profound, it usually means it has a deep impact, is very thoughtful, or offers substantial wisdom or insight. Profundity involves layers of meaning that may not be immediately apparent and often requires contemplation or reflection to fully appreciate.
This post is part of my video blog.
I’m not sure what I should say about this. Or if I should say anything about it at all.
I was having a conversation on IRC and I wanted to demo some code generation I did this afternoon.
I used this PHP to generate this BASH code.
And I used this PHP to generate this PHP code.
I think PHP is a good choice for code generation.
Here is another PHP thing I need to think clearly about from time to time:
var_dump( [ 'a' => 1 ] + [ 'a' => 2, 'b' => 2 ] );
Returns:
array(2) {
'a' =>
int(1)
'b' =>
int(2)
}
I was in bed trying to get to sleep but my brain wanted to know the answer to this question. So I was forced out of bed to write this experiment:
function main( $argv ) {
register_shutdown_function( 'shutdown_1' );
register_shutdown_function( 'shutdown_2' );
exit( 0 );
}
function shutdown_1() {
exit( 1 );
}
function shutdown_2() {
exit( 2 );
}
main( $argv );
With this PHP code, what do you expect is the resultant error level?
The answer is ‘1’. After main() calls exit( 0 ) the shutdown function shutdown_1() is invoked. When shutdown_1() calls exit( 1 ) the process exists and shutdown_2() is never called.
I’m glad we cleared that up. Back to bed.