Scala Posts

The Toptal Engineering Blog is a hub for in-depth development tutorials and new technology announcements created by professional freelance software engineers in the Toptal network.
Subscribe for daily updates today and check out the wealth of technical resources published by the Toptal network.
Michele Sciabarra
Scaling Scala: How to Dockerize Using Kubernetes

Are you a Scala developer hoping to scale your application in the cloud? If so, meet Kubernetes, a cluster manager for Docker applications. Developed by Google, it’s the latest in new open source tools making major waves.

In this article, Toptal Freelance Software Engineer Michele Sciabarra guides us through a step-by-step tutorial on how to take a generic Scala application and implement Kubernetes and Docker to launch multiple instances of the application.

Continue reading →
Sergey Reznick
Get Your Hands Dirty With Scala JVM Bytecode

The Scala language has continued to gain popularity over the last several years, thanks to its excellent combination of functional and object-oriented software development principles, and its implementation on top of the proven Java Virtual Machine (JVM).

Creating a language that compiles to Java bytecode requires a deep understanding of the inner workings of the Java Virtual Machine. To appreciate what Scala’s developers have accomplished, it is necessary to go under the hood, and explore how Scala’s source code is interpreted by the compiler to produce efficient and effective JVM bytecode.

Continue reading →
Michele Sciabarra
Using Scala.js With NPM And Browserify

Today, writing applications in languages that compile to JavaScript is a very common practice. Scala developers, for example, can use Scala.js and have the same language for both the server and the client. That said, Scala’s compiler and standard dependency management tools are too limiting in the modern JavaScript world.

In this article, Toptal Freelance Software Engineer Michele Sciabarra shows us how to integrate Scala.js with the plethora of JavaScript modules available on NPM, using tools like Browserify, and explains how to do this without even having to install Node.js.

Continue reading →
Michele Sciabarra
Developing for the Cloud in the Cloud: BigData Development with Docker in AWS

More and more people are moving their work from desktop applications to the cloud using an equivalent online web application. However, this has unfortunately not been true for software development IDEs. Although there have been some attempts to provide an online IDE, they have not come anywhere close to traditional IDEs.

In this article, Toptal Freelance Software Engineer Michele Sciabarra guides us on how to build a cloud-based development environment for Scala and big data applications, with the help of Docker in Amazon AWS.

Continue reading →
Federico Tomassetti
Creating Usable JVM Languages: An Overview

Java Virtual Machine (JVM), the powerful virtual machine behind programming languages like Java and Scala, provides a platform-independent environment for executing compiled bytecode. Programming languages built for the JVM can be used to write programs that can run on a wide range of platforms without modification and can even leverage all the libraries and frameworks that exist for the JVM.

In this article, Toptal engineer Federico Tomassetti presents an overview of the strategy and various tools involved in creating our very own programming language for the JVM.

Continue reading →
Josip Medic
Context Validation in Domain-Driven Design

Handling all validation in domain objects results in objects that are huge and complex to work with. In domain-driven design, using decoupled validator components allows your code to be much more reusable and enables validation rules to rapidly grow.

In this article, Toptal engineer Josip Medic shows us how validation can be decoupled from domain objects, made context-specific, and structured well to achieve more sustainable validation code.

Continue reading →
Diego Castorina
Concurrency and Fault Tolerance Made Easy: An Akka Tutorial with Examples

Writing concurrent programs is hard. Having to deal with threads, locks, race conditions, and so on is highly error-prone and can lead to code that is difficult to read, test, and maintain. This post provides an introductory guide to the Scala-based Akka framework, showing (with code samples) how Akka facilitates and simplifies the implementation of robust, concurrent, fault-tolerant applications.

Continue reading →
Paulo Renato Campos de Siqueira
Scaling Play! to Thousands of Concurrent Requests

Web Developers often fail to consider the consequences of thousands of users accessing our applications at the same time. Perhaps it’s because we love to rapidly prototype; perhaps it’s because testing such scenarios is simply hard.

Regardless, I’m going to argue that ignoring scalability is not as bad as it sounds—if you use the proper set of tools and follow good development practices. In this case: the Play! framework and the Scala language.

Continue reading →
Subscribe
The #1 Blog for Engineers
Get the latest content first.
No spam. Just great engineering posts.
The #1 Blog for Engineers
Get the latest content first.
Thank you for subscribing!
Check your inbox to confirm subscription. You'll start receiving posts after you confirm.
Trending articles