I feel like there's a big online niche for intermediate-level programming tutorials. I googled around a few months ago for SQL resources to assist a team member who'd progressed past basic operations and joins and found little of use. I ended up writing my own set of questions like "write a query to remove duplicate records from this table".
I've given this a lot of thought. My main conclusion is that independent learning usually breaks down at intermediate levels.
Let's say a novice is someone who has no skill in a topic. A beginner is someone who knows a bit. Going from novice to beginner means increasing your skill level to the point that you can complete some tasks.
An intermediate is someone who can do more than an a beginner. To go from beginner to intermediate, you build on your foundation. Wait, what foundation? What skills do you already have? What did you learn when going from novice to beginner?
We don't know. This is the huge difference between novice -> beginner and beginner -> intermediate. The second transformation has dependencies.
There are solutions to this that aren't hard. When you run into an unmet dependency (the author assumes you know something you don't) backtrack and learn it. This works in theory and usually fails in the real world.
Most people hate unmet dependencies of knowledge. Hate hate hate it. They make them feel dumb and people hate feeling dumb. (You are most likely this way and don't realize it. If not, you have a strength and you should be using it).
I believe this is the problem that traditional learning solves (a bit) and independent learning does not. You can rant about how much colleges suck (I do sometimes) but they provide a few important things for real people learning: A track meant to avoid unmet dependencies, some amount of resources to backfill unmet dependencies, and social pressure to stick through it even when you hate it.
Hyperlinks and footnotes. I wish blog/tutorial content making use of various libraries or non-trivial language features would link to something providing more information if it's available. Even a citation (see "The Go Programming Language" section 4.5) would be helpful.
I'm learning Go (relearning, I learned it when it first came out but never used it) and came across something like this:
type Record struct {
Name string `json:"name"`
}
My first thought was, "Why is there a reference to JSON here?", the reason became apparent in the next section (so the order of presentation was poor to begin with), but my second thought was, "The language/compiler understands JSON?" If, on the first instance of this form, there were a link, margin note, or footnote to an explanation then the novice (either a programming novice or a language novice) would be able to more effectively dive deeper into the material in a guided fashion.
This is what intermediate-to-advanced material can do to really help out, especially for people who want to see real world use-cases and for one reason or another don't want to or haven't fully gone through all the basic material (or just forgot parts of it).
Backfilling the dependencies is a graph traversal problem. An author can put work in and add references for everything and it will help a lot. The problem is as soon as those links are to something that doesn't follow this pattern (most things), the student will be in the same position.
That's a good point, and certainly an argument for intermediate courses being directly linked to novice courses which cover the prerequisites.
I believe there's also a factor that intermediate knowledge requires much more of a conceptual grasp. Selecting or joining on the correct columns is one thing, but actually knowing when to use what operation and which might have better performance means you need an intuition about the data structures. This is much harder to teach, and probably the only really good way is to get people to attack lots of problems set at the right level of challenge.
Regarding intermediate level SQL, I'd highly recommend Jenniffer Widom's edx courses[0]. They have a good mix of cs theory and practical exercises, which combined gave me a big push in my approach to databases.
I've had the same problem with SQL for ages until a few months ago when I had bunch of small trial by embers (not really fires) at a job I had just started.
Overall, I agree that there's a dearth of intermediate content out there.
