- Know almost every pitfall, gotcha, and best practice. Have a rock solid grasp of the ecosystem.
- Up-to-date on the language roadmap and philosophy.
- Have written a substantial amount of source code that others deem high quality.
- Hard time convincing yourself that you have finally mastered the language. 😉
- You are part of the community. (hopefully, you give back)
- Know when to “dumb it down” and exclude advanced usage.
- Deep understanding of runtime and performance.
- Know most of the best practices and gotchas.
- Mostly aware of upcoming language features and philosophy.
- Most of the syntax is in your head. If you are rusty, it will take only a couple days to give yourself a refresher.
- Occasionally look at references but the vast majority of your time is spent solving the real problem at hand.
- Able to whiteboard in it during interviews. (i.e. fair game if listed in resume)
- You’ve read and studied a substantial amount of source code that is known to be of high quality.
- Can identify bad code and smells.
- Can rattle off at least 5 people in the community whose work you study and respect.
- Decent knowledge of runtime and performance.
- You are still hung up on syntax at this stage. You spend substantial time looking at syntax references instead of solving the real problem at hand.
- Don’t expect to whiteboard in it during interviews.
- You can read and mostly understand the source code.
- You can prepare simple bug fixes or patches.
- Don’t know much about the ecosystem.
- You cannot identify bad code and smells.
- No clue where the community even hangs out.
- You would be happy if your code compiled or worked at all. Runtime and performance considerations are the least of your concerns.
- You need someone to tell you if you qualify as being “familiar”. 😉
- If someone showed you some source code in the language, you couldn’t even identify what language it is in (or you would have many doubts as to what it might be).