DEV Community: Fedor Bystrov

9 Simple Rules that will make your Java Code Better

Fedor Bystrov — Tue, 06 Jun 2023 12:44:30 +0000

1. Use `java.util.Optional` instead of `null`

By using java.util.Optional you will force clients to check existence of the value.

Consider getBeer(...) method below, the caller of the method expects to receive a Beer object and it’s not clear from the method API that the Beer can be null. The caller might forget to add a null check and will potentially receive NullPointerException which is a programmer error, by the way.

Before

public Beer getBeer(Customer customer) {
  return customer.age < 18
    ? null
    : this.beerCatalogue.get(0);
}

After

public Optional<Beer> getBeer(Customer customer) {
  return customer.age < 18
    ? empty()
    : Optional.of(this.beerCatalogue.get(0));
}

2. Return empty collection/array instead of `null`

Motivation is the same as above - we should not rely on null

Before

public List<Beer> getBeerCatalogue(Customer customer) {
  return customer.age < 18
    ? null
    : this.beerCatalogue;
}

After

public List<Beer> getBeerCatalogue(Customer customer) {
  return customer.age < 18
    ? emptyList()
    : this.beerCatalogue;
}

3. Use `var`

Type inference reduces the amount of boilerplate code and reduces cognitive complexity, which leads to better readability.

Before

static FieldMapper fieldMapper(FieldDescriptor fieldDescriptor,
                               SchemaDefinition schemaDefinition) {
    ValueGetter valueGetter = valueGetter(schemaDefinition, fieldDescriptor);
    return (dynamicMessageBuilder, row) -> {
        Iterable<DynamicMessage> iterable = (Iterable<DynamicMessage>) valueGetter.get(row);
        for (Object entry : iterable) {
            dynamicMessageBuilder.addRepeatedField(fieldDescriptor, entry);
        }
    };
}

After

static FieldMapper fieldMapper(FieldDescriptor fieldDescriptor,
                               SchemaDefinition schemaDefinition) {
    var valueGetter = valueGetter(schemaDefinition, fieldDescriptor);
    return (dynamicMessageBuilder, row) -> {
        var iterable = (Iterable<DynamicMessage>) valueGetter.get(row);
        for (var entry : iterable) {
            dynamicMessageBuilder.addRepeatedField(fieldDescriptor, entry);
        }
    };
}

4. Make local variables `final`

Making local variables final hints to a programmer that the variable can’t be reassigned, which generally leads to better code quality and helps avoid bugs.

Before

static FieldMapper fieldMapper(FieldDescriptor fieldDescriptor,
                               SchemaDefinition schemaDefinition) {
    var valueGetter = valueGetter(schemaDefinition, fieldDescriptor);
    return (dynamicMessageBuilder, row) -> {
        var iterable = (Iterable<DynamicMessage>) valueGetter.get(row);
        for (var entry : iterable) {
            dynamicMessageBuilder.addRepeatedField(fieldDescriptor, entry);
        }
    };
}

After

static FieldMapper fieldMapper(FieldDescriptor fieldDescriptor,
                               SchemaDefinition schemaDefinition) {
    final var valueGetter = valueGetter(schemaDefinition, fieldDescriptor);
    return (dynamicMessageBuilder, row) -> {
        final var iterable = (Iterable<DynamicMessage>) valueGetter.get(row);
        for (final var entry : iterable) {
            dynamicMessageBuilder.addRepeatedField(fieldDescriptor, entry);
        }
    };
}

5. Use static imports

Static imports make code less verbose and hence more readable.

Please note, there is one edge case to this rule - There are a bunch of static methods in Java (List.of(), Set.of(), Map.of() etc.) static importing which would harm code quality, making it ambiguous. So, using this rule, always ask yourself - Does this static import make code more readable?

Before

public static List<FieldGetter> fieldGetters(SchemaDefinition schemaDefinition,
                                             FieldName fieldName,
                                             FieldDescriptor fieldDescriptor) {
    final var schemaField = SchemaUtils.findFieldByName(schemaDefinition, fieldName)
        .orElseThrow(SchemaFieldNotFoundException::new);
    if (fieldDescriptor.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
        return schemaField.getFields().stream()
            .flatMap(it -> fieldGetters(schemaDefinition, it.getName(), it.getDescriptor()))
            .collect(Collectors.toList());
    }
    return Collections.emptyList();
}

After

