Forem: RITER.CO

Chat as a project management system

Alexey Osipenko — Tue, 15 Nov 2022 08:56:55 +0000

The easiest way to manage tasks is the one that isn't. Or the one you don't notice.

Let's be honest. Each task or issue in your project can be agreed upon or even solved in a chat. Well, some of them may be discussed not in the chat, but via the calls, but this thing highlights the main point. Any project management tool, like the monstrous Jira or the fancy Notion, has always been secondary in the management process. The such system only tries to keep up with the real world. To keep the management process actual company hires a separate employee who should be responsible for this. Also, they may create additional rules, for example, demanding an issue prefix in the branch name or issue number in the brackets before each commits message. Such things are not simplified debug porocess or bring order to the process. It allows us to be sure that the user creates the task before writing the code. As a consequence, a user creates the task, estimate it, and have a discussion with the managers and colleagues. That's it.

Next to the tasks are relentless time-tracking systems, multiple layers of decision makers, bug trackers, release notes, release flags, and many more things specific to a particular industry, but these are even further away from the actual process. Even if you imagine a perfectly spherical situation in a sterile project. For example, the bug tracker automatically got a new report, after that, an internal system created a new task by a trigger, picked the author of commits, and automatically assigned a responsible developer. Will that be the end of it? Of course not. The system should have feedback from the participants. Whether it's the developer, the tester, or the manager, they will ask in a chat channel, "Hey guys, look what happened. Who's to blame and what to do?". Then there's bound to be a discussion about the nature of the bug, free developers, and assigning responsibility. And when all these questions are solved, a developer can go to the tracker and fix the problem. Well, or create the new one. And there will be something rather dry in the title and formulaic in the task body. And all of that heated discussion, all those attempts to determine what is missing and transfer the folklore knowledge about this particular module will remain in the depths of chat and then disappear after 90 days in the free plan.

Chat is primary. Chat is the place where the most important and key things for a given task happen. Chat is where the decision maker makes the important decisions, where the person who will do the task points out potential problems and points out the shortcomings of the current solution. I will stipulate again that sometimes this happens in the voice chat, but it certainly does not lure in the comments to the task.

You just have to stop lying to yourself that the task tracker is the central place of the project, where all the data threads converge. Chat is where everything happens. There are no chance to change it except the way when the any chat in a team will be denied.

Some people objected to this and said that in their project, everything happens within the tasks of the project tracker. The arguments usually pointed to the remoteness of the team in space and the different time zones of various chat participants. Someone is sleeping or eating, and someone is working. It's better to read the comments, not the chats. But the slightest study showed that when it was really necessary to decide something, not just to write something formal, the discussion quickly moved to the chat room. In most cases in private chat room, which is worse. Then it was possible to discuss the details, so that then in the comments formal language to write not explaining anything, but only declaring the decision.

We choose the other way. We're trying to figure out what we needed that wouldn't fit into a regular thread in Slack. We came up with only three points.

Any message in a chat room can become a task. And correspondence in that message's thread becomes a discussion of that task.
The responsible person for the task is not always the one who writes or the one who gets written to. The person responsible can be tagged or simply tagged via the nickname.
It is obvious, but it is important to have a task performer. Sometimes (not in all cases) it is important to set deadlines.

It turned out that this is the minimum functionality that will not only meet our needs but will also suit the vast majority of project teams. At the very least, this is the right place to start any project, when you want some order to tasks that were chaotically solved simply in Slack.

As a result, we created the application in Slack with the telling title "Task for Slack" first for ourselves, and then we opened it for everyone who wants to use it. Use it, it's completely free without any restrictions, additional registrations, integrations, or external services. Everything is done without leaving Slack.

I would like to hear in the comments what is missing in the tool, and what should be added to your opinion.

Software Developer’s Efficiency: How to Evaluate and Improve?

katglin — Sun, 19 May 2019 14:17:36 +0000

I know I’m preaching to the choir now, but a good programmer is distinguished from a bad one by efficiency. And the first thing that comes to mind when we hear the word “efficiency” is the time spent on implementing a particular feature. For example, when one developer does something in three days, and another one — in six days, then a small amount of arithmetic calculations reveals that the first developer is twice as effective as the second one, isn’t he?

No! This criterion will be correct only in the short run and totally wrong during long-term development.

The right way to test a developer’s performance is to see how he handles several typical (repetitive) tasks. Each next task of the same type must take less and less time. You can try to derive a certain formula of reducing the execution time of a next task and use it to evaluate and compare the effectiveness of developers in your team. The so-called developer’s efficiency ratio. Well, for example, each next task of the same type should take two times less time than the previous one. Until a certain point, of course.

Becoming more efficient

We could talk a lot about how to achieve efficiency gains and speed up the development process. This time we will offer you a couple of analogies for reflection.

Do you remember the idiom about the sharpening of the ax and deforestation? The one where an abstract developer has no time to sharpen an ax, because he’s too busy chopping wood.

The problem is obvious, but the solution is not always so straightforward. There is a flipside here — premature ax sharpening. The ax needs to be sharpened when it is clear that the costs of sharpening the ax will pay off by the speed of deforestation.

And to check it out, you need to:

Find out the speed of deforestation with a blunt ax. To this end, you need to do the task at least once before any optimizations. No need to implement a separate library and introduce extra abstractions till then.
Understand the characteristics of the ax, know what will happen after sharpening. The initially written inline solution, built within the current architecture, will fully make it clear what and where you can later replace and refactor.
Know the next time you need to sharpen an ax. It’s impossible to make all the code completely polished at once, but it is never necessary. It is much better to take care only of a specific task each time when refactoring. Your goal is to shorten the development time of this particular task the next time, say, twice.

There is another similar popular idiom. It says something like: “It’s better to spend the whole day building an airplane to fly to your destination in five minutes, than to spend the whole day trying to run there.” But the “ax” and the “plane” idioms describe different cases. The “ax idiom” tells about different tasks of the same type, while the “airplane idiom” — about routine processes within the same task.

Originally published at Riter Agile Blog.

Diving into programming: where not to begin?

katglin — Mon, 13 May 2019 08:56:45 +0000

I have already raised the issue in one of my previous posts, however, daily practice shows that the problem is still relevant. This time, I’ll also talk about paid programming courses which are so popular today. Lots of courses like “Learn PHP/Java/C++/... in a month/2 weeks/...” and high demand for them don’t allow me to just keep silent. Moreover, an enormous number of their advertising, exceeding reasonable limits, also do not allow to ignore this topic. So I will try to save a couple hundred dollars for those who want to dive into programming through courses.

For starters, here are some statements to think about.

The overwhelming majority of programmers’ daily tasks consist of finding and assessing the necessary information and building new mental abstractions. So it is just impossible to learn everything you need for work in advance. First of all, it is better to study the mechanism for obtaining new knowledge. It is about “learning to learn”.
The most topical technology turns into an ancient enterprise in six months or a year. The process of learning technologies should be continuous and never stop. The material which is taught to you on courses right now was prepared a couple of months ago and mastered by the teacher themself six months ago or earlier. The relevance of such knowledge is extremely small.
The learning process is always based on drawing analogies with already known things. And for each person, the process of making such analogies is strongly individual. All that a teacher is able to do is to impose their own analogies.
A certain basic set of knowledge can still be obtained during courses, but it is so fundamental that you can easily learn it independently. Git, the basics of Unix, algorithms and data structures, a bit of math. In addition, some basis for a specific profession. For example, in web programming you need to understand HTML, CSS, HTTP and stuff.

