Technology articles, tutorials, news, and more
A language-agnostic look at what makes a good developer. We take a high-level view of several of the most important areas of being an effective developer, and the skills which developers at any level should strive to continually improve. This includes technical skills, such as understanding and correctly applying development best practices, and soft skills, such as collaboration and understanding business requirements.
Like any language, Scala has pros and cons, making it a great choice for jobs at which it really excels. In this article, we discuss jobs for which Scala is particularly suited and some alternatives for jobs where Scala may be the wrong tool. We also take a look at the idea of language purity and how being able to use the right tool for the job, rather than force Scala to do every job, makes for a more versatile developer.
One of the hardest but most fundamental jobs of a developer is to approach a large, complex problem and break it down into smaller, self-contained, simpler components. Akka helps you do this by letting you define nicely-encapsulated, independent actors, allowing you to describe your functionality with a messaging API and store some internal state as needed.
In part one of a series on this project, today we'll take a look at the top-level architectural design of a multiplayer games backend serving several different games on the web.
Dealing with errors is an essential part of any application's design, and a key thing to consider while building software. Here we cover some best practices for how to deal with something going wrong, and how to design, propagate and catch exceptions specifically.
Implicits in Scala aim to make your code simpler and more concise by abstracting away some of the details of your implementation into some implicitly-resolved utilities. This keeps your concerns separated, keeping low-level logic like serialisation or the specifics of accessing data structures away from higher-level logic.
Today we'll take a look at how to write implicits, how they're resolved at compile time, and good and bad use cases for them.
Data modelling and JSON serialisation are very common concerns for any backend application, and Scala provides the ability to transform any JSON data into a strongly-typed set of models suitable for use within your application. This article covers some of the principles of modelling your data effectively and managing your serialisation logic, even in cases where the JSON data is poorly designed or difficult to work with.
Typesafe config is ubiquitous in Scala and is written in HOCON, a powerfully expressive superset of JSON, but it's common to overlook some key features which can simplify how you write your config. Are you making full use of what HOCON offers?
Need more advice? Want to talk?
Get in touch