Writing, adapting and maintaining code to create and improve digital services.
Development in digital services requires code to be created and constantly improved, with a constant focus on how it will be used. Identifying new tools and techniques and removing technical bottlenecks are vital to successful development and continuous service improvement.
Some relevant roles: technical architects, developers
Understand the differences and synergies between front-end design and back-end development.
Knowing a language
Having an aptitude for programming and being confident in at least 1 language for both front-end and server-side uses (eg, Python, Ruby, PERL, Java, Scala or PHP).
Applying programming paradigms
- being confident in the core concepts of major programming paradigms (eg object-oriented programming)
- applying these to new and developing technologies and languages
Understanding data formats and architectural styles
Understanding and using data formats (eg, XML and JSON) and architectural styles (eg, REST).
Continuous integration and improvement
Releasing code frequently
- understanding the concept of continuous integration
- being confident in releasing code as it is ready for deployment
- analysing and refining code to improve performance
- continually improving services to make them ‘simpler, faster and clearer’
- visually inspecting code for quality (both your own code or the code of others in the team)
- creating code on the concept of progressive enhancement
- creating code for the most basic functionality that works on a baseline of devices before enhancing services so that they are platform and device agnostic
- understanding the features of various web browsers
- being able to create code that is compatible with a wide variety of browsers (and being able to test that compatibility)
- prototyping designs and layouts
- being able to adapt those designs based on user research
Creating code in multiple layers, so that it is modular and potentially re-usable, to enable more robust services to be created.
Knowing when to reuse code
Understanding the advantages and risks of using third-party code related to open-source technologies.
Knowing how to reuse code
Knowing the options for reusing code, such as:
- copying the code into your project
- pulling in third party dependencies automatically using a dependency management tool
- forking the third party code into a separate repository that you manage
Decreasing risks of reusing code
Decreasing the risks of reusing code by using:
- dependency management tools (eg Maven or Bundler)
- commercial tools (eg Gemnasium or Sonatype CLM)
- mailing lists (eg RedHat or CERT-UK)
Developing to avoid security exploits
Writing secure code
- understanding how security procedures and standards affect how you code
- writing code that’s secure
Understanding security attack vectors
- making sure these loopholes are closed when programming
- having an understanding of the risks of developing in an agile environment
- setting expectations about the length of time it might take for services to become minimal viable products
- managing those expectations
Having a strong understanding of service-oriented architecture and how it supports server-side web applications, as the government moves towards more interdependent services as part of the digital transformation.
Server-based operating systems
- using server-based operating systems comfortably
- maintaining those application environments
- having a strong understanding of the server environment you work in
Assistive technologies and accessible services
- developing services that are accessible by default (which includes not only the visual elements but also the code mark-up, format and page structure)
- ensuring the service is usable with assistive technologies such as screen readers, screen magnifiers and speech recognition software
Web standards and the Equalities Act
- creating layouts and interfaces that meet web standards to ensure accessibility and compatibility for as many end users as possible (as a starting point, services should aim to meet Level AA of the Web Content Accessibility Guidelines (WCAG) 2.0)
- understanding individual and organisation-wide duties under the Equalities Act 2010
Using different environments
Assessing the environmental needs of a project in terms of development needs and a live service need (eg environments might include performance testing, staging and integration).
Testing and debugging tools
- using testing and debugging tools (eg Chrome Dev tools and Firebug) to support the development and improvement of digital services
- performance testing to assess the stability and responsiveness of a service
Building useful, robust, automated testing suites, and preview and staging areas, to support a continuous deployment environment.
Scaling, hosting and applications
Understanding how to scale an application or its hosting environment to support variation in demand.
Application programming interfaces (APIs)
This involves understanding:
- Application Programming Interfaces (APIs), their structure and components (eg caching and authentication)
- the role of good APIs in the context of open data and interoperable services
Designing and implementing database schemas
Designing and implementing database schemas which group information in a logical order.
Setting up and using a version control system and code management technologies for collaboration, review and management of projects.
Open source technologies
This involves knowing:
- what open source technologies are available to help develop a service
- when it is appropriate to use them
The Service Design Manual covers developer skills - what developers do and what to look for when recruiting. It also includes a section on managing software dependencies, which looks at the opportunities and challenges for developers when using third party libraries and frameworks.