Of course, in practice, it can be difficult to master both the fundamentals and a certain programming language on your own, especially without any technical background, since you don’t have an overall picture. In this case, it is still important to distinguish good courses from bad ones.

Good courses give you new challenges, tasks which you learn to solve. Sometimes these are typical tasks and often typical approaches. Good courses do not impose approaches, but explain which ones are better and why. And the tool for solving the problem — say, ruby or python — you can choose depending on the situation. Bad courses teach you a language. Good courses teach you to meet the challenges and solve tasks.

And finally, even if you succeed to choose the best and the most rigorous courses, it’ll still be very hard to stand out from the increasing number of other similar students, not to say about thousands of computer science graduates.

And what is your take on this issue? Have you had your own experience with such courses or their graduates? How successful was it?

Originally published at Riter Agile Blog.

Sharing and Concealing Startup Ideas

katglin — Wed, 08 May 2019 07:54:51 +0000

— What are you working on now?
— I’m doing a project.
— What kind? Tell me, I’m curious.
— I can’t tell you anything now, you will see it later.

Probably every programmer has an idée fixe which will one day allow them to take over the world together with nearby planets. It is different for everybody, with varying degrees of ambitions, forethought, and planning. Gamers want to write a game. Home life optimizers want to create culinary apps, home bookkeeping tools, and smart home software. Holiday fans want social networks for drunks and mobile apps for camping and picnics organizing.

Some are lucky to find like-minded people to work together on the “wunderwaffe” which will save millions of lives, revive the Ussuri tigers, and make them billions of dollars. Only a few begin to implement at least something and only a handful of them are able to bring the idea to at least some workable stage of a product. This is all well-known, logical, and this is the way it should be.

But what is really incomprehensible and illogical is the desire to hide what you are working on now. Well, or, at least, what you are planning to work on.

On the one hand, it is clear that you don’t want to be unfounded and talk about an idea that you haven’t even begun to do in a too pretentious way. On the other hand, any idea that you share with people is strongly criticized. And this criticism is worth listening to. Correctly posed questions and answers to them help to develop in the right direction. The same “rubber duck” method applies here, but only at the stage of system requirements analysis and software design. First, you train to answer awkward questions and hone that very “elevator pitch”. Secondly, you begin to see the obvious weaknesses of the project still at the idea stage. This is not touching the fact that like-minded people can be found only if you talk about your project.

Of course, this does not mean that you need to talk about your projects on every corner. We are talking only about the places where it is relevant, such as thematic conferences and meetings, and when someone is really interested in what you are working on.

In some cases, developers refer to a risk that a good idea can be stolen. However, in the modern world it is rather pointless to be afraid of this. More likely you need to be afraid that someone else will come up with the same idea and its implementation will turn out to be a million times cooler than you could imagine on your own. Or that this idea is already being developed by someone else, or even has already been implemented. The chances that you will miss this will be much lower if you do not keep the idea secret, but discuss it with friends and colleagues.

Sometimes, on the contrary, such a reluctance to tell about the project is connected with the author’s uncertainty that it is worth the discussion. High competition, slow development of the project in comparison with similar apps, thoughts like “well, if it starts to go well, then I’ll tell them” often prevent startups from turning into something more than a hobby or even force an author to drop out of it over time. However, as mentioned earlier, the presence of competition does not mean that the idea is not destined to grow into something significant.

“If you are afraid to create or always compare your content with others’, fearing to produce something ‘worse than others’, think about the theory of two cakes” (@Charodei_Ent)

Sometimes you can hear a more reasoned opinion as an alternative to ours “tell everyone about your idea.” For example, one of our subscribers shared the following statement: “When a developer tells someone about his plans, it may be a feeling that he has already achieved something. As a result, false satisfaction appears and motivation gets low.”

And what is your opinion in this regard? At what stage do you begin to discuss and share your project ideas and success?

Originally published at Riter.co.

Project Management Digest, March 2019

katglin — Sun, 31 Mar 2019 14:38:34 +0000

Originally published on Riter.co.

This is the third release of our monthly digest of the most discussed, popular, and entertainment articles focused primarily on product owners and project manager. However, everybody working in the IT field can find something useful here.

Most popular articles

Startups, product management, and related fields

How AI Will Change The Future Of Project Management — the topic of AI is becoming more popular each year and many experts have their own opinion on its implementation in project management. The author tells about task prioritization, project re-planning, better and efficient analysis, insights and prediction, and much more. Some assumptions are already being implemented in practice by existing project management software, but some are quite new and deserve attention.
The Future of Project Management – Post Brexit, Apprenticeships and AI — one more view on the future of project management and the most possible changes.
Applying Project Management Skills to Guide Production of an Off-Road Triathlon Film. Project management skills are applicable in many industries. The author tells about changing his roles from an IT professional to a principal in a video-content firm. Can you share your own life situations where your project management experience and skills came in handy?
Why Agile and How to be Good at It As UX Designer. Having worked on various agile projects for clients in different industries, the author is sharing what he learned from these agile projects as a UX designer.
How my side project became my full-time Startup. Learn how to turn your side project into a promising startup, how to develop, scale, and promote it properly.

Career and leadership

How To Navigate Turmoil Without Sinking The Boat. Unresolved turmoil weakens your team, leads to frustration, helplessness, and regret. Find out what can cause turmoil and how to manage it.
Cultural Fit versus Cultural Fit — a little about hiring developers, organizational culture, team management, good and bad approaches to recruitment.
10 Ways To Help Reluctant People Make Commitments. Leaders spend much time trying to get performance from people who aren’t committed. Spend more time helping people commit and less time pressuring people to conform. As a team leader, how do you help people make commitments?
3 Ways to Perfect Your Strategic Skills. What creates long-term success in a project management career? In the author’s opinion, developing strategic skills is the best path to that destination. And the article explains how you can improve them.

Agile and Scrum

Free Your Team With Liberating Structures. The author tells about “liberating structures” and different ways to use them to organize your work. If you are a fan of liberating structures, feel free to share which ones you used, in what context, and how was the result.
About that Scrum Master/Agile Project manager role.... The article is going to explain why you can’t be a Scrum Master & Project Manager at the same time.
All for One Backlog, One Backlog for All. It’s well-known that Scrum supposes the only backlog used by the team. However, in practice, some organizations try to split the backlog between “product” and “tech” and give each their own product owner. The author tells about problems which can cause such a behavior, why this is a wrong approach, and how teams could avoid it.
A Daily Scrum in the Cave. The author uses Plato’s Allegory of the Cave to talk about Scrum and tremendous opportunities outside “the cave”.

Productivity and teamwork

