DEV Community: Deividas Strole

Java HTTP Requests Made Easy: A Practical Guide to java.net.http

Deividas Strole — Mon, 07 Sep 2026 03:07:44 +0000

If you're building a Java application that needs to communicate with a REST API, download data from a website, send JSON, or make HTTP requests, you don't necessarily need an external library.

Modern Java includes its own HTTP client in the java.net.http package.

In this tutorial, we'll learn how to use it to make:

GET requests
POST requests
Requests with headers
JSON requests
Asynchronous requests
Requests with query parameters
Requests with timeouts
Error handling

By the end, you'll have a reusable pattern for calling APIs directly from Java.

1. What is `java.net.http`?

The java.net.http package contains Java's built-in HTTP client API.

The three classes you'll use most often are:

HttpClient
HttpRequest
HttpResponse

They represent three different parts of an HTTP operation:

HttpClient
    ↓
HttpRequest
    ↓
Server / API
    ↓
HttpResponse

Think of them this way:

HttpClient   = sends requests
HttpRequest  = describes what you want to send
HttpResponse = contains what the server sends back

The API supports both HTTP/1.1 and HTTP/2.

2. Your First GET Request

Let's start with the simplest possible example.

Suppose we want to request:

https://jsonplaceholder.typicode.com/posts/1

We first create an HttpClient.

HttpClient client = HttpClient.newHttpClient();

Then create an HttpRequest.

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://jsonplaceholder.typicode.com/posts/1"))
        .GET()
        .build();

Finally, send the request.

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

Here is the complete program:

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {

    public static void main(String[] args) throws Exception {

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(
                        "https://jsonplaceholder.typicode.com/posts/1"
                ))
                .GET()
                .build();

        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        System.out.println(response.body());
    }
}

The response should look similar to:

{
  "userId": 1,
  "id": 1,
  "title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
  "body": "quia et suscipit..."
}

Notice something important:

HttpResponse<String>

We told Java that we want the response body converted into a String.

That happens because we used:

HttpResponse.BodyHandlers.ofString()

3. Reading the HTTP Status Code

Usually, you don't want to blindly trust the body.

You should first check the HTTP status code.

System.out.println(response.statusCode());

For example:

means the request was successful.

Common HTTP codes include:

200  OK
201  Created
204  No Content

400  Bad Request
401  Unauthorized
403  Forbidden
404  Not Found

500  Internal Server Error
503  Service Unavailable

You can handle the response like this:

if (response.statusCode() >= 200 &&
    response.statusCode() < 300) {

    System.out.println(response.body());

} else {

    System.out.println(
            "Request failed: " + response.statusCode()
    );
}

This is a much safer pattern than assuming every HTTP request succeeds.

4. Adding Request Headers

Real APIs often require headers.

For example:

Accept: application/json
Authorization: Bearer TOKEN
User-Agent: MyJavaApplication

You can add a header using:

.header()

Example:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://example.com/api"))
        .header("Accept", "application/json")
        .header("User-Agent", "MyJavaApp")
        .GET()
        .build();

You can also use:

.headers()

Example:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://example.com/api"))
        .headers(
                "Accept", "application/json",
                "User-Agent", "MyJavaApp"
        )
        .GET()
        .build();

5. Sending an Authorization Token

Many APIs use bearer-token authentication.

The HTTP header looks like:

Authorization: Bearer YOUR_TOKEN

In Java:

String token = "YOUR_TOKEN";

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://example.com/api/users"))
        .header(
                "Authorization",
                "Bearer " + token
        )
        .GET()
        .build();

For production applications, avoid hardcoding secret API keys directly into source code.

Instead, use environment variables or another secret-management mechanism.

For example:

String token = System.getenv("API_TOKEN");

6. Sending a POST Request

GET requests retrieve information.

POST requests usually send information.

Suppose we want to send this JSON:

{
  "title": "Learning Java HTTP Client",
  "body": "java.net.http is surprisingly convenient",
  "userId": 1
}

First create the JSON as a string:

String json = """
        {
          "title": "Learning Java HTTP Client",
          "body": "java.net.http is surprisingly convenient",
          "userId": 1
        }
        """;

Then construct the request:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://jsonplaceholder.typicode.com/posts"
        ))
        .header("Content-Type", "application/json")
        .POST(
                HttpRequest.BodyPublishers.ofString(json)
        )
        .build();

Send it normally:

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

Complete example:

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class PostExample {

    public static void main(String[] args) throws Exception {

        HttpClient client = HttpClient.newHttpClient();

        String json = """
                {
                  "title": "Learning Java HTTP Client",
                  "body": "java.net.http is surprisingly convenient",
                  "userId": 1
                }
                """;

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(
                        "https://jsonplaceholder.typicode.com/posts"
                ))
                .header(
                        "Content-Type",
                        "application/json"
                )
                .POST(
                        HttpRequest.BodyPublishers.ofString(json)
                )
                .build();

        HttpResponse<String> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

        System.out.println(
                "Status: " + response.statusCode()
        );

        System.out.println(response.body());
    }
}

7. What Are `BodyPublishers`?

You'll notice this code:

HttpRequest.BodyPublishers.ofString(json)

A BodyPublisher tells Java how to create the body of the HTTP request.

For a string:

HttpRequest.BodyPublishers.ofString("Hello")

For no body:

HttpRequest.BodyPublishers.noBody()

For a file:

HttpRequest.BodyPublishers.ofFile(path)

For raw bytes:

HttpRequest.BodyPublishers.ofByteArray(bytes)

A useful mental model is:

BodyPublisher = data going OUT

8. What Are `BodyHandlers`?

A BodyHandler tells Java how you want to receive the server's response.

For text:

HttpResponse.BodyHandlers.ofString()

For bytes:

HttpResponse.BodyHandlers.ofByteArray()

To save directly to a file:

HttpResponse.BodyHandlers.ofFile(path)

To ignore the body:

HttpResponse.BodyHandlers.discarding()

A useful mental model is:

BodyPublisher = request body going OUT
BodyHandler   = response body coming IN

For example:

HttpResponse<byte[]> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofByteArray()
);

Now:

response.body()

returns:

byte[]

instead of a String.

9. Downloading a File

The HTTP client can also download files.

For example:

Path destination = Path.of("image.jpg");

HttpResponse<Path> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofFile(destination)
);

Complete example:

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;

public class DownloadExample {

    public static void main(String[] args) throws Exception {

        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(
                        "https://example.com/image.jpg"
                ))
                .GET()
                .build();

        Path file = Path.of("image.jpg");

        HttpResponse<Path> response = client.send(
                request,
                HttpResponse.BodyHandlers.ofFile(file)
        );

        System.out.println(
                "Downloaded to: " + response.body()
        );
    }
}

10. Adding a Timeout

Network requests can hang or take longer than expected.

For that reason, you should usually configure timeouts.

You can configure a connection timeout when creating the client:

HttpClient client = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(10))
        .build();

And a request timeout:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://example.com"))
        .timeout(Duration.ofSeconds(20))
        .GET()
        .build();

You will need:

import java.time.Duration;

11. HTTP/2

Java's HTTP client supports HTTP/2.

You can explicitly request it:

HttpClient client = HttpClient.newBuilder()
        .version(HttpClient.Version.HTTP_2)
        .build();

You can check which version was actually used:

System.out.println(response.version());

Possible results include:

HTTP_1_1
HTTP_2

12. Sending PUT Requests

PUT is commonly used for replacing or updating resources.

Example:

String json = """
        {
          "name": "John"
        }
        """;

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://example.com/users/10"
        ))
        .header("Content-Type", "application/json")
        .PUT(
                HttpRequest.BodyPublishers.ofString(json)
        )
        .build();

13. Sending DELETE Requests

DELETE is simple:

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://example.com/users/10"
        ))
        .DELETE()
        .build();

Then send it as usual:

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

14. Sending PATCH Requests

HttpRequest.Builder has convenient methods for:

GET
POST
PUT
DELETE

But there isn't a dedicated .PATCH() method.

Use .method() instead:

String json = """
        {
          "email": "john@example.com"
        }
        """;

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://example.com/users/10"
        ))
        .header("Content-Type", "application/json")
        .method(
                "PATCH",
                HttpRequest.BodyPublishers.ofString(json)
        )
        .build();

15. GET Requests with Query Parameters

Imagine an API expects:

https://example.com/search?q=java&page=2

A simple request is:

String url =
        "https://example.com/search?q=java&page=2";

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(url))
        .GET()
        .build();

But values containing spaces or special characters should be URL-encoded.

For example:

String search = URLEncoder.encode(
        "Java HTTP Client",
        StandardCharsets.UTF_8
);

Then:

String url =
        "https://example.com/search?q=" + search;

You will need:

import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

16. Synchronous vs Asynchronous Requests

So far, we've been using:

client.send()

This is synchronous.

That means Java waits until the server responds.

send request
     ↓
wait
     ↓
receive response
     ↓
continue program

Example:

HttpResponse<String> response =
        client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

Java also provides:

sendAsync()

17. Making an Asynchronous Request

An asynchronous request looks like this:

client.sendAsync(
        request,
        HttpResponse.BodyHandlers.ofString()
);

Instead of returning:

HttpResponse<String>

it returns:

CompletableFuture<HttpResponse<String>>

Example:

CompletableFuture<HttpResponse<String>> future =
        client.sendAsync(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

You can process the response when it becomes available:

future.thenAccept(response -> {
    System.out.println(response.statusCode());
    System.out.println(response.body());
});

Complete example:

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class AsyncExample {

    public static void main(String[] args) {

        HttpClient client =
                HttpClient.newHttpClient();

        HttpRequest request =
                HttpRequest.newBuilder()
                        .uri(URI.create(
                                "https://jsonplaceholder.typicode.com/posts/1"
                        ))
                        .GET()
                        .build();

        client.sendAsync(
                request,
                HttpResponse.BodyHandlers.ofString()
        ).thenAccept(response -> {

            System.out.println(
                    response.statusCode()
            );

            System.out.println(
                    response.body()
            );

        }).join();
    }
}

The .join() keeps this small demo program alive until the asynchronous operation finishes.

18. Why Use `sendAsync()`?

Imagine you need data from three APIs.

With synchronous requests:

Request A ──────── finish
                   Request B ─────── finish
                                       Request C ───── finish

The total time can roughly become:

A + B + C

With asynchronous requests, they can run concurrently:

Request A ──────────
Request B ──────
Request C ─────────────

Example:

var request1 = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://jsonplaceholder.typicode.com/posts/1"
        ))
        .GET()
        .build();

var request2 = HttpRequest.newBuilder()
        .uri(URI.create(
                "https://jsonplaceholder.typicode.com/posts/2"
        ))
        .GET()
        .build();

var future1 = client.sendAsync(
        request1,
        HttpResponse.BodyHandlers.ofString()
);

var future2 = client.sendAsync(
        request2,
        HttpResponse.BodyHandlers.ofString()
);

var response1 = future1.join();
var response2 = future2.join();

System.out.println(response1.body());
System.out.println(response2.body());

19. Reading Response Headers

The HTTP response contains more than just a body.

You can get all headers with:

response.headers()

Example:

System.out.println(
        response.headers().map()
);

You can retrieve one specific header:

response.headers()
        .firstValue("content-type")
        .ifPresent(System.out::println);

firstValue() returns an Optional because the header may not exist.

20. Handling Exceptions Properly

Earlier examples used:

throws Exception

That's convenient for tutorials, but production code should handle exceptions more carefully.

client.send() can throw:

IOException
InterruptedException

A better example:

try {

    HttpResponse<String> response =
            client.send(
                    request,
                    HttpResponse.BodyHandlers.ofString()
            );

    System.out.println(response.body());

} catch (IOException e) {

    System.err.println(
            "Network error: " + e.getMessage()
    );

} catch (InterruptedException e) {

    Thread.currentThread().interrupt();

    System.err.println(
            "Request was interrupted"
    );
}

Calling:

Thread.currentThread().interrupt();

restores the thread's interrupted status.

21. Network Failure Is Different from HTTP Failure

This distinction is important.

Suppose a server returns:

404 Not Found

Java does not normally throw an exception just because the server returned a 404.

You still receive an:

HttpResponse

and:

response.statusCode()

might return:

Exceptions are more likely for things such as:

DNS failure
connection failure
network interruption
timeout

