Wix Engineering Blog

When I started with Scala in 2011 it was a pretty easy sell: show any Java developer the collections library, maybe a couple of lambdas as well, and they’re hooked. A few years later, lambda expressions are no longer a novelty: C# has had lambdas for years, JavaScript gained them with ES6, and even Java joined the pack with Java 8. This begs the question: With one of its traditional selling points off the table, is Scala still relevant? We at Wix believe the answer is an emph

Though the question of “How to query data from a database?” is quite an old one, we still have a reason to investigate it nowadays. True, it is common to query a list of rows from a database since that usually means less code and configuration and it's also the default approach. However, in certain scenarios, this method is just not optimal. In these cases, we don’t need all rows in memory right away, and sometimes we just can’t afford it. When addressing the issue of queryin

For quite awhile we have been maintaining an application that processes XML and JSON data. Usually the maintenance consists of fixing defects and adding minor features, but sometimes it requires refactoring old code. Consider, for example, a function that extracts an XML node by path: This function works fine, but requirements change and now we need to: Extract nodes from JSON and other tree-like data structures, not only XML Return a descriptive error message if the node is

In this post i will demonstrate a nice trick to add “extension methods” for a given class. Note: The feature is based on implicit class feature and available only in Scala 2.10 A class Cat has a name and a list of kittens. in this example we add a method named “hasKittens()” to the Cat class. This is done by creating the implicit class SmellyCat which implicitly wraps our Cat instance when calling “hasKittens()”. The following test shows the usage of this feature: To use the

One of the most common pattern we use on our day to day is converting objects from one type of object to another. The reasons for that are varied; one reason is to distinguish between external and internal implementations, another reason would be to enrich incoming data with additional information or to filter out some aspects of the data before sending it over to the the user. There are several approaches to achieve this conversion between objects: 1. The Naïve Approach Add

At Wix, we make extensive use of the Specs² testing framework. It has become the standard tool for writing software specifications in our backend group, replacing JUnit, Hamcrest and ScalaTest. We have always been highly fond of matchers, having adopted Hamcrest back in 2010, and our testing methodology has developed to heavily rely on matchers. We went as far as writing a small utility framework, back in our Java days, that takes an Interface and creates a matcher from it us

In this post I will cover usage of the Slick library, which provides a Scala-centric API over JDBC. Slick offers 3 flavors for querying the DB; I will focus on the plain SQL flavor. Note: Slick is only compatible with Scala 2.10. Maven dependency: DB table: We will represent the Animal domain object using the following case class: Note: The first parameter is complex type (UUID) and the third parameter is also complex type (Joda DateTime). We will hide all DB operations using

So we have some Scala code that consumes text from an InputStream from an HTTP response. So, like any good Scala developer, I handed over the response to a function that returns a String. This function performs some validations such as checking that the response status is 200, then consumes the InputStream. This was done by creating a scala.io.Source from the InputStream, then calling source.mkString to consume the response body. Or so I thought. Apparently, scala.io.Source i

How many times did you find yourself looking at an API which accepts some sort of string or int-based identifier and not being sure what the identifier should represent? This sort of thing happens a lot when you use several different DAO or Repository objects. For instance, I may have: Note how easy it would be to accidentally pass a dog id into the get method of CatRepository. Now, back in the happy days of Ada and Delphi (and Pascal, of course), you could define your own ty

In slightly more than 2 weeks, Tomer Gabel – with whom I have founded Underscore, the Israeli Scala user group – and myself are hosting Scalapeño, the first Israeli Scala conference. Working to promote the conference, Typesafe have been so kind as to host me as a guest blogger. Here’s a reblog of that post. Of two beginnings I first came upon the name Scala in 2009, when the startup I worked for started using Groovy to write smaller, more concise end-to-end tests. Starting to