Are you being (responsibly) transparent? — the author describes the need for team members to act with responsible transparency.
How hidden are your hurdles? How does your team cope with team’s blockers and how bold they are? In the post, the author tells about possible ways to deal with such blockers — issues preventing developers from completing their work items — without the need for broader communication or escalation.
How to Disagree with Your Boss. Your boss isn’t always right, and sometimes you need to show them the error of their ways, however difficult that may be.
How To Overcome The Frustrations Of Collaboration. The truth is, the fastest way to get simple work done is clear direction and obedient compliance. But you’re on your own when people feel excluded and disrespected.
How to Build a Successful Team — “every leader should take the ‘12 minutes’ out of their day to read and internalize this”.

Most discussed articles

3 Ways To Set Yourself Apart. Not all project managers are created equal. How do you differentiate yourself as a project manager? The post suggests a few ideas.
How To Boost Your Productivity & Get Sh*t Done. Productivity is a skill that can be learned. The post includes some of the tips & tricks which the author uses to prioritize her commitments and tasks.
8 Common Project Manager Mistakes — some common weaknesses of many project managers and suggestions how we could deal with them. Familiarizing yourself with common mistakes can help you prevent a project disaster.
Reducing Waste in Project Management. When a company grows, the complexity of project management methodologies used also grows. As a result, project managers suddenly find themselves inundated with a wealth of templates, processes and tools, but project success rate only falls. The author tells about scaling your project management processes and some common mistakes.
What’s your type? Join the discussion of Scott Hanselmans interview with Camille Fournier on Hanselminutes — this is an episode relating to management and what behaviors managers should and shouldn’t exhibit to motivate engineering teams.

Entertainment content

The best Agile jokes from reddit community. Read and don’t forget to share your own examples.
A manager, a mechanical engineer, and software analyst are driving a car...
Estimates
Geplanus: The PM — a collection of funny comics on project management and Agile.

Resources for project managers

General resources and blogs

Project Management Huts — a collection of articles oriented on project managers with varying levels of skill and experience. Also, several new articles appear almost every day at their website. In addition, you can find book and software reviews, knowledge base, and other related materials covering specific subjects for project managers there.
Girl’s Guide to PM — a blog for project, program and portfolio managers and project delivery professionals. It includes templates, mentoring programs, training tutorials and guides, blog posts and some paid content.
Tyner Blain Blog — the author shares lessons he’s learned from his own project management experiences as well as from what he’s observed as a consultant for companies both large and small.
Agile blog, the original source of this monthly digest. In addition to the posts on general project management topics (time management, risks, AI in project management, productivity, collaboration, etc.), you will find there many non-standard views and thoughts on the best coding practices, team working, managing startups, and a few articles on technologies and achievements in software development based on our own experience.
Bob Sutton’s Blog — not a new or active blog indeed, however, its content still remains actual and can be useful for project managers regardless of their experience.
ProofHub Blog — a space of posts on common issues and tasks in project management.

Books and educational resources

“Against the Gods, The remarkable story of Risk” by Peter L. Bernstein — perhaps the best general history of risk — and presentation of the major concepts of risk — that is understandable by all practitioners at any level.
10 books about project management worth reading — if you are looking for a way to improve your project management skills, this is a rather fair March collection of books worth reading.
Knowledge Train — free resources for project management grouped by categories and types. Their materials are mainly categorized as Careers, Practice, Qualifications, Training and Exams, News. The content appears in different formats like videos with transcriptions, PDF downloads, infographics, etc.
Free Project Status Report Template — a free PDF report template along with a recent post which explains what a report template is and how you can use it for your needs.

Podcasts

LEAP! with Tina Seelig — a podcast series hosted by Tina Seelig, Professor of the Practice in Stanford’s Department of Management Science and Engineering. Each episode takes about 20 minutes. 4 new episodes were released in March. You can find more articles and podcasts on the website and on the Medium blog.
The Burn Up — a new podcast that may be of interest to project managers and product owners. Authors share their combined 40 years of experience in software design and delivery. The podcast was released in January 2019 and has 10 episodes for now. They tell about team management, user stories, business analyst, and product management and take about 20 minutes.

Slack communities

Serious Scrum

Thank you for reading. We would be glad to know which topics and resources are the most interesting for you. Also, feel free to share your favorite articles and other materials for the next digests. We always take into account all suggestions. Follow us on social media or subscribe to our blog not miss them.

The previous releases:
Project Management Digest, February 2019
Project Management Digest, January 2019

Serverless Approach to Integrate Gitlab Webhooks with GraphQL API

katglin — Sat, 16 Mar 2019 08:12:48 +0000

Originally published at Riter.co.

In this post, we describe how to integrate Gitlab webhooks with Riter API and deploy the service on the Google Cloud Platform using Cloud Functions — a serverless compute solution for creating event-driven applications. Cloud Functions let you reduce the infrastructure costs and provide a relatively convenient way to build and deploy services. The whole code is available on Github along with unit and performance tests.

Service purpose

As you may know, Riter is a project management tool used (and developed) by our team. Each pull request created in Gitlab is always associated with a certain task (a story, as we call it) in Riter. So, up until now, we had to insert a link to the task in the pull request description, and after that — add a corresponding link to pull request inside the task comments. As a result, it was easy to see which particular code changes a specific task includes, and which task a certain pull request relates to. On the other hand, such an approach resulted in some “double work” which we’d like to avoid.

To this end, we’ve written a simple service that uses Gitlab webhooks to track and process merge request events and Riter API — to report these events in appropriate tasks. In our case, we suggest that each Gitlab repository corresponds to a particular Riter project. We also suggest that either a pull request description or a source branch name contain a story slug. If so, then each time when somebody performs a merge command, the service figures out a task to which it belongs and adds a link to this pull request (with its id, title, and action performed) in the task annotations. As a result, we’ve got an automatically generated history of changes in our project management tool.

Requirements to the initial data

Generate Riter access token

All Riter users have full access to its GraphQL API which covers all existing functionality. Go to “My Profile” settings and open “Access tokens” tab. Here you can generate a personal access token to all your projects at once. However, in our example, we generate several separate access tokens for different projects and save them in appropriate environment variables (see below).

Also, we could create a separate user identity (a bot) to generate annotations on its behalf. However, for ease, let’s suppose that we use just a regular Riter user account to report all events.

Set up Gitlab webhooks

In Gitlab, go to the project “Settings -> Integration” page to add a webhook. We chose “Merge request events” trigger to process only events when a merge request is created, updated, and merged. In the same way, we could process any other events in the repository.

Here you also need to specify the URL which is unique for each function and appears in the console after deploy. It can be found in the Google Cloud Admin panel as well.

In our case, we call the same function for several Gitlab repositories. However, it would be better to deploy separate instances with different environment variables for each repository.

Environment variables

We use several environment variables. We’re going to track events only from specific users, so USERS include a space-separated list of Gitlab user nicknames.

USERS: nickname1 nickname2

Also, we create environment variables (“ProjectName_GraphQL_API_URL”) for different project access tokens along with the full API endpoint. For example, for the Demo company, the “The night’s watch” project, the env.yml file could include the variable:

THE_NIGHTS_WATCH_GRAPHQL_API_URL: https://demo.riter.co/the-night_s-watch/graphql?api_token=18dc7...

