Platform and Technologies

This page discusses the technology stack that we selected for the new Grants and Agreements application.

Moving Toward

At the direction of the Forest Service CIO, we are transitioning to a stack that uses a client-side Angular application (TypeScript) and a backend Express application (NodeJS, Express, TypeScript) hosted on AWS Lambda.

At a high level Angular and Lambda were chosen because they align with the modernization long term vision of a streamlined tech stack. Those were chosen by the ADMO/EAD group because it aligns well with the current skill sets of the development teams and has widespread usage in both the private and public sector.

They are part of the larger platform context that includes API driven development, capability for both UI and backend development using TypeScript, and for readily available resources. The goal will be to create loosely coupled functions that will allow NRM to transition the UI and Oracle databases.

(Source)

Supporting Languages, Platforms, and Tools

At present, we're using the following languages, platforms, and tools to support our work. These may change, and our ADRs should be considered the primary trusted source of information on technologies.

Languages

• TypeScript: Having TypeScript on both the frontend and backend reduces context switching and may enable code reuse (e.g. interfaces / type definitions).

Platforms

• Forest Service Jenkins: The Forest Service Jenkins instance is used to build, test, and deploy software.
• [transitioning off] CircleCI: Continuous Integration pipeline. We expect to be migrating our CircleCI pipeline to Jenkins once ADR 2 has been decided.
• Docker Compose: Allows us to stand up isolated infrastructure on our local environments for development and local testing.

Tools

• Prettier (CI, local): Enforces code style
• OWASP (CI): Checks for security vulnerabilities
• SonarQube (CI): Checks code quality
• [by default, ADR to come] Jasmine (CI, local): default test framework for Angular frontend
• [by default, ADR to come] Jasmine (CI, local): test framework for NodeJS/Express, aligns with Angular frontend to reduce context switching

Original Prototype

There was an initial prototype application developed on a different platform.

The application is cloud-native, server-side rendered, and written in Python using the Django web application framework.

The Grants and Agreements application has some particular features that inform the decision making:

• there is a detailed workflow as an agreement moves back and forth between multiple staff members
• it has a very long time scale; agreements often last for five years and the lifetime of the application could be 10 or 15 years
• it is financially focused rather than spatially focused

Cloud Native

In 2021, this is fairly obvious for making a new application. A truly cloud-native application can flexibly move from platform to platform as an organization evolves. The essential properties of cloud-native applications are captured by https://12factor.net/ or https://www.cdta.org/sites/default/files/awards/beyond_the_12-factor_app_pivotal.pdf. In particular,

• the application processes are stateless and stateful data is in a separate database service
• all communication is over exposed ports across the network
• continuous testing and deployment

Server-side rendering

The detailed workflow that a grant or agreement follows has a well-defined set of states and attached information. The interactions of users move the items between these states and manipulate the information. 18F recommends simplicity for application architectures and a server-side rendered application is simpler than a client-side architecture. With the limited requirements for interactivity, this application is a good fit for the simplest possible database-backed, server-side web application.

Python with Django

The long time horizon of this application argue for a mature web application framework that will be flexible and maintainable over the long term. Simultaneously, time to delivery is important for the modernized application, so a more dynamic language and framework have value as well. Python is a mature, modern language, solid and easily deployed for cloud applications and integrating different systems and technologies.

• Python programming experience is common in the market and Python is a respectable middle-aged programming language.
• Flexibility is built into the architecture.
• Python is an excellent glue language for interconnecting other things. We can allow inter-operability using that.
• Python and Django operates very well with the FS CIO standards for cloud, CI/CD, cybersecurity, etc.
• Django isn’t just convenient for prototyping. We considered micro-frameworks such as Flask, but the model-template-view setup is well suited for this application and provides the tools out of the box to make these types of applications easily.