На что обратить внимание новичкам - разработчикам: открытость, коммуникации, задачи, git, команда

Main ideas / lessons for beginner developers

• Set expectations quickly when joining a team

  • A new developer must quickly understand the team’s existing expectations and processes so work can continue smoothly.
  • Note that team members (PM/mentor/seniors) also need to understand the newcomer’s status and availability.

• Practice “healthy openness” in team communication

  • Team communication is largely done through project chats (including mentoring-related chats).
  • A newcomer should:
    • Warn promptly if something affects work (sick/need to go home/urgent situation; work from home).
    • Keep openness “adequate”: be transparent, but don’t abuse the system.
  • The goal is to avoid unnecessary phone calls, confusion, and wasted time.

• Act inside the boundaries of assigned tasks

  • Do the work you were explicitly assigned—don’t “pull in” extra tasks you weren’t given.
  • Big projects are broken down into small units (screens → blocks → components/parts), so assigning precisely helps avoid misestimation and destructive work.

• Finish tasks to spec (quality + compliance)

  • A task should be considered done only if it matches:
    • Technical specifications
    • Design (including layout details like indents, fonts, colors, shadows, gradients, proportions)
  • If anything doesn’t match or you don’t know how to do it, raise questions before assuming it’s “good enough.”

• Ask questions early and treat them positively

  • Don’t stay silent when blocked.
  • Questions are treated as an indicator of interest and a desire to produce results.
  • Expected behavior when you’re stuck:
    • Try to solve small issues yourself first (e.g., via search) for about 10–30 minutes.
    • If still blocked (or if it’s a known complex problem), ask directly in the chat.
  • Help can come as:
    • Direct answers
    • Guidance (“mind games”) that lead you to reasoning-based solutions

• Use the knowledge base + verify your work

  • Double-check against documentation/design before sending the result.
  • Don’t shift responsibility to reviewers:
    • Reviewers/mentors exist to support learning and cover edge cases,
    • but you should still verify things at your competence level.

• Maintain Git and commit hygiene

  • One task → one coherent change set
    • Keep commits integral (avoid mixing unrelated work).
    • Don’t commit “garbage” or chained/irrelevant changes.
    • Remove system changes that don’t affect code if they’re unnecessary.
  • When pushing conflicts:
    • If you can’t solve them safely yourself (especially early on), ask a senior for help—conflict resolution can easily break the project.
  • Keep feature branches aligned:
    • Merge from a tested branch (e.g., master) so your feature branch stays up to date.

• Handle potential problems in artifacts normally

  • Sometimes tasks, technical specs, designs, or test coverage can contain mistakes or inconsistencies.
  • Healthy behavior:
    • Discuss in chat if something seems wrong (with tasks, requirements, bugs, or tester feedback).
    • Assume every role (analysts, designers, testers, devs) is human—issues can happen, and clarification is normal.

• Track task status and time transparently

  • Update task status appropriately:
    • Change to paused when stopped.
    • Provide a reason for pausing/unblocking issues.
    • Unblock/resume with correct updates.
  • Keep time tracking (“tracks”) current:
    • PMs use this to detect when a developer is stuck on a bug/problem for too long.
    • Tracks should be set regularly, with separators like switching tasks, breaks, and end of day.
    • Don’t let tracked work become opaque for teammates.

• Use Git commits regularly to avoid losing code

  • Don’t work all day without intermediate commits—there’s risk of losing progress (crash, OS failure, disk issues).
  • Make commits when you have meaningful results so progress is visible and reversible.
  • Frequent commits improve transparency and reduce unnecessary interruptions (others can see work is progressing).

---

Methodology / instruction-style checklist (as conveyed)

Onboarding

• Learn team expectations and processes quickly after joining.
• Ensure availability/communication expectations are clear (especially for mentors/PMs planning around newcomers).

Communication rules (chat)

• Post in the relevant project/mentoring chats as needed.
• If something interrupts work:
  • Warn immediately (sick/leave/away/need to work from home).
• If blocked by a technical issue:
  • Ask questions rather than staying silent.
• Keep openness “adult/healthy”: transparent but not careless or excessive.

Task execution

• Work only on tasks that are assigned to you.
• Decompose within the task as required (screens → blocks → sub-tasks).
• Complete work only if it matches:
  • Technical specs
  • Design (all visual/layout details)
• If something is unclear:
  • Ask in chat (after a short self-research attempt).

Self-check before submission

• Verify via knowledge base/docs.
• Re-check after implementing:
  • Ensure design/spec compliance.
  • Avoid shifting responsibility purely to code reviewers.

Git workflow

• Commit coherently:
  • Don’t mix multiple unrelated tasks in one commit.
  • Keep each commit tied to a clear scope.
• Avoid committing unnecessary chained/system changes.
• If conflicts happen and you’re unsure:
  • Request help from a senior rather than risking corruption.
• Update feature branches by merging from the tested branch regularly.

Task statuses + time tracking

• Monitor task status continuously after starting.
• Update when pausing/resuming and explain pause reasons.
• Track time in regular segments:
  • When you switch tasks, stop for breaks, or end the day.
• Don’t let tracking become stale/opaque.

Commit frequency

• Commit incrementally as progress is made.
• Don’t wait until end of day to commit significant work.

---

Speakers / sources featured

• Single speaker: the video narrator (no other named individuals or sources are explicitly identified in the subtitles).