Spock is a powerful Groovy-based framework that makes testing applications written in Java (as well as Groovy, Kotlin etc.) a very pleasant experience. Because it’s built on top of good ol’ JUnit, it integrates well with most of the existing test/build tooling. However, making it play nicely with the testing infrastructure of Spring framework (especially Spring Boot) used to be a bit tricky. Luckily, the latest Spock version 1.1 comes with a few improvements that make testing Spring apps (including mocking) easier.

They say a picture is worth a thousand words. I would say that a great talk is worth ten times more than that. Especially if you are a beginner looking for their way into a new topic. One such topic is functional programming, with its endofunctors, lambda calculus and set theory.

Luckily you don’t have to have a PhD in mathematics to approach functional programming, because we selected few talks to get you started. These range from a total beginner to slightly advanced, but all of them explain their topics in a very approachable language. So don’t worry and dig in!

Since the dawn on Android development, there have always been efforts to use some of the alternative JVM languages instead of plain Java. But given the constraints of the mobile world, most of them faced issues that prevented them from receiving large adoption. Kotlin, a new language developed by JetBrains with Android in mind, aims to change this.

Overview

I had a some time this weekend and was exploring the ways we could improve our javascript unit tests. The one thing I do not really like about angular unit testing is too much boilerplate code. Probably you all know something like this:

1

2

3

4

5

6

7

8

9

10

11

beforeEach(module('blabla'));

beforeEach( inject ( function ($controller, $rootScope, _$q_) {

$q = _$q_;

$scope = $rootScope.$new();

controller = $controller('createUserController', {

$scope: $scope,

TeamsService: TeamsService,

CountriesService: CountriesService,

Toggles: Toggles

});

}));

It’s not very exciting. Sure, you could create some level of abstraction above it and reuse it in all your tests, but it’s not so trivial and probably need significant amount of time to implement.

Introduction

There is the trend in last years chasing the high application availability. It’s really rare to see our application working in vacuum, more often it’s using another couple of services its depends on, aggregating and transforming their contents. And sloppiness any of these could really hurt performance of the whole. The last thing you want in this situation is to leave your application waiting for response from slow service and waste the valuable cpus cycles and blocking threads. The Java language try hard to provide us with tools of trade: Fork/Join framework was added to Java 7 and Parallel Stream to Java 8. All of them help us to be more productive working in highly concurrent environment by creating the right level of abstraction that makes our work more easy and less error prone. In this article I’ll try to introduce you the new concept of CompletableFuture in Java 8.