In our example, we use similar variables defined as TRACKER_GRAPHQL_API_URL, CLIENT_GRAPHQL_API_URL, and WEBHOOK_TEST_GRAPHQL_API_URL.

Source code

The entire code takes 84 lines and is written in pure JavaScript. An example of the same code written in Go is also available.

We get all users (whose pull requests we’d like to track) separated with a space:

const users = process.env.USERS.split(' ');

In GraphQL, we use mutations to perform POST requests. So, we describe a mutation to create a new annotation (input) to a particular story (specified by slug) in Riter:

const query = `
  mutation($input: AnnotationTypeCreateInput!) {
    createAnnotation(input: $input) {
      resource {
        slug
      }
    }
  }
`;

Then we list endpoints for different project names:

const projects = {
  'tracker': {
    endpoint: process.env.TRACKER_GRAPHQL_API_URL
  },
  'client': {
    endpoint: process.env.CLIENT_GRAPHQL_API_URL
  },
  'webhook-test': {
    endpoint: process.env.WEBHOOK_TEST_GRAPHQL_API_URL
  }
};

Finally, compose and send a request. We respond immediately to the webhook to speed up request processing:

  response.status(200).send();

Get the endpoint specified for a current project:

  if(req.body.project) {
    project = projects[req.body.project.name];
  }

Only calls from specific users and for certain projects are allowed:

  if(!project || !req.body.user || req.body.user && !users.includes(req.body.user.username)) {
    return 1;
  }

Then we validate the presence of content: URL to the pull request, pull request id, title, and action (for example, “open” or “update”):

  const attributes = req.body.object_attributes;

And try to define story slug from the pull request description or the related source branch:

  let storySlug;

  if(attributes.description) {
    [, storySlug] = attributes.description.match(/stories\/([\w-]+)/) || [];
  }

  if(!storySlug && attributes.source_branch) {
    [storySlug] = attributes.source_branch.match(/^[\w-]+/) || [];
  }

  if(!storySlug) {
    return 3;
  }

Finally, if all the data is correct, we perform the API call:

  const { url, iid, title, action } = attributes;
  const { endpoint } = project;

  const variables = {
    input: {
      body: `[Merge request !${iid} - "${title}" (${action})](${url})`,
      storySlug: storySlug
    }
  };

  request(endpoint, query, variables).catch(() => {});
  return 0;

Deploy and run

All commands required to deploy the service on Google Cloud Platform are provided in the README file. For example, here’s how we can deploy the service:

gcloud functions deploy http --env-vars-file .env.yml --trigger-http --runtime nodejs8

We’ve used Cloud Functions Node.js Emulator to deploy, run, and debug the app on the local machine before deploying them to the production. We’ve used the following tutorial to set up Local Functions Emulator.

Performance

Event processing speed appeared to be quite high. Memory usage, on the contrary, was rather low, as we had expected. That’s well since you are charged based on resources consumption (and on the number of requests to your function). While deploying Cloud Functions, you only have to specify the amount of memory your function needs and CPU resource is allocated proportionally. Here’re some screenshots from Google Cloud statistics:

Usage of memory

Request processing speed

In such a simple way, Riter can be quickly integrated with any third-party service, and its functionality can be extended as far as you need to meet all the specific requirements of your team and workflow.

Project Management Digest, January 2019

katglin — Sun, 03 Feb 2019 09:31:44 +0000

Originally published on Riter.co.

Having a hard time managing teams, projects, or the whole company lately? You’re not alone. This is a pilot release of our monthly project management digest designed to spread experience of many teams and companies among project/product managers. However, we also believe that it will be useful for everybody working in the IT field.

Topical articles in accordance with your goals

Most popular content

Look thought the most popular articles on project management just to keep up with the latest news in your field of activity.

In the post Epics are dead. Here’s what we should do instead (6 min read) the author makes us think again about epics and describes how he is destroying epics in his Agile practice.
Find out 15 things you should know about product managers (12 min read) to be sure you are ready to interact with them properly.
In the post Data science project flow for startups (20 min read) the author presents and structures the flow of data science projects (mostly for small teams/startups), describes scope & KPIs validation process, shares his experience in running, leading or managing data science projects.
Some tips on managing millennials on project team are provided in the post Millennials: your best resources for project management in the world of NGOs (3 min read).

Most discussed articles

Looking for communication with colleagues instead of dry facts? Join the most intense discussions on topics of interest to you.

3 levels of project quality (Infographic) — the infographic, inspired by a book on project management called “Project-Driven Creation” by Jo Bos, Ernst Harting, and Marlet Hesslelink, sets out the three levels of project quality that you can reach for your deliverables.
In the post Good project managers wear many hats the author describes several roles of project managers. Can you add any?
Monty Hall for projects: to switch or not to switch?. And how would you deal with the Monty Hall Problem in the project management environment? Join the discussion to share your ideas.
Read about project budgeting and contracts in the post Project budgeting: an anti-pattern. An author, a scrum master and agile coach, describes anti-patterns which he meets in many companies over and over again.

Most controversial content

The following group of articles seems to be the most controversial topics on project management and related issues for now. Share your experience and thoughts on them.

The post It’s time for a long, hard look at processes describes the evolution of process as a concept and raises a question: “What should the next edition of the PMBOK Guide look like?”
Read about 9 rules of effective development team meetings and suggest your own opinion and convictions.
Some thoughts on Stand-Up meetings and how we could change them: Time to change how we do Stand-Ups.

Entertainment materials

Feeling tired after a long day of work? Leave the news and controversial articles for tomorrow. Just view the following entertainment materials for fun and relaxation.

Friday humor, no so funny when it really happens: Friday
The post “Your app will be finished on Tuesday.” — which Tuesday?!(7 min read) describes 10 reasons why software development projects fail in a humorous manner and with fun life examples.
A short comix about well-known situation: As soon as possible (ASAP) and some more similar stories.

Choose the most interesting articles by topics

Agile, Scrum, and the best PM practices

The post Design thinking, lean startup and Agile: what is the difference?(3 min read) explains what the terms “Design Thinking”, “Lean Startup” and “Agile” relate to, and how they can be integrated with each other.
Read about Agile development training tips to follow in 2019 to improve your business processes, management, and teamwork.
Find out how to hire right people for your Scrum team in the post 4 things to check out before hiring for your Scrum team. What kind of person do you want?

Time management, KPIs, and productivity

Know whether you’re using story points properly with the post Debunking 4 misconceptions about story points.
Several tips and links to tell you How to double your team’s productivity from Adrian Shepherd, the creator of “The One-Bite Time Management System” (TMS).
There are challenges most companies come across while implementing project management KPIs. In the post 5 challenges in implementing project management KPIs the author explains what these challenges are and how to overcome them.
Do you know the 3 drivers of project Success? Read the post for details or join the discussion to add something.

Teamwork and collaboration

A short article about Training for flexibility and teamwork written by Helen Green, a collaborator, a deadline demon and a diplomat.
“Can’t we just...?” — about teamwork, collaboration, and using the terminology by your teammates.

Managing teams and companies

