- Beginner: still struggles with algorithmic thinking.
- Elementary: knows how to write an algorithm, but is still learning how to properly structure his code (just want to make things work). Also doesn't fully understand how the technology stack he's using is integrated. In a web application context, he'd struggle with integrating an AJAX request. Follows religiously the framework's guidelines, even when he shouldn't.
- Intermediate: knows how to build full applications, and is excited about best practices and design patterns. Hates repetition, and is easily convinced of any new "best practice" to the point where he'll over-design an application and make it even more difficult to maintain than if there wasn't any abstraction. Knows how to use the available tools to perform almost any given task, and is starting to escape the framework's guidelines when appropriate.
- Advanced (I'd be framed at this level, I think): understands when to use abstractions and when not. Understands fully the technology stack, and is able to lead a whole complex project.
- Expert (from what I was able to see by observing other programmers): is able to notice code smells from a distance, and have so much experience that can point the best alternatives in the first stages of a project. Also usually masters some advanced programming techniques, like algorithms optimization, distributed programming, etc., depending on the path he took.
There's much more to it, and I think this list is a good general guide. Don't take it too seriously, though, as the skills you'll need varies greatly from domain to domain.
Some topics in Rails that is really important that you understand for almost any project:
- Model:
- Built-in validations
- Custom validations
- Associations using conventions
- Polymorphic associations
- Custom associations (using options like :through, :class_name, :foreign_key, :source, etc.)
- Scopes
- Advanced querying
- Controller:
- Routes and HTTP actions
- Custom routes (with namespace, member, collection, etc.)
- Callbacks, or as they call it, filters (before_action, after_action, around_action, etc.)
- What's the purpose of the protect_from_forgery macro
- Strong parameters
- respond_to and respond_with
- Cookies and sessions (both using, how they work and what are their limitations)
- View (not much to do here):
- Helpers (and when to avoid them)
- Partials (passing local variables)
- Collection partials
Other, more general topis:
- Automated testing tools (RSpec, MiniTest, etc.), and how to apply them to every piece of code
- TDD
- Timezones and what are the safe methods to use on the classes Time, Date and DateTime
- How to safely store a money data type on the database and apply operations over it (aka why not to use float)
- Debugging tools (pry, Google Developer Tools, etc.)
Now, to some advanced topics:
- Caching (class-level caching, SQL caching, view caching, etc.)
- Authentication
- Authorization
- Ruby metaprogramming
- Consuming an API
- Providing an API
- SQL and relational databases foundation