What Matters To Developers in 2018
I was thinking recently about how software development seems less and less about writing code than it used to be. Consider a typical set of responsibilities for building a website in 1998:
- Pick a language. This basically meant Perl or Python or C. In most cases, there was only one viable tool. For web development, you used CGI.
- Write your code. This meant hacking on some files in your home directory. No one really cared about version control yet. Testing was a sanity check before a server was made live. Deployment was rcp, or in many cases a site was simply served directly from your home directory on the computer under your desk (vpns were not a thing yet).
- Monitor the service. This typically meant a shell script pinging a host or some other trivial healthcheck. Full-time NOCs were not yet a thing, ops was a best-effort.
In 1998, writing the code was 80% of the work. Forget "twelve factor" apps, you were lucky to have three! Now, fast forward to 2018...
- Pick an ecosystem. You are probably already hemmed in by someone else's awful choice, but if you are lucky/cursed enough to be able to choose your ecosystem (because it is now about much more than just a language and a compiler), you have many things to consider. Is the ecosystem going to meet your needs? Does it have a reasonable selection of libraries and tool support? Do major cloud vendors support it? Does the world care about it enough to create a supply of cheap-enough developers? Is the language learnable? Is it cool enough to keep your employees from bolting for hipper pastures?
- Pick a cloud vendor (or not). I mention this next since most of your other choices and responsibilities will depend on what cloud you work with (or none if you go "on prem").
- Pick partners for services no one builds in-house anymore. For example, billing.
- Pick a repository hosting partner.
- Pick a container strategy.
- Pick a wiki/bug hosting solution.
- Pick a development methodology.
- Pick a storage model. SQL? NoSQL? Document-oriented? Graph? If you get this wrong, you're dead.
- Pick a QA methodology and toolkit. Unit testing won't be enough.
- Pick a load-testing, live-testing methodology. This is arguably QA of a sort, but is its own discipline now.
- Pick a logging strategy. Logging is a primary tool for both development, QA and increasingly, management.
- Pick a high-availability strategy. CAP theorem, consensus...distributed systems are everyone's business now.
- Pick a monitoring strategy. Your monitoring architecture can end up being as complicated as your actual code and reaches into the logging system with distributed tracing.
- Make it all secure.
- Implement a documentation standard. In modern teams, documentation can end up being a dedicated task for an entire group.
- Now, at long last, you are finally ready to code! In 2018 this is probably less than 20% of your work. Remember when you only had "twelve factor" apps?
last update 2018-01-20