What to store?

[+] All source code files

[+] All resources necessary for compilation

[+] project compilation settings

[-] project settings in the IDE

[-] files compiled from source

[-] executable files

Deleting from index

git rm filename

A commit may contain changes to multiple files

When to commit?

  • When I completed a small task
  • If the problem is large – divide into logical subparts
  • The code must be operational!

View History

git log

Revision Number = SHA-1 Change Hash

Switch to audit

Branches

A branch is a sequence of commits in which is parallel development of a functional.

Main branch – master

Branches in GIT

Show all branches existing in the repository

Create branch

Switch to branch

There should be no unsaved changes at this time.

Create a branch and switch to it

Merge Branches

Merge branches – the process of integrating changes (commits) from one branch to another:

b1 – branch to which we add changes

b2 – branch from which we add changes

View History

Window Utilities:

  • gitg
  • gitk
  • gitx
  • gitKraken

Delete branches

Delete branch

DELETE branch

Or rather, delete the branch without waiting for the commits to move to master

Unsaved change buffer

Or “what to do if you need to switch to another branch, and commit early?”

Write changes to the temporary buffer

Extract these changes from the buffer

Useful links:

git-scm.com/book/en/v2

githowto.com/ru

en.wikipedia.org/wiki/version_system

Team development

So, if you got to this line, it means you at least a little bit figured out what git is (I really hope so). But what about team development? Let’s look at this issue in more detail.

A little humorous puzzle:

Given:

  • N developers
  • Workplaces
  • Terms of Reference (TOR)
  • the Internet

Question:

How to carry out a project without attracting the attention of management?

Answer:

Well-coordinated team and hard work

Hmm, what is a team in general? What is it like?

A team is a small number of people:

  • with complementary skills (someone is programming, someone is designing, etc.)
  • aspiring to common goals (they all need to fulfill the task of the customer in order to get complete self-satisfaction)
  • sharing responsibility for achieving the project goal (if suddenly one of the team members has a difficulty with his personal task, his teammates will always come to help (this should not be abused, otherwise you will simply be unnecessary for the team)).

A very important note: in the team you should feel absolutely comfortable and try to get along with the whole team, otherwise everything may go wrong.

So, now you understand what a team is. But the next question that arises in your head (yes, yes, the authors of this article can read minds): “And who is responsible for what is in the team? Does everyone have their own place? Or is everyone doing what they want? ”

Naturally, each participant in the team has its own role and its own tasks. Indeed, instead of developing a product, there would be chaos. Let’s look at what roles are in command programming:

Team Leader

Team Leader is a cross between a project manager and a qualified developer.

There are two lead roles on projects: managerial – PM, and technical – System Architect. Team leader partly fulfills both roles, but the focus of his responsibilities is on management.

Rule for a Team Lead # 1: Care for Your Team. The team should feel comfortable in the working environment and be well motivated. In addition, the team leader also provides professional and career growth for his children, regularly holds discussions on the topic where people are interested in developing, and helps them in this. ”

The managerial role of the team leader includes such responsibilities as management, allocation and delegation of tasks, all kinds of evaluations and scheduling, monitoring the status of the project, as well as meetings, communication with the customer, management and all team members (developers, testers, managers).

Under the technical role: participation in the writing of technical documentation, selection of technologies for the project, architecture development, R&D, code review, mentoring of juniors, conducting technical interviews, competent involvement of new team members in the work process, responsibility for the technical part of the project.

A typical team lead’s working day includes:

  • consideration of new tasks and their distribution
  • stand-up with a team
  • meetings
  • programming
  • architectural issues
  • code review

Project manager

Project Manager is a specialist whose main task is to manage the project as a whole: designing and prioritizing, scheduling tasks, monitoring, communication, and quickly solving problems.

PM’s primary responsibility is to bring the customer’s idea to production on time using existing resources. As part of this task, PM’s need to build a development plan, organize a team, set up a project workflow, provide feedback between teams and the customer, eliminate interference for teams, control the quality and delivery of the product on time.

PM’s objectives can be classified as tactical and strategic. Tactical – this is the solution to the everyday problems of the project, the removal of obstacles from the team. The strategic ones are to coordinate the overall goal of the project, the path to it, as well as the speed of movement.

“The main goal statement for PM’s is:“ We need this to work, ”which implies that the team will deliver results in a reasonable amount of time with a reasonable level of quality.”

Tester

A tester is a specialist who is engaged in testing a software product in order to identify errors in its work and their subsequent correction.

The main duties of the tester:

  • Quality control of developed products.
  • Identification and analysis of errors and problems encountered by users when working with software products.
  • Development of autotests and their regular run.
  • Testing script development.
  • Documenting defects found.