public static List<FieldGetter> fieldGetters(SchemaDefinition schemaDefinition,
                                             FieldName fieldName,
                                             FieldDescriptor fieldDescriptor) {
    final var schemaField = findFieldByName(schemaDefinition, fieldName)
        .orElseThrow(SchemaFieldNotFoundException::new);
    if (fieldDescriptor.getJavaType() == MESSAGE) {
        return schemaField.getFields().stream()
            .flatMap(it -> fieldGetters(schemaDefinition, it.getName(), it.getDescriptor()))
            .collect(toList());
    }
    return emptyList();
}

6. Prefer fully qualified imports

The same as above, it makes code more readable.

Before

public SchemaDefinition.GraphView makeSchemaDefinitionGraph() {
    final var rootNode = new SchemaDefinition.RootNode();

    final var messageNode1 = new SchemaDefinition.MessageNode.MessageNodeBuilder()
        .withHeader("message-header-1")
        .withBody("message-body-1")
        .build();
    final var messageNode2 = new SchemaDefinition.MessageNode.MessageNodeBuilder()
        .withHeader("message-header-2")
        .withBody("message-body-2")
        .build();

    rootNode.addNode(messageNode1);
    rootNode.addNode(messageNode2);

    return rootNode.asGraph();
}

After

public GraphView makeSchemaDefinitionGraph() {
    final var rootNode = new RootNode();

    final var messageNode1 = new MessageNodeBuilder()
        .withHeader("message-header-1")
        .withBody("message-body-1")
        .build();

    final var messageNode2 = new MessageNodeBuilder()
        .withHeader("message-header-2")
        .withBody("message-body-2")
        .build();

    rootNode.addNode(messageNode1);
    rootNode.addNode(messageNode2);

    return rootNode.asGraph();
}

7. Put each parameter on a new line in long method/constructor declarations

Having a particular code style and using it across the codebase reduces cognitive complexity, meaning that code is easier to read and understand.

Before

public void processUserData(String name, int age, String address, double salary, boolean isEmployed, String occupation) {
    //...
}

// or

public void processUserData(
    String name, int age, String address, double salary, boolean isEmployed, String occupation
) {
    //...
}

// or

public void processUserData(String name, int age,
  String address, double salary, boolean isEmployed, String occupation
) {
    //...
}

// or

public void processUserData(String name, int age, String address, double salary, 
                            boolean isEmployed, String occupation
) {
    //...
}

After

public void processUserData(String name,
                            int age,
                            String address,
                            double salary,
                            boolean isEmployed,
                            String occupation) {
    //...
}

// or

public void processUserData(
    String name,
    int age,
    String address,
    double salary,
    boolean isEmployed,
    String occupation) {
    //...
}

8. Create immutable POJOs or use `record`

Immutable classes are easier to design, implement, and use than mutable ones. They are less prone to error and are more secure. With immutable objects, you don't have to worry about synchronisation or object state (Was the object initialised or not?).

To make class immutable:

Make all fields in the class final
Create a constructor/builder that will initialize all fields
If the value is optional (can be null ) use java.util.Optional
Use immutable collections or return immutable views in getters ( Collections.unmodifiableList(...) etc)
Don’t expose methods that modify object’s state

Before

public class User {
    private String name;
    private int age;
    private String address;
    private List<Claim> claims;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public List<Claim> getClaims() {
        return claims;
    }

    public void setClaims(List<Claim> claims) {
        this.claims = claims;
    }

// ...
}

After

public class User {
    private final String name;
    private final int age;
    private final String address;
    private final List<Claim> claims;

    public User(String name, int age, String address, List<Claim> claims) {
        this.name = requireNonNull(name);
        this.age = requirePositive(age);
        this.address = requireNonNull(address);
        this.claims = List.copyOf(requireNonNull(claims));
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getAddress() {
        return address;
    }

    public List<Claim> getClaims() {
        return claims;
    }

// ...
}

Or using record if you use java 14+

public record User(String name, int age, String address, List<Claim> claims) {
    public User {
        requireNonNull(name);
        requirePositive(age);
        requireNonNull(address);
        claims = List.copyOf(requireNonNull(claims));
    }
}

9. Use Builder pattern for classes with many parameters/optional parameters

The Builder pattern simulates named parameters available in Python/Scala/Kotlin. It makes client code easy to read and write, and it enables you to work with optionals / parameters with default values more fluently.

Before

public class User {
    private final UUID id;
    private final Instant createdAt;
    private final Instant updatedAt;
    private final String firstName;
    private final String lastName;
    private final Email email;
    private final Optional<Integer> age;
    private final Optional<String> middleName;
    private final Optional<Address> address;

