THE OPTIS DEFINITION OF GOOD CODE

So, what does good Java and JavaScript code look like for us? You've probably heard a lot about software craftmanship and clean code. They aren't exactly new and applying them is a baseline expectation for any professional developer today. Essentials like meaningful variable names, short descriptive functions, and consistent formatting definitely help to keep things readable, but they simply aren't enough in today's world.

For us at Optis, good code needs to be highly readable and predictable. Code you can trust, and that's easy to change and adapt as your application grows and evolves alongside your organisation. It's code that doesn't surprise you with regression and defects weeks or months down the line. And, crucially, it's code that's thoroughly tested.

WHAT MAKES GOOD CODE?

Predictable and well-tested Java and JavaScript code doesn't just happen by accident. We combine proven practices and modern tools to achieve what you could call ‘Software Craftsmanship 2.0’: taking code quality to the next level. Let's take a look at some of the key elements.

Automation

Depending on the client's tech stack, we use inspection tools like SonarQube and Wiz to automatically analyse our code. This helps us find and prevent potential issues, from code smells and bugs to security vulnerabilities. We integrate these checks directly into our clients’ Continuous Integration (CI) pipelines, so builds fail if the code doesn't meet our quality gate. This way problems get caught early, when they're easiest to fix.

A test-first mindset

Testing is an integral part of our development process. We write tests that cover different scenarios and edge cases as a crucial part of the development process. This helps us catch bugs early and gives us the confidence to refactor and improve our code without fear of breaking things.

import { expect } from 'chai';

// Develop test scenarios that matter and build trust
describe('ShoppingCart', () => {
     it('should allow adding items to the cart', () => {
     });
     it('should allow removing items from the cart', () => {
    });
    it('should calculate the total price of items in the cart', () => {
     });
     it('should indicate when the cart is empty', () => {
     });
    it('should handle removing an item that does not exist', () => {
     });
});

Always improving through refactoring

Applications evolve, and so should their code. Continuous refactoring is crucial to keep things clean, maintainable, and adaptable, especially when you're building products that need long-term reliability. We use refactoring patterns to make small, incremental changes, so we can keep our clients’ code high-quality over time while avoiding major rewrites.

// Simplify by delegating responsibilities
// It improves readability and makes the code easier to maintain
function processOrder(order) {
     console.log(`Processing order for ${order.customer}`);
     printOrderItems(order.items);
     console.log(`Total: $${calculateTotal(order.items)}`);
}
‍
function printOrderItems(items) {
     for (const item of items) {
          console.log(`${item.name}: $${item.price}`);
     }
}
‍
function calculateTotal(items) {
     return items.reduce((total, item) => total + item.price, 0);
}

Observability tools

Systems have become more and more complex since we started many years ago, so simply monitoring for errors doesn't cut it anymore. That's why we've embraced observability: building applications specifically so we can easily understand their internal state while they are running. This deeper understanding is crucial: it improves resilience during failures, makes complex systems more manageable, and helps to keep our delivery reliable and consistent.

Luckily, there's plenty of help out there. We use tools like NewRelic, Prometheus, HyperDX, Splunk, SignalFX, and PagerDuty to collect logs, metrics, and traces. This telemetry gives us clear visibility into application performance across all environments, letting us proactively identify and address potential issues well before they impact end users.

AI-generated code? Yes, but no.

Like everyone, we're using AI coding assistants daily as a productivity tool to see how they can help us speed up development for our customers. But to be honest, you can't let important or strategic code be generated by any of today's assistants. We only recommend it for boilerplate code or suggesting some improvements. It's simply not ready (yet) to write production-worthy code, especially without a thorough check.

The developer needs to stay in the driver's seat when it comes to maintaining and improving the code. All code that is deployed to production is the responsibility of the developer, whether it was generated or not.

READY TO STOP WORRYING ABOUT YOUR CODE?

For us, software craftmanship is key to everything we do: it helps us build software people can depend on. Long-term solutions that are reliable, maintainable, and ready to adapt, because we want our clients to spend less time worrying about potential issues and more time focusing on their business.