The first impressions of a Java enthusiast when looking at Go's features.

The conclusion of this series about multiple dispatch focuses on using the technique in Clojure.

Tuning any database for maximum performance is crucial to most any application. We have a look at some of the bets practices for tuning one important aspect of MySQL: memory usage.

Dropwizard has taken the Java world by storm with it's ease of use and great functionality. The metrics library is particularly powerful for anyone wanting to measure statistics in their Java applications.

In this post, you will learn about autowiring—its limitations, advantages, and disadvantages in detail. You also get to know about different modes of autowiring used in Java web development.

This article discusses the history of polyglot programming, and considers whether it's still a valid premise.

Part 3 on multiple dispatch goes back to the roots of the concept from Common Lisp

Persistence is a part of almost every Java enterprise application. Unfortunately, persisting domain objects is a non-trivial task. On the contrary, it generates a lot of problems, especially when we're using a relational database. Let's see different approaches to the problem.

Not everything in JavaScript is an object, and some things are objects that you wouldn't expect to be.

To diagnose any memory problems, the Garbage Collection log file is the best place to start. Take a look at the anatomy of a GC log file in this helpful article.

One of the major new language features in Java 8 is the lambda function. In fact, it is one of the biggest changes since the Java 1 release. Take a look at this introduction to Java 8's lambda function.

Are you pro-Anemic Domain Model or pro-Rich Domain Object? This article looks at both and seeks to find a balance between the two approaches.

The Oracle functions CASE, DECODE, and COALESCE all perform similar functionality. They can transform a value into another value. Which one should you use? I'll explain the pros and cons of each in this article.

Part 2 of this Multiple Dispatch series focuses on implementing multiple dispatch in Python.

If you see an annotation, there must be some code somewhere to process it.

How to use F# to store state in object or class fields.

Learn how to use services registered with Apache Zookeeper to issue API calls correctly.

Testing that goes beyond just unit testing and integration testing. Why we should be doing full system testing.

[Ivan Zerin provides a primer on mocking methods that contain generic return types.] There are several cases where construction when().thenReturn is not suitable during Unit tests. One of then generic return type. I have faced such issue, let's take a look. There is a method in interface declaration: public interface FooInterface { public Iterable getList(); ... } Implementation looks like this: public class Foo implements FooInterface { public List getList() { ... } ... } At first mocking of such method should not be something unusual: public class UnitTest { @Mock private FooInterface mockFoo; @Test public void someUnitTest() { ... List testList = generateTestList(); when(mockFoo.getList()) .thenReturn(testList); } } But this code won't compile with error: Cannot resolve method 'thenReturn(List). Seems to be some mistake, cause returned type are correct from the interface point of view. This error happening cause compiler can not gurantee that returned type of method getList() will be List. Actually return type of method getList() in this case is Iterable and this means "Return some Iterable object with any objects that extends SomeClass". Let's rename this type as 'X'. So when(mockFoo.getList()) will create object OngoingStubbing> and it has method thenReturn(Iterable). Compiler can not tell what type X before runtime and cannot perform safe cast from List to Iterable (we perfrom actuall call of method thenReturn(List)). Sounds a little tricky but let's assume that SomeClass is standard Java class Number. Then classes Integer and Double are both fulfill the criteria of List. Let's say that as return type of mock we will use List, in this case, compiler should be ready that actual work with code during runtime will be performed with List too, but it is clearly that cast from Double to Integer will be incorrect (try to cast double value 12.6 to int). You could argue that in the case of mockito compiler won't need to bother about the casting of returned type because call of original method would not produce anything, but it is known by mockito. From compiler point of view, it is only Java code, that should be checked for safety and correctness before compiling. Ok, so how we should deal with such cases in mockito? Use doReturn() method: doReturn(testList).when(mockFoo).getList(); Such expression is not type safe, so it were designed for exceprional cases, so use it only when you cannot use standart when().thenReturn(), which is the type-safe, elegant and more readable syntax.

CSS is essential for web development; however, it's difficult to get right for your average developer, who may have interests elsewhere in the stack. Read this article to avoid needling inconsistencies and adopt best practices.