The Official Language Of The Conference Is…

I always thought that the words “the official language of the conference is <…> mean precisely that: that the talks are presented in this language, the questions asked, and that during the coffee breaks and other social activities, the participants are mostly communicating on that same language.
I am very well aware that it’s egotistical to assume that “everybody speaks English.” Still, if the conference website says that “the official language is English,” one would assume that all participants can speak English :).

Recently, there were several cases when I found myself with my English being a minority at conferences where the official language was English. How this could happen? Well, when the majority of participants are local, and the local language is not English.

I think that I figured out how to navigate the coffee breaks: when I wanted to talk to somebody, I waited for a pause in the conversation and then asked in English whether it was OK to interrupt and ask my question. I didn’t figure out what to do when at a conference dinner, your neighbors from your right and left talk over you in a language you do not understand :). And when a couple of attempts of other participants to “re-engage” you into a conversation fails.

Any suggestions, except for to pretend that it does not bother you? I tried, but if you know me, it’s not in my character to stay silent for an extended period of time:).

Promotional Video for Uptime Conference

When I presented last week at Swiss PG Day 2022 in Rapperswil, I mentioned that the complete version of NORM_GEN will be presented at the Uptime conference Sep 13-14 2022 in Amsterdam. I am very thankful to the organizers who gave me enough time to highlight the most important aspects of the NORM_GEN project.

Postgres London 2022 in Pictures

I tried my best to take a picture of each speaker at Postgres London except for the very end when I had to take care of my next day’s airline reservation which had to be rebooked along with two more flights.

Opening remarks

Gabriele Bartolini

Nilesh Trivedi

Tomas Vondra

Jimmy Angelakos

Anthony Nowocien

Simon Riggs

Laetitia Avrot

Hettie Dombrovskaya

If somebody has pictures of the last two speakers, I would appreciate the links! Then, this report will be complete (except for the post-conference :))

My Presentation at Postgres London 2022

It was great to be in London again. It was great to present at Postgres London for the first time, and I am especially grateful to the Talk Selection Committee for choosing my bitemporal talk. 

I could not be happier with the feedback I received – people actually want to try using pg_bitemporal! 

Since the traffic to the pg_bitemporal repo has increased, I decided to add some comments and answer some questions that people asked me after my presentation.

About the presentation. I honored the organizer’s request to run it from their computer. I mainly was concerned about the videos – whether they would play with a clicker, which was the only thing I checked. Only during the presentation did I realize that two-thirds of the colors were not visible and that animations didn’t work. 

That being said, the slides are available here (at least for some time), and the SQL for the tutorial is here. I hope that with all colors in place, the tutorial will be more understandable. 

bt_tutorial_london2022 (1)Download

About pg_bitemporal. I know that when you google pg_bitemporal, the first repo which comes up is the scalegenius one. Since the beginning on 2022, I maintain my own fork, and all the changes/bug fixes which were done after January 2022 are present in my fork only. Please go to  https://github.com/hettie-d/pg_bitemporal to get the latest. 

How to use. On the database where you want to use it, run _load_all.sql. It will create all schemas and functions you will need. 

Thank you again for attending my presentation, and I hope you will give pg_bitemporal a try! Please let me know how it goes!

NORM News

For those who follow the NORM project and specifically our most recent addition, NORM_GEN, I have some exciting news. As we continue the work on automation of the creation of the functions and on making them more usable for application developers, we made two critical improvements:

First, the build_conditions function now accepts the MongoDB syntax.
For example, the call:

select norm_gen.build_conditions(
'{
"User account":{
"phone_type":"cell",
"email_priority":"primary",
"account":{"last_name":"johns",
"emails":{"email_address":{"$like":"%gmail%"}},
"dob":{"$gt":"1901-01-01"},
"phones":{"phone_number":{"$like":"312%"}}
}
}}'
::json);

will generate the following conditions:

account_id IN (
select account_id from norm.phone where
phone_id IN (
select phone_type_id from norm.phone_type where
phone_type = ('cell'::text) )
AND phone LIKE ('312%'::text) )
AND account_id IN (
select account_id from norm.email where
email_id IN (
select email_priority_id from norm.email_priority where
email_priority = ('primary'::text) )
AND email LIKE ('%gmail%'::text) )
AND last_name = ('johns'::text) AND dob > ('1901-01-01'::date)

Second, for any specific hierarchy, we can generate its own search function using norm_gen.generate_search_generic_function.

For example, generic search for account will look like this:

create or replace function norm.account_search_generic(p_search_json json
) returns norm.account_record[]
language 'plpgsql'
as $BODY$
declare
v_result norm.account_record[];
v_sql text;
begin
v_sql:=norm_gen.nested_root('User account')||
$$ where $$||norm_gen.build_conditions(('{
"User account":'||p_search_json::text||'}')
::json);

execute v_sql into v_result;
return (v_result);
end;
$BODY$;

Note that calling norm_gen.nested_root allows us to pick up a new type definition instantaneously after it was changed.

You do not need to write this search; everything is done automatically. Now you can call a function

select norm.account_search_generic($${
"phone_type":"cell",
"email_priority":"primary",
"account":{"last_name":"johns",
"emails":{"email_address":{"$like":"%gmail%"}},
"dob":{"$gt":"1901-01-01"},
"phones":{"phone_number":{"$like":"312%"}}
}
}$$::json)

And it will return exactly the result you expect!