    public User(UUID id,
                Instant createdAt,
                Instant updatedAt,
                String firstName,
                String lastName,
                Email email,
                Optional<Integer> age,
                Optional<String> middleName,
                Optional<Address> address) {
        this.id = requireNonNull(id);
        this.createdAt = requireNonNull(createdAt);
        this.updatedAt = requireNonNull(updatedAt);
        this.firstName = requireNonNull(firstName);
        this.lastName = requireNonNull(lastName);
        this.email = requireNonNull(email);
        this.age = requireNonNull(age);
        this.middleName = requireNonNull(middleName);
        this.address = requireNonNull(address);

        if (firstName.isBlank()) {
            // throw exception
        }

        // ... validation
    }

    // ...
}

// And then you would write:
public User createUser() {
    final var user = new User(
        randomUUID(),
        now(),
        now().minus(1L, DAYS),
        // firstName, lastName and email are String, what if you
        // mix up parameters order in constructor?
        "first_name",
        "last_name",
        "user@test.com",
        empty(),
        Optional.of("middle_name"),
        empty()
    );

    // ...
    return user;
}

After

public class User {
    private final UUID id;
    private final Instant createdAt;
    private final Instant updatedAt;
    private final String firstName;
    private final String lastName;
    private final String email;
    private final Optional<Integer> age;
    private final Optional<String> middleName;
    private final Optional<Address> address;

    // private constructor
    private User(Builder builder) {
        this.id = requireNonNull(builder.id);
        this.createdAt = requireNonNull(builder.createdAt);
        this.updatedAt = requireNonNull(builder.updatedAt);
        this.firstName = requireNonNull(builder.firstName);
        this.lastName = requireNonNull(builder.lastName);
        this.email = requireNonNull(builder.email);
        this.age = requireNonNull(builder.age);
        this.middleName = requireNonNull(builder.middleName);
        this.address = requireNonNull(builder.address);

        if (firstName.isBlank()) {
            // throw exception
        }

        // ... validation
    }

    // ...

    public static class Builder {
        private UUID id;
        private Instant createdAt;
        private Instant updatedAt;
        private String firstName;
        private String lastName;
        private String email;
        // Optionals are empty by default
        private Optional<Integer> age = empty();
        private Optional<String> middleName = empty();
        private Optional<Address> address = empty();

        private Builder() {
        }

        public static Builder newUser() {
            // You can easily add (lazy) default parameters
            return new Builder()
                .id(randomUUID())
                .createdAt(now())
                .updatedAt(now());
        }

        public Builder id(UUID id) {
            this.id = id;
            return this;
        }

        public Builder createdAt(Instant createdAt) {
            this.createdAt = createdAt;
            return this;
        }

        // ...

        public Builder address(Address address) {
            this.address = Optional.ofNullable(address);
            return this;
        }