So your application should handle both HTTP failures and network failures.

try {

    HttpResponse<String> response =
            client.send(
                    request,
                    HttpResponse.BodyHandlers.ofString()
            );

    if (response.statusCode() >= 200 &&
        response.statusCode() < 300) {

        System.out.println(response.body());

    } else {

        System.err.println(
                "HTTP error: " +
                response.statusCode()
        );
    }

} catch (IOException e) {

    System.err.println(
            "Network error: " + e.getMessage()
    );

} catch (InterruptedException e) {

    Thread.currentThread().interrupt();
}

22. Creating a Reusable API Method

Once you start making multiple requests, repeating the same code becomes annoying.

You can create a reusable method:

public static String get(String url)
        throws IOException, InterruptedException {

    HttpClient client =
            HttpClient.newHttpClient();

    HttpRequest request =
            HttpRequest.newBuilder()
                    .uri(URI.create(url))
                    .GET()
                    .build();

    HttpResponse<String> response =
            client.send(
                    request,
                    HttpResponse.BodyHandlers.ofString()
            );

    if (response.statusCode() >= 200 &&
        response.statusCode() < 300) {

        return response.body();
    }

    throw new IOException(
            "HTTP error: " +
            response.statusCode()
    );
}

Then calling an API becomes:

String result = get(
        "https://jsonplaceholder.typicode.com/posts/1"
);

System.out.println(result);

23. Reuse `HttpClient`

There's one improvement we should make to the previous example.

Instead of creating a new HttpClient for every request, you should generally reuse one.

public class ApiClient {

    private final HttpClient client;

    public ApiClient() {

        this.client = HttpClient.newBuilder()
                .connectTimeout(
                        Duration.ofSeconds(10)
                )
                .build();
    }

    public String get(String url)
            throws IOException, InterruptedException {

        HttpRequest request =
                HttpRequest.newBuilder()
                        .uri(URI.create(url))
                        .timeout(
                                Duration.ofSeconds(20)
                        )
                        .GET()
                        .build();

        HttpResponse<String> response =
                client.send(
                        request,
                        HttpResponse.BodyHandlers.ofString()
                );

        if (response.statusCode() >= 200 &&
            response.statusCode() < 300) {

            return response.body();
        }

        throw new IOException(
                "HTTP " +
                response.statusCode() +
                ": " +
                response.body()
        );
    }
}

Usage:

ApiClient api = new ApiClient();

String response = api.get(
        "https://jsonplaceholder.typicode.com/posts/1"
);

System.out.println(response);

This is closer to how HTTP code is usually structured in a real application.

24. But What About JSON?

One thing java.net.http does not try to be is a complete JSON library.

Suppose an API returns:

{
  "id": 1,
  "name": "John"
}

java.net.http can retrieve it:

String json = response.body();

But converting that JSON into:

User user;

is normally handled by another library.

Popular choices include:

Jackson
Gson
JSON-B

A common architecture looks like this:

java.net.http
       ↓
HTTP communication
       ↓
JSON String
       ↓
Jackson / Gson
       ↓
Java object

For example, with Jackson:

String json = response.body();

User user = objectMapper.readValue(
        json,
        User.class
);

The HTTP client handles networking.

The JSON library handles serialization and deserialization.

25. A More Realistic REST API Client

Putting everything together:

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class RestClient {

    private final HttpClient client;

    public RestClient() {

        client = HttpClient.newBuilder()
                .connectTimeout(
                        Duration.ofSeconds(10)
                )
                .build();
    }

    public String get(String url)
            throws IOException, InterruptedException {

        HttpRequest request =
                HttpRequest.newBuilder()
                        .uri(URI.create(url))
                        .timeout(
                                Duration.ofSeconds(20)
                        )
                        .header(
                                "Accept",
                                "application/json"
                        )
                        .GET()
                        .build();

        return send(request);
    }

    public String post(
            String url,
            String json
    ) throws IOException, InterruptedException {

        HttpRequest request =
                HttpRequest.newBuilder()
                        .uri(URI.create(url))
                        .timeout(
                                Duration.ofSeconds(20)
                        )
                        .header(
                                "Accept",
                                "application/json"
                        )
                        .header(
                                "Content-Type",
                                "application/json"
                        )
                        .POST(
                                HttpRequest.BodyPublishers
                                        .ofString(json)
                        )
                        .build();

        return send(request);
    }

    private String send(HttpRequest request)
            throws IOException, InterruptedException {

        HttpResponse<String> response =
                client.send(
                        request,
                        HttpResponse.BodyHandlers.ofString()
                );

        int status = response.statusCode();

        if (status >= 200 && status < 300) {
            return response.body();
        }

        throw new IOException(
                "HTTP " +
                status +
                ": " +
                response.body()
        );
    }
}

Now your application code becomes very simple:

RestClient client = new RestClient();

String result = client.get(
        "https://jsonplaceholder.typicode.com/posts/1"
);

System.out.println(result);

Or:

String json = """
        {
          "title": "Hello",
          "body": "Java HTTP Client",
          "userId": 1
        }
        """;

String result = client.post(
        "https://jsonplaceholder.typicode.com/posts",
        json
);

System.out.println(result);

26. Quick Cheat Sheet

Create a client

HttpClient client =
        HttpClient.newHttpClient();

GET

HttpRequest request =
        HttpRequest.newBuilder()
                .uri(URI.create(url))
                .GET()
                .build();

POST

HttpRequest request =
        HttpRequest.newBuilder()
                .uri(URI.create(url))
                .POST(
                        HttpRequest.BodyPublishers
                                .ofString(body)
                )
                .build();

PUT

.PUT(
    HttpRequest.BodyPublishers.ofString(body)
)

DELETE

.DELETE()

PATCH

.method(
    "PATCH",
    HttpRequest.BodyPublishers.ofString(body)
)

Add a header

.header(
    "Content-Type",
    "application/json"
)

Send synchronously

HttpResponse<String> response =
        client.send(
                request,
                HttpResponse.BodyHandlers.ofString()
        );

Send asynchronously

client.sendAsync(
        request,
        HttpResponse.BodyHandlers.ofString()
);

Status code

response.statusCode()

Response body

response.body()

Response headers

response.headers()

27. The Mental Model

If you remember nothing else from this tutorial, remember this pattern:

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(url))
        .GET()
        .build();

HttpResponse<String> response = client.send(
        request,
        HttpResponse.BodyHandlers.ofString()
);

System.out.println(response.body());

Or visually:

1. Create HttpClient
        ↓
2. Build HttpRequest
        ↓
3. client.send(...)
        ↓
4. Receive HttpResponse
        ↓
5. Check statusCode()
        ↓
6. Read body()

Once that pattern makes sense, most of the API becomes easy to understand.

Final Thoughts

Java's built-in HTTP client is easy to overlook because developers often immediately reach for external dependencies.

But for many applications, java.net.http gives you everything you need:

HTTP/1.1
HTTP/2
GET
POST
PUT
DELETE
PATCH
Headers
Authentication headers
Request bodies
File downloads
Timeouts
Synchronous requests
Asynchronous requests

For simple REST API clients, scripts, desktop applications, microservices, and backend integrations, it can be more than enough.

The main thing it does not replace is a JSON serialization library such as Jackson or Gson.

A useful separation of responsibilities is:

java.net.http
    → talks to the server

Jackson / Gson
    → translates JSON

Your application
    → handles business logic

And that's often all you need to build a clean Java API client.

If you found this useful, the next logical step is combining java.net.http + Jackson to automatically convert API responses into Java records and objects.

About the Author

Deividas Strole is a Full-Stack Developer based in California, specializing in Java, Spring Boot, JavaScript, React, SQL, and AI-powered applications. He writes about software engineering, modern full-stack development, and digital marketing.

Connect with me:

🌐 Portfolio
💼 LinkedIn
💻 GitHub
🎥 YouTube
✍️ Medium
🐦 X
👽 Reddit
🚀 Lake Apps
🔧 Strole Consulting

Why Java Is a Great Choice for AI Development

Deividas Strole — Sun, 09 Aug 2026 19:54:41 +0000

When people think about artificial intelligence, Python is usually the first language that comes to mind. It has an enormous AI and machine learning ecosystem is simple and easy to learn.

But Python is not the only good choice.

For production applications, especially enterprise systems, Java can be an excellent language for building AI-powered software. Modern Java applications can connect to large language models, run machine learning models, build retrieval-augmented generation systems, process large amounts of data, and expose AI capabilities through scalable APIs.

In this tutorial, we’ll look at why Java works well for AI development and where it fits best.

1. Java Is Already Everywhere in Enterprise Software

One of Java’s biggest advantages is that companies already use it.

Java powers:

Backend APIs
Banking systems
E-commerce platforms
Enterprise applications
Microservices
Data-processing systems
Cloud applications

When a company wants to introduce AI into an existing Java platform, rewriting the application in Python usually doesn’t make much sense.

Instead, AI can become another capability inside the existing Java architecture.

React Frontend
      ↓
Spring Boot API
      ↓
AI Service
      ↓
OpenAI / Local Model / Vector Database

The application remains a normal Java system while AI becomes one component of it.

2. Spring Boot Makes AI Integration Natural

Java developers already have a mature framework for building production services: Spring Boot.

An AI-powered endpoint can look very similar to any other REST endpoint.

@RestController
@RequestMapping("/api/ai")
public class AiController {

    private final AiService aiService;

    public AiController(AiService aiService) {
        this.aiService = aiService;
    }

    @PostMapping("/ask")
    public String ask(@RequestBody String question) {
        return aiService.ask(question);
    }
}

Your AI functionality can then live inside a service:

@Service
public class AiService {

    public String ask(String question) {
        // Call an AI model here
        return "AI response for: " + question;
    }
}

This architecture is familiar to Java developers:

Controller
    ↓
Service
    ↓
AI Provider

You can combine AI with authentication, databases, caching, queues, logging, monitoring, and the rest of your application without creating a completely separate technology stack.

3. Spring AI Makes Java AI Development Easier

The Spring ecosystem includes Spring AI, which provides abstractions designed specifically for AI applications.

Instead of creating custom integrations for every model provider, developers can work with higher-level APIs.

A basic example might look like this:

@Service
public class ChatService {

    private final ChatClient chatClient;

    public ChatService(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    public String ask(String question) {
        return chatClient
                .prompt()
                .user(question)
                .call()
                .content();
    }
}

Then your controller can expose it:

@RestController
@RequestMapping("/chat")
public class ChatController {

    private final ChatService chatService;

    public ChatController(ChatService chatService) {
        this.chatService = chatService;
    }

