Can you tell the level of dev by their portfolio?

Summary

In this video, Frederick discusses how to assess a developer’s skill level through their GitHub portfolio. While seniority may suggest experience, it doesn't always equate to skill. He explains how a junior, mid-level, and senior developer’s code can be distinguished, noting that simple projects aren’t enough to determine a developer's abilities. Complex projects and good coding practices provide more insight. Frederick emphasizes the importance of both evaluating code and speaking with developers to get a holistic understanding of their abilities, highlighting that experience is key in identifying the nuances of software development.

Takeaways

• 😀 GitHub portfolios can give an indication of a developer’s skill level, but it's not always accurate due to varying project types and experience.
• 😀 It's challenging to differentiate between a senior and a junior developer based solely on GitHub repositories, especially at the mid-level.
• 😀 Seniority in software development doesn’t always equate to higher quality code or greater skill; experience can sometimes be just about time spent in the field.
• 😀 Code quality and complexity (such as tests, structure, and functionality) are key indicators when evaluating a developer's GitHub portfolio.
• 😀 It’s important to evaluate both the code and the person. Interviews and code tests are essential to assess developers accurately.
• 😀 Code that looks good on the surface doesn’t always reflect a developer’s true abilities if they can’t explain their own work or struggles to troubleshoot.
• 😀 Seniority can sometimes be more about past work experience rather than the current skill level or ability to write clean code.
• 😀 When evaluating developers, consider how they handle a variety of tasks, not just their coding abilities. Look at their approach to debugging, testing, and project management.
• 😀 A senior developer’s portfolio may not always reflect their expertise due to factors like time constraints or varying job roles.
• 😀 The key to identifying a developer’s level is a combination of their code, how they communicate about it, and how they perform in various real-world tasks.

Q & A

Can a developer's skill level be determined solely from their GitHub portfolio?

Not entirely. While extreme cases (very junior or very experienced developers) may be somewhat identifiable, determining the precise skill level from GitHub alone can be difficult, especially for mid-level developers. Talking to the person and evaluating multiple aspects of their work is also necessary.

What are some indicators of a junior developer in a GitHub portfolio?

Junior developers often write smaller, simpler projects, may structure their code or repositories poorly, might not write tests, or include unnecessary files due to lack of experience.

Why is it difficult to distinguish between mid-level and senior developers based on GitHub?

Because some mid-level developers may code very effectively while some seniors may have titles without demonstrating advanced skills. Skill level is not always correlated with seniority.

What does seniority typically indicate according to the speaker?

Seniority generally indicates experience, usually meaning someone has worked for over five years, but it doesn’t necessarily reflect higher skill or talent.

What factors help evaluate a developer's skill from their code?

Factors include code structure, repository organization, presence and quality of tests, handling of complex applications, and overall problem-solving approach.

Why is evaluating a single small piece of code insufficient?

Because a single trivial function or small script doesn't reveal the developer's ability to handle larger, more complex systems or showcase their full skill set.

How can a conversation or code review supplement the evaluation?

Talking to the developer and reviewing their code together helps confirm understanding, uncover skills not evident in the code alone, and identify if the developer actually wrote the code themselves.

What analogy is used to explain the difficulty of judging skill from limited evidence?

The speaker compares it to a boxer: both an amateur and a professional punch once, and without seeing more action, it’s hard to determine who is the pro based on a single punch.

What holistic approach does the speaker recommend when evaluating developers?

Use both code tests and interviews, consider multiple dimensions like task prioritization, debugging ability, testing quality, and overall system understanding to get a complete picture of skill level.

Why might some high-quality code not reflect the developer’s true ability?

Because the code may not have been written by the individual themselves, or the developer may not be able to explain it well, which raises doubts about their actual skill.

What is the speaker's overall advice about assessing developer skill?

GitHub and code samples provide indicators but never tell the whole story. A combination of code review, interviews, and observing real-world work is necessary to accurately evaluate a developer’s level.