1. There are plenty of beginner tutorials. Often they just go through the examples from the docs or show a very simple proof of concept. Not very useful if you can read the docs.
2. Then you are left on your own reading through uncommented GitHub repos to understand how to put these things actually into production for use cases that go beyond 'add a todo to this list'.
You almost never find tutorials on how to structure your application, best practices, common mistakes etc.
That's the knowledge that is really helpful though and that I would pay $$$ to learn. Not 'how to create a simple todo app'. Why are there barely any learning resources that target the intermediate level?
More intermediate stuff goes into the data structures and algorithms. https://sp19.datastructur.es/ ^UCB's Josh Hug is a good lecturer, also provides course textbook, hw, side projects.
For best practices, try to get the Head First Design Patterns PDF.
Common mistakes? Search for "Effective <whateverLanguage>" and you should find a PDF for whatever you're looking for.
Also, goalkicker.com has compiled a lot of intermediate stuff from scraping StackOverflow question-answers.
After looking through your suggestions, I think I better understand what I actually meant with 'intermediate-level learning resources'.
I suppose what I am looking for are videos where people walk you through some really advanced open-source applications and explain the application structure and design decisions they have made. That could be relevant for all sorts of tech stacks and combinations.
Basically a video after which you have a good starting ground to build your own application with a similar tech stack. These videos should ideally be made for open-source applications that follow many best practices for the given tech stack.
I think that would be extremely valuable. As of right now, you are stuck reading through random projects on GitHub and often times you don't even feel confident that the way they have approached the problem, is necessarily sane and a good way to go about it.
It would also be a lot more time-efficient if someone explains the application structure and design decisions to you than if you have to figure it out by yourself.
If that's what you're looking for, consider checking out 'The Architecture of Open Source Applications' here http://aosabook.org/en/index.html
It's not in video form, and the focus, as the name suggests, is on the architecture more than on the tech stack, but you might find it useful.
The last dude is TheCherno https://www.youtube.com/user/TheChernoProject/playlists?app=...
All three of these folks walk you through intermediate-level projects with commentary on their decisions.
You should also look into conference talks on the tech stack you are interested in. Then look up the speaker/topic for more specific material.
I'll fire up a tutorial on something and 20 minutes into this and I'm all "yeah this does what it says, but it can't be used to do almost anything else..." and I fear the actual person doing the tutorial doesn't know.
Heck I've commented on some Medium blogs where they mention how to do a thing and I'm 100% sure in any real world that code won't do the thing. I post and ask about some aspect of it and the blog author ... doesn't know.
Like outside this one off tutorial and everything working perfectly ... the code is useless.
There's valid reasons to simply code for illustration, but at the same time, without exposing even how to handle an error... what have you really taught someone?
Unfortunately, signaling games are difficult to avoid in any burgeoning ecosystem. The problem is that our signaling schemes are almost as crude as “spray and pray” and our information seeking methods are as crude as “click and pray” (to the search overlords, or to the algorithmic feed overlords).
Both sensitivity and specificity are increasingly impoverished in online information communication. Maybe this is a fundamental caveat to large one-size-fits-all platforms... they cannot serve a variety of needs beyond a simplified representative.
If you're looking to self promote, you can either target the larger audience base of beginner content, or provide domain expertise with advanced topics.... with the gap in the middle then being underrepresented
1. Out of the total time spent in building an application, a non-significant amount of time is spent on boring tasks to make the application real world ready. In some cases at least, you use third party libraries and custom developed components to do so. Including those in a learning resource/tutorial will, at least in some cases, make the code exponentially more complex to absorb.
2. Some of the code you use for building production-ready applications is proprietary - either proprietary to the developer or to the company.
Sidenote: I would argue that we have an abundance of resources. What we don't have is that many laser focused "here are the 35 most common gotchas you will face while moving this to production and here is exactly what you need to do" type of resources.
For exploring some huge codebase where there is no design documentation one way is just to use a fancy ide and sabotage something to see what it breaks in your ide, then you can trace what code is relying on. Some open source projects have books written about their architecture, you could also start with those then everything you see there is often similar in undocumented projects in my experience, in terms of organization of code like where is the directory containing all the core functionality, where are the feature addons.
As regards educational content, I'm at an early stage with this, but I've got a couple of videos over on YouTube https://www.youtube.com/channel/UC17mJJnvzAa_e9qQqLIfIeQ
As for your question as to why there are so few intermediate level learning resources, I think it's because the market size for intermediate stuff is much much smaller than it is for beginner resources and therefore content creators prefer to focus on the beginner stuff.
Maybe this is the result of commercialization of information: much finer optimization of follower count inevitably leads to oversimplification and overselling. And experts are increasingly less motivated to share knowledge with non-experts, like in academia where clarity of explanation to outsiders is sometimes valued negatively.
Also, most of the useful beginner to intermediate level content is created in video format, and that’s just grossly inefficient for a busy person: you cannot quickly scan a video, and you need sound, and good understanding of spoken English (IME much harder than reading) so the barrier to learning is actually higher.
Also, there were blogs, and now there are mostly walled gardens. In many industries (e.g. I’m familiar with professional dog training) most information is there and is poorly accessible.
I’d like to hear other opinions too.
Companies selling development software/libraries can pay for teams of content developers and evangelists. They also would serve as single source of truth for the canonical way of doing things. And they would give away the content in order to get license sales
The rise of the free (as in beer) software doesn’t have the same incentives, culturally or economically. The documentation of the better libraries is often great and better then the what I remember from closed source vendors in the past, but it normally stops at the boundary of the library. It’s rare to see teams of evangelists/content on OSS projects directly creating integration level content (although some of the bigger projects see that).
Unfortunately, I can’t remember any source that is publishing such materials on regular basis, seems that this type of knowledge is tightly connected with exact company best practices and it takes a lot of work to make this knowledge useful for the general public.
You mention video walkthroughs and that you would pay for something like this. I'd love to do a video call and chat to learn more: nirmalthacker@gmail.com
There's only so far one can get by looking at Quickstarts and tutorials. If you do find a tutorial online, a big struggle is replicating and getting it to run. There's quite a lot of Open source software now, thanks to Github, but getting to a point where you can run the code, understand what it does and replicate parts of that are super time consuming. If companies knew how many man hours are dedicated towards this, they'd be shocked at the loss of productivity.
My main thesis is that intermediate stage learning is self-driven, and there needs to be an ecosystem of tooling that can provide & enable replication, remixing of software with sufficient walkthrough of what the code does
The other aspect of advanced is how to maintain an application and write it so its easier to maintain. Once something is live, how you get changes in, fix bugs, monitor, etc. is not really talked about online because it is boring. It is a combo of process, tooling and some tech.
(Judging from your comment would I be correct in guessing that you are doing mainly JavaScript stuff? If you are, then the Python world is generally a lot nicer.)
-Just my thoughts.
Do you mean books on theory or on language-specific libraries? Either way I can think of many examples. Also, the pre-2014 books are still very relevant - it's only deep learning that has seen significant developments since then.
