It's important for engineers to optimize for speed as much as possible. By solving performance problems, we can ensure advertisers don’t miss out on auctions and that publishers receive the bids needed to maximize revenue. The speed of our platform is crucial in making these auctions happen, which is why we closely monitor our elastic load balancing (ELB) surge queue. We want to share how we recently remedied capacity issues after noticing a case with an unusually high surge queue length.
At Smaato, we use several different database management systems to create, retrieve, update and manage data. These include MySQL, Vertica, Aerospike and, the one we will explore today, PostgreSQL.
As a PostgreSQL fan and long-time user (since 8.4), I have come across many “gotchas” in my work with the system when it comes to managing user permissions.
In order to help my fellow PostgreSQL users not get caught in these same pitfalls, this blog post highlights two of these common “gotchas” and outlines how to avoid them.
Receiving more than 19 billion ad requests every day, Smaato operates one of the world’s largest mobile advertising marketplaces. Our talented team of developers ensures the smooth operation of this marketplace — both our client-facing platforms (SPX and SDX) and the core technology “under the hood.” We're excited to provide a glimpse into the challenges and successes that our development team recently encountered: how to manage database changes in an efficient and effective way.
Smaato operates one of the world’s largest mobile advertising marketplaces. Our platform handles up to 10 billion mobile ads every day around the world. One of the challenges we, as Smaato developers, face daily is successfully integrating and communicating with the vast variety of technical interfaces used by our many partners who transact on our marketplace platform.
In this blog post, we wanted to give the technically inclined among you a glimpse into the challenges and successes we face in solving issues, in this case, related to monolithic applications by implementing extensible components using the Groovy language and also discuss why our developers chose Groovy over other available options.
Development is one of the key activities that build, enable and ultimately power the overall mobile environment. Today we are sharing some key insight into an important aspect of development – testing framework – from one of our most experienced developers here at Smaato.
Developers know that choosing the right testing framework for the job can be really complicated. The jUnit Framework is an excellent Java testing tool, but for specific tests that require sample data, better tools - like the Groovy-based Spock - are available. This post describes how to use Spock and how it handles test data. It also explores how Spock tests can be executed with jUnit tests and maven.
How jUnit Runs Parameterized Tests
To have a test that works with a set of test data, you need to define a data method which returns all samples in a Collection. Each sample is used to instantiate a new test class. The constructor needs suitable parameters for the test samples. Then all test methods are executed, as you can see in the code samples below:
Internet traffic is moving increasingly towards ubiquitous use of secure connections (HTTPS rather than HTTP). Proper handling of these secure connections in order to make them as fast as possible is an area of real concern for anyone running a web-based or mobile business.
For mobile companies like Smaato, the challenge with HTTPS is not encryption itself, but rather the certificate exchange and session key negotiation which imposes additional overhead on a small request over cellular networks. Even high speed 4G/LTE carrier networks can be problematic for the SSL/TLS handshake.
Let’s take a look at a highly simplified HTTPS request from a mobile device:
It’s widely acknowledged that testing is a key aspect of software quality. Due to the complexity of modern software development, many firms have started using end-to-end testing procedures as part of their software release process.
What is end-to-end testing? Let’s start with a definition. “End-to-end testing is a technique used to test whether the flow of an application right from start to finish is behaving as expected. The purpose of performing end-to-end testing is to identify system dependencies and to ensure that the data integrity is maintained between various system components and systems.”1
A few months ago at Smaato, we decided to implement end-to-end tests inside our Publisher Platform (SPX). SPX is a Java application on the backend and a mix of Angular, JS, Primefaces and pure HTML pages on the frontend. We apply a continuous integration system based on Jenkins to build the application and run tests.
In our quest to develop the most efficient, full featured mobile-first advertising platform, it has become evident that Smaato's development team had to adopt user acceptance tests (UATs). Manual checks done directly in releases or integrations tests on small parts of the application wasn't sufficient enough to minimize risks for bugs. Besides, we couldn't afford to take a full day to do complete round trips or tests for a feature. UATs allowed us to run those crucial tests in an automated fashion and focus on quality.
One year ago we in Smaato's data engineering team decided to use Scala programming language instead of Java for all new applications. This decision was driven by a number of reasons. First, the software we’ve been using in this space (Spark and Kafka) is predominantly developed in Scala. We need to have a good grasp on the language to work with these tools to contribute and extend them. Furthermore, our development team was pushing to use a modern language, and Scala's functional aspects lend themselves well to the kind of problems we have to solve.
Being able to seamlessly interface with Java code allows us to leverage our existing code base and work with other teams at Smaato. This is a good moment to reflect on the transition and talk about our learnings.
Agile is eating the world and user stories are at the heart of it. There's hardly a person in the business of software development who doesn't know the famous Connextra template: "As a <role>, I want <goal/desire> so that <benefit>." Management attitude depicted by this Dilbert comic strip is fading away to oblivion.
User story is a simple concept. It's easy to start writing it and that's one of its strengths. But writing good user stories is a whole different story.