    @GetMapping
    public String chat(@RequestParam String question) {
        return chatService.ask(question);
    }
}

Spring AI supports concepts commonly needed in modern AI applications, including:

Chat models
Embeddings
Vector stores
Prompt templates
Tool calling
Retrieval-Augmented Generation
Structured output
Model-provider abstractions

This makes Java much more attractive for developers building AI into existing Spring applications.

4. Java Is Excellent for AI APIs

Most production AI systems are not simply machine learning notebooks.

They are applications.

Consider an AI customer-support platform.

It might need to:

Authenticate the user.
Retrieve customer information.
Search internal documentation.
Generate embeddings.
Query a vector database.
Send relevant context to an LLM.
Store the conversation.
Log the request.
Return a response to the frontend.

Java is extremely well suited for this type of architecture.

User
 ↓
React
 ↓
Spring Boot
 ├── Authentication
 ├── PostgreSQL
 ├── Vector Database
 ├── Business Logic
 ├── AI Model
 └── Monitoring

The AI model is only one part of the system.

The rest is traditional software engineering—and that is where Java is very strong.

5. Java Works Well With Retrieval-Augmented Generation

One of the most useful AI architectures today is Retrieval-Augmented Generation, usually called RAG.

Instead of asking an LLM to answer purely from its training data, your application retrieves relevant information first.

The basic architecture looks like this:

Question
   ↓
Embedding Model
   ↓
Vector Search
   ↓
Relevant Documents
   ↓
LLM
   ↓
Answer

Imagine building an internal company assistant.

A user asks:

"What is our refund policy for enterprise customers?"

Your Java application can retrieve relevant documents and create a prompt:

String question = "What is our refund policy for enterprise customers?";

List<Document> documents = vectorStore.similaritySearch(question);

String context = documents.stream()
        .map(Document::getText)
        .collect(Collectors.joining("\n"));

String prompt = """
        Answer the question using the following information.

        Context:
        %s

        Question:
        %s
        """.formatted(context, question);

The final prompt can then be sent to the model.

This allows Java developers to build AI systems grounded in company-specific information.

6. Java Has Strong Concurrency Support

AI applications often involve many simultaneous operations.

For example:

Request
 ├── Database lookup
 ├── Vector search
 ├── External AI API call
 └── Logging

Java has mature concurrency capabilities and continues to improve them.

Modern Java includes virtual threads, which make handling large numbers of blocking operations much easier.

For AI services that make many external API calls, this can be especially useful.

Developers can often keep straightforward synchronous code while still supporting many concurrent requests.

7. Java Is Fast

AI development involves two different types of computation.

Model Computation

This is usually handled by:

GPUs
Specialized inference engines
Cloud AI providers
Dedicated model servers

Application Computation

This includes:

HTTP requests
Authentication
Data transformation
Database queries
Business rules
Caching
Search
Message processing

Java is very strong at the second category.

The JVM has decades of optimization behind it and performs extremely well for long-running backend services.

For production AI platforms, this matters.

8. Java Is Strongly Typed

AI APIs frequently return structured information.

For example:

{
  "symbol": "AAPL",
  "trend": "bullish",
  "confidence": 0.84
}

In Java, that can become a record:

public record StockAnalysis(
        String symbol,
        String trend,
        double confidence
) {}

Now the rest of your application can work with strongly typed data instead of loosely structured strings.

StockAnalysis analysis = aiService.analyze("AAPL");

if (analysis.confidence() > 0.8) {
    // Perform additional processing
}

Typed data provides better:

IDE support
Refactoring
Validation
Compile-time checking
Maintainability

This becomes increasingly valuable as AI systems grow.

9. Java Has a Mature Production Ecosystem

An AI demo is relatively easy to build.

A production AI platform is much harder.

You eventually need things like:

Authentication
Authorization
Database migrations
API validation
Rate limiting
Caching
Logging
Testing
Monitoring
Metrics
Retries
Circuit breakers
Deployment
Security

Java has mature libraries and frameworks for all of these problems.

For example:

Spring Boot
Spring Security
Spring Data
Hibernate
JUnit
Mockito
Resilience4j
Micrometer
Docker
Kubernetes
Kafka
PostgreSQL
Redis

This ecosystem is one of Java’s greatest advantages for AI engineering.

10. Java Can Run Machine Learning Models Too

Java does not have to call external AI APIs for everything.

There are Java-compatible machine learning and inference libraries such as:

Deep Java Library (DJL)
ONNX Runtime
TensorFlow Java
Tribuo
Smile

For example, models trained using Python frameworks can sometimes be exported to ONNX and executed in a Java production environment.

A common architecture could look like this:

Python
  ↓
Train Model
  ↓
Export ONNX
  ↓
Java Production Service
  ↓
Inference

This gives teams access to both ecosystems.

Data scientists can use Python for experimentation while Java developers integrate models into production systems.

11. Java and Python Can Work Together

Choosing Java does not mean abandoning Python.

In many organizations, the best architecture uses both.

Python
 ├── Model training
 ├── Data science
 └── Experiments

Java
 ├── Production APIs
 ├── Business logic
 ├── Authentication
 ├── Database integration
 └── Enterprise services

The systems can communicate through:

REST
gRPC
Kafka
RabbitMQ
Cloud messaging platforms

This is often more practical than trying to use one language for everything.

12. Where Java Is Especially Good for AI

Java is particularly attractive for:

AI-Powered Enterprise Applications

Examples:

CRM + AI
ERP + AI
Banking + AI
Insurance + AI
Healthcare Platform + AI

AI Microservices

Spring Boot
     ↓
LLM / Embedding Model
     ↓
REST API

Retrieval-Augmented Generation Systems

Documents
    ↓
Embeddings
    ↓
Vector Database
    ↓
Java RAG Service
    ↓
LLM

AI Features Inside Existing Java Applications

Examples include:

Document summarization
Semantic search
Recommendation systems
Fraud detection
Customer-support assistants
Market analysis
Document classification
Natural-language interfaces
Automated reporting

13. When Python May Still Be Better

Java is not automatically the best language for every AI task.

Python remains the strongest choice for many areas of AI research and model development.

If your main work involves:

Training neural networks
Experimenting with models
Data science notebooks
Computer vision research
NLP research
Building new ML algorithms

Python will usually provide the easiest ecosystem.

Libraries such as PyTorch, TensorFlow, NumPy, pandas, scikit-learn, and Hugging Face remain extremely important.

But that does not mean your entire production application has to be written in Python.

A common pattern is:

Python → Build the intelligence

Java → Build the product around it

Conclusion

Java may not be the language most strongly associated with artificial intelligence, but it has an important role in modern AI development.

Java provides:

Excellent backend performance
Strong typing
Mature enterprise frameworks
Powerful concurrency
Spring Boot integration
Growing AI tooling such as Spring AI
Access to machine learning inference libraries
Excellent infrastructure for production systems

Python will continue to dominate AI research and experimentation.

But as AI moves from notebooks into real business applications, languages used to build reliable production systems become increasingly important.

That is where Java becomes extremely interesting.

The future of AI development probably won't be Java versus Python.

It will increasingly be:

Python + Java + AI models + cloud infrastructure

with each technology doing what it does best.

About the Author

Connect with me:

🌐 Portfolio
💼 LinkedIn
💻 GitHub
🎥 YouTube
✍️ Medium
🐦 X
👽 Reddit
🚀 Lake Apps
🔧 Strole Consulting

Tags: #java #ai #artificialintelligence #springboot #springai #machinelearning #backend

Why Java Is Still Important and Relevant in 2026

Deividas Strole — Mon, 06 Jul 2026 01:11:14 +0000

Java has been around for more than 30 years, and every few years someone asks the same question:

"Is Java still relevant?"

In 2026, the answer is still YES!.

Java is not the newest or flashiest programming language, but it remains one of the most important languages in real-world software development. It powers enterprise systems, banking platforms, Android-related ecosystems, backend APIs, cloud services, microservices, data pipelines, and large-scale applications that need to be reliable and maintainable.

Java is not popular only because of legacy code. Java is still relevant because it keeps evolving.

JDK 25 reached general availability on September 16, 2025, and Java 25 is an LTS (Long-Term Support for you regular people) release, which means Java continues to receive long-term platform investment. JDK 26 reached general availability on March 17, 2026, as a non-LTS release under Java's six-month release cadence, but Java 25 remains the LTS version many enterprise teams are likely to target.

1. Java Is Still Everywhere in Enterprise Development

Many companies use Java because it is stable, mature, and proven.

Banks, insurance companies, logistics companies, healthcare systems, government platforms, and large SaaS businesses often need software that can run for many years. They care about:

Stability
Security
Performance
Long-term support
Large developer talent pool
Strong tooling
Maintainable code
Reliable backend architecture

Java fits these needs very well.

This is one reason Java remains common in backend job postings and enterprise software projects. Even when frontend trends change quickly, backend systems often need long-term reliability.

Java is especially strong for:

REST APIs
Microservices
Payment systems
Internal business tools
Authentication systems
Reporting systems
Cloud applications
Large database-backed applications

2. Java Has a Huge Ecosystem

One of Java's biggest strengths is not only the language itself. It is the ecosystem around it.

Java developers have access to mature tools and frameworks such as:

Spring Boot
Spring Framework
Hibernate
Maven
Gradle
JUnit
Mockito
Jakarta EE
Quarkus
Micronaut
Apache Kafka
Tomcat
Jetty

Spring Boot is still one of the most important Java frameworks for backend development. The official Spring Boot project describes it as a way to create stand-alone, production-grade Spring applications.

That matters because modern companies do not usually build plain Java applications from scratch. They build applications using frameworks, libraries, testing tools, security modules, database layers, and cloud integrations.

Java has all of that.

3. Java Is Modern Now

Some developers still think Java means old-style verbose code. That used to be more true, but modern Java is much cleaner than older Java.

For example, Java now supports features like records, switch expressions, text blocks, pattern matching, improved garbage collectors, better performance, and many API improvements.

Compare an older Java class:

public class User {
    private Long id;
    private String username;
    private String email;

    public User(Long id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
    }

    public Long getId() {
        return id;
    }

    public String getUsername() {
        return username;
    }

    public String getEmail() {
        return email;
    }
}

With a modern Java record:

public record User(Long id, String username, String email) {
}

That is much cleaner.

Java is still strongly typed and structured, but it is no longer as heavy as many people remember.

4. Java Is Great for Learning Backend Development

If you want to understand backend development seriously, Java is a very good language to learn.

Why? Because Java teaches important concepts clearly:

Object-oriented programming
Type safety
Interfaces
Dependency injection
Layered architecture
Testing
Exception handling
Database access
API design
Build tools
Application configuration

These concepts transfer to many other languages and frameworks.

A Java Spring Boot project usually teaches you how real backend applications are structured:

Controller layer
Service layer
Repository layer
Entity/model layer
DTO layer
Configuration layer
Security layer
Test layer

Here is a minimal controller that shows several of these concepts at once: a REST endpoint, dependency injection, and delegation to a service layer.

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserResponse getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

That is why Java is not just useful for jobs. It is useful for learning how professional software is built.

5. Java Works Very Well With Databases

Most business applications are database applications.

They need to store users, orders, invoices, payments, messages, logs, reports, and other records.

Java has excellent database support through:

JDBC
Spring Data JPA
Hibernate
JPA
Flyway
Liquibase
PostgreSQL drivers
MySQL drivers
MongoDB drivers
Redis clients

Example Spring Data repository:

public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

With this small interface, Spring Data JPA can automatically provide database operations such as save, findById, findAll, delete, and findByEmail — no implementation required.

This makes Java very productive for real-world backend development.

6. Java Is Strong for Large Applications

Some languages are great for small scripts or quick prototypes. Java can also be used for small apps, but its real strength appears in large applications.

Java is good for large codebases because it has:

Static typing
Clear package structure
Mature IDE support
Refactoring tools
Strong testing ecosystem
Build automation
Dependency management
Long-term readability

In large teams, this matters a lot.

When many developers work on the same application, the code must be understandable, testable, and safe to change. Java's structure helps with that.

For example, this kind of interface-based design is common in Java applications:

public interface PaymentService {
    PaymentResult processPayment(PaymentRequest request);
}

Then you can have different implementations:

@Service
public class StripePaymentService implements PaymentService {

    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        // process payment with Stripe
        return new PaymentResult("SUCCESS");
    }
}

This style makes applications easier to test and extend.

7. Java Has Excellent Tooling

Java has some of the best developer tooling in the software world.

Popular Java tools include:

IntelliJ IDEA
Eclipse
VS Code
Maven
Gradle
JUnit
Mockito
Testcontainers
Spring Initializr
VisualVM
JProfiler
Docker
Kubernetes

A good IDE can rename classes, extract methods, generate constructors, find usages, debug applications, run tests, inspect dependencies, and help with refactoring.

This makes Java very productive, especially in large applications.

8. Java Is Cloud and Microservice Friendly

Modern Java is not only for old enterprise servers.

Java is widely used in cloud-native development with:

Docker
Kubernetes
AWS
Google Cloud
Azure
Spring Boot
Quarkus
Micronaut
Kafka
RabbitMQ
Redis
PostgreSQL
MySQL

A basic Java Spring Boot application can be containerized with Docker:

FROM eclipse-temurin:25-jdk

WORKDIR /app

COPY target/myapp.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

Then it can run as a cloud service, microservice, or containerized backend API.

Java has adapted very well to modern backend architecture.

9. Java Is Still Popular

Java continues to appear near the top of many programming language popularity rankings. The TIOBE Index, which tracks programming language popularity based on search engine results and other signals, continues to list Java among major programming languages.

Popularity rankings are not perfect. They do not prove that one language is "better" than another. But they do show that Java is still widely discussed, searched, taught, and used.

Java also has a very large learning ecosystem:

Official documentation
Books
Courses
YouTube tutorials
Stack Overflow answers
Open-source projects
Enterprise examples
Spring guides
Dev.to articles

For a developer, this is important. When you get stuck, there is usually an answer somewhere.

10. Java Is a Good Career Investment

Java is still a practical career skill in 2026.