        public User build() {
            return new User(this);
        }
    }
}

// And then:
public User createUser() {
    // You end up writing more code in User class but the
    // class API becomes more concise
    final var user = newUser()
        .updatedAt(now().minus(1L, DAYS))
        .firstName("first_name")
        .lastName("last_name")
        .email("user@test.com")
        .middleName("middle_name")
        .build();

    // ...
    return user;
}

Best tech stack for indie hackers in 2023

Fedor Bystrov — Sat, 27 May 2023 18:00:00 +0000

What is the best tech stack for indie hackers - solopreneurs or small/medium teams? What software framework should you choose? What database? Should you use old-school MVC-style frameworks or a new and fancy JavaScript-based one? In this post, together, we will go through all these questions and try to select a stack that will work for us!

Before we dive deeper, let’s start with a few remarks:

The first and most important one is - no “ultimate tech stack” will help you solve any problem. You should always select the right tool for the job!
Next, even though it could be a viable option, I won't take No-Code into consideration as I believe it’s a very niche solution.

That said, let’s start by defining our expectations.

The most valuable asset we have is our time. To move fast, we must reuse as much software, technology, and infrastructure as possible. It means we should write as little boilerplate code as possible and spend as little time dealing with infrastructure as possible. Also, the technology we will use should be easy to work with and, at the same time, be flexible enough so that we can apply it to solve most of the problems.

So, we can say that:

We will use cloud computing services like AWS, Azure or Google Cloud / Firebase.
We will use the battle-tested, “boring” software stack with many libraries and utilities.
We will not reinvent the wheel. For example: want to send emails? – use SendGrid; need authentication and authorization, but the framework doesn’t provide it out of the box? – use Auth0 or Firebase. I hope you got the idea.

Okay, with expectations set, let’s see what’s out there that we can use for our projects.

Jamstack

Jamstack (JavaScript, API, Markup stack) is a novel approach to writing software for the web.

In essence, it means that

You will use a Static Site Generator (SSG) – there is actually quite a lot of them. I would recommend looking at Eleventy, Jekyll and Hugo. Writing plain HTML (see html5-boilerplate) is also an option, but SSG allows you to extract most of the boilerplate into a separate template, saving you much time.
Most likely, you will not have a “traditional” back end. Instead business logic of your app will reside partially on the front end and partially in the serverless functions (like AWS Lambda, Cloud Functions etc.). One particularly good option is Firebase. It has everything you need - authentication, cloud functions, hosting, database and many more.
You will use vanilla JavaScript to add interactivity to your web app.

Overall, it’s a very solid option. Using Firebase, you will have hosting, database and authentication out of the box. Cloud functions will enable you to create an API for both web and mobile. In addition, you will not need to manage any infrastructure; Google will handle everything.

But there are a few significant downsides as well:

The first downside is Cloud functions – the truth is that it’s harder to manage complex business logic using cloud functions compared to the old-school backend approach. Having many functions doesn’t help either. Also, keep in mind that each function call is basically an HTTP call.
The second downside is vanilla JavaScript. Of course, you can use tools like petite-vue or Alpine.js, but they are far from what React or Vue has to offer. Keep in mind that there is a particular reason we use SSGs. Frameworks like React use a thing called Virtual DOM which makes your website less SEO friendly, but luckily there is a solution.

Next.js

Next.js is a framework that allows you to create a rich user interface using React and gives you all benefits of SSGs - you can fully pre-render your React code into static HTML, choose to render your component server-side on each request or render component on the client side like regular React component.

Note, Next.js is a Node.js application, so you will have an additional complexity of deploying, managing/scaling/monitoring it.

Also, there are a bunch of frameworks similar to Next.js: Remix, Nuxt, and SvelteKit, to name a few. They all provide similar functionality. Frankly, if you want the job to be done – Next.js is your best option, with tons of documentation, tutorials and libs.

Old-school full-stack frameworks

Since we agreed to not reinvent the wheel, we should pick a framework that will resolve most of the hassle for us. Also, ideally, we would like to master one framework and apply it to as many projects as possible. Learning and mastering a new framework takes time which we would better spend delivering functionality to our users and testing new hypotheses.

Let's consider the features we would prefer to have in a framework:

It should be a full-stack framework. Having front-end and back-end separately has advantages but also comes with significant complexity. For example, using a full-stack framework you can fetch data from the database, render a template and return an HTML page to the user in one flow. With separate front-end and back-end, you must export an API, make HTTP calls, handle possible HTTP exceptions, etc.
The framework should have built-in database integration. It should be able to manage database migrations and have utilities to fetch data from the database
It should be easy to expose an API for your users or your mobile application
Since most applications require user authentication in some form, we would like our framework to provide it as well. Of course, you can argue that there’s an Auth0 which can be integrated into any framework, and you will be correct. But native authentication provides a few benefits over Auth0. For example, simple tasks like changing password, email or deleting an account will be provided for you by the framework, whereas doing it with Auth0 is trickier
Finally, even though it’s not a “must have” requirement, I would like to have the ability to integrate WebSocket easily in case I need to communicate with the user in real-time

I deliberately didn’t mention performance/scalability in the list above. Using the modern cloud, scaling your application vertically and horizontally, and caching correctly will allow you to scale your service infinitely. Most likely, your SQL database will become the bottleneck first.

Given everything we discussed so far, only a handful of frameworks satisfy all our requirements – Django, Ruby on Rails, Laravel and .NET. I won't delve into the specifics of every framework here. Each one is good and will help you go a long way. Instead, let's make a high-level comparison and understand their strengths and weaknesses.

One interesting observation I want to share with you is that a headline on each framework’s website 100% accurately represents the essence of the framework:

Django

“Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. Built by experienced developers, it takes care of much of the hassle of web development, so you can focus on writing your app without needing to reinvent the wheel. It’s free and open source.”

Strengths

Python – fantastic language, a huge library of packages, massive community
User Authentication built-in
Easiest among these four frameworks
Amazing documentation

Weaknesses

Weak asynchronous support
Outdated approach to the front end. Whereas other frameworks provide you with the tools like Hotwire in Rails or Blazor in .Net, to achieve the same in Django, you will have to hack everything together yourself
No built-in asset pipeline

By the way, I have an article demonstrating Django’s capabilities.

Ruby on Rails

“Rails is a full-stack framework. It ships with all the tools needed to build amazing web apps on both the front and back end. Rendering HTML templates, updating databases, sending and receiving emails, maintaining live pages via WebSockets, enqueuing jobs for asynchronous work, storing uploads in the cloud, providing solid security protections for common attacks. Rails does it all and so much more.”

Strengths

The best framework here in terms of developer productivity
Hotwire
Good documentation
A lot of high-quality gems for every occasion

Weaknesses

No User Authentication out of the box, though there are a few solid options that are relatively easy to integrate
Ruby language is not for everyone. However, if you don’t have strong preferences, I encourage you to try it before making any judgements

Laravel

“Laravel is a web application framework with expressive, elegant syntax. We’ve already laid the foundation — freeing you to create without sweating the small things.”

Strengths

Livewire
Starter Kits
Perfect choice if you are already familiar with PHP

Weaknesses

The most verbose framework out of these four
Deployment process is quite complex, and it’s easy to shoot yourself in the foot

.NET

“.NET is the free, open-source, cross-platform framework for building modern apps and powerful cloud services.”

Strengths

Blazor – .Net has the most advanced front-end stack among these four frameworks
The best user authentication functionality among these four frameworks, including session-based authentication, JWT and easy external provider authentication
Amazing asynchronous programming support
Static typing
The default Identity framework is highly customizable and has a decent default user interface, so you will not need to create sign-in, sign-up etc. templates from the ground up

Weaknesses

• Documentation could be better
• Steep learning curve

A few words about the database

Even though it’s not an absolute requirement, the above-mentioned full-stack frameworks assume that you will use an SQL database. Frankly, if you need a database, there’s no good reason to avoid the SQL database. Modern MySQL and PostgreSQL have everything you need, even the json types with indexing and are pretty cheap to spin up in the cloud.

Conclusion

So, “What stack is the best then?” you could ask me… Well, the answer is – it depends:

If you want to test a hypothesis and hack MVP together super fast, the Jamstack will be your best friend
Use Next.js + Firebase or .Net if you’re building a highly interactive web interface
If you’re just starting and don’t have experience with any of the frameworks – Django or Ruby on Rails will be your best options
If you’re building an AI application and want to keep the ML model along with your other code together in the same service, pick Django
If you are an experienced developer or a team, I strongly encourage you to try .Net. The Blazor functionality is simply unmatched by other frameworks. Also, static typing, exceptional asynchronous programming support and Identity framework are solid selling points
If you want a "Swiss Army Knife" framework your best options will be Ruby on Rails or .NET

In the afterword, I want to emphasize once again that there is no “ultimate tech stack”. You should always research and compare your requirements with what each technology offers. I hope this article can serve as a starting point for your research and will guide you in the right direction.

DEV Community: Fedor Bystrov

9 Simple Rules that will make your Java Code Better

1. Use java.util.Optional instead of null

Before

After

2. Return empty collection/array instead of null

Before

After

3. Use var

Before

After

4. Make local variables final

Before

After

5. Use static imports

Before

After

6. Prefer fully qualified imports

Before

After

7. Put each parameter on a new line in long method/constructor declarations

Before

After

8. Create immutable POJOs or use record

Before

After

9. Use Builder pattern for classes with many parameters/optional parameters

Before

After

Best tech stack for indie hackers in 2023

Jamstack

Next.js

Old-school full-stack frameworks

Django

Strengths

Weaknesses

Ruby on Rails

Strengths

Weaknesses

Laravel

Strengths

Weaknesses

.NET

Strengths

Weaknesses

A few words about the database

Conclusion

1. Use `java.util.Optional` instead of `null`

2. Return empty collection/array instead of `null`

3. Use `var`

4. Make local variables `final`

8. Create immutable POJOs or use `record`