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 😉