The world of software is a vast and erratic one, with constant improvements to the tools and technologies developers use everyday. In such a fluctuating field, it is no wonder that colleges and universities focus software related coursework on fundamentals such as programming languages and basic algorithms. Recent grads can then find themselves reeling upon graduating and entering the tech field, where an expansive portfolio and diverse skill-set are valued much more highly than a degree alone. As a recent grad myself, the transition from education to industry has proven both challenging and incredibly rewarding, and I thought I would record some of the key differences I have experienced throughout that might just help the next generation of software developers on their journey.
In college, many students consider what and how many programming languages a person knows to be most important when entering the software industry. While valuable, languages are just the tip of the iceberg in software development. For myself, the usage of development frameworks was a concept almost entirely missing during college, but in reality frameworks are a near universally used tool in software. In fact, often the decision of what framework to use for a project is what determines the language being used.
Frameworks are invaluable platforms for application development, providing collections of functions, classes, libraries, and other useful tools to a project. However, frameworks often have their own syntax and methodology to learn, just like a programming language. For some, all this new information to learn can be daunting when starting as a new dev, but thankfully most modern frameworks have plenty of documentation and examples available. Looking back, implementing a framework into various homeworks or practice projects would have been invaluable to my education, while also making me a more industry-ready developer. Of course, there are many other things I wish I had known prior to graduating as well, but frameworks are one of the most accessible and instrumental.
As a student, almost everything you do is done at an individual level. Assignments, projects, practice work - just about everything done affects only the person doing it. Your grade will only be your own. Even in cases of group projects, often the work is split at the beginning and combined at the end, with little interaction in the meantime. This couldn’t be farther from how modern software teams interact and collaborate on projects. Software development is compelling in that much of the work is done at an individual level, but the work itself is a part of a greater whole in which all involved contribute and rely on the work of others.
The process of creating an application is complex, requiring immense amounts of coordination and planning. This makes communication and interaction paramount, with each team member providing input for the next steps of a project and feedback to constantly improve one another as well as the project itself. To enhance the collaborative nature of software development, many tools have been created, though none more popular than Git version control.
At a basic level, Git allows developers to keep different versions of the same codebase in different stages of development, as well as to track changes to that codebase as they happen. As a college student, it is very unlikely for most to have worked on a project of large enough size or with enough members to necessitate Git, despite its almost universal usage within the industry. Git is the tool which allows individual members of a dev team to work on the same project with minimal toe-stepping, and easily combine separately developed features into one. Of course, using Git requires some familiarization as well, utilizing its own syntax and methodologies to accomplish all that it is capable of. Additionally, there are many different strategies for version control that exist, requiring further learning.
Git can sometimes be intimidating as a new developer, particularly due to the lack of coverage in college. However it’s almost inevitable that new grads will utilize Git at some point in the software industry, making it an alluring skill to bring to the table as a new developer.
For some, the title ‘software developer’ means you are someone who can huddle over a keyboard and seemingly conjure magic from the many windows and tabs on-screen. As a developer, ‘develop’ is certainly the operative word, with progress only incrementally achieved. Developers don’t create magic, but instead carefully and systematically build illusions, in the sense that the end-user only sees what is intended, and not the smoke-and-mirrors behind the scenes. In most cases the ‘magic’ is the product of sometimes years of planning and implementation, developing from an idea to the end product. As a student, rarely does the education process accurately reflect this long-term process.
Many courses regarding software utilize homework and projects to apply the knowledge being taught, but few encompass the full scope of what a true industry project envelops. A homework assignment might ask a student to accomplish a particular task by writing a function within a week, with 6 or 7 such assignments given in a semester. While excellent for reinforcing the fundamentals of programming, these assignments do not prepare students for true software development. In school these functions are usually a means to an end; either they accomplished the task as described, or they didn’t. Conversely as a developer, accomplishing the task is only the first benchmark for a good program, with things such as maintainability and scalability being of almost equal importance. These types of homework are essentially non-existent in industry, where sometimes numerous programs are working in unison, as well as multiple facets of the application as a whole. Even in large semester-long projects, it is unlikely for students to work on something that includes a database, front and back ends, API usage, and appropriate security, all things you can expect to find in an industry project.
New devs might find the change in work challenging due to the differences from that done in college courses, which makes personal practice and projects all the more important while in school. Similarly, new devs may have driven their education to be exclusively good at one element of development such as the front-end, and feel confused as to how to successfully integrate with other application areas. Diversifying skill sets and identifying both strengths and weaknesses helps to ease these feelings, and to quickly feel comfortable as a developer!
In an industry as constantly innovating as software, no graduate starting their career is going to seamlessly transition to software development. However if, like the industry itself, new devs constantly improve their skills and understanding, success should follow!