Video summary

КАК СТАТЬ ПРОГРАММИСТОМ. УЛЬТИМАТИВНЫЙ ГАЙД НА ВКАТ В АЙТИ

Main summary

Key takeaways

Educational

Main ideas, concepts, and lessons

  • Goal of the video: Provide a practical “from zero” roadmap to becoming a programmer / IT specialist in the current reality, with an explicit focus on the Russian job market and its hiring filters.

  • Addressing fears and the “AI/neural networks” question:

    • Neural networks won’t directly replace you as a beginner.
    • The real risk is that other developers will use neural networks better than you.
    • So, learn to use AI consciously to increase productivity and competence.

  • Start with market validation:

    • Check job demand via job aggregators and vacancy volume for your target language.
    • Example insight: Go has lots of vacancies (and “response volume” for each created vacancy is mentioned).
    • Conclusion: the profession is still relevant—people keep getting hired, even if competition is high.

  • University vs. self-learning:

    • A university degree is not required, but it can help with:
      • networking and structured access to internships,
      • the “prestige magnet” effect for top universities.
    • However, university knowledge is often insufficient without serious independent study.

  • Personal traits required (soft skills + discipline):

    • Perseverance: ability to sit and work for hours daily.
    • Hard work: ongoing training plus stress management (resume, interviews, onboarding).
    • Confidence in your knowledge—especially during interviews.
    • Persistence after failures:
      • keep applying,
      • build an “interview question bank,”
      • improve after every failed attempt.

  • Choose a development direction wisely:

    • The video discusses multiple options with pros/cons:
      • Game dev: low wages / possible overtime; requires higher math.
      • ML: highest pay potential, but highest entry barrier due to math.
      • Mobile dev: split by platforms; recommends Android over iOS due to fewer iOS vacancies in Russia.
      • QA / AQA (automation): good if you like testing and want to code automation.
      • Frontend: web UI / interfaces.
      • Backend (“CAND” in subtitles): server logic—more “real” programming unseen by users.
      • DevOps: deploying/operating infrastructure; high responsibility, on-call pressure.
      • 1C (Russian ecosystem): possible if you only care about Russia, but limited prospects and less flexibility outside Russia.
    • Rough training-time estimates (very approximate):
      • ~6 months for many directions,
      • ~4 months for 1C.

  • Training prerequisites & preparation:

    • Math level: start with basic logical math; advanced math mainly for ML.
    • English: “not strictly required” at first in Russia, but needed long-term for docs and deeper understanding.
    • Equipment: recommend a desktop/laptop with enough RAM:
      • ideal: MacBook (M1/M-chip) with at least 16GB RAM
      • minimum alternative: 4 cores / 8GB RAM (but 8GB is “too tight” later)

  • Build a “birth map” (learning roadmap):

    • A birth map is a sequenced set of topics needed to become job-ready.
    • Method:
      • Collect 3–4 roadmaps from different sources (e.g., Habr, YouTube authors, roadmap sites).
      • Extract topics and compute the intersection:
        • keep topics appearing in 3 of 4 sources (or multiple sources),
        • skip topics appearing only once as likely non-essential.
      • Validate against vacancies:
        • read job ads and keep technologies that appear in at least 3 of 4 vacancy stacks.

  • Mentoring:

    • Mentors differ from schools because mentors have strong incentives to help you get hired (often linked to your success).
    • How to choose:
      • prioritize reviews (ideally many, with proof),
      • ensure the mentor provides:
        • a finished roadmap,
        • mock interviews,
        • resume/cover-letter help,
        • advice on the market,
        • support on first tasks.
      • check the pricing model (often a % after your first salary).

  • Learning methods (practical strategy):

    • Effective learning depends on:
      • minimizing distractions
      • consistency
      • sequential learning (no multitasking)
    • Suggested schedules:
      • “Speedrun method” (e.g., 12 hours): more for interview prep, not core learning.
      • Steady daily learning: ~2–4 hours/day.
      • “Hard mode”: many hours daily (faster entry, but burnout risk).
    • Pomodoro: short distraction-free blocks (e.g., 20–30 min) to start when procrastinating (but can break context).
    • Time blocking: schedule study time on a calendar to reduce internal debate/anxiety.
    • GTD-style dumping: write down thoughts so they stop competing for attention.
    • Eisenhower Matrix concept: prioritize important but not urgent work (structured learning), not “urgent busywork.”

  • Notes + theory-to-practice loop:

    • Process theory actively:
      • write notes in your own words, including:
        • what it is,
        • what it’s for,
        • how it works “under the hood.”
    • Then practice:
      • first, rewrite code examples from videos/articles,
      • later, transition to modifying and implementing your own versions.
    • If stuck:
      • search solutions, but aim to implement your own variations eventually.

  • Using neural networks during training:

    • Use AI initially not to write full code, but as a hint/personal assistant.
    • Suggested approach to choose tools:
      • try several (e.g., Gemini for research/hints; code-focused models for later coding),
      • test multiple tools.
    • For access/subscriptions:
      • buy via intermediaries/marketplaces to avoid account-sharing issues.
    • Core rule: AI is a tool—you still must learn fundamentals yourself.

  • Pet projects / portfolio practice:

    • Definition of a pet project (“pedagogical project”):
      • not just a toy; it should implement real functionality.
    • Levels:
      • simple: small apps (e.g., todo list with CRUD),
      • complex: closer to production (e-commerce-like features).
    • Key ideas:
      • one worthwhile pet project is enough (not five shallow ones),
      • also do a team pet project for team skills.
    • Why it matters:
      • primarily for hard-skill practice, not just “portfolio lines.”
    • Team project organization:
      • learn Git/version control,
      • daily syncs to assign ownership,
      • use a task tracker (Jira/Track/Asana-like; even Telegram can start),
      • do code reviews.

  • Interview preparation:

    • Junior/middle/senior questions overlap heavily:
      • same core topics, deeper expectations.
    • Preparation approach:
      • watch many real interviews for your language/role,
      • compile a question list by finding recurring topics,
      • do mock interviews with friends or mentors,
      • then attempt real interviews.
    • Stress handling:
      • treat interviews as attempts; the first often fails due to stress.
    • Use feedback:
      • record what happened and update weak areas.
    • Market test idea:
      • after a fixed prep window (example: ~1.5 months), apply.

  • Job applications / responses strategy:

    • Your resume must pass HR filters; response volume matters:
      • submit more applications,
      • higher response count improves odds.
    • Respond properly:
      • apply from the correct “employer vacancy context” so metrics reflect that you read the vacancy.
    • “Confirmed skills”:
      • complete platform tests if available (photos/recordings may be allowed).
    • Cover letters:
      • can be generated by AI using your resume + vacancy text, but should be adapted per vacancy.

  • Resume construction (explicit “experience boosting” discussion):

    • The video emphasizes “Russian resume reality”:
      • sometimes juniors are not hired directly (“junior is not needed”),
      • candidates try to position for middle or beyond.
    • “Experience boosting”:
      • some inflate years of experience to pass HR screening.
      • the speaker argues it’s risky/controversial:
        • hard to distinguish cheating vs non-cheating,
        • verification may happen (e.g., labor-book / employment evidence).
    • Resume elements the speaker claims matter:
      • Age: keep a plausible range; extreme mismatch looks suspicious.
      • Experience years: match market expectations (examples for mid/senior).
      • Education: list higher education; checks may occur.
      • Achievements over responsibilities:
        • include measurable results and numbers,
        • include relevant keywords (e.g., high-load services).
      • “About me” section:
        • include contacts (Telegram/email/phone),
        • emphasize responsibility and readiness for high load.
    • Resume templating process:
      • inspect strong resumes on aggregators,
      • mirror structure and keyword patterns,
      • draft versions using GPT,
      • refine for metrics/achievements (numbers/percentages).

  • About HR, recruiters, and “neuro-hiring”:

    • Hiring is described as: HR filters many resumes via neural networks (“neuro-hiring” concept).
    • Recruiters narrow thousands to a few candidates using:
      • resume screening → interviews → (sometimes) verification/security checks.