Still working at office? Make sure you understand all the reasons and advantages of remote work (and know how to manage remote teams) described in the post Top 5 benefits of remote working.
For company owners and team leads, it will be useful to know What the next 20 years will mean for jobs — and how to prepare — make sure you’re looking for the right future workforce.
In the post 6 tips for cutting IT costs the author provides some ways to reduce IT costs for business. “Every business is now a digital business. This doesn’t mean that IT costs must keep rising, however”, he says.

The best resources for project managers

A huge number of novice project managers often ask about good resources and appropriate communities for obtaining experience and sharing knowledge with colleagues. We have compiled such a selection that will be equally interesting to both professionals and novice specialists, and whoever just interested in this area.

General resources

Projectmanagement.com — maybe one of the most large-scale resources with discussions, blogs, huge knowledge base, events, templates, webinars, tools, and all the rest for project managers.
Manager Tools — this website offers free weekly podcasts, contains a forum, and some informational content (events, tools, reviews, links) for project managers.
Agile Alliance — a nonprofit community focused on exploring and applying Agile values, principles, and practices of software development. The website contains a great number of resources (reports, articles, educational materials), upcoming events, news, and a list of community groups around the world.

Currently active PM podcasts

PM Podcast — hosted by Cornelius Fichtner, the podcast already includes 427 (mostly free) episodes for project managers, both beginners and experts. Episodes are usually released weekly (sometimes even more often) and last up to 30 minutes.
5 Minutes Project Management Podcast — 455 episodes (organized into 15 playlists by topics) published by Ricardo Vargas and focused on project, portfolio, and risk management (each 5 to 10 minutes long). Episodes are released at intervals of 1 to 4 weeks.
PM for the Masses Podcast — hosted by Cesar Abeid, the podcast already includes about 118 episodes about general project management concepts, based mostly on interviews with project management and productivity gurus, personal stories of success or failures, and own author’s tips and experience. Episodes last 20-60 minute and are released about once a week.

Author blogs

Joel on Software — the blog includes about 1114 articles about software development, management, and business written by Joel Spolsky, CEO and co-founder of Stack Overflow.
Mountain Goat Software — a lot of posts since 2005 about estimating, main Agile and Scrum concepts, planning, leadership, etc., prepared for product owners, managers, and scrum masters. In addition to blog posts, the website includes presentations, videos, and much more.
The Accidental Product Manager hosted by Dr. Jim Anderson, the blog tells how to develop, launch, and manage products. The author analyzes and interprets examples of project management success and failures from companies around the world, shares own 25+ years experience and practices of applying project management skills to products at different stages of development.

Telegram groups/channels

PrMaB — the channel publishes a great number of actual project management materials (books, articles, reports, events, etc.), mostly in PDF format, as a rule, several posts daily.

Reddit communities

Projectmanagement — the biggest Reddit community dedicated to project management with a focus on the software development area with 17,000+ subscribers and no commercial promotion allowed. The community includes all about PM: discussion, success and failures stories, educational materials, news, etc.
Productivity — a more general community, however, with a lot of useful content for managers: planning and time tracking, communication, co-working, team building, meetings, deadlines, and so on. Open to sharing your views and experience.
Agile — one more community for project managers, scrum masters, and most software development teams in general following Agile principles. A great number of subscribers makes it a good place to ask questions and share your experience in Agile, Scrum, Extreme Programming, Lean, Kanban, etc.

Dev.to communities

At Dev.to posts are written by many different authors around the world that makes them quite diverse and frequent.

For example, the Productivity content includes posts about holding effective meetings, ways of improving team productivity, open source time tracking software, and much more things not only for project managers, but also for the whole software development team.
Posts about Agile, Startups, Leadership, and Management will be interesting for project and product managers, team leads, product owners, and entrepreneurs.
The Softskills, Teamwork and Team topics will be useful for a wider audience, including articles about time estimation, communication with the team, managers and customers, problems with deadlines, etc.

Medium publications

Take a look at the Startup publication designed for product owners, managers, team leads, and all other software development enthusiasts. A wide range of topics includes collaboration, time management, communication with customers, software development, and much more.
ProductCoalition — the world’s largest free product management community with 2,000+ articles, 300+ writers, and 2,700+ members in their Slack community.
Entrepreneurs Handbook — another popular Medium publication about startups, entrepreneurship processes, tech innovations, and management with frequent updates and many authors.

Have something to share?

Are there any particular challenges you’ve faced on your own? Or opinions you’d like to address to the community? Feel free to share your own blog posts with us and we’ll add the most valuable articles in the next digest. Or you can do it directly in the comments.

Let’s make this digest better

What other content and resources you’d like to see here? Please share your favorite communities and thoughts in the comments or write to us directly. We’d like to make this digest better with your help. Do not be limited to typical project management topics and feel free to suggest any new ones.

Who we are and why we’re writing here

We’re a software development team with own, mostly successful, experience in project and remote team management. However, this is only a drop in the ocean compared with the experience of thousands of teams and companies around the world. Therefore, we prefer to collect and summarize existing examples and mistakes instead of imposing our own views on you. We definitely won’t tell you about our projects, and much less promote something here. However, you can share your own projects with us and own readers as examples of your success stories, instructive or fun experiences, and innovative ideas.

We hope you’ve found something interesting here. If so, we will appreciate if you subscribe and share the post with your colleagues. Wait for more resources and articles in the next digest in a month.

Cursed custom selects

Alexey Osipenko — Tue, 18 Sep 2018 11:32:46 +0000

When a design requires something special from inputs, layout designers crouch in the twine and do pretty crazy things, like an image inside the input, but still leave the tag <input> on the page. However, if suddenly it comes to styles of a drop-down list, the tag <select> along with a set of <option> tags go to the dump, and then <div> and javascript appear to take their place. Well, you are not allowed to customize selects in browsers even with the latest html/css, and that's very sad!

A traditional select is awesome, it is opened with "Cmd+down", closed with "Esc", it supports search (just open a select and start typing), and nothing of this, as a rule, cannot be done by all your custom selects. Just because a design developer, working on this component, has not gotten around to that yet.

Of course, there are some successful solutions, for example, custom selects from bootstrap, jQuery, and similar and famous React.js component. But even in these cases the number of leaky abstractions is not zero, but simply less than in other analogs. If you think that you know an example that proves the opposite, where a set of divs behaves exactly the same as an original select and no abstraction leaks, then you should immediately remember about autocomplete of forms in browsers or about long drop-down lists and low browser windows.

By the way, when browsers were young Internet Explorer only dreamed of the seventh version and Chrome did not exist at all, the selects were even more independent. Some browsers, apparently due to some internal limitations, refused to implement drop-down lists in standard ways and tricks were used instead. Such clumsy unpolished heavy kludges. There could be no question of additional styles for selects at all, there were much more serious problems. For example, no div with an absolute position and an increased z-index could have select-input components inside just because a drop-down list was not a part of the document. All selects were rendered separately from the whole document and, in fact, atop of the document. If you suddenly wanted to create something like a modal window, then with help of an extra javascript code you could apply such a ninja trick: while opening any modal div-element, all drop-down lists on the page were updated with visibility: hidden. You could also notice on slow computers that calculation of the select's position were lagged a little behind when scrolling a page. Select calculated its position a bit later than a page itself did that, and moved with a slight delay.

Currently we're working on custom selects.

In that one, which is "multi", I still tried to implement a proper work with a keyboard, but I dumped it when it came to a usual select. If you try to copy the behavior of a native element, you can waste a week, while nobody ever estimates a div with a text and another div with a drop-down list at a whole week.

And you should not forget about custom selects on mobile devices. This is a separate pain for the user, and native selects are completely different anything else, take, at least, those iOS "drums". And, surely, the user won't be delighted with custom designer's garbage.

Another interesting idea is of the evolution of native controls. Take, for example, the scrollbars. In the past, we had bags and bags of libraries implementing custom scrollbars. And if at that time a designer could not resist the temptation to add a little beauty to his creation, now his scroll, no matter how cool it was before, will look pretty dull against the backdrop of neat, sometimes even self-removing in passive state native scrolls. Of course, no design lives for so long, but it's great to always keep in mind the possibility of browser evolution when working on a design.

SQL tests in your smart framework

Alexey Osipenko — Mon, 10 Sep 2018 06:55:09 +0000

Many complain that sql-code, in one form or another, becomes unsupported very quickly and, in fact, it is not even worth starting to write any logic in sql. "Use sql only as tables, and implement all the logic inside the code", they say not entirely without some slyness at the same time.

Well, tell me, some specific data types are nevertheless permissible in sql, aren't they? For example, is it considered shameful to use enum instead of string, or it is still acceptably? It seems to be permitted even in the eyes of ardent defenders of code purity. And what about using of a floating point numbers of certain accuracy (precision and scale) - is it still eligible? Or reasonable default values like created_at timestamp without time zone DEFAULT CURRENT_TIMESTAMP, we are allowed to use them so far, right?

If answers for all questions above are positive, then most likely we can also add data validation to be sure that the format of, say, a string is met. We mean, for example, checking the format of the email address, absence of dangerous characters in fields-identifiers of the address bar (slug or uid), or even validation of uniqueness in a specific subset of records (scope).

And then it's a short road to stored procedures. Let's say, you have a 'name' field, and you want to make sure that the value of this field is unique without matching case. It's a typical task, right? Traditional MVP-frameworks say that verification should be done in advance, like SELECT 1 FROM table_name WHERE lower(name) = $1, and if a record is present, then saving process mustn't even be started. A database, as a concept, tells us that it should be checked at the time of recording. In some cases constraints on tables come to our rescue, in others we can apply rules and triggers. In general, it would be much more convenient to do that with a database, except, support of the written code becomes more complicated.

In our project riter.co we came up with some simple rules, adhering to which you can worry about sql-code no more than about some other piece of your project, for example javascript-code or css-rules.

It is necessary to clearly distinguish cases when you create a rule, a trigger, and a constraint. Rules should be better defined on your own in a separate project, but anyway you will certainly follow some priority of creation. Like, if it is possible to create a constraint, then create a constraint. If not, you should create a rule. As a last resort, if even a rule is not suitable in your case, that use a trigger.
Standards for naming triggers and rules. If you want to create some sort of a trigger on the table, the name must be uniquely defined. I propose to begin thinking about this naming rule with "#{table_name}_#{affected_colum_name}_#{verb}_on_#{action}". You will get something like "companies_subdomain_lowercase_on_insert". In addition, then it will be much easier to find existing rules with the mask:

  SELECT routine_name AS name
  FROM information_schema.routines
  WHERE
    routine_name LIKE 'companies_%_on_insert' AND
    routine_type ='FUNCTION' AND
    specific_schema='public';

KISS. All procedures in your database must be simple. Complex things result in complex bugs, and bugs at the level of the database are quite scary. Let's keep them simple. It is better to leave complicated logic to high-level programming languages with their frameworks. For example, we can convert everything to a lowercase or generate a unique identifier inside the database, but when it is about checking the intersection of time intervals, it is better, probably, to do that in the code.
Tests. Actually, the entire post is written for the sake of this point, and all that is said above is more like a preamble.

Tests should be presented in three ways, as always: integration, unit and acceptance.

Unit-tests have much less sense and in the overwhelming majority they must be written in a high-level code. It's a good practice to write unit tests for some single procedures independent of the current state of the database. For example, we have such a procedure that looks very nice in the context of unit tests:

CREATE FUNCTION public.generate_slug(slug character varying, table_name character varying) RETURNS character varying
    LANGUAGE plpgsql
    AS $$
      DECLARE
        key varchar;
        query text;
        found varchar;
      BEGIN
        query := 'SELECT slug FROM ' || quote_ident(table_name) || ' WHERE slug = ';
        key := slug;

        EXECUTE query || quote_literal(slug) INTO found;

          WHILE found IS NOT NULL LOOP
            key := encode(gen_random_bytes(5), 'base64');
            key := replace(key, '/', '-');
            key := replace(key, '+', '-');
            key := replace(key, '=', '');
            key := slug || '-' || key;

            EXECUTE query || quote_literal(key) INTO found;
          END LOOP;

        RETURN key;
      END;
      $$;

By and large, it's impossible to implement a full mock and stub, so real unit-tests can not be written either.

Integration tests should be written in the language of the framework chosen for the project, and they must check that all your sql-triggers' actions are reflected in the objects and structures of your program. For example:

subject { create(:company, name: 'CamelCase') }
its(:name) { is_expected.to eq('camelcase') }

Firstly, it will check the properly working RETURNING name. Secondly, it will test work of your framework and its willingness to cooperate with the database. For example, if your framework is ready to monitor the correctness of data in some fields, then such tests can reveal a conflict and it can be resolved in time.

What about acceptance-tests, that's where things get interesting. After all, it really does not matter what exactly makes all letters from the name field lowercase, whether triggers, or rules. It is much more important to be convinced of the results.

First, you need to agree on the structure. We have considered several options and reached the most reasonable one - for each individual test we create a separate function, then we call it and check the return value. Of course, we want these tests to run along with all the other tests, so we use a small wrapper with our frameworks.

Here's the test itself:

it { expect(ApplicationRecord.connection.execute("SELECT #{f.function_name}()").to_a.first[f.function_name]).to eq('ok') }

It's terribly simple, isn't it? Certainly, before running the test, you need to create this function. We do this right before the test:

before do
  ApplicationRecord.connection.execute("CREATE OR REPLACE FUNCTION #{f.function_name}() RETURNS varchar LANGUAGE plpgsql AS $$ #{f.content} $$;")
end

And after the test we immediately delete the function:

after do
  ApplicationRecord.connection.execute("DROP FUNCTION IF EXISTS #{f.function_name}()")
rescue ActiveRecord::StatementInvalid
  nil
end

Now about content of this function. The most convenient solution is to keep the content in separate files with the .sql extension and read it before creating the sql-function:

    Dir[File.expand_path('**/*_spec.sql', __dir__)].map do |path|
      content = IO.read(path).strip
      basename = Pathname.new(path)
                         .relative_path_from(Rails.root.join('spec', 'sql'))
                         .to_s
                         .gsub('/', '__')
                         .gsub(/_spec.sql\z/, '')
      OpenStruct.new(path: path.to_s, content: content, empty?: content.empty?, basename: basename, function_name: "rspec_#{basename}")
    end

