Strategies for Becoming a High-Impact Software Developer

So you've decided to become a software developer for one reason or another. Perhaps you want to rake in the big bucks at a technology-centric company? Perhaps you want to create a sellable technical product from scratch? Perhaps you want to flex your technical expertise - I'm definitely not speaking from personal experience 😂 - so that you can assert yourself as the chosen one amongst your colleagues? Whatever your reason for learning software development might be, every software developer wants to accomplish activities effectively and efficiently. Well, that's easier said than done.

In this blog post, I hope to break down some insights that I have accrued while becoming a more effective and efficient software developer myself. I will discuss the following:

• Setting up your workstation
• Pedagogy for learning software development
• Defining the scope of your project
• Writing modular code centred around a feature
• Shipping your project

To preface this discussion, we can first define what it is meant to be an 'effective' and 'efficient' software developer. An effective software developer is successful in producing a desired or intended result. An efficient software developer achieves maximum productivity with minimum wasted effort or expense. Moreover, before one can be an efficient software developer, one must become an effective software developer since being efficient in implementing an incorrect, incomplete, or sub-optimal solution to a problem at best may not yield the results that you are hoping to achieve and at worst may be counterproductive to your project's goals.

The first question that one naturally asks is what is a great workstation setup? This can be broken down into your workstation's technical requirements, your environment's ambience, and your workstation's ergonomics.

In the context of web development, you will primarily be developing applications using the Command-Line Interface, a development environment such as Visual Studio Code, and a desktop browser such as Google Chrome, so you will need a computer with at minimum mid-range technical specifications, which would usually include at least 8GB of RAM for multitasking purposes.

Your workstation should be set up in a quiet (and perhaps isolated) space since most technical work requires long periods of uninterrupted concentration on the task at hand. In particular, bedrooms or home offices serve as a great location for such work.

Additionally, establishing a comfortable workstation entails finding a comfortable chair with great back support (since you may be sitting for hours on end), a sturdy desk that allows you to position your eyes in line with the top of your primary monitor, and multiple monitors for quickly viewing development-related applications (i.e. previewing your code in a browser on a secondary screen that you write in a development environment on your primary screen). The monitors should be large enough to easily see the smallest parts of your viewable applications but small enough that you do not have to turn your head to see content on another monitor. On a personal note, I find that using my software development applications in dark mode and turning the room's lights off tend to increase my ability to focus on the monitors' content.

Next, we move on to the most important aspect of becoming an efficient and effective software developer, which is employing the best pedagogy for learning computer science fundamentals and new technologies.

Learning software development can be categorized into three phases. Those phases include learning computer science fundamentals, learning about the multitude of features in your development environments, and learning about specific technologies related to the type of software that you are developing (i.e. a Web, an Android, or an iOS application).

In the first phase, you will want to develop your computer science fundamentals in the following topics: software tools and systems programming; theory of computation; computer organization; data structures and analysis; databases; operating systems; and algorithm design, analysis, and complexity. Effective pedagogy for learning computer science fundamentals entails going through textbooks that cover the breadth and depth of the aforementioned topics in a rigorous manner. In particular, it is crucial to paraphrase proofs/solutions that you study and to attempt as many practice problems as possible in your chosen textbooks. The reasoning behind this is to develop a rock-solid foundational understanding of computer science through first-principles reasoning, which is at the heart of any mathematical STEM domain. Moreover, creating software applications from scratch requires first-principles reasoning to understand how complex pieces of code work and how they fit together.

In the second phase, you will want to learn more about your specific development environments. For example, within Google Chrome, you will want to become familiar with Developer Tools' features to test and debug your web applications. This information can be found in the documentation for the development environments that you are using. Effective pedagogy for learning more about your development environment is to immediately test features you read about in its documentation in an attempt to apply what you learn.

In the third phase, you will want to learn specific technologies for the front-end and back-end of your applications. For example, here are some typical technologies that are used in a MERN stack web application:

• Front-End: HTML (for webpage structuring), CSS (for webpage styling), Bootstrap CSS Framework (or another CSS Framework), JavaScript (for webpage scripting), GitHub Pages (for deploying front-end websites), and/or Heroku (for deploying full-stack websites)
• Back-End: Node.js (which is a runtime environment for using Javascript in the Command-Line Interface), Express.js (which is a web application framework that provides a robust set of features to develop web and mobile applications), MySQL (for SQL databases) or MongoDB (for NoSQL databases), GraphQL (which is an is an open-source data query and manipulation language for APIs), React (for webpage rendering), bcrypt (for hashing passwords), dotenv (for hiding sensitive information), JSON Web Tokens (JWT) (which is a proposed Internet standard for creating JSON data with optional signature and/or optional encryption), and Stripe (for processing financial transactions).

Effective pedagogy for learning new technologies is to immediately test features you read about in its documentation in an attempt to apply what you learn. Typically, the documentation for technology provides examples and sample code on how to correctly implement it.

Next, it is critical to define the scope of your project. To do so, one must wireframe the proposed software application, discuss application requirements and constraints with stakeholders, and design an architecture for the application. The application's architecture will inform how the application will be developed and what technologies will be used. This is the cornerstone in developing effective software applications that solve a well-defined problem using a well-defined solution.

Once high-level project details have been finalized, it is time to write modularized code that is thoroughly tested (e.g. through unit tests). Modular code allows for development focus on singular features and how they interface with the rest of the software application while also providing the ability to test those features in isolation away from the rest of the codebase in order to minimize your code's interference with other developers' work. Modularity also makes code easier to modify and reuse in the future. This is the cornerstone of efficient software development.

Finally, you are ready to ship your project (i.e. push your code to the production branch) once it passes a code review. This provides you will an opportunity to solicit feedback from senior developers on the structure and functionality of your code. In particular, senior developers can point you in the direction of writing more effective and efficient code.

To conclude, becoming an effective and efficient software developer entails having a strong understanding of fundamental computer science concepts, your development environment tools, the technologies used in your software application, and the production process. Moreover, soliciting feedback throughout the software learning and production processes can accelerate your ability to become a high-impact software developer and, consequently, catapult your career to new heights.

Feel free to check out jaspreetkhela.github.io/JaspreetKhela to find general information about me and links to my work-related social media profiles for more content!