Methodologies / step-by-step instructions (detailed bullets)

1) Market validation before committing

  • Check job demand via:
    • job aggregators (e.g., LinkedIn, HeadHunter-like sources),
    • language-specific vacancy volume,
    • relevant Telegram channels.
  • If demand exists (even with high competition):
    • continue with the learning plan rather than quitting.

2) Build a learning roadmap (“birth map”) using intersection logic

  • Collect 3–4 roadmaps for your chosen direction/language.
  • For each roadmap:
    • extract topics.
  • Build your roadmap by:
    • keeping only topics that appear in ~3 out of 4 sources,
    • skipping topics that appear only once (likely non-core).
  • Validate against job ads:
    • open multiple vacancy descriptions,
    • extract required technologies,
    • keep technologies appearing in ~3 out of 4 vacancy stacks.

3) Choose a direction (quick decision rules)

  • For fast entry into IT:
    • choose AQA or Frontend (as suggested).
  • If you have real interest:
    • choose the direction you enjoy (interest improves persistence).
  • For maximum salary potential:
    • ML is implied as the highest, then DevOps/backend—though barriers are higher.

4) Train effectively day-to-day (core routine)

  • Prepare equipment to avoid lag (enough RAM/cores).
  • Use a schedule:
    • steady method: 2–4 hours/day.
  • Reduce distractions:
    • turn off notifications,
    • keep your phone out of reach,
    • minimize interruptions.
  • Learn sequentially:
    • complete one topic before moving to the next.
  • Confirm learning productivity at the end of a session:
    • “What did I learn today?”
    • “Did I actually understand the new material?”

