João Fraga's website

Concurrency - Concurrency

Wed, 21 Jan 2026 09:00:00 +0000

Overview of Java concurrency primitives, patterns, and best practices for writing thread-safe, high-performance concurrent applications.

Thread Fundamentals

Thread Creation

Java provides two primary ways to create threads: extending Thread class or implementing Runnable interface. The Runnable approach is preferred as it separates the task from the execution mechanism.

// Using Thread
class MyThread extends Thread {
 public void run() {
 System.out.println("Thread: " + Thread.currentThread().getName());
 }
}

// Using Runnable
class MyTask implements Runnable {
 public void run() {
 System.out.println("Task: " + Thread.currentThread().getName());
 }
}

public class ThreadDemo {
 public static void main(String[] args) {
 // Thread approach
 MyThread t1 = new MyThread();
 t1.start();

 // Runnable approach
 Thread t2 = new Thread(new MyTask());
 t2.start();

 // Lambda expression
 Thread t3 = new Thread(() -> {
 System.out.println("Lambda: " + Thread.currentThread().getName());
 });
 t3.start();
 }
}

Thread Lifecycle

Threads progress through different states: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, and TERMINATED.

DP - Design Patterns

Mon, 30 Dec 2024 13:00:00 +0000

Overview of the patterns described in the book “Dive Into Design Patterns” in Java:

Creational

Factory Method
Abstract Factory
Builder
Prototype
Singleton

Structural

Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy

Behavioral

Chain of Responsibility
Command
Iterator
Mediator
Memento
Observer
State
Strategy
Template Method
Visitor

Creational Patterns

Factory Method:

A creational design pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created.

DS - Data Structures

Thu, 26 Sep 2024 12:00:00 +0100

Overview of the most commonly used data structures from both the Java Collections API and the Java Concurrent API.

Note: you can use the following to make collections thread-safe:

List<String> list = Collections.synchronizedList(new ArrayList<>());
Set<Integer> set = Collections.synchronizedSet(new HashSet<>());
Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>());

But you should prefer specialized collections from Java Concurrent API.

Arrays

Fixed-size, contiguous memory structures that store elements of the same type. They provide high-performance random access via zero-based indexing but require manual resizing if capacity is exceeded.

Sudoku - Sudoku Solver

Wed, 12 Jul 2023 22:57:00 +0100

The code used in this post can be found here: http://github.com/Fraguinha/Sudoku-Solver.

Sudoku

In Sudoku, the goal is to fill a 9 × 9 grid with digits so that each column, each row, and each of the nine 3 × 3 blocks that compose the grid contain all of the digits from 1 to 9.

Solver

Lambda - Lambda Calculus System

Mon, 17 Oct 2022 20:35:28 +0100

The code used in this post can be found here: http://github.com/Fraguinha/Lambda.

Lambda Calculus

At it’s core, Lambda Calculus is composed of three elements: variables, abstractions, and applications.

Variables are placeholders that represent an unknown value or lambda term. They are typically represented by a single lowercase letter.
Abstractions are expressions that define a function. They consist of a lambda, followed by a variable, followed by a dot, followed by a lambda term. e.g.: λx.x is an abstraction that defines a function that takes x and returns x.

IPFS - InterPlanetary File System

Sat, 27 Aug 2022 00:24:13 +0100

The InterPlanetary File System is a protocol, hypermedia and file sharing peer-to-peer network for storing and sharing data in a distributed file system.

1. Hosting on ipfs

After you have ipfs installed in your system, you will need to initialize your node.

$ ipfs init

Create a directory where your website files will be stored such as my-ipfs-website. Within it, write a simple index.html file with the following content:

<!doctype html>
<html lang="en">
 <head>
 <title>Helloworld</title>
 </head>
 <body>
 <h1>Helloworld</h1>
 </body>
</html>

We are now ready to start hosting our content on ipfs. Let’s add (and pin) the file we’ve just created on our node by running:

Hugo - Static Site Generator

Fri, 22 Jul 2022 13:34:17 +0100

Hugo is a static site generator. It is used to create website content using markdown instead of having to write html. You can read more about hugo on it’s website.

If you are curious about how hugo was used in the implementation of this website you can also check out my github repository.

1. Creating the website

After you have installed hugo through your package manager of choice, you can create a new hugo site by running in your terminal: