Is there a reason you all want to be notified when someone captures certain codes?

Question

I know there are things like manual checking to make sure that the perfect codes are fundamentally correct. But other than that? The reason I'm asking about is because there are so many daily transactions in a large project.

Answer 1

Generally speaking, commit notifications are useful, so you have an idea of ​​what happens in the code on a daily basis. For example, I know when a new function was added or bug fixes were fixed. If there are so many commits that it gets lost in the noise, then it may be necessary to filter out or reduce the number of commit messages that you see (maybe you can limit it only to the specific modules you are working on, for example).

Speaking of this, in addition to giving other developers the opportunity to at least easily view the code, it can also notify people that:

• A good time to start the update from the original control and merge any new changes if necessary
• Hey, someone found a regex regular expression error in Foo, but forgot to update Bar with it.
• Oh Bob working on the Baz module, I have to ask him to take a look at this too.

You get the idea. In principle, this was intended to promote transparency throughout the group, not just to focus more on fixation, but to improve the development cycle for the team as a whole.

Answer 2

This can be useful if someone makes a change to one or more programs that you can work on yourself. If you want, you can decide what conflicts may be required for further communication.

I saw a situation where Programmer A made some changes, and then went on vacation in a couple of days. Programmer B also worked on the same programs, and at that time there were some conflicts that Programmer B went into to make his changes. This is usually not a biggie, plus communication should always remain open between team members. In this case, programmer B had some questions about the changes made by programmer A, but he had to wait a week until this programmer returned. In this situation, it would be useful to get an email address, even auto-generated.

Just my two cents.

Answer 3

Many of the things mentioned above are useful when receiving verification notifications. I usually use it for several things:

• If the project somehow breaks down, sometimes I can push off the problem more quickly, because I am aware of the checks that have entered the system. This may indicate a solution faster.
• It provides an easy-to-see set of checks (at least because I receive them by email). Yes, your version control system has all this information, but it may not be easy to find the whole comment. With email, it’s quite trivial for me to go back and look for the user, module, keyword, etc., And Outlook overwhelms the corresponding letters.
• I can easily track young developers and what they do. This gives me the opportunity to see when they check the code and what they do with the code. This provides a permanent chance for a mentor outside of other regularly scheduled events, such as code reviews.
• This enables the team to track progress and consider when they can check for conflicts.

Even if there are many notifications, I don’t feel that they need to be read in full. I look through a bunch of them, but that's enough to get me back to the appropriate commits when I need more information.

Answer 4

Of course, you need to look into the code that you get into, so you have an idea of ​​what other people in your team are doing, and you are not stuck in a cave, just writing down your code.

Even if you do not control the quality code, you can understand that other people are working.

This helps to assemble a team.

Answer 5

I find this primarily useful for tracking. In general, such automatic notifications are filtered out in a bucket in my mail program, as well as with a message like "smoketest passed, smoketest failed" ... then when a failure occurs, you can easily track it to a set of checks.

Note that you can also realize the maturity of the project in the form of a check curve - the number of lines of code changed per day as a function of the total size of the code base. Actually it gives a reasonable idea of ​​when you are going to “do” ...

Hope this helps!

Answer 6

Usually we have updates that let everyone know that something is updated and needs to be checked by experts. If you do not need to assign one user, you can get it and deal with it when you have time.

I saw someone post a system that sends Twitter style messages to Yammer when they commit for a quick and easy “change” in the code style comment journal. Well maintained. I can not find the link now.

Answer 7

In many companies, code reviews are mandatory, but performed in the honor system. Email notifications of commit implement the “trust but verify” mechanism for these environments.

Answer 8

I use it mainly for measuring the heart rate of a project. Each commit message is an impulse. Over time, you get an idea of ​​how a “normal” impulse sounds.

On a typical day, we get 4 to 6 commit messages. This slows down to 1 or 2 as the iteration date expires and stops about a couple of days before the iteration is issued. A day or two after the iteration, it starts collecting again, and if errors are found, we can get 1 commit message per hour when the errors are fixed. A typical day with few commits may mean that it is difficult for the developer to perform certain functions or spend too much time on stackoverflow.

I also find that messages with informative messages are very useful. Sometimes a manager or tester does not even need to ask the developers for the status of a function or error - just look at the commit messages to see if there is any work on it.

Answer 9

My understanding is that the main reason for CCI compiling reports for developers is to avoid conflict: you see the commit of the file you are working with, so you know that you have problems, even before you make a deal. However, this is quite distracting, so there are tools (e.g. Palantir, old IBM Jazz) that will actually show you which files are being edited at the same time.