It is especially valuable if you want to work in:

Backend development
Full-stack development
Enterprise software
Financial technology
Insurance systems
Healthcare software
Government systems
Cloud services
Android-related ecosystems
Microservices
DevOps-heavy backend teams

Learning Java also makes it easier to learn other typed languages such as:

C#
Kotlin
Scala
TypeScript
Go

Even if you later move to another language, Java gives you a strong foundation.

11. Java and AI Development

AI tools are changing how developers write code, but they do not remove the need to understand programming fundamentals.

In fact, AI makes fundamentals more important.

If an AI tool generates Java code, you still need to know whether the code is correct, secure, efficient, and maintainable.

You need to understand:

What the code does
How dependencies work
How exceptions are handled
Whether the database query is safe
Whether the API design makes sense
Whether the test actually tests the correct behavior

AI can help generate code, but professional developers still need to review, debug, improve, and maintain that code.

Java's clear structure can actually help here because it makes generated backend code easier to inspect.

12. Putting It All Together

Here is how the pieces from the sections above — a record, a service, and a controller — combine into a small but complete Spring Boot REST endpoint.

User response record

public record UserResponse(
        Long id,
        String username,
        String email
) {
}

Service layer

@Service
public class UserService {

    public UserResponse getUserById(Long id) {
        return new UserResponse(
                id,
                "deividas",
                "deividas@example.com"
        );
    }
}

Controller layer

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public UserResponse getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

Calling GET /api/users/1 returns:

{
  "id": 1,
  "username": "deividas",
  "email": "deividas@example.com"
}

This simple example shows why Java is still useful. You can build clear, structured, production-style backend APIs with very little code.

13. When Java May Not Be the Best Choice

Java is important, but it is not always the best tool for every job.

Java may not be the best first choice for:

Small automation scripts
Very quick prototypes
Simple static websites
Data science notebooks
Small command-line experiments

For those cases, Python, JavaScript, Bash, or another tool may be faster.

But for long-term backend systems, APIs, enterprise platforms, and large applications, Java remains one of the strongest choices.

Conclusion

Java is still important in 2026 because it solves real problems.

It is stable, mature, fast, scalable, and widely used. It has a huge ecosystem, strong tooling, excellent backend frameworks, and long-term support. Modern Java is also cleaner and more developer-friendly than older versions.

Java may not always be trendy, but it is practical.

And in professional software development, practical matters.

If you want to become a backend or full-stack developer, Java is still worth learning in 2026.

Not because it is old.

Because it is still used to build serious software.

About the Author

Connect with me:

🌐 Portfolio
💼 LinkedIn
💻 GitHub
🎥 YouTube
✍️ Medium
🐦 X
👽 Reddit
🚀 Lake Apps

Three Months with Java 26: My Thoughts After Using the Latest Release

Deividas Strole — Sat, 27 Jun 2026 02:53:28 +0000

Three Months with Java 26: My Thoughts After Using the Latest Release

Java 26 was officially released on March 17, 2026, and after spending the past three months exploring its improvements, experimenting with new APIs, and using it in personal projects, I think it's a good time to share my impressions.

Unlike launch-day articles that simply list every new feature, this is a practical look at what stood out to me after having some time to work with Java 26.

Some improvements are immediately noticeable, while others continue Java's long-term evolution toward a faster, safer, and more productive platform. Although Java 26 isn't a revolutionary release, it continues the predictable six-month release cycle with meaningful refinements.

In this article, I'll share the features and improvements I found most interesting, what I like, what I'll continue using, and whether I think Java 26 is worth upgrading to.

Why Upgrade to Java 26?

Every Java release makes the platform a little better by improving:

Performance
Security
Developer productivity
Runtime reliability

Even if you don't immediately use every new API, upgrading allows you to benefit from JVM optimizations, bug fixes, and tooling improvements.

1. Real Java 26 Highlights

While Java 26 doesn't introduce sweeping new stable language features, it does deliver meaningful improvements worth knowing about.

Post-Quantum and Cryptography Improvements

Java 26 takes security seriously with several new capabilities: hybrid public key encryption (HPKE), post-quantum ready JAR signing, and updated support for Unicode 17.0 and CLDR v48. These aren't flashy, but they matter for production applications.

G1 GC Throughput Gains

One of my favorite concrete improvements in this release: G1 Garbage Collector improvements reduce synchronization overhead between application and GC threads, delivering up to 15% throughput gains in workloads with heavy object-reference modifications. That's a real, measurable win for many server-side applications.

Foreign Function & Memory API Continues to Mature

The Foreign Function & Memory (FFM) API is one of the most important recent additions to Java. Finalized in JDK 22, it provides a modern way for Java applications to interact with native libraries while offering safer and more efficient memory management than traditional JNI.

Although most developers won't use it every day, it remains an important step toward making Java interoperability with native code much simpler.

Applet API Removed

Java 26 permanently removes the Applet API, which had been deprecated since Java 9 and marked for removal since Java 17. No modern browser has supported applets for years, so this is a long-overdue cleanup that trims legacy baggage from the platform.

AOT Object Caching with Any GC

Java 26 improves Ahead-of-Time (AOT) object caching by making it compatible with any garbage collector, including ZGC. Previously, AOT caching was limited to Serial, Parallel, and G1 collectors. This expands the performance benefits of AOT to teams running latency-sensitive applications on ZGC.

2. Better Performance Behind the Scenes

One thing I appreciate about Java is that every release includes work that most developers never directly notice.

Java 26 continues refining the JVM with improvements focused on runtime performance, startup time, memory efficiency, and overall stability. Many of these optimizations happen behind the scenes, allowing existing applications to benefit without requiring code changes.

3. Pattern Matching Makes Code Cleaner

Pattern matching isn't new in Java 26, but after using it regularly across several releases, I can't imagine going back.

Instead of writing:

if (obj instanceof String) {
    String text = (String) obj;
    System.out.println(text.length());
}

You can simply write:

if (obj instanceof String text) {
    System.out.println(text.length());
}

The instanceof operator checks whether obj is actually a String. If it is, Java automatically creates the variable text, eliminating the need for an explicit cast.

It's a small change that makes everyday code much cleaner.

4. Records Continue to Be One of My Favorite Features

Records were introduced several Java releases ago, but they're still one of my favorite additions.

public record User(
    Long id,
    String name,
    String email
) {}

Instead of writing constructors, getters, equals(), hashCode(), and toString() manually, Java generates them automatically.

5. Better Developer Experience

Another thing I appreciate is how Java continues improving the overall developer experience.

Small improvements to compiler diagnostics, debugging tools, profiling, runtime monitoring, and IDE support add up over time.

6. Virtual Threads Are Becoming More Practical

Virtual Threads were introduced before Java 26, but they continue to be one of the most exciting modern Java features and are increasingly well-supported across the ecosystem.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {

    executor.submit(() -> {
        System.out.println("Running...");
    });

}

Here, var allows Java to infer the variable type automatically, so you don't have to write the full type name.

Virtual Threads are especially useful for:

REST APIs
Microservices
Web servers
Background processing

7. Switch Expressions Make Code More Readable

String result = switch(day) {
    case MONDAY -> "Work";
    case SATURDAY, SUNDAY -> "Weekend";
    default -> "Unknown";
};

No more forgotten break statements.

8. Immutable Collections Are Simple to Create

List<String> colors = List.of(
    "Red",
    "Green",
    "Blue"
);

Creating immutable collections now takes a single line instead of several.

Should You Upgrade?

If your applications are running well on your current Java version, upgrading to Java 26 isn't a necessity. However, it's definitely worth exploring if you:

Enjoy staying up to date with the latest Java releases
Want the newest performance improvements, including G1 GC throughput gains
Like experimenting with modern APIs before they reach the next LTS
Want to prepare for future LTS releases

Final Thoughts

Java continues evolving without sacrificing backward compatibility, and that's one of the reasons it remains my favorite backend language.

After spending several months using Java 26, my biggest takeaway isn't a single headline feature. Instead, it's the continued refinement of the language and platform. Each release removes a little more boilerplate, improves performance, strengthens security, and makes development just a bit more enjoyable.

While Java 26 doesn't introduce sweeping new stable language features, it delivers real, concrete improvements: better GC throughput, continued work around native interoperability, post-quantum cryptography groundwork, and a cleaner platform overall.

If you're already developing with Java, it's definitely worth downloading and exploring.

What has been your favorite Java feature recently? Let me know in the comments!

About the Author

Connect with me:

🌐 Portfolio
💼 LinkedIn
💻 GitHub
🎥 YouTube
✍️ Medium
🐦 X
👽 Reddit
🚀 Lake Apps

How to Host Your Website on GitHub Pages for Free

Deividas Strole — Sat, 20 Jun 2026 19:38:25 +0000

GitHub Pages is one of the easiest ways to publish a website online for free. It is great for portfolios, landing pages, documentation, small business websites, and simple frontend projects. I use them all the time as all my code is stored on GitHub.

In this tutorial, I will show you how to host your website using GitHub Pages step by step.

What is GitHub Pages?

GitHub Pages is a free hosting service from GitHub that lets you publish static websites directly from a GitHub repository.

You can use it to host websites built with:

HTML
CSS
JavaScript/ TypeScript
React
Vue
Documentation sites
Portfolio websites

GitHub Pages is best for static websites. That means it does not run backend code like Java, Spring Boot, PHP, or Node.js servers. However, it is perfect for frontend projects. For my bigger projects, I still use GitHub Pages for the front-end and host the back-end somewhere else.

Step 1: Create a GitHub Account

After logging in to GitHub:

Click the New button to create a new repository.
Give your repository a name.
Make the repository Public.
Click Create repository.

For example, you can name it:

deividas-strole-website

Your website URL will look something like this:

https://your-username.github.io/deividas-strole-website/

Step 3: Add Your Website Files

Your project should include at least an index.html file.

Example project structure:

deividas-strole-website/
├── index.html
├── style.css
└── script.js

Here is a simple example:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>Deividas Strole Website</title>
  <link rel="stylesheet" href="style.css" />
</head>
<body>
  <h1>Hello from GitHub Pages!</h1>
  <p>This website is hosted for free using GitHub Pages.</p>

  <script src="script.js"></script>
</body>
</html>

You can upload the files directly through GitHub, or you can push them using Git.

Step 4: Push Your Files to GitHub

If you are using Git from your computer, open your terminal inside your project folder and run:

git init
git add .
git commit -m "Initial website files"
git branch -M main
git remote add origin https://github.com/your-username/deividas-strole-website.git
git push -u origin main

Replace:

your-username
with your GitHub username.

Also replace:

deividas-strole-website
with your repository name.

Step 5: Enable GitHub Pages

Now go to your repository on GitHub.

Then follow these steps:

Click Settings
Click Pages in the left menu
Under Build and deployment, choose Deploy from a branch
Select the branch: main
Select the folder: /root
Click Save

GitHub will now build and publish your website.

Step 6: Open Your Live Website

After a short moment, GitHub will show you your live website URL.

It will look like this:

https://your-username.github.io/deividas-strole-website/

Open that link in your browser, and your website should be live.

Congratulations! Your website is now hosted for free.

Important: Use the Correct File Paths

When using GitHub Pages, file paths are very important.

For example, if your CSS file is in the same folder as your HTML file, use:

<link rel="stylesheet" href="style.css" />

If your image is inside an images folder, use:

<img src="images/photo.jpg" alt="My photo" />

Avoid using paths that only work on your local computer, like:

C:/Users/YourName/Desktop/project/image.jpg

That will not work online.

Common GitHub Pages Problems

Website Shows a 404 Page

This usually means GitHub Pages is not enabled correctly, or your project does not have an index.html file.

Make sure your main page is named exactly:

index.html

Not:

home.html
Index.html
index.htm

The file name must be correct.

CSS or Images Are Not Loading

Check your file paths carefully.

For example, this will only work if the image is inside an images folder:

<img src="images/logo.png" alt="Logo" />

Also make sure the file names match exactly. GitHub Pages is case-sensitive.

This means these are different:

logo.png
Logo.png
LOGO.png

Changes Are Not Showing

Sometimes GitHub Pages takes a minute to update.

You can also try:

Refreshing the page
Clearing your browser cache
Checking the GitHub Pages deployment status
Making sure your latest changes were pushed to GitHub

Can You Use a Custom Domain?

