Enthusiasm is usually the key, so it's important to aim for some small, achievable goal that you'd like to achieve. For example, making a game; or automating something on your computer; or doing something interactive/visual on a Web page; or analysing some dataset; etc. If you pick a project you care about, it makes the required reading, trial-and-error, etc. much less tedious. Likewise, if you're not at all interested in some sub-field, then no amount of hand-holding, gamification, drag-and-drop tooling, etc. will make up for that!
If your chosen task seems daunting, feel free to break it into something simpler (e.g. for a game, turn-based may be easier than realtime; text interaction may be easier than graphics; 2D easier than 3D; etc.)
Your choice of project will then determine your learning path. For example, Web stuff is all about Javascript; but data analysis may be better in Python; and automation may be easier with Applescript; etc.
I would avoid starting with something "overly ceremonial"; e.g. Java forces everything into a "class hierarchy", Rust requires references to be "borrowed", C requires memory to be manually allocated and freed, etc.
So-called "scripting" languages are a good way to avoid such complications, e.g. Python, Scheme, Javascript, etc. That way you can focus on one thing at a time (you can learn class hierarchies, borrow-checking, memory management, etc. later!).
Avoid languages/systems which have a bad reputation, e.g. Perl, PHP, C, Bash, etc. When learning, it's hard to know what's fundamental and what's just a quirk of that particular system; learning with a particularly-quirky system can make this harder.
When learning a concept, try it in a few different languages (again, to work out what's fundamental)
Don't bother too much about "good practice" or "bad practice" when learning. Make a note if you come across such recommendations, but they can lead to second-guessing oneself and unneeded complexity that obscures what's going on. Focus on "minimum viable projects". Also, following advice that you're not yet able to understand can lead to "cargo culting". Once you're confident/competent enough that you can hack together some solution, you can revisit that advice to see why some approaches may be better than others.
Once you start to feel comfortable, try playing with some big new idea. Sometimes it can help to use a radically different language which forces you to think in that new way; good examples include Prolog (logic programming), Pure (term rewriting), Haskell (pure functional), Smalltalk (message-passing), Forth (stack based). This is good for making you think more deeply, and gain a better understanding of what's going on.