In the last few months, I was looking for a new job as a software developer.

I attended various interviews, talked to a lot of diverse people, had to solve different tasks, answered plenty of questions, and asked at least as many.

In this post, I will share with you what I have learned, and tell you some useful tips for doing well at your interview to get the job of your dreams.

I won’t give you an exhaustive list of technical questions, brainteasers and riddles. Instead, I’ll tell you how to make the most sense out of them.

Image for post
Image for post
Horizontal tree by Piet Mondrian

Software Today

Software development nowadays is less about technology and more about people. Good communication skills, knowledge sharing, and team spirit are essential qualities of software professionals in modern organizations. Software becomes more and more a people problem. …


As I was finishing my blog post about defining service boundaries, I had a very strong feeling that there must be some abstract concept of what I was trying to explain on concrete examples…

Of course, there is! It’s the concept of cohesion and coupling I will discuss in this post.

Image for post
Image for post
In the rain (cut) by Franz Marc

Let’s start with little definitions:

Cohesion: the degree to which the elements inside a module belong together.
Coupling: the degree of interdependence between software modules.

High cohesion and loose coupling are the most important principles in software engineering. They manifest themselves everywhere from code to team organization.

Cohesion and coupling are tightly related. Why are they so important? Both help us reduce complexity, the true fun killer of software development. …


Serialization is a great thing and a revolutionary feature of Java from the early days, but it does have some flaws. Among others, there are serious security issues I want to address in this post.

The problem

A typical example of a security issue is a communication via network using serialized Java objects. When the server is not secured against serialization exploits, it is theoretically possible to execute any command on the server:

client> curl -XPOST -H "Content-Type: application/x-java-serialized-object" http://127.0.0.1:8080/service/toupper --data-binary @exploit.serserver> ls -l /HACKED
-rw-rw-r-- 1 tomas admin 2770 Okt 12 07:40 /HACKED

Oops. This is not good. The command to execute in the exploit is pretty…


The Interface Segregation Principle (ISP) is the “I” in the SOLID acronym and states that clients should not be forced to depend on methods they don’t use.

It attempts to decouple clients from unnecessary details.

Image for post
Image for post
Garden in blossom by Kazimir Malevich

The Problem

Consider a typical violation of the ISP (in Java):

class UserService {

User register(String username) { … }

User find(String username) { … }

void lock(User user) { … }
}

class UserRegistrationClient {

private UserService userService;

/*constructor*/

void registerUser() {
String username = …

User user = userService
.register(username);

}
}

The UserRegistrationClient class doesn’t need anything else than the register method from the UserService, but it does depend on the whole API. …


In my previous post I briefly mentioned the importance of a good DevOps culture in an organization as an enabler to build state-of-the-art software, especially in the cloud environment.

The role of DevOps is crucial in modern software development and, at the same time, often misunderstood even by professionals. Creatively, new meanings were assigned to the term recently, and things got worse once again.

Is DevOps completely profaned or is there still a chance?

First, let’s summarize what I mean when talking about DevOps.

Image for post
Image for post
Stables by Franz Marc

DevOps is a mindset, a way of working, not a job title or a department. That is, DevOps is not the guy who’s taking care of your server or pipeline. In a true DevOps model, everybody is a DevOps engineer. Although the name is a bit misleading, not only developers (Dev) and system administrators (Ops) are involved. Any team member is included: developers, operations, testers, QA, support, infosec, product owner, etc. …


You Aren’t Gonna Need It (YAGNI) is one of the most important principles in software development.

“Perfection is achieved not when there is nothing more to add, but when there is nothing more to take away.” ~ Antoine de Saint-Exupery

We can see YAGNI as a special case of the Keep It Simple Stupid (KISS) principle. YAGNI applies to a higher level as it tells us to cut off any unnecessary part while KISS advises to make the rest as simple as possible.

“Everything should be made as simple as possible, but no simpler.” ~ Albert Einstein

Image for post
Image for post
Blowing Blues II (cut) by František Kupka

Violation of YAGNI is sometimes called overengineering. A feature for every possible case, functions/methods with a lot of input parameters, multiple if-else branches, rich and detailed interfaces, all those could be a smell of overengineering. It’s the opposite to the famous UNIX-mantra: Do one thing well. …


After several years of the microservice hype, now it seems monoliths are cool again! Does it mean, we have learned a lesson? I guess at least we accepted what Neal Ford stated in his book Building Evolutionary Architectures:

If you can’t build a monolith, what makes you think microservices are the answer?

The disturbing question is: Why is monolith synonymous with bad design for some and the right thing to do for others?

The reason is, there are two different kinds of monolith. While one is good, the other is pure evil.

Two Kinds Of Monolith

The first kind of monolith is what we usually picture under the word: a physical block of software, typically running as a single process. A physically monolithic system is developed and built as a single artifact, deployed at once and falling down as whole. Resources such as a database are often shared, communication is local, interprocess. …


Records are likely the most discussed feature new in Java 14. At the same time, there is a lot of criticism due to their non-object-oriented nature. A typical argument says that records are a concept from procedural programming and have no place in an object-oriented language.

Do records really encourage procedural rather than object thinking?

Image for post
Image for post
The Cathedral (cut) by František Kupka

Well, yes and no. I totally agree that records are no object-oriented feature, on the other hand, I believe there are valid use-cases for them even in perfectly object-oriented applications.

The reason is, there are no true objects at the boundaries. Consider for instance a REST resource, database entity or configuration properties. Those are all mere data structures, but still need to have their representations in Java code. …


Frameworks are good stuff, at least for middle to big enterprise applications. One doesn’t want to reinvent the wheel. Aspects like security, caching, monitoring are hard and it’s easy to get them wrong if implemented from scratch.

On the other hand, there are valid use cases where you probably don’t need all this advanced stuff. Examples can be a personal webpage, blog, product catalog etc.

For a lot of simple cases a static web generator is the right way to go, but you do want something interactive on your web like search, form or comments, a static page is just not enough, but a framework could be a bit overkill. …


Configuration properties is a great feature in Spring Boot. In a monolithic long-time running application, we often want to change the application settings. Those changes must be persisted to survive the application restart.

We can use environment post-processing for that. This post describes how.

Image for post
Image for post
Color King (cut) by František Kupka

Let’s start slowly; consider a simple class with configuration properties:

@ConfigurationProperties("hello")
@Getter
@Setter
class HelloConfigurationProperties {
private String greeting = "Hello!";
}

The property of greeting is used to print a greeting message from a REST controller:

@RestController
@RequestMapping("/hello")
@AllArgsConstructor
class HelloController {
private String greeting; @GetMapping
public String sayHello() {
return this.greeting;
}
}

After building and starting the application, we can see the default greeting to be…

About

Tomas Tulka

Software developer and occasional blogger: https://blog.ttulka.com

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store