Getting Practical

One of the problems we face is that we have a tendency to teach and learn concepts in a vacuum.

Students practice code in a controlled environment setting where there are negligible variables and a pre-determined expected outcome.

As a result, we may not be adequately equipping beginners for what they will likely experience in the wild.

More often than not we are dealing with pre-existing codebases with legacy code. We have to contend with all the quirks from outdated library versions conflicting with one another and all the undocumented patches that were applied by everyone that has worked on the project in the past.

Learners should probably find opportunities to solve practical problems in the real world.

This can be through personal projects, offering your services to friends and family to build a simple website or app, or contributing to open source projects.

Writing Code

I expect any college course, code school, or code bootcamp to teach how to debug code.

Prospective candidates should be equipped with an established process that works for them that helps them arrive closer to a solution.

Students should be familiar with where to look to check for errors, how to output values or utilize breakpoints to understand where code is failing, and how to perform successful search queries and filter them by relevancy.

There is a great wealth of solutions to problems that already exist and it is a task of sifting through bug reports, forum posts, and chat archives. Sometimes we are faced with problems that have no easily available solution.

Students should be comfortable with this churning cycle of searching for answers, trying a solution, and rebuilding when that solution does not pay off.

Writing Good Code

I expect any college course, code school, or code bootcamp worth its salt to have discussions about what is "good code".

It is not just important that code solves the problem but also how it solves the problem is equally important.

Good Code
XKCD #844, Randall Munroe

We should be writing for people and not computers. We should anticipate another person using and modifying our code. That person can very well be ourselves returning to the project at a later date.

Students should be familiar with the pitfalls of spaghetti code and technical debt. And practices that can help mitigate those problems - like style guides and coding standards.

I believe that there is an arc of developing as a developer.

At the first stage, you work towards solving a problem.

You might not know exactly how the example, Stack Overflow post, or random library solved the problem. But you accomplished the immediate task at hand.

At the second stage, you begin to understand the solution.

You might not know exactly why one solution is better than another. But you now know how the underlying mechanics work. Here you begin to recognize what a problem will likely involve - caches, networks, client-side, server-side. Your eyes are open to how the problem you are solving interacts with other parts of the project.

At the third stage, your understanding of all the interacting parts now allows you to percieve areas that can improve.

You can now research a language and tool and weigh the pros and cons of implementation with how it relates to a particular use case. Here you are equipped to extrapolate from previous solutions and create new novel ones. You have learned from your mistakes and have created processes to mitigate them from recurring.

Recommended Skills

Perhaps largely overlooked in all this technical knowledge is the reality that you will not just be working with a computer but with other people in varying capacities. Having a fair amount of "soft skills" will contribute to your ability to work with others as part of a "team".

  • Communication
  • Asking Questions
  • Giving and Receiving Criticism

The following is a purely subjective list of common skills that are necessary in modern development:

  • Familiarity with email in an professional setting
    • Understanding cc and bcc
    • Avoiding Reply All
    • Can utilize attachments (compressed zip or links to large files)
    • Can follow conversations in email threads
    • Can reply or provide follow-up updates in a timely manner
    • Ability to reread what they wrote and anticipate if there is enough information in the email for the recipient
  • Familiarity with a ticket system workflow with a team (GitHub Issues, Bugzilla, Jira, Lighthouse)
    • Can manage their time when responding to and resolving tickets
    • Can create informative bug reports
      • Expected behavior and experienced behavior
      • Including information about operating system and browser
      • Can create reproducible steps
      • Can create reduced test cases
      • Can take and attach annotated screenshots
    • Can follow comment threads and reference past issues
  • Familiarity with a version control workflow with a team (Git, GitHub, GitLab, BitBucket, SourceTree, Tower, GitKraken)
    • Can create atomic commits
    • Can create descriptive messages
    • Can revert commits
    • Can use feature branches
    • Can resolve merge conflicts
  • Familiarity with basic computer literacy for operating system and application usage
    • Saving files
    • Moving files
    • Navigating directories
  • Familiarity with networking concepts like IP Addresses and DNS
  • Familiarity with the command line
  • Understands the benefits of linting and testing
  • Awareness of modern deployment workflows

A good number of these skills are remedied by participating in and contributing to active and well-maintained open source projects.

Further Reading

⬅
➡