programming like with most skills is about having "tools" in your "toolbelt". the progamming language(s) you know is also just one of those tools and is just the tip of the iceberg.
# motivation:
make a (simple) game:
You must be registered to see links
-> Game Engine By Language
solve a problem one has like automating a task
curiosity
...
the difference between doing some programming or doing something else. a concrete problem also helps with limiting what one needs to learn next and making it simpler to remember since it is connected to each other. otherwise one dabbles in many things and remembers little after a while.
often the problem one has when starting with programming as a hobby is knowing what is out there. at least knowing what it is about and maybe some experience with it. this will be useful if one does go deeper into the subject in the future.
when you do not have a teacher finding out what exists can be also done with books. look at least at the indexes of books and google about words/topics to find out more without buying hundreds of books.
one should focus on one language for a while in order to gain some experience so that one has something to compare other stuff to later. dabbling into multiple languages is good to discover different ways of doing things. some languages have higher programming patterns added directly to the language. since nothing is truly exclusive to a language you can program everything in someway or another into any other language. an example is programm in an OOP way even in non OOP languages, if you are willing to write code a certain way. you just have to constantly remember that certain way since nothing provents you (or someone else) from doing it dfferently/wrongly. it is just not as easy and safe to use compared to native language features. however much more customizable since you made it yourself.
# languages all programmers should know
regular expressions (regex): this is like the swiss army knife for programmers when it comes to searching, exploring code and when refactoring code in ways beyond the capabilites of ones editor/IDE/tools
# core programming structures
loops, brachning/conditions, functions/procedures, ...
learned with every language but with some differences depending on the language.
# data structures
arrays/lists, linked lists, hashtables, stack, queue, ...
You must be registered to see links
You must be registered to see links
You must be registered to see links
You must be registered to see links
...
programming ist mostly about data. the data that you need to work with decides often how you need to write your program to be efficient with computer resources and limitations (cpu, data size and transfer speeds). if you optimize your programs for the human(user/programmer) by having nice language patterns, that often costs efficiency in memory/cpu. this is because you need to translate between the human optimized layer and the machine optimized layer in your program. in the beginning one tends to think one can have both but you pretty much always have to compromize here for one or the other.
# higher programming patterns (design patterns, ...)
delegates/lambdas/clojures, proxy, factory, dependency injection/inversion of control, domain driven design(every problem has its own (programming) language), data driven design(external files configure internal program, change program behaviour without the need to recompile every time), data oriented design(cpu cache optimisations, SIMD asembly commands), modular desing/decoupling(divide and conquer), event systems, messaging systems, pull vs push, synchrone/asynchrone, prallel/concurrent/multithreading/coroutines/fibers, ORM(object relational mapping), AOP(aspect oriented programming), OOP(object oriented programming), entity systems, microservices, static(compile time) vs dynamic(runtime) programming, imperative vs/with functional, ...
You must be registered to see links
You must be registered to see links
just like core programming structures these are helpful to understand programs faster or to have certain advantages. like not having to recompile the program to change it, easy to maintain source code, easy to merge changes on same code from many different programmers. but because of the may possibilities how these can be implement to be useful, they are often not part of the language itself.
# automated testing
junit(java), cunit(c++), ...
automated testing for everything the compiler cannot check for you. the bigger the code is the more important auto tests become. especially when you want to change/refactor your code. manually testing everything just waste time. you dare not change something for the fear of breaking something. you avoid refactoring/improving code and your code becomes worse and worse to read,understand,bugfix and add new features.
# build systems
c++: cmake, make(old), ...
java: gradle, maven(popular), ant(old)
You must be registered to see links
...
automating common tasks to get your program in a runnable or installable state. like building/compiling, packaging, running automatic tests, deploying. each language tends to have at least some of these.
# version control systems
git, svn(old), cvs(very old), ...
useful to try out ideas or finding code changes. a must when working together with other programmers for merging different code changes together.
# editors: IDE(input device environment), programmable editors: visual studio code,emacs,vim,textmate,sublime text,...
eclipse, intellij, visual studio, ...
You must be registered to see links
free open source IDE for some languages: java, c++, php,
You must be registered to see links
many ide/tools/extentions for different languages, some free some not
having a good IDE is often underestimated. digging through documentation manually or pressing a shortcut to get what you want adds up very fast. one can save huge amounts of time and make things much easier with a good IDE. the ones specific to one language tend to be more powerful. but more and more of the major ones started to support multiple languages, therefore one is less forced to switch the IDE nowdays. there are also programmable editors that are highly customizable but they are usually more work to setup(choosing/install plugins etc), are not as well polished and less feature rich than IDEs. however for smaller edits or for smaller scripts/programs they can be much better as they usually load much faster. at least one PE and IDE depending on language(s) should be in ones toolbelt.
# debugging (step through code one line/command at a time)
learn to use the debugger for your language if it has one. the better IDEs support this more comfortably than in a console window. consider learning some assembly if you use languages thar are close to the metal like c/c++.
# compilers/transpiler/interpreters/virtual machines(byte code, java vm)/code generators/code parsers
ANTLR, bison+yacc, truffle(graalvm)
(rough) steps: lexing, parsing, AST(abstract syntax tree), compiling, linking, assembly, ...
creating your own language can make programming in a certain domain much easier. even without a separate domain specific language (DSL), code is always a mix of several domain language with the main language. DSL are used for scripting, querying or just for helpful short expressions(regex) that do something or describe data in a better way. these are much easier to read, write, find or teach because they are not heavily intertwined with your main language. a separate DSL allows to check/prevent wrong ways of use. also just some simple code generators can ease ones life and save a lot of time in the future, not needing to change many lines by hand which is more likely to have mistakes.
# project management
kanban, agile, v-model, ...
trello.com (kanban)
even just some (kanban) organisational skills can go a long way in saving time and reaching goals. a must when working together with others.
# self health management
like with everything managing oneself is also important.
- set reachable goals so you wont give up or go suicidal, there are limits to how hardcore one can be
- doing a little often instead of much at once is easier to handle since you have enough pauses to recuperate, it might cost you overall more time if switching what you are doing takes long. but the longer the pause the more one forgets
- take care of your health. sitting in front of a screen can mess up your body more than one might think. sit correctly and change your sitting position from time to time, have the screen at the right distance and angle, choose colors for programs that you feel comfortable with watching for hours, move your hands enough so you wont get problems with your fingers/wrists/shoulders/...
and there is much much more depending on what domain one programs for, most of this can be learned without programming knowledge. examples for domain specific knowledge: AI,audio,visual 2D/3D,...