Yes. GitHub Pages allows you to connect a custom domain.

For example, instead of using:

https://your-username.github.io/deividas-strole-website/

You can use something like:

https://deividasstrole.com

You need to buy a domain separately and update your DNS settings.

When Should You Use GitHub Pages?

GitHub Pages is a good choice for:

Portfolio websites
Resume websites
Landing pages
Project demos
Documentation
Simple business websites
Frontend practice projects

It is not the best choice for websites that need a backend server, database, login system, or server-side processing.

For those, you may need services like Render, Railway, Vercel, Netlify, AWS, or a VPS.

Final Thoughts

GitHub Pages is a simple and free way to publish your website online.

If you are learning web development, building a portfolio, or sharing frontend projects, GitHub Pages is one of the best tools to start with.

You do not need complicated hosting or paid servers. You only need a GitHub account, your website files, and a few minutes to publish your project.

Happy coding!

About the Author
Deividas Strole is a Full-Stack Developer based in California, specializing in Java, Spring Boot, JavaScript, React, SQL, and AI-driven development. He writes about software engineering, modern full-stack development, and digital marketing strategies.

About the Author

Deividas Strole is a Full-Stack Developer based in California, specializing in Java, Spring Boot, JavaScript, React, SQL, and AI-driven development. He writes about software engineering, modern full-stack development, and digital marketing strategies.

Connect with me:

Build a Node.js HTTP Server From Scratch (No Frameworks Needed and Less Then 30 Lines!)

Deividas Strole — Mon, 16 Mar 2026 23:08:42 +0000

Most Node.js tutorials jump straight to Express. But before you reach for a framework, it's worth understanding what's happening underneath — because once you do, everything else clicks.

In this tutorial, Deividas Strole walks you through building a simple HTTP server using only Node's built-in modules. No Express, no npm install, no dependencies of any kind. Just the runtime doing its thing.

By the end, you'll have a working local server that serves a static HTML file — and a much clearer mental model of how the web actually works.

What You'll Learn

How the Node.js http module handles requests and responses
How to read files from disk using the fs module
How to serve a static HTML page
How to handle 404 routes cleanly
How to run everything locally in under a minute

Prerequisites

Node.js installed (nodejs.org)
Basic JavaScript knowledge
A text editor (VS Code, Vim, anything works)

No package manager needed. We're going fully built-in.

Step 1: Create the HTML File

First, create index.html. This is what your server will send to the browser.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
  <title>My Node Server</title>
  <style>
    body {
      font-family: monospace;
      background: #0d1117;
      color: #e6edf3;
      display: flex;
      align-items: center;
      justify-content: center;
      min-height: 100vh;
      margin: 0;
    }
    h1 { color: #3fb950; }
    p  { color: #8b949e; }
  </style>
</head>
<body>
  <div>
    <h1>✓ Server is running</h1>
    <p>Served by Node.js — no frameworks needed.</p>
  </div>
</body>
</html>

Simple, clean, and it'll look great in the browser.

Step 2: Create the Server

Now create server.js. This is where the magic happens.

const http = require('http');
const fs   = require('fs');
const path = require('path');

const PORT      = process.env.PORT || 3000;
const HTML_FILE = path.join(__dirname, 'index.html');

const server = http.createServer((req, res) => {
  // Only serve the root route
  if (req.url === '/' || req.url === '/index.html') {
    fs.readFile(HTML_FILE, (err, data) => {
      if (err) {
        res.writeHead(500, { 'Content-Type': 'text/plain' });
        res.end('500 Internal Server Error');
        return;
      }
      res.writeHead(200, { 'Content-Type': 'text/html' });
      res.end(data);
    });
  } else {
    // Everything else gets a 404
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('404 Not Found');
  }
});

server.listen(PORT, () => {
  console.log(`✅ Server running at http://localhost:${PORT}`);
});

That's it. 30 lines. Let's break down what each part does.

Step 3: Run It

In your terminal, navigate to your project folder and run:

node server.js

Open your browser and go to http://localhost:3000. You'll see your HTML page served by your own server.
Try visiting http://localhost:3000/anything-else — you'll get the 404 response.
To stop the server, press Ctrl + C.

Full Source Code

The complete project is on GitHub:
👉 github.com/deividas-strole/node-js-server
Drop a ⭐ if you found it useful.

About the Author

Connect with me:

Super Simple Web Scraping in Java (Jsoup)

Deividas Strole — Mon, 16 Feb 2026 00:51:43 +0000

Lets create a super-duper simple web scraper with Java! For that we will need Java, Jsoup, 5 minutes and a good mood!

Add Jsoup

<dependency> 
    <groupId>org.jsoup</groupId> 
    <artifactId>jsoup</artifactId> 
    <version>1.17.2</version> 
</dependency>

Create super-duper minimal scraper

In this our example we will print all links (text and URL) from a page:

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;

public class SimpleScraper {
    public static void main(String[] args) throws Exception {
        String url = "https://example.com"; // change this 

        Document doc = Jsoup.connect(url).get(); 

        for (Element link : doc.select("a[href]")) {            
            System.out .println(link.text() + " -> " + link.absUrl("href")); 
        }
    }
}

Thats it!!!! You are done! No models, No JSON, and no extra libraries!

Extra credit: If you want something spacific - change the selector.

Examples:

Article titles: h1, h2, h3
Product cards: .product
Price: .price
Any element by id: #price

Example: print all <h2> titles:

for (Element h : doc.select("h2")) {
  System.out.println(h.text());
}

More extra credit: In this code, the request originates from a Java client, which many websites will identify as a bot. As a result, they may block your access. To make your scraper appear as though it is coming from a real user, include this line before .get():

.userAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36")

Happy Coding!!!

About the Author

Deividas Strole is a Full-Stack Developer based in California, specializing in Java, Spring Boot, React, and AI-driven development. He writes about software engineering, modern full-stack development, and digital marketing strategies.

Connect with me:

Complete Java Tutorial: From Zero to Building Real Applications

Deividas Strole — Sun, 01 Feb 2026 18:53:14 +0000

Introduction

Java is one of the oldest and most popular programming languages in the world. It is a general-purpose programming language, which means you can do with it everything... well, maybe not everything, but almost everything :)
With Java, you can do Android Mobile Development, Enterprise Applications, Web Applications, Big Data Technologies, Cloud-Based Applications, Financial Services, Scientific Applications, Game Development, Internet of Things (IoT), and other stuff... In this tutorial, you'll learn Java fundamentals and build practical projects along the way.

What you'll learn:

Java basics and syntax
Object-Oriented Programming concepts
Working with collections and data structures
File handling and exception management
Building a real-world console application

Prerequisites: Basic computer literacy. No prior programming experience required!

Part 1: Setting Up Your Java Environment

Installing Java Development Kit (JDK)

Download the latest JDK from Oracle or OpenJDK
Install and verify by opening terminal/command prompt:

java -version
javac -version

Choosing an IDE
Go with one of these:

IntelliJ IDEA Community Edition (beginner-friendly and my favorite!)
Eclipse (lightweight)
VS Code with Java extensions (if you're already familiar with VS Code)

Part 2: Your First Java Program

Let's start now with the classic "Hello, World!" program:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Breaking it down:

public class HelloWorld - Defines a class named HelloWorld
public static void main(String[] args) - The entry point of every Java program
System.out.println() - Prints text to the console

To run:

Save as HelloWorld.java
Compile: javac HelloWorld.java
Run: java HelloWorld

Part 3: Java Fundamentals

Variables and Data Types
Java is statically typed, meaning you must declare variable types:

public class DataTypes {
    public static void main(String[] args) {
        // Primitive types
        int age = 25;
        double price = 19.99;
        boolean isActive = true;
        char grade = 'A';

        // String (reference type)
        String name = "Alice";

        // Printing variables
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Price: $" + price);
    }
}

Common data types:

int - integers (whole numbers)
double - decimal numbers
boolean - true/false
char - single character
String - text

Operators

public class Operators {
    public static void main(String[] args) {
        int a = 10, b = 3;

        // Arithmetic operators
        System.out.println("Addition: " + (a + b));       // 13
        System.out.println("Subtraction: " + (a - b));    // 7
        System.out.println("Multiplication: " + (a * b)); // 30
        System.out.println("Division: " + (a / b));       // 3
        System.out.println("Modulus: " + (a % b));        // 1

        // Comparison operators
        System.out.println("Is equal: " + (a == b));      // false
        System.out.println("Is greater: " + (a > b));     // true

        // Logical operators
        boolean x = true, y = false;
        System.out.println("AND: " + (x && y));           // false
        System.out.println("OR: " + (x || y));            // true
        System.out.println("NOT: " + (!x));               // false
    }
}

Part 4: Control Flow

If-Else Statements

public class ControlFlow {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 90) {
            System.out.println("Grade: A");
        } else if (score >= 80) {
            System.out.println("Grade: B");
        } else if (score >= 70) {
            System.out.println("Grade: C");
        } else {
            System.out.println("Grade: F");
        }
    }
}

Loops

public class Loops {
    public static void main(String[] args) {
        // For loop
        System.out.println("For loop:");
        for (int i = 1; i <= 5; i++) {
            System.out.println("Count: " + i);
        }

        // While loop
        System.out.println("\nWhile loop:");
        int j = 1;
        while (j <= 5) {
            System.out.println("Count: " + j);
            j++;
        }

        // Enhanced for loop (for arrays)
        System.out.println("\nEnhanced for loop:");
        String[] fruits = {"Apple", "Banana", "Orange"};
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Switch Statement

public class SwitchExample {
    public static void main(String[] args) {
        String day = "Monday";

        switch (day) {
            case "Monday":
                System.out.println("Start of the work week!");
                break;
            case "Friday":
                System.out.println("Almost weekend!");
                break;
            case "Saturday":
            case "Sunday":
                System.out.println("Weekend!");
                break;
            default:
                System.out.println("Midweek day");
        }
    }
}

Part 5: Methods and Functions

Methods help organize code into reusable blocks:

public class Methods {
    // Method with no parameters and no return value
    public static void greet() {
        System.out.println("Hello!");
    }

    // Method with parameters
    public static void greetUser(String name) {
        System.out.println("Hello, " + name + "!");
    }

    // Method with return value
    public static int add(int a, int b) {
        return a + b;
    }

    // Method with multiple parameters and return value
    public static double calculateArea(double length, double width) {
        return length * width;
    }

    public static void main(String[] args) {
        greet();
        greetUser("Alice");

        int sum = add(5, 3);
        System.out.println("Sum: " + sum);

        double area = calculateArea(5.5, 3.2);
        System.out.println("Area: " + area);
    }
}

Part 6: Object-Oriented Programming (OOP)

Classes and Objects
Java is an object-oriented language. Everything revolves around objects:

// Define a class
class Car {
    // Properties (fields)
    String brand;
    String model;
    int year;

    // Constructor
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }

    // Method
    public void displayInfo() {
        System.out.println(year + " " + brand + " " + model);
    }

    public void honk() {
        System.out.println("Beep beep!");
    }
}

public class OOPExample {
    public static void main(String[] args) {
        // Create objects
        Car car1 = new Car("Toyota", "Camry", 2023);
        Car car2 = new Car("Honda", "Civic", 2022);

        // Use objects
        car1.displayInfo();
        car1.honk();

        car2.displayInfo();
    }
}

Encapsulation (Getters and Setters)

class BankAccount {
    // Private fields (encapsulated)
    private String accountNumber;
    private double balance;

    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    // Getter methods
    public String getAccountNumber() {
        return accountNumber;
    }

    public double getBalance() {
        return balance;
    }

    // Setter with validation
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited: $" + amount);
        } else {
            System.out.println("Invalid deposit amount");
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: $" + amount);
        } else {
            System.out.println("Invalid withdrawal amount");
        }
    }
}

public class EncapsulationDemo {
    public static void main(String[] args) {
        BankAccount account = new BankAccount("123456", 1000.0);

        System.out.println("Balance: $" + account.getBalance());
        account.deposit(500);
        account.withdraw(200);
        System.out.println("Final balance: $" + account.getBalance());
    }
}

Inheritance

// Parent class
class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating");
    }

    public void sleep() {
        System.out.println(name + " is sleeping");
    }
}

// Child class
class Dog extends Animal {
    public Dog(String name) {
        super(name);  // Call parent constructor
    }