A name of the function, that is function_name, can be generated from the file name with some authentic prefix, so that you could distinguish test-function from all other functions. Then you will be able to make sure that there is nothing superfluous left in the database once more before and after running all the tests:

DO $$
DECLARE
  routine record;
BEGIN
  FOR routine IN
    SELECT routine_name AS name
    FROM information_schema.routines
    WHERE
      routine_name LIKE 'rspec_%' AND
      routine_type ='FUNCTION' AND
      specific_schema='public'
  LOOP
    EXECUTE 'DROP FUNCTION ' || quote_ident(routine.name);
  END LOOP;
END $$ LANGUAGE plpgsql;

And the test itself is a matter of technique. Here is, for example, a separately saved company_name_spec.sql, which will check the uniqueness of the name field in the companies table.

DECLARE
  company_name companies.name%TYPE;
BEGIN

  INSERT INTO companies (name) VALUES ('qwe1') RETURNING name INTO company_name;
  ASSERT company_name = 'qwe1', 'companies.name is allowed to be a string';

  BEGIN
    INSERT INTO companies (name) VALUES ('qwe1') RETURNING name INTO company_name;
    ASSERT FALSE, 'companies.name should raise unique violation';
  EXCEPTION
    WHEN unique_violation THEN
      ASSERT TRUE;
  END;

  RETURN 'ok';
END;

Instead of conclusions, I would like to say that an intelligent database is the very place that must be thoroughly covered with tests. And leave your excuses in the past, now you know how to write them.

SQL on Rails concept

Alexey Osipenko — Mon, 30 Jul 2018 08:05:58 +0000

First of all, this article is not about how much I love Rails. And secondly, it is not about how I hate it. We can treat Rails quite differently and it will become better only if we change something. But also, Rails can get worse just if we try to make corrections to it. Well, anyway, you've been warned and I hope you got me.

One of the basic concepts of ActiveRecord is that the database is quite utilitarian in nature and can be easily modified. So, there you are sitting and writing your models for MySQL, and suddenly you find out somewhere that it's that simple to just up and replace MySQL with MongoDB. Well, not so drastically, but, say, you may have reasons to replace MySQL with PostgreSQL. Or vice versa, I have nothing against MySQL.

And here ActiveRecord claims to come in handy, since supposedly it's a piece of cake for it. After all, scopes, before/after filters and associations are abstract enough not to worry about generating queries on databases and focus just on the logic of the application. Instead of writing WHERE is_archived = TRUE, you can easily write where(is_archived: true) and ActiveRecord will do the rest for you.

But it's not really as simple as all that! In practice, it turns out that this layer of abstraction is full of gaps, like a broken trough from the tale of the Golden Fish. And that many basic features can not be used, like comparing dates or working with arrays. And we have got scopes with forced where("#{quoted_table_name}.finished_at >= ?", Date.current) or where("#{quoted_table_name}.other_ids <@ ARRAY[?]", ids). To which ActiveRecord gives a completely conscious and expected answer: do not use this. Instead of arrays, use habtm-association, and if you need to compare dates, accept this. And God forbid, you miss quoted_table_name in such a scope - the first includes or joins will put everything in its place. It's easier to add them wherever and whenever possible, so that you do not lose the skill.

And, of course, once you decide on such an interference in the work of ActiveRecord, there's no going back. Not only chances, but also a vague hope for a painless transition to another database will be gone. It will be much better to print this code out and burn it. And surely, there is no other reason not to use extra-database capabilities in your application. You're welcome to use and make everybody do!

And when it turns out that use of extra-opportunities is more than half of your scopes in the models folder, it will be quite obvious that ActiveRecord is just a convenient wrapper for integrating one labeled piece of code with another piece of code. And scopes like where(is_archived: true).joins(:sprint).merge(Sprint.archived) will work fine and their combining won't be much more difficult than cooking eggs, will it?

The next stage is denormalization. Of course, denormalization has always been and has not disappeared anywhere, but taking care of it was placed on mighty shoulders of Rails and ActiveRecord, and you know, that these two guys don't suffer from excessive lightness and ascetic in their resource requirements. Let's say, counter_cache: true is the first step to denormalization, after all, ActiveRecord won't let you just do COUNT(*) AS sprints_count so easily (I mean, you're not going to use select method, are you?). And counter_cache is far from ideal and in some cases there may be a desynchronization of the real quantity from the cached one. Not critical, of course, but unpleasant. And this is only the first candidate to settle in the database and not load the already burden head of the Ruby machine. Just a couple of triggers and it's done! When deleting and adding an entry to the A-table, you need to recalculate the number of records in the B-table and that's all, right? And, of course, you do the same when editing an entry if foreign_key has been changed, so as the request UPDATE B SET a_id = $1 WHERE id = $2 will break counter_cache down both for the old and new tables.

  CREATE OR REPLACE FUNCTION update_#{parent_table}_#{child_table}_counter_on_insert() RETURNS TRIGGER AS $$
  BEGIN
    UPDATE #{parent_table} SET #{counter_column} = COALESCE((SELECT COUNT(id) FROM #{child_table} GROUP BY #{foreign_column} HAVING #{foreign_column} = NEW.#{foreign_column}), 0) WHERE (#{parent_table}.id = NEW.#{foreign_column});
    RETURN NULL;
  END;
  $$ LANGUAGE plpgsql;

The next piece of work with a database will be related to the date-time. First, let the created_at and updated_at fields be serviced in the database itself, fortunately, it's much simpler. Primarily, let's set default values:

change_column_default :table_name, :created_at, -> { 'CURRENT_TIMESTAMP' }
change_column_default :table_name, :updated_at, -> { 'CURRENT_TIMESTAMP' }

And to do this everywhere at once, we can organize a cycle throughout all tables, where these fields are present. Except of the schema_migrations and ar_internal_metadata tables, certainly:

(tables - %w(schema_migrations ar_internal_metadata)).each { ... }

That's all, now the default values for these tables will be exactly the same as we need. And now it's time to make sure that Rails won't touch these fields. There is an option in the configuration of the framework, which is responsible for this:

Rails.application.config.active_record.record_timestamps = false

So, the next step is to change the updated_at field when a record is changed. That's simple:

CREATE OR REPLACE FUNCTION touch_for_#{table_name}_on_update() RETURNS TRIGGER AS $$
  BEGIN
    SELECT CURRENT_TIMESTAMP INTO NEW.updated_at;
    RETURN NEW;
  END;
  $$ LANGUAGE plpgsql;

Now we need to completely get rid of touch: true in models. This thing is very similar to the target in the shooting gallery - it's also completely leaky. And I won't even explain why, because you already know all these cases. This is not much more difficult, you just need to update updated_at where necessary:

CREATE OR REPLACE FUNCTION touch_for_#{table_name}_on_update() RETURNS TRIGGER AS $$
  BEGIN
    UPDATE foreign_table_name SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.foreign_column_name;
    SELECT CURRENT_TIMESTAMP INTO NEW.updated_at;
    RETURN NEW;
  END;
  $$ LANGUAGE plpgsql;