{"account_id":1,
"username":"aliceacct1",
"last_name":"johns",
"first_name":"alice",
"dob":"1996-04-01",
"emails": [{"email":"alicejons@gmail.com","email_id":1,"email_priority":"primary","email_priority_id":1},{"email":"johnsonbs@hotmail.com","email_id":2,"email_priority":"primary","email_priority_id":1}],
"phones":[{"phone_id":1,"phone_type":"cell","phone":"2021234567","phone_type_id":2},{"phone_id":2,"phone_type":"cell","phone":"3121233344","phone_type_id":2}]}

And no application developer needs to know that there is pure PostgreSQL inside!

Dear application developers, software engineers, and anybody else who might be interested – would you try it out :)?

Impostors And How to Identify Them

Today, I want to talk about impostors. No, not about impostor syndrome, but impostors. Nowadays, you hear about “impostor syndrome” more often, and even when you start to google “impostor,” the “impostor syndrome” comes first. It looks like a more common situation when somebody feels like an impostor when they are actually not. You often come across a story where a female professional feels that she “does not deserve” a specific position, and others are trying to convince her that she does.

However, we rarely see stories about actual impostors in IT, although I know several people and organizations that fell victim to impostors. The damage ranges from poor people management to data loss to material financial losses. Organizations rarely admit that they made a mistake in hiring an impostor. I recall a situation when a person from the Technical Leadership team asked an impostor to find another job. He promised that an impostor would be allowed to go to the interviews during business hours and that this organization would keep him on the job until he would find a new place. (He refused and eventually was fired). 

Apparently, nobody wants to admit that they made a mistake and didn’t identify an impostor from the start. And you know what happens next?  

• This person comes to the next organization and occupies a position they are not qualified for;
• The organization does not evaluate its hiring practices and hires another impostor.

 I wanted to write this article for a very long time but was putting it off because the topic is uncomfortable: each time I write a blog on an uncomfortable topic, people start to reach out to me privately and ask whom exactly I meant. And as surprising as it may sound, the reason I am writing it today is more political than technological. A couple of days ago, I watched Mikhail Khodorkovskiy’s interview with the BBC. He admitted his mistake of “trusting Putin” in 2012 and said that he regrets it since then. At this point, I want to scream: how could anybody trust him?! You do not need to be an expert in politics to see that he lied! All the time! Why do so many people say that they didn’t see it?!

Back to the topic. Each time I had to confront an impostor, their manager would ask me for “proof,” which would sometimes go as far as to extract relevant records from a database log. However, I would be the first to admit that anybody can make mistakes, and I made more mistakes than anybody else I know. The problem is not making mistakes – the problem is that they lied!

I can always tell when a person lies (not like “always-always,” but when they make a professional statement). I do not necessarily know the field in-depth, but I can tell when someone talks about something they have no clue about. And I know I am not alone. I was fortunate to work together with some great leaders who could tell the technical worth without knowing the field in-depth. They would ask for my opinion, but they would have their own. I think that being able to make such judgment is an essential part of leadership. I wish I could provide a standard algorithm for “how to identify an impostor,” and I wish it would be as straightforward as an “ultimate optimization algorithm.”

This brings in another question. Suppose you are a director of IT or a CTO, or a CIO, somebody who manages different departments and does not have an in-depth knowledge of what each department is doing. That is a perfectly normal situation, but the question is how such a person would keep themselves from becoming an impostor and hiring impostors? How would they sort out the buzzwords and decide whether “what everybody is doing” applies to their company? 

Do you have any suggestions for the critical questions such a person should ask?

Believing in Magic of Parameters…

It continues to surprise me how much people believe that there is a magical combination of PostgreSQL configuration parameters that can suddenly make everything fly. I’d say if such a magical combination would exist, why we won’t make it default, and then there will be no need to tune anything – ever! Still, we modify parameters – all the time. Another surprising fact is that people are more willing to modify system parameters than to tune one single SQL statement. 

I do not understand that logic. When you change parameters, you change them for the whole system, so each SQL statement will be affected. And although we know how parameters tuning should affect the database performance, we are not verifying how each SQL statement will perform after parameters change.

In contrast, when you tune one specific SQL statement, you modify just this single statement, and other statements’ performance will remain unchanged. From my perspective, it means that the change results are more predictable, and the change is easier to implement. I am not sure why such suggestions are usually received with skepticism.

Recently, I suggested a customer rewrite one SQL statement in their system performance test. This statement was executed multiple times during the test, and I was pretty confident that a minor rewrite would drastically improve performance.

The results exceeded my expectations: this minor rewrite cut the total execution time of the test from 46 hours to 23 hours! twice! Without any configuration parameters changes 🙂

Bitemporal bug fixes

Attention to those who are currently using pg_bitemporal or just exploring it. I’ve received some bug reports from new users and fixed them. Please note that the fork I support is

https://github.com/hettie-d/pg_bitemporal

All fixes are there.

NORM_GEN (NORM Phase II)

Thank you to everybody who attended my virtual presentation on April 13! And for those who did not attend but were interested in the NORM project’s new developments, please check out the recent updates on GitHub. all new stuff is located in the NORM_GEN subdirectory.

Any feedback will be appreciated!

And yes, I am working on a tutorial 😉 

Looking for feedback from app developers

Dear former collegues! No matter how many years have passed since we worked together last time, I am still (hopelessly? optimistically?) looking for ways to improve database/application communications.

I have been actively building a tool you all wanted for many years – the way to automate Hettie:), and although it is still very much work in progress, I would love to hear your feedback.
Will you be willing to use it when it is done? What needs to be improved?

I will present the current state of the project at Chicago PUG on Wednesday – details are here:
https://www.meetup.com/Chicago-PostgreSQL-User-Group/events/285050288/

Believe it or not, I have only eight years left until retirement!!! And that’s one of the things I want to accomplish in my life:)