    public void bark() {
        System.out.println(name + " says: Woof!");
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    public void meow() {
        System.out.println(name + " says: Meow!");
    }
}

public class InheritanceDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.eat();
        dog.bark();

        Cat cat = new Cat("Whiskers");
        cat.sleep();
        cat.meow();
    }
}

Polymorphism

class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }

    public double getArea() {
        return 0;
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        // Polymorphism: treating different objects through same interface
        Shape[] shapes = {
            new Circle(5),
            new Rectangle(4, 6),
            new Circle(3)
        };

        for (Shape shape : shapes) {
            shape.draw();
            System.out.println("Area: " + shape.getArea());
            System.out.println();
        }
    }
}

Part 7: Arrays and Collections

Arrays

public class ArraysDemo {
    public static void main(String[] args) {
        // Declare and initialize array
        int[] numbers = {1, 2, 3, 4, 5};

        // Access elements
        System.out.println("First element: " + numbers[0]);

        // Array length
        System.out.println("Length: " + numbers.length);

        // Iterate through array
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        // 2D array
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        System.out.println("Element at [1][2]: " + matrix[1][2]); // 6
    }
}

ArrayList

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        // Create ArrayList
        ArrayList<String> fruits = new ArrayList<>();

        // Add elements
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Access elements
        System.out.println("First fruit: " + fruits.get(0));

        // Size
        System.out.println("Size: " + fruits.size());

        // Iterate
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // Remove element
        fruits.remove("Banana");

        // Check if contains
        if (fruits.contains("Apple")) {
            System.out.println("We have apples!");
        }
    }
}

HashMap

import java.util.HashMap;

public class HashMapDemo {
    public static void main(String[] args) {
        // Create HashMap
        HashMap<String, Integer> scores = new HashMap<>();

        // Add key-value pairs
        scores.put("Alice", 95);
        scores.put("Bob", 87);
        scores.put("Charlie", 92);

        // Get value by key
        System.out.println("Alice's score: " + scores.get("Alice"));

        // Iterate through HashMap
        for (String name : scores.keySet()) {
            System.out.println(name + ": " + scores.get(name));
        }

        // Check if key exists
        if (scores.containsKey("Bob")) {
            System.out.println("Bob is in the system");
        }
    }
}

Part 8: Exception Handling

public class ExceptionHandling {
    public static void main(String[] args) {
        // Try-catch block
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Error: Cannot divide by zero!");
        }

        // Multiple catch blocks
        try {
            String text = null;
            System.out.println(text.length());
        } catch (NullPointerException e) {
            System.out.println("Error: Null reference!");
        } catch (Exception e) {
            System.out.println("Some other error occurred");
        } finally {
            System.out.println("This always executes");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

Custom Exceptions

// Custom exception class
class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

class BankAccountAdvanced {
    private double balance;

    public BankAccountAdvanced(double balance) {
        this.balance = balance;
    }

    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException(
                "Insufficient funds. Balance: $" + balance + ", Requested: $" + amount
            );
        }
        balance -= amount;
        System.out.println("Withdrawn: $" + amount);
    }

    public double getBalance() {
        return balance;
    }
}

public class CustomExceptionDemo {
    public static void main(String[] args) {
        BankAccountAdvanced account = new BankAccountAdvanced(100);

        try {
            account.withdraw(150);
        } catch (InsufficientFundsException e) {
            System.out.println("Transaction failed: " + e.getMessage());
        }
    }
}

Part 9: File Handling

import java.io.*;
import java.util.Scanner;

public class FileHandling {

    // Writing to a file
    public static void writeToFile(String filename, String content) {
        try {
            FileWriter writer = new FileWriter(filename);
            writer.write(content);
            writer.close();
            System.out.println("Successfully wrote to file");
        } catch (IOException e) {
            System.out.println("Error writing to file: " + e.getMessage());
        }
    }

    // Reading from a file
    public static void readFromFile(String filename) {
        try {
            File file = new File(filename);
            Scanner reader = new Scanner(file);

            while (reader.hasNextLine()) {
                String line = reader.nextLine();
                System.out.println(line);
            }
            reader.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        String filename = "example.txt";

        // Write to file
        writeToFile(filename, "Hello, Java!\nThis is file handling in action.");

        // Read from file
        System.out.println("Reading from file:");
        readFromFile(filename);
    }
}

Part 10: Real-World Project - Task Manager Application

Let's build a complete console-based task manager:

import java.util.ArrayList;
import java.util.Scanner;

class Task {
    private String title;
    private String description;
    private boolean completed;

    public Task(String title, String description) {
        this.title = title;
        this.description = description;
        this.completed = false;
    }

    public String getTitle() { return title; }
    public String getDescription() { return description; }
    public boolean isCompleted() { return completed; }

    public void setCompleted(boolean completed) {
        this.completed = completed;
    }

    @Override
    public String toString() {
        String status = completed ? "[✓]" : "[ ]";
        return status + " " + title + " - " + description;
    }
}

class TaskManager {
    private ArrayList<Task> tasks;

    public TaskManager() {
        tasks = new ArrayList<>();
    }

    public void addTask(String title, String description) {
        tasks.add(new Task(title, description));
        System.out.println("Task added successfully!");
    }

    public void listTasks() {
        if (tasks.isEmpty()) {
            System.out.println("No tasks found.");
            return;
        }

        System.out.println("\n===== YOUR TASKS =====");
        for (int i = 0; i < tasks.size(); i++) {
            System.out.println((i + 1) + ". " + tasks.get(i));
        }
        System.out.println("======================\n");
    }

    public void completeTask(int index) {
        if (index >= 0 && index < tasks.size()) {
            tasks.get(index).setCompleted(true);
            System.out.println("Task marked as complete!");
        } else {
            System.out.println("Invalid task number.");
        }
    }

    public void deleteTask(int index) {
        if (index >= 0 && index < tasks.size()) {
            tasks.remove(index);
            System.out.println("Task deleted!");
        } else {
            System.out.println("Invalid task number.");
        }
    }
}

public class TaskManagerApp {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        TaskManager manager = new TaskManager();
        boolean running = true;

        System.out.println("===== TASK MANAGER =====");

        while (running) {
            System.out.println("\nOptions:");
            System.out.println("1. Add Task");
            System.out.println("2. List Tasks");
            System.out.println("3. Complete Task");
            System.out.println("4. Delete Task");
            System.out.println("5. Exit");
            System.out.print("Choose an option: ");

            int choice = scanner.nextInt();
            scanner.nextLine(); // Consume newline

            switch (choice) {
                case 1:
                    System.out.print("Enter task title: ");
                    String title = scanner.nextLine();
                    System.out.print("Enter task description: ");
                    String description = scanner.nextLine();
                    manager.addTask(title, description);
                    break;

                case 2:
                    manager.listTasks();
                    break;

                case 3:
                    manager.listTasks();
                    System.out.print("Enter task number to complete: ");
                    int completeIndex = scanner.nextInt() - 1;
                    manager.completeTask(completeIndex);
                    break;

                case 4:
                    manager.listTasks();
                    System.out.print("Enter task number to delete: ");
                    int deleteIndex = scanner.nextInt() - 1;
                    manager.deleteTask(deleteIndex);
                    break;

                case 5:
                    System.out.println("Goodbye!");
                    running = false;
                    break;

                default:
                    System.out.println("Invalid option. Try again.");
            }
        }

        scanner.close();
    }
}

Best Practices and Tips

1. Naming Conventions

Classes: Use PascalCase (e.g., MyClass, BankAccount)
Methods and variables: Use camelCase (e.g., calculateTotal, userName)
Constants: Use UPPER_SNAKE_CASE (e.g., MAX_SIZE, DEFAULT_VALUE)

2. Code Organization

One public class per file
File name must match the public class name
Use packages to organize related classes

3. Comments and Documentation

/**
 * Calculates the factorial of a number
 * @param n the number to calculate factorial for
 * @return the factorial of n
 */
public static long factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

4. Always Use Try-With-Resources