Of course, the sequence of calls of such triggers will cause extra actions, but Postgres doesn't provide any sane mechanism to call triggers without changing the record itself. You could try to write SET title = title but this is hardly ever better than SET updated_at = CURRENT_TIMESTAMP.

Exactly the same trigger serves for insertion, just update_at is not necessary:

CREATE OR REPLACE FUNCTION touch_for_#{table_name}_on_insert() RETURNS TRIGGER AS $$
  BEGIN
    UPDATE foreign_table_name SET updated_at = CURRENT_TIMESTAMP WHERE id = NEW.foreign_column_name;
    RETURN NEW;
  END;
  $$ LANGUAGE plpgsql;

Certainly, you could try to write this with one function by adding a check on the current event directly into the trigger like IF TG_OP = 'UPDATE' THEN, but it is preferable to make all triggers as simple as possible, in order to reduce the probability of error.

You might want to somehow automate the generation of such triggers, and then you will most likely need to find all foreign relations between the current table and the rest ones. Here you can easily do that with this request:

SELECT ccu.table_name AS foreign_table_name, kcu.column_name AS column_name
  FROM information_schema.table_constraints AS tc
    JOIN information_schema.key_column_usage AS kcu
    ON tc.constraint_name = kcu.constraint_name
    JOIN information_schema.constraint_column_usage AS ccu
    ON ccu.constraint_name = tc.constraint_name
  WHERE constraint_type = 'FOREIGN KEY' AND tc.table_name = '#{table_name}'
  ORDER BY ccu.table_name;

One more very useful tip. Name all triggers from a template to be able to verify the presence or absence of a required trigger with a single request. For example, this query will find all touch-insert triggers:

SELECT routine_name AS name
  FROM information_schema.routines
  WHERE
    routine_name LIKE 'touch_for_%_on_insert' AND
    routine_type ='FUNCTION' AND
    specific_schema='public';

And the last thing left is the most terrible. The fact is that Rails is not designed for at least a marginally smart database and it definitely doesn't care that something can be changed there, except ID-field, and even then only when inserting data into the table. Therefore, there is no sane way to add RETURNING id, updated_at to update-queries, you will need to dive headlong into Rails thicket.

Monkey patch turned out not so much neat, but primarily the goal was to minimize contravention of the current work of the framework as much as possible. Here's how it looks in the end:

module ActiveRecord
  module Persistence
    # https://github.com/rails/rails/blob/v5.2.0/activerecord/lib/active_record/persistence.rb#L729-L741
    def _create_record(attribute_names = self.attribute_names)
      attribute_names &= self.class.column_names
      attributes_values = attributes_with_values_for_create(attribute_names)

      an_id, *affected_rows = self.class._insert_record(attributes_values).dup
      self.id ||= an_id if self.class.primary_key
      Hash[ApplicationRecord.custom_returning_columns(self.class.quoted_table_name, :create).take(affected_rows.size).zip(affected_rows)].each do |column_name, value|
        public_send("#{column_name}=", self.class.attribute_types[column_name.to_s].deserialize(value)) if value
      end

      @new_record = false

      yield(self) if block_given?

      id
    end
    private :_create_record

    # https://github.com/rails/rails/blob/v5.2.0/activerecord/lib/active_record/persistence.rb#L710-L725
    def _update_record(attribute_names = self.attribute_names)
      attribute_names &= self.class.column_names
      attribute_names = attributes_for_update(attribute_names)

      if attribute_names.empty?
        affected_rows = []
        @_trigger_update_callback = true
      else
        affected_rows = _update_row(attribute_names)
        @_trigger_update_callback = affected_rows.any?
      end

      Hash[ApplicationRecord.custom_returning_columns(self.class.quoted_table_name, :update).take(affected_rows.size).zip(affected_rows)].each do |column_name, value|
        public_send("#{column_name}=", self.class.attribute_types[column_name.to_s].deserialize(value))
      end

      yield(self) if block_given?

      affected_rows.none? ? 0 : 1
    end
    private :_update_record
  end

  module ConnectionAdapters
    module PostgreSQL
      module DatabaseStatements
        # https://github.com/rails/rails/blob/v5.2.0/activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb#L93-L96
        def exec_update(sql, name = nil, binds = [])
          execute_and_clear(sql_with_returning(sql), name, binds) { |result| Array.wrap(result.values.first) }
        end

        # https://github.com/rails/rails/blob/v5.2.0/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb#L147-L152
        def insert(arel, name = nil, pk = nil, _id_value = nil, sequence_name = nil, binds = [])
          sql, binds = to_sql_and_binds(arel, binds)
          exec_insert(sql, name, binds, pk, sequence_name).rows.first
        end
        alias create insert

        # https://github.com/rails/rails/blob/v5.2.0/activerecord/lib/active_record/connection_adapters/postgresql/database_statements.rb#L98-L111
        def sql_for_insert(sql, pk, id_value, sequence_name, binds) # :nodoc:
          table_ref = extract_table_ref_from_insert_sql(sql)
          if pk.nil?
            # Extract the table from the insert sql. Yuck.
            pk = primary_key(table_ref) if table_ref
          end

          returning_columns = quote_returning_column_names(table_ref, pk, :create)
          if returning_columns.any?
            sql = "#{sql} RETURNING #{returning_columns.join(', ')}"
          end

          super
        end

        # No source in original repo
        def quote_returning_column_names(table_ref, pk, action)
          returning_columns = []
          returning_columns << pk if suppress_composite_primary_key(pk)
          returning_columns += ApplicationRecord.custom_returning_columns(table_ref, action)
          returning_columns.map { |column| quote_column_name(column) }
        end

        # No source in original repo
        def sql_with_returning(sql)
          table_ref = extract_table_ref_from_update_sql(sql)

          returning_columns = quote_returning_column_names(table_ref, nil, :update)

          return sql if returning_columns.blank?
          "#{sql} RETURNING #{returning_columns.join(', ')}"
        end

        # No source in original repo
        def extract_table_ref_from_update_sql(sql)
          sql[/update\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*set/im]
          Regexp.last_match(1)&.strip
        end
      end
    end
  end
end

The most important thing is that here we turn to ApplicationRecord.custom_returning_columns to find out which columns, besides id, we are interested in. And this method looks something like this:

class << self
    def custom_returning_columns(table_ref, action)
      return [] if ['"schema_migrations"', '"ar_internal_metadata"'].include?(table_ref)

      res = []
      res << :created_at if action == :create
      res << :updated_at

      res += case table_ref
             when '"user_applications"'
               [:api_token]
             when '"users"'
               [:session_salt, :password_changed_at]
             # ...
             else
               []
             end

      res
    end
  end

All examples are given for PostgreSQL, not for MySQL, so MySQL followers will have to reinvent their own wheel.

Instead of conclusions, we could say that now the aching Rails's head will hurt a little less. Such routine processes as counter_cache and touch are going to sink into oblivion, and the next article will be focused on something more global, like removing hanging spaces, validating data, cascade data deletion, or paranoid removal and rspec for sql. If this article proves to be interesting, of course.