Coding Tutorials Blog

Tips for Aspiring Developers

January 20, 2021

Solid houses are built on strong foundations

Whatever language is your first language, build a strong foundation in it. Don’t rush to learn all the fanciest libraries and frameworks, those become 10x easier to learn if you spend the time to practice and get very comfortable with as much of the languages core syntax as possible, in particular…

  • Data Types
  • Collections (Any data structure that holds multiple pieces of data, how to create, how to add to them, how to remove items from them, how to alter them, how to find data inside them)
  • Control Flow (Conditionals and Loops)
  • Functions and Basic Functional Programming Principles (pure functions)
  • Classes and Object-Oriented Programming Concepts (Inheritance, Encapsulation, Composition)
  • The languages standard HTTP library and how to make HTTP Requests: While many frameworks and libraries provide useful abstractions over any languages HTTP library, I found it quite useful to understand how all that worked under the hood to write more flexible code.

Immersion: Speak Code

Listen to podcasts regularly, even if a lot of info may not apply to you it will help you build your coding vocabulary and appreciation. Why not start with mine, the Web Dev 101 podcast.

Here are many terms you eventually want to understand in the coding context: Traversal, Memory, Stack, Heap, Ephemeral, Implementation, Abstraction, Higher Level, Lower Level, Specification, Version Control, IDE, Text Editor, Package Manager, Cloud, Virtual Private Server, Cloud Functions, Backend, Frontend, Garbage Collection, Data Structures, Design Patterns, Algorithms, Standard Library, Framework, Component, Deprecation, HTTP Requests, File System, Shell, Console, Routing, Typing, Compiled, Interpreted, Transpiled, API

ABC: Always be Coding

Try to spend at least an hour a day doing some light coding practice, even if it’s just reading some documentation or source code. 60 minutes can be broken into 3x 20-minute chunks if that’s easier. Maintaining this habit will limit rusting of knowledge and make sure your mind is always anticipating learning. All the advice or teaching in the world can’t replace hundreds of hours of debugging and researching as you work to write working code.

Stay Uncomfortable

If you ever feel comfortable like what you are doing is easy, it is time to push the boundaries into areas you felt uncomfortable with. Feeling very comfortable with React, branch out into Redux, Next, React Native, Gatsby. Feeling comfortable with Javascript, try a compiled language like C++, Java, Rust, Go, Crystal or Nim. Feel backend code is just second nature, try going deeper on the frontend, machine learning, mobile development, etc.

Embrace Being an Imposter

Imposter Syndrome can be a liability if it makes you feel so hopeless you stop trying, but it can also be your greatest asset if you take that feeling that you can and should be better to motivate further learning. Your choice.

Share your knowledge, Grow your knowledge

Blogging, Vlogging, and Podcasting coding will assist you on several levels.

  • The more you express your coding knowledge the better you get at it which will pay dividends when writing documentation, working in a team, or on an interview
  • You help build your reputation if your output gains popularity which can also help in finding opportunities.
  • New tutorials are always needed (even if older tech) as technology changes so quickly a tutorial written a few months prior can quickly get outdated. Also, maybe your voice is the right voice for someone’s learning style, share it.
  • You’ll find trying to explain things will make clear what you know and what you don’t know which will make improving your skills easier.

The Theory Matters More than you know

Depending on your role you may not find yourself writing Linked Lists and Hash Tables on a regular basis, but understanding Data Structures and Design Patterns still go a long way.

  • In higher-level languages like Javascript, Python, and Ruby the data collections you are working with (Arrays, Objects, Dictionaries, Lists, Hashes) are implementations of many of these data structures under the hood. Understanding how they are created and the implications that has with memory usage and traversal will make a huge difference in your design choices.
  • OOP Design Patterns give you an arsenal of typical solutions as a starting place for many typical problems. Understand what is usually done can save you time but also make it easier to innovate since you know where the box is to think outside of it.
  • Practicing Algorithms and code challenges will help your programmatic thinking so you can break apart problems faster into smaller solvable challenges, and at the end of the day what your potential employer or client wants more than anything is your productivity so you are making the best use of your time.

Don’t be afraid to explore

While I agree with the advice that you should really have one language you should really invest your time into for a level of mastery, I have found a lot of value in learning the basic syntax of as many languages as possible (just some light exposure, most of your time should still be in your “home” language unless you get a job that requires you to shift focus).

When I’ve learned new languages I’ve noticed much of what there is to learn are just “general programming” concepts making it much much easier to discern from concepts unique to that language. . Also, you begin to notice patterns in the syntax of different languages that after a while you look at a language you haven’t seen before and really pick up on what’s going without much effort.

List of Languages based on Similarity
  • Traditional Multi-Paradigm General Purpose Compiled Languages: C, C++, C#, Rust, Go, Crystal, Nim, Dart
  • High-Level Multi-Paradigm General Purpose Interpreted Languages: Javascript, PHP, Ruby, Python, Swift, Perl, Raku
  • Virtual Machine Bytecode Based: Java, LUA, Groovy, Haxe, Kotlin, Ballerina, Scala
  • Transpiled Languages: Rescript, Typescript
  • Functional Language Family I (LISP): Lisp, R, Clojure, Scheme, Julia, Idris
  • Functional Language Family II (Erlang): Erlang, Elixir
  • Functional Language Family III (ML/Haskell): ML, Haskell, OCAML, Reason, F#, ELM

Basic Testing and Dev Ops

Learning how to write unit tests, using docker containers and cloud functions are worthwhile skills to have regardless of what area of development you are going into.

Bookmark this article, I’ll add to it as I think of more tips and check out the other posts on this blog (updates will be on the original posting at

© 2020