Developers

Junior

Junior is an entry-level developer.

After completing an internship, a person turns into a full-fledged junior. The main requirement for him is the ability to independently perform technical tasks. If a project is built in architecture, he should immediately implement another piece of the typical application logic. Although Junior may make mistakes from time to time, do not understand the nuances, discuss implementation plans with team leader or check the finished code with him.

You need to understand that for the tasks that the Senior will solve in ten minutes, the June may need three approaches each hour, and in the process, the code will have to be completely rewritten, spending a lot of additional energy. It is important not to be afraid of this and feel the balance: when to push, trying to solve the problem on your own, and when, on the contrary, stop banging your forehead against the wall, burning the project time, and ask for help. Justifying your lack of performance with the phrase “I’m still Junior” is a bad idea.

Middle

Middle is a mid-level developer.

The main requirement for a middle developer is the ability to independently carry out the tasks assigned to him. Very similar to what was written in the previous paragraph, right? However, there is an important nuance – the word “technical” is missing here. It means, at a new level, you need to understand the requirements of the business and be able to translate them into technical solutions.

Thus:

The middle developer understands what the application is doing. This allows you to better understand the task, and, therefore, more accurately evaluate it and better implement it. If the requirements do not completely cover a scenario, a good developer will pay attention to this at the planning stage. And not when the application starts to crash at any non-standard user action.

The middle-developer is familiar with standard templates and solutions when building an application in his field, understands why they are needed, and knows how to apply them. Standardization of decisions is of great importance in the collective development of code, because it allows a new person to quickly figure out what’s what and minimizes the number of errors. Understanding the structure of a typical application makes the task of building it from scratch quite trivial, allows you to talk about the principles of proper implementation and to distinguish good code from bad.

Middle-developer understands that not only he one works. He knows how to interact with other team members: he can discuss a difficult moment with a designer, clarify incomplete requirements with a business analyst or coordinate some important technical solution with the project architect (if any) and, of course, owns the appropriate tools for team development.

Senior

Senior is a high-level developer who has seen a lot of code and managed to draw the right conclusions from this. Senior’s main task is to make the right technological decisions in the project. The “right ones” are those that maximize business benefits and minimize costs. A good senior not only understands what the team is developing, but thinks about what tasks the finished application should solve. Developing a site for the auction, the Senior always wonders about the peak load and tries to foresee attempts to competitively write to the database tables. He thinks in advance about the bottlenecks of the system, about the possibility of scaling it, remembers the vulnerabilities and problems caused by the improper use of tools.

Such a specialist does an amazing thing – solves problems even before they appear. From the outside, it resembles the gift of foresight. But if your project lives from fire to fire, and you constantly have to throw out and rewrite pieces of code – these are symptoms that the project receives insufficient signatory attention.

Designer

A designer is a person who designs. Logically, isn’t it?

Designer’s work begins long before the first pixel appears, and ends much later than the last.

Most people are used to believing that design is actually a set of pictures, colors and fonts that are passed on to layout designers and programmers to make a product. Sometimes this approach works, but more often it turns out to be a project, which is then embarrassing to add to the portfolio.

The fact is that to solve the problem it is not enough to draw a picture. In the process, a good designer goes through 4 steps. Here they are:

Understanding the problem

The work begins with an understanding of the problem, like a theater with a hanger: until you give up your outer clothing, you won’t go any further. If you do not delve into the problem, you will get a non-viable product.

Search for a solution

When the problem is clear, it’s time to look for a solution. In established terms, these are all sorts of sketches and prototypes that help to build a preliminary vision of the final product.

Description

This is just drawing pictures and selecting fonts. Many designers start from here and immediately finish the work, and the results of the work of such designers can be seen in large numbers at Dribble or Behance.

Matching

Even if you have an elegant solution in your head and on paper, this does not mean that for the client it will look the same. If you omit this stage and simply give the client the best practices, then at best they will be redone according to their own understanding. What will eventually remain after the client edits will be a little like your work.

Well, now, finally, you are familiar with all the positions in team development. Here I have listed only those positions that are related to programming. If we consider the development of a software product as a business project, then of course there will be added more roles, for example, accountants, marketers, etc.

Conclusion

Well, if you read up to this point – congratulations, you’re incredibly cool! No, really, you haven’t got your brain boiling with so much information? I hope no.

So, I hope our article helped you understand all the intricacies of team development. And you have no questions left on this topic. And when you come to a super-duper-unreal-cool-and-famous company and you will be hired (if only they try not to accept), then you will not be confused and show your boss who the main programmer is. Or maybe you will create your own company, who knows 😉