5) Start learning a language (the theory → code progression)

  • Do theory actively:
    • don’t just watch/read—write notes in your own words.
  • Practice progression:
    1. rewrite small tutorial code examples (mechanical practice first),
    2. modify code to test understanding:
      • variable types,
      • conditions,
      • loops,
    3. implement simple tasks:
      • small calculator-like programs using functions/methods/structures.

6) Use neural networks during training (hint-first)

  • After you can write simple code:
    • ask the model for hints, explanations, and edge-case checks.
  • Avoid early “AI writes everything” mode:
    • use AI to help you understand, not to bypass learning.

7) Pet project strategy

  • Choose:
    • one worthwhile solo pet project (meaningful features),
    • one team pet project.
  • Solo project:
    • start with basic CRUD, then grow toward more “real” features.
  • Team project:
    • learn Git branching + merge requests,
    • do daily syncs for ownership split,
    • use a task tracker (Jira-like or alternatives; Telegram can start),
    • practice code reviews.

8) Pet project quality filter (implied)

  • It should include realistic engineering elements (architecture/refactoring).
  • It should not be a shallow “toy” rushed in a day.
  • It should have enough credible scope across engineering areas (backend/frontend/testing/infrastructure).

9) Interview prep procedure

  • Find and watch multiple interviews for the same language/role.
  • Extract recurring questions/topics into a dedicated question list.
  • Do mock interviews (friend or mentor if possible).
  • Then go to real interviews within a set timeframe (example: ~1.5 months).
  • After each interview:
    • record what you missed,
    • update your preparation plan.

10) Resume strategy on Russian aggregators (high-level workflow)

  • Enable/complete “confirmed skills” tests when available.
  • Apply with targeted “responses”:
    • respond from the vacancy context in the employer profile.
  • Cover letter:
    • generate per vacancy using GPT (resume + vacancy text).
  • Resume structure:
    • include age (plausible), education, experience years (possibly “boosted” as described),
    • highlight achievements with numbers/percent metrics,
    • add “about me” at the end with contacts.

Speakers / sources featured

Speakers

  • Rostislav (main speaker; recorded at age 22; described his job-hiring timeline; 2 years of IT experience at the time described)

Sources mentioned (not as video speakers)

  • Job aggregators / platforms: LinkedIn, HeadHunter (implied “Headthunter”), and similar recruiting sites
  • Roadmap sources: Habr, YouTube, various roadmap websites
  • Mentoring community: Telegram chats (for mentors/teams)
  • Task trackers: Jira, Trello/Asana-like tools (examples: “Track” and “Asanna” in subtitles)
  • AI tools: ChatGPT, Gemini, “Codex/Cloud Code” (as mentioned), DeepSeek (as mentioned)
  • Miscellaneous frameworks/tools: Git, VS Code, Linux/terminal concepts, Grafana, REST API, Docker/microservices, PostgreSQL, Kafka/RabbitMQ, “metrics/logs”

Original video