// Good practice - automatically closes resources
try (Scanner scanner = new Scanner(new File("data.txt"))) {
    while (scanner.hasNextLine()) {
        System.out.println(scanner.nextLine());
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

What's Next?
Now that you've learned Java fundamentals, here are some paths to explore:

Web Development: Learn Spring Boot for building web applications
Android Development: Create mobile apps with Android Studio
Data Structures & Algorithms: Deepen your problem-solving skills
Design Patterns: Learn common solutions to recurring problems
Testing: Explore JUnit for unit testing

Recommended Resources

Official Java Documentation: docs.oracle.com/javase
Practice coding: LeetCode, HackerRank, Codewars
Java communities: r/learnjava, Stack Overflow

Conclusion
Congratulations! You've learned Java from the basics to building a real application. The key to mastering Java is practice, practice, practice, and practice. Try building your own projects. Start with small ones and go up in size. Also, open an account on GitHub (Free!) and put all your learning and projects there for everybody to see! Don't forget to contribute to open-source, and keep coding every day.
What will you build with Java? Drop a comment below and share your projects!
Happy coding! ☕

If you found this tutorial helpful, please give it a ❤️ and follow for more programming tutorials!

About the Author

Connect with me:

Building Your First AI Client in Java (Cerebras AI)

Deividas Strole — Sun, 18 Jan 2026 20:48:51 +0000

In this tutorial, you'll learn how to build a very simple AI chat client in Java. Because of the free tier and the speed, we will be using Cerebras AI here. The same principles though apply to other AI providers like OpenAI (ChatGPT), Claude, or Gemini. If you decide to use other AI models — just adjust the API endpoint and model names.

Prefer video? You can watch the full tutorial on YouTube above.

What You'll Need

Java 11 or higher (we'll use the modern HttpClient API)
A Cerebras AI API key
Your favorite IDE or text editor

Step 1: Get Your Cerebras API Key

First, you'll need to get an API key from Cerebras:

Visit Cerebras AI and sign up for an account
Navigate to the API section or developer dashboard
Generate a new API key
Copy the key—you'll need it in the next step

... and of course - keep your API key secure and never commit it to version control!

Step 2: Set Up Your API Key as an Environment Variable

Instead of hardcoding your API key in your source code, store it as an environment variable. This keeps your key secure and makes your code more portable.

On Windows
Open Command Prompt or PowerShell and run:
SETX CEREBRAS_API_KEY "your-api-key-here"

Replace your-api-key-here with your actual API key. You'll need to restart your IDE or terminal for the changes to take effect.

On macOS/Linux
Add this line to your ~/.bashrc, ~/.zshrc, or ~/.bash_profile:
export CEREBRAS_API_KEY="your-api-key-here"

Then reload your configuration:
bashsource ~/.bashrc # or ~/.zshrc

Step 3: Create Your Java Project

Create a new Java file called AIChat.java and add the following code:

javaimport java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class AIChat {
    public static void main(String[] args) throws IOException, InterruptedException {
        String apiKey = System.getenv("CEREBRAS_API_KEY");

        String requestBody = """
        {
            "model": "llama3.1-8b",
            "messages": [
                {"role": "user", "content": "How to win a lotto?"}
            ],
            "temperature": 0.2
        }
        """;

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.cerebras.ai/v1/chat/completions"))
                .header("Content-Type", "application/json")
                .header("Authorization", "Bearer " + apiKey)
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

        HttpClient client = HttpClient.newHttpClient();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

Understanding the Code

Let's break down what this code does:

1. Reading the API Key
String apiKey = System.getenv("CEREBRAS_API_KEY");

This retrieves your API key from the environment variable you set earlier.

2. Building the Request Body

String requestBody = """
{
    "model": "llama3.1-8b",
    "messages": [
        {"role": "user", "content": "How to win a lotto?"}
    ],
    "temperature": 0.2
}
""";

The request body is a JSON object containing:

model: The AI model to use (Cerebras offers various Llama models)
messages: An array of message objects with roles and content
temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)

3. Creating the HTTP Request

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.cerebras.ai/v1/chat/completions"))
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer " + apiKey)
    .POST(HttpRequest.BodyPublishers.ofString(requestBody))
    .build();

This builds an HTTP POST request with:

The Cerebras API endpoint
JSON content type header
Authorization header with your API key
The request body we created

4. Sending the Request

HttpClient client = HttpClient.newHttpClient();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

This creates an HTTP client, sends the request, and prints the JSON response.

Step 4: Run Your Application
Compile and run your program:

javac AIChat.java
java AIChat

You should see a JSON response containing the AI's answer!

Parsing the JSON Response

The raw JSON response isn't very user-friendly. Let's improve our code to extract just the AI's message. You can use a JSON library like Gson or Jackson, or parse it manually for simple cases:

// Add this method to extract the content
private static String extractContent(String jsonResponse) {
    int contentStart = jsonResponse.indexOf("\"content\":\"") + 11;
    int contentEnd = jsonResponse.indexOf("\"", contentStart);
    return jsonResponse.substring(contentStart, contentEnd)
        .replace("\\n", "\n");
}

// In main, replace the println with:
String aiResponse = extractContent(response.body());
System.out.println("AI Response: " + aiResponse);

Adapting to Other AI Providers

Want to use a different AI provider? Here's what you need to change:

OpenAI (ChatGPT)

Endpoint: https://api.openai.com/v1/chat/completions
Model: gpt-4 or gpt-3.5-turbo
API Key env var: OPENAI_API_KEY

Anthropic (Claude)

Endpoint: https://api.anthropic.com/v1/messages
Model: claude-sonnet-4-5-20250929
Headers: Add "x-api-key" instead of "Authorization"
API Version: Add header "anthropic-version": "2023-06-01"

Google (Gemini)

Endpoint: https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent?key=YOUR_KEY
Different request format (check Google's documentation)

Next Steps

Now that you have a working AI client, you can:

Add user input to make it interactive
Implement conversation history by maintaining a messages array
Add error handling for network issues and API errors
Parse JSON responses properly using Gson or Jackson
Create a command-line chat interface
Experiment with different models and temperature settings

Conclusion

Congratulations - you have successfully built your first AI client in Java! Yahoo! This simple example demonstrates the core concepts you'll use regardless of which AI provider you choose. The key takeaways are understanding HTTP requests, JSON formatting, and secure API key management.

Happy coding, and enjoy exploring the world of AI integration!

About the Author

Connect with me:

AI-Powered Commit Message Generator with Sring Boot & Cerebras

Deividas Strole — Mon, 12 Jan 2026 04:29:32 +0000

I don't know anyone who likes writing proper commit messages. Everyone knows they have to write them, but most are too lazy to think a good message and compose one. I, for example, am so lazy that even for 'work in progress' I just type 'wip'... In this tutorial we will create a REST API which will take your git diff (differences between versions of your code) and automatically generate a professional commit message. Magic!

Our battle plan:

A simple Spring Boot REST API
Integration with Cerebras Cloud API
One endpoint: send a diff, get a formatted commit message

Why Cerebras?

They give free API keys if you ask nicely! Shhh... it's a secret! Also—their API is OpenAI-compatible! ;)

Prerequisites

Java 17+
Maven
A Cerebras API key (get free credits at https://cloud.cerebras.ai)
Basic Spring Boot knowledge

Project Setup

1. Create Spring Boot Project
Using Spring Initializr, create a project with these dependencies:

Spring Web
Spring WebFlux
Lombok
Validation

Or use this pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>commit-message-generator</artifactId>
    <version>1.0.0</version>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2. Application Configuration
Create src/main/resources/application.properties:

# Cerebras API Configuration
cerebras.api-key=${CEREBRAS_API_KEY}
cerebras.api-url=https://api.cerebras.ai/v1/chat/completions
cerebras.model=llama3.1-70b

# Server Configuration
server.port=8080

# Logging
logging.level.com.example.commitgen=INFO

Building the Application

1. Configuration Class
Create src/main/java/com/example/commitgen/config/CerebrasConfig.java:

package com.example.commitgen.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import lombok.Data;

@Configuration
@ConfigurationProperties(prefix = "cerebras")
@Data
public class CerebrasConfig {
    private String apiKey;
    private String apiUrl;
    private String model;
}

2. DTOs (Data Transfer Objects)

Create src/main/java/com/example/commitgen/dto/CommitRequest.java:

package com.example.commitgen.dto;

import jakarta.validation.constraints.NotBlank;
import lombok.Data;

@Data
public class CommitRequest {
    @NotBlank(message = "Diff cannot be empty")
    private String diff;

    private String type; // feat, fix, docs, etc. (optional)
    private String scope; // Optional scope
}

Create src/main/java/com/example/commitgen/dto/CommitResponse.java:

package com.example.commitgen.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommitResponse {
    private String message;
    private String type;
    private String scope;
    private String description;
    private String body;
}

Create Cerebras API DTOs in src/main/java/com/example/commitgen/dto/CerebrasRequest.java:

package com.example.commitgen.dto;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import java.util.List;

@Data
@AllArgsConstructor
public class CerebrasRequest {
    private String model;
    private List<Message> messages;

    @JsonProperty("max_tokens")
    private Integer maxTokens;

    private Double temperature;

    @Data
    @AllArgsConstructor
    public static class Message {
        private String role;
        private String content;
    }
}

Create src/main/java/com/example/commitgen/dto/CerebrasResponse.java:

package com.example.commitgen.dto;

import lombok.Data;
import java.util.List;

@Data
public class CerebrasResponse {
    private List<Choice> choices;

    @Data
    public static class Choice {
        private Message message;

        @Data
        public static class Message {
            private String role;
            private String content;
        }
    }
}

3. Cerebras API Service

Create src/main/java/com/example/commitgen/service/CerebrasService.java:

package com.example.commitgen.service;

import com.example.commitgen.config.CerebrasConfig;
import com.example.commitgen.dto.CerebrasRequest;
import com.example.commitgen.dto.CerebrasResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

import java.util.List;

@Service
@RequiredArgsConstructor
@Slf4j
public class CerebrasService {

    private final CerebrasConfig config;
    private final WebClient.Builder webClientBuilder;

    public Mono<String> generateCompletion(String prompt) {
        WebClient webClient = webClientBuilder
            .baseUrl(config.getApiUrl())
            .defaultHeader("Authorization", "Bearer " + config.getApiKey())
            .defaultHeader("Content-Type", "application/json")
            .build();

        CerebrasRequest request = new CerebrasRequest(
            config.getModel(),
            List.of(
                new CerebrasRequest.Message("system", 
                    "You are a helpful assistant that generates conventional commit messages."),
                new CerebrasRequest.Message("user", prompt)
            ),
            500,
            0.3
        );

        return webClient.post()
            .bodyValue(request)
            .retrieve()
            .bodyToMono(CerebrasResponse.class)
            .map(response -> {
                if (response.getChoices() != null && !response.getChoices().isEmpty()) {
                    return response.getChoices().get(0).getMessage().getContent();
                }
                throw new RuntimeException("No response from Cerebras API");
            })
            .doOnError(error -> log.error("Error calling Cerebras API", error));
    }
}

4. Commit Message Service

Create src/main/java/com/example/commitgen/service/CommitMessageService.java:

package com.example.commitgen.service;

import com.example.commitgen.dto.CommitRequest;
import com.example.commitgen.dto.CommitResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;

@Service
@RequiredArgsConstructor
@Slf4j
public class CommitMessageService {

    private final CerebrasService cerebrasService;

    public Mono<CommitResponse> generateCommitMessage(CommitRequest request) {
        String prompt = buildPrompt(request);

        return cerebrasService.generateCompletion(prompt)
            .map(this::parseResponse)
            .onErrorResume(error -> {
                log.error("Error generating commit message", error);
                return Mono.just(createErrorResponse());
            });
    }

    private String buildPrompt(CommitRequest request) {
        StringBuilder prompt = new StringBuilder();

        prompt.append("Based on the following git diff, generate a conventional commit message.\n\n");
        prompt.append("Format:\n");
        prompt.append("<type>(<scope>): <description>\n\n");
        prompt.append("<body>\n\n");
        prompt.append("Where:\n");
        prompt.append("- type: feat, fix, docs, style, refactor, test, chore\n");
        prompt.append("- scope: optional, component/file affected\n");
        prompt.append("- description: brief summary (50 chars max)\n");
        prompt.append("- body: detailed explanation (optional)\n\n");

        if (request.getType() != null) {
            prompt.append("Preferred type: ").append(request.getType()).append("\n");
        }
        if (request.getScope() != null) {
            prompt.append("Scope: ").append(request.getScope()).append("\n");
        }

        prompt.append("\nDiff:\n");
        prompt.append(request.getDiff());
        prompt.append("\n\n");
        prompt.append("Return ONLY the commit message in the format specified above. ");
        prompt.append("Do not include any explanations or additional text.");

        return prompt.toString();
    }

    private CommitResponse parseResponse(String response) {
        // Clean up the response
        String cleaned = response.trim();

        // Parse conventional commit format
        String[] lines = cleaned.split("\n", 2);
        String firstLine = lines[0].trim();
        String body = lines.length > 1 ? lines[1].trim() : "";

        // Extract type, scope, and description
        String type = "";
        String scope = "";
        String description = firstLine;

        // Parse: type(scope): description
        if (firstLine.contains(":")) {
            String[] parts = firstLine.split(":", 2);
            String prefix = parts[0].trim();
            description = parts.length > 1 ? parts[1].trim() : "";

            if (prefix.contains("(") && prefix.contains(")")) {
                int scopeStart = prefix.indexOf("(");
                int scopeEnd = prefix.indexOf(")");
                type = prefix.substring(0, scopeStart).trim();
                scope = prefix.substring(scopeStart + 1, scopeEnd).trim();
            } else {
                type = prefix;
            }
        }

        return new CommitResponse(
            cleaned,
            type,
            scope,
            description,
            body
        );
    }

    private CommitResponse createErrorResponse() {
        return new CommitResponse(
            "chore: update files",
            "chore",
            "",
            "update files",
            "Failed to generate AI-powered commit message. Using default."
        );
    }
}

5. REST Controller

Create src/main/java/com/example/commitgen/controller/CommitController.java:

package com.example.commitgen.controller;

import com.example.commitgen.dto.CommitRequest;
import com.example.commitgen.dto.CommitResponse;
import com.example.commitgen.service.CommitMessageService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/api/v1/commit")
@RequiredArgsConstructor
@CrossOrigin(origins = "*")
public class CommitController {

    private final CommitMessageService commitMessageService;

    @PostMapping("/generate")
    public Mono<ResponseEntity<CommitResponse>> generateCommitMessage(
            @Valid @RequestBody CommitRequest request) {
        return commitMessageService.generateCommitMessage(request)
            .map(ResponseEntity::ok);
    }

    @GetMapping("/health")
    public ResponseEntity<String> health() {
        return ResponseEntity.ok("Commit Message Generator is running!");
    }
}

6. Main Application

Create src/main/java/com/example/commitgen/CommitMessageGeneratorApplication.java:

package com.example.commitgen;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.reactive.function.client.WebClient;

@SpringBootApplication
public class CommitMessageGeneratorApplication {

    public static void main(String[] args) {
        SpringApplication.run(CommitMessageGeneratorApplication.class, args);
    }

    @Bean
    public WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }
}

Running the Application

1. Set Your API Key
export CEREBRAS_API_KEY=your-api-key-here

2. Start the Application
bashmvn spring-boot:run

Conclusion

You have built functional AI commit message generator in under 200 lines!!! Et voilà !

About the Author

Connect with me:

How to Optimize Your Personal Website for Keywords: A Simple Guide

Deividas Strole — Mon, 05 Jan 2026 00:09:54 +0000

How to Optimize Your Personal Website for Keywords: A Simple Guide

When you are building a website, you want it to be not only visually nice, but also discoverable by other people. To achieve that you need to adjust the code and text for keywords - words that people will look for. I created this guide using my name as an example. You can freely copy and use the code for your own keywords though.

Why Keyword Optimization Matters

When someone searches for your name, or professional identity your personal website should appear in the top results. This is especially important for:

Building your professional brand
Getting found by clients and recruiters
Establishing credibility in your field
Controlling your online narrative

The techniques in this guide not only work for classical Search Engine Optimization, but also are a must have for Artificial Intelligence Optimization in 2026. We will use SEO and AIO interchangeably in this guide.

The Foundation: Semantic HTML Structure

Search engines and AI love well-structured HTML. Start with proper semantic elements:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Deividas Strole - Web Developer</title>
</head>
<body>
    <header>
        <h1>Deividas Strole</h1>
        <nav><!-- Navigation --></nav>
    </header>
    <main>
        <section><!-- Content --></section>
    </main>
    <footer><!-- Footer --></footer>
</body>
</html>

Critical Meta Tags for SEO/AIO

Your <head> section is prime real estate for SEO and AIO. Here are the essential meta tags:

1. Title Tag

The title tag is the most important on-page SEO/AIO element. It appears in search results and browser tabs.

<title>Deividas Strole - Web Developer</title>

Best practices:

Keep it under 60 characters
Include your primary keyword (your name or your product) at the beginning
Add a secondary keyword or descriptor
Make it compelling and click-worthy

2. Meta Description

While not a direct ranking factor, the meta description influences click-through rates:

<meta name="description" content="Deividas Strole is a web developer specializing in Java, JavaScript, and SQL. Explore my portfolio, projects, and get in touch for collaborations.">

Best practices:

Keep it between 150-160 characters
Include your keyword naturally
Write for humans, not just search engines
Include a call-to-action

3. Open Graph Tags

These tags control how your site appears when shared on social media:

<meta property="og:title" content="Deividas Strole - Web Developer Portfolio">
<meta property="og:description" content="Explore the portfolio and projects of Deividas Strole, a web developer specializing in modern web technologies.">
<meta property="og:image" content="https://deividasstrole.com/images/deividas-strole-lawander-sc.png">
<meta property="og:url" content="https://deividasstrole.com">
<meta property="og:type" content="website">

4. Twitter Card Tags

Similar to Open Graph, but for X (Twitter) - this is what is shown if your website is shared on X (Twitter):

<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:title" content="Deividas Strole - Web Developer">
<meta name="twitter:description" content="Web developer specializing in modern applications and user experiences.">
<meta name="twitter:image" content="https://yourwebsite.com/images/twitter-card.jpg">

Strategic Keyword Placement

Now that the foundation is set, let's strategically place your keyword throughout the page:

1. H1 Heading

Your H1 should contain your primary keyword and appear only once per page:

<h1>Deividas Strole</h1>

2. Subheadings (H2, H3)

Use related keywords and variations in subheadings:

<h2>About Deividas Strole</h2>
<h2>Projects by Deividas Strole</h2>
<h3>Contact Deividas Strole</h3>

3. First Paragraph

Include your keyword in the opening paragraph naturally:

<section>
    <p>Hello! I'm <strong>Deividas Strole</strong>, a web developer passionate about creating elegant solutions to complex problems. With expertise in modern web technologies, I help businesses build exceptional digital experiences.</p>
</section>

4. Image Alt Text

Search engines can't "see" images, but they read alt text:

<img src="profile.jpg" alt="Deividas Strole - Web Developer">
<img src="project1.jpg" alt="E-commerce website designed by Deividas Strole">

5. Internal Links

Create descriptive anchor text with your keyword:

<a href="#about">Learn more about Deividas Strole</a>
<a href="#portfolio">View Deividas Strole's portfolio</a>

Structured Data (Schema.org)

Help search engines understand your content better with JSON-LD structured data:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "Deividas Strole",
  "url": "https://deividasstrole.com",
  "jobTitle": "Web Developer",
  "description": "Web developer specializing in modern web applications",
  "sameAs": [
    "https://linkedin.com/in/deividas-strole",
    "https://github.com/deividas-strole",
    "https://youtube.com/@deividas-strole",
    "https://x.com/deividasstrole"
  ]
}
</script>

This creates a "Knowledge Graph" that can appear in search results.

Technical SEO Considerations

1. URL Structure

Keep your URLs clean and keyword-rich:

✅ yourwebsite.com/deividas-strole
✅ deividasstrole.com
❌ yourwebsite.com/page?id=12345

2. Canonical Tag

Prevent duplicate content issues:

<link rel="canonical" href="https://yourwebsite.com/">

3. Favicon

While not directly impacting SEO, a favicon improves brand recognition:

<link rel="icon" type="image/png" href="/favicon.png">

4. Mobile Optimization

Google uses mobile-first indexing, so ensure your viewport meta tag is set:

<meta name="viewport" content="width=device-width, initial-scale=1.0">

Content Strategy for Personal Brands

Beyond technical optimization, create content that naturally incorporates your keyword:

About Section

<section id="about">
    <h2>About Deividas Strole</h2>
    <p>Deividas Strole is a web developer with 5+ years of experience building scalable applications. Specializing in Java, JavaScript, Spring Boot, React, SQL, and AI, Deividas helps startups and enterprises transform their digital presence.</p>
</section>

Portfolio/Projects

<section id="portfolio">
    <h2>Projects by Deividas Strole</h2>
    <article>
        <h3>E-commerce Platform</h3>
        <p>Deividas Strole designed and developed a full-stack e-commerce solution processing 10,000+ daily transactions.</p>
    </article>
</section>

Avoiding Keyword Stuffing

While you want to include your keyword, don't overdo it. Aim for a keyword density of 1-2%. For a 500-word page, that's 5-10 mentions. Focus on natural language and user experience first.

Bad example (keyword stuffing):

"Deividas Strole is the best developer. Deividas Strole builds websites. If you need Deividas Strole, contact Deividas Strole today."

Good example:

"As a web developer, I help clients to solve all their web related problems. My approach is hard work, no sleep, and hundred cups of coffee. All this combined deliver unseen and unheard incredible results... :D"

Performance Optimization

Page speed is a ranking factor. Optimize your index.html:

Minimize HTML: Remove unnecessary whitespace and comments
Optimize images: Use WebP format and appropriate dimensions
Lazy load: Load images below the fold lazily
Inline critical CSS: Include above-the-fold styles in <head>
Defer JavaScript: Use defer or async attributes

<script src="script.js" defer></script>

Complete Example

Here's a simplified but optimized index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Deividas Strole - Web Developer & Designer</title>
    <meta name="description" content="Deividas Strole is a web developer specializing in modern web applications. Explore projects, skills, and get in touch for collaborations.">
    <link rel="canonical" href="https://deividasstrole.com/">

    <!-- Open Graph -->
    <meta property="og:title" content="Deividas Strole - Web Developer">
    <meta property="og:description" content="Portfolio and projects of web developer Deividas Strole.">
    <meta property="og:image" content="https://deividasstrole.com/images/deividas-strole-lawander-sc.png">
    <meta property="og:url" content="https://deividasstrole.com">

    <!-- Structured Data -->
    <script type="application/ld+json">
    {
      "@context": "https://schema.org",
      "@type": "Person",
      "name": "Deividas Strole",
      "url": "https://deividasstrole.com",
      "jobTitle": "Web Developer"
    }
    </script>
</head>
<body>
    <header>
        <h1>Deividas Strole</h1>
        <nav>
            <a href="#about">About</a>
            <a href="#portfolio">Portfolio</a>
            <a href="#contact">Contact</a>
        </nav>
    </header>

    <main>
        <section id="hero">
            <h2>Web Developer & Designer</h2>
            <p>Hello! I'm <strong>Deividas Strole</strong>, a passionate developer creating modern web experiences.</p>
        </section>

        <section id="about">
            <h2>About Deividas Strole</h2>
            <img src="profile.jpg" alt="Deividas Strole profile photo">
            <p>With expertise in modern web technologies, I help businesses build exceptional digital products that users love.</p>
        </section>

        <section id="portfolio">
            <h2>Featured Projects</h2>
            <article>
                <h3>Project Name</h3>
                <img src="project.jpg" alt="Web application by Deividas Strole">
                <p>A responsive web application built with React and Node.js.</p>
            </article>
        </section>

        <section id="contact">
            <h2>Get in Touch</h2>
            <p>Interested in working together? <a href="mailto:hello@example.com">Contact Deividas Strole</a></p>
        </section>
    </main>

    <footer>
        <p>&copy; 2024 Deividas Strole. All rights reserved.</p>
    </footer>
</body>
</html>

Monitoring and Iteration

After implementing these optimizations:

Submit to Google Search Console: Monitor how your site appears in search
Check Google Analytics: Track organic traffic and user behavior
Test with PageSpeed Insights: Ensure fast loading times
Monitor rankings: Use tools like Ahrefs or SEMrush to track keyword positions
Update regularly: Fresh content signals to search engines and AI that your site is active and not forgotten.

Conclusion

Optimizing your personal website for keywords is interesting but tedious job. You need to start with the code and finish with the content of your website itself. This guide is a good start and will give you nice fundament on which you can build your brand and strong online presence.

Remember, SEO and AIO is a marathon, not sprint. To see results, you need weeks if not months. But it is doable and rewarding.

Now go and optimize your index.html - Internet is waiting for you!

About the Author

Connect with me:

💡 How to Install Gemini CLI on Your Computer

Deividas Strole — Mon, 29 Dec 2025 01:43:24 +0000

Gemini CLI is a great open source command line tool that lets you use Google's Gemini on your computer right in the terminal. You can install and use it on Windows, Mac, or Linux. It can help you with code development, file and project management, and AI-powered assistance. Why I like and use it is also not only because it is a very powerful tool, but also because of its cost - or in reality - no cost! For individuals, it has a 1000 requests per day limit, which is way too much for the average user (60 requests per minute). So, try it, see if you like it, and comment under the article. Now, let's install it:

🛠 Prerequisites

Node.js (v20 or higher) — this provides the runtime environment Gemini CLI needs.
A working terminal.

🚀 Step 1 — Install Gemini CLI

npm install -g @google/gemini-cli

▶️ Step 2 — Launch Gemini CLI

In your command-line shell type:

gemini

🔑 Step 3 — Authenticate

You will need to log in with your Google account - that is how Google will track how many requests you make. But don't worry, they are giving more than needed for an average user.

🧪 Step 4 — Try a Command!

Enter a prompt and wait for an answer. My question about why the sky is blue—it took 9 seconds to answer :)

About the Author

Connect with me:

DEV Community: Deividas Strole

Java HTTP Requests Made Easy: A Practical Guide to java.net.http

1. What is java.net.http?

2. Your First GET Request

3. Reading the HTTP Status Code

4. Adding Request Headers

5. Sending an Authorization Token

6. Sending a POST Request

7. What Are BodyPublishers?

8. What Are BodyHandlers?

9. Downloading a File

10. Adding a Timeout

11. HTTP/2

12. Sending PUT Requests

13. Sending DELETE Requests

14. Sending PATCH Requests

15. GET Requests with Query Parameters

16. Synchronous vs Asynchronous Requests

17. Making an Asynchronous Request

18. Why Use sendAsync()?

19. Reading Response Headers

20. Handling Exceptions Properly

21. Network Failure Is Different from HTTP Failure

22. Creating a Reusable API Method

23. Reuse HttpClient

24. But What About JSON?

25. A More Realistic REST API Client

26. Quick Cheat Sheet

Create a client

GET

POST

PUT

DELETE

PATCH

Add a header

Send synchronously

Send asynchronously

Status code

Response body

Response headers

27. The Mental Model

Final Thoughts

About the Author

Why Java Is a Great Choice for AI Development

1. Java Is Already Everywhere in Enterprise Software

2. Spring Boot Makes AI Integration Natural

3. Spring AI Makes Java AI Development Easier

4. Java Is Excellent for AI APIs

5. Java Works Well With Retrieval-Augmented Generation

6. Java Has Strong Concurrency Support

7. Java Is Fast

Model Computation

Application Computation

8. Java Is Strongly Typed

9. Java Has a Mature Production Ecosystem

10. Java Can Run Machine Learning Models Too

11. Java and Python Can Work Together

12. Where Java Is Especially Good for AI

AI-Powered Enterprise Applications

AI Microservices

Retrieval-Augmented Generation Systems

AI Features Inside Existing Java Applications

13. When Python May Still Be Better

Conclusion

About the Author

Why Java Is Still Important and Relevant in 2026

1. Java Is Still Everywhere in Enterprise Development

2. Java Has a Huge Ecosystem

3. Java Is Modern Now

4. Java Is Great for Learning Backend Development

5. Java Works Very Well With Databases

6. Java Is Strong for Large Applications

7. Java Has Excellent Tooling

8. Java Is Cloud and Microservice Friendly

9. Java Is Still Popular

10. Java Is a Good Career Investment

11. Java and AI Development

12. Putting It All Together

User response record

Service layer

1. What is `java.net.http`?

7. What Are `BodyPublishers`?

8. What Are `BodyHandlers`?

18. Why Use `sendAsync()`?

23. Reuse `HttpClient`