Our Preferred Technologies

Though any self-resepcting software engineer can solve problems with any tools they're given, we still believe that you should choose the right tools for the right job, and that some tools are simply better than others. Everything will have benefits and drawbacks — there is no such thing as a free lunch, but some get their lunch more effectively than others.

We are generally concerned with the following problem domains:

• Product Development
  • Web Applications
  • Security
  • High Assurance Computing
  • Systems Programming
• Algorithm Design

Product Development

We recognize that there are a million ways of achieving a business goal, but we also believe that there are far fewer ways to do so in ways that are maintainable, efficient, and secure. Depending on the product, one or two of these facets might outweigh the others, but generally, they are fundamental factors affecting the life of any software product. We tend to be proactive when it comes to adopting better options — one problem domain traditionally solved with one technology might not be favorable in our opinion, while in other situations, we'd actually prefer the classic solution — it all depends on the goals of the product.

Web Applications

Aralia excels at web application development — although we don't repute a particular "stack", we find the following technologies to be very effective at achieving fast, secure, and maintainable web applications:

• Rust
• Haskell
• PostgreSQL
• NGINX
• Docker
• Nix

Our aim is to be flexible in how we design or contribute to applications and services, with an unapologetic passion for excellence.

Security

Security should never be an afterthought — you can't slap some encryption on a communications channel and think it's ready for a production environment. We minimize attack vectors in our application architecture before we begin developing:

• All passwords should be hashed as closely to the client as possible, prefering Argon2
• Use of Public Key Infrastructure (PKI) where encryption and signatures are concerned, preferring Elliptic-Curve Cryptography
• All HTTP and WebSocket connections should be secured with the latest effective TLS standards

…among a littany of other decisions for well-operating secure systems.

High Assurance Computing

Too often are bug reports made regarding stack overflows, memory leaks, or other issues where programs weren't operating by their intended design. Luckily, there are many tools available for engineers to employ, allowing them to minimize or eliminate these scenarios:

• Property testing a 'la QuickCheck for test-case generation
• Datatype design with Generalized Algebraic Data Types, Higher-Kinded Types, and Type-Level Programming
• Refinement types via Liquid Haskell
• Dependent types with Idris

Systems Programming

While Haskell other strongly-typed programming languages offer great deals of security and referential transparency, they don't offer strict runtime performance or low-overheads; often, they aren't concerned with memory consumtion, inefficiency, or proper secret deallocation, as they're intended to be intuitive and closer to mathematics than machines. Unfortunately for us, all we actually have is machines, and if you need higher performance or proper memory management, you'll have to turn to systems programming.

Lucky for us, though, there are modern approaches to systems programming that make our lives much easier and lend a much higher rate of maintainability for applications using those technologies. At Aralia, we consider Rust to be a top-performer; elegant, fast, and sturdy.