DEV Community: André Borba

Surfing with FP Java - Mastering Supplier

André Borba — Wed, 10 Sep 2025 15:00:00 +0000

Introduction

In the last episode, we mastered Consumer, the functional interface for performing actions.

Now, let’s turn our focus to Supplier, the simplest yet most powerful interface for lazy value generation.

If Predicate decides, Function transforms, and Consumer acts, then Supplier is the source. It provides values on demand, without requiring input.

What Is Supplier?

Here’s the definition:

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

Input: none.
Output: an object of type T.
Purpose: generate or supply values, often lazily or repeatedly.

Why Use Supplier?

Traditionally, values are produced eagerly:

String token = UUID.randomUUID().toString();

With Supplier, we can defer execution and encapsulate value creation:

Supplier<String> tokenSupplier = () -> UUID.randomUUID().toString();

System.out.println(tokenSupplier.get()); // A new token each call

This is especially powerful in lazy evaluation, configuration loading, testing, and dependency injection.

Practical Examples

1. Random or Unique Values

Suppliers naturally express randomness or unique generation:

Supplier<Integer> randomInt = () -> new Random().nextInt(100);

System.out.println(randomInt.get()); // e.g., 42
System.out.println(randomInt.get()); // e.g., 17

2. Deferred Initialization

Delay expensive computation until it’s needed:

Supplier<List<User>> heavyQuery = () -> database.fetchAllUsers();

// Nothing happens yet
List<User> users = heavyQuery.get(); // Query executes only here

3. Factories and Object Creation

Suppliers are elegant factories:

Supplier<User> newUser = () -> new User(UUID.randomUUID().toString());

User user1 = newUser.get();
User user2 = newUser.get();

4. Stream Integration

Suppliers work with Stream.generate to produce infinite sequences:

Supplier<String> uuidSupplier = () -> UUID.randomUUID().toString();

List<String> ids = Stream.generate(uuidSupplier)
    .limit(3)
    .toList();

System.out.println(ids); 
// [550e8400-e29b-41d4-a716-446655440000, ...]

Real-World Patterns

Configuration Providers:
Load config lazily when requested.
Caching with Lazy Evaluation:
Compute once, then reuse.
Dependency Injection:
Pass Suppliers instead of concrete objects for flexible object creation.
Testing and Mocking:
Suppliers make it easy to inject fake or mock data.

Best Practices

Keep Suppliers Pure: Avoid hidden side effects. Suppliers should primarily generate values.
Name Clearly: Use names like tokenSupplier, userFactory, configProvider.
Combine with Higher-Order Functions: Suppliers can be passed to methods to delay execution or customize behavior.

Common Pitfalls

Uncontrolled Infinite Streams: Stream.generate without a limit leads to infinite loops.
Heavy Logic Inside: Don’t hide complex operations inside Supplier#get(), it should be lightweight and predictable.
Side Effects: While possible, side-effect-driven suppliers (e.g., network calls) blur responsibilities. Prefer purity.

Functional Analogy

Think of Supplier as a well:

You don’t provide anything to it.
Each time you draw (get()), it gives you fresh water (T).
The well might be deep, infinite, or cached, but it always supplies.

Conclusion

Supplier is the lazy generator of functional Java.
It encapsulates value creation, supports lazy evaluation, and integrates seamlessly with streams, factories, and testing strategies.

By mastering Supplier, you unlock on-demand computation and flexible object creation.

What’s Next

In the next episode, we’ll dive into UnaryOperator, a specialized function for single-input transformations.
Where Function transforms from one type to another, UnaryOperator specializes in transforming within the same type, a cornerstone of functional composition.

Surfing with FP Java - Mastering Consumer

André Borba — Tue, 09 Sep 2025 11:00:00 +0000

Introduction

In the last episode, we explored Function, the transformer that converts inputs into outputs.

Now, let’s dive into Consumer, the functional interface designed for side-effect actions.

If Predicate decides, and Function transforms, then Consumer acts.

It consumes a value and performs an operation, printing, logging, storing, or triggering an event, without returning a result

What Is Consumer?

The definition:

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    // Composition method
    default Consumer<T> andThen(Consumer<? super T> after) { ... }
}

Input: an object of type T.
Output: none (void).
Purpose: perform an action, typically with side effects.

Why Use Consumer?

Before Java 8, side-effect actions like printing or logging were scattered inside loops:

for (String name : names) {
    System.out.println(name);
}

With Consumer, these actions become first-class citizens, making them reusable and composable:

Consumer<String> printName = System.out::println;

names.forEach(printName);

This decouples behavior definition from execution context.

Practical Examples

1. Printing and Logging

Consumer<String> printer = System.out::println;

List<String> names = List.of("Filipe", "André", "Borba");
names.forEach(printer);

2. Updating State (Carefully)

Consumers are useful for updates, though this introduces side effects, so use with caution:

Consumer<User> activateUser = user -> user.setActive(true);

users.forEach(activateUser);

3. Chaining Consumers

With andThen, you can build pipelines of actions:

Consumer<String> print = s -> System.out.println("Name: " + s);
Consumer<String> upperPrint = s -> System.out.println("Upper: " + s.toUpperCase());

Consumer<String> chained = print.andThen(upperPrint);

chained.accept("Borba");
// Output:
// Name: Borba
// Upper: BORBA

4. Event-Driven Style

Consumers integrate naturally with event systems:

Consumer<Order> processOrder = order -> System.out.println("Processing: " + order.getId());
Consumer<Order> sendNotification = order -> System.out.println("Notifying user...");

Consumer<Order> orderPipeline = processOrder.andThen(sendNotification);

orderPipeline.accept(new Order(42L));

Real-World Patterns

Logging Pipelines
Attach Consumers to stream processing for debugging or monitoring.
Callbacks
Pass Consumers as parameters to configure behavior dynamically.
Event Handlers
Model listeners as Consumers that accept an event and perform an action.

Best Practices

Isolate Side Effects
Keep Consumers focused and limit what they modify.
Name Actions Clearly
Names like logUser, sendEmail, or saveOrder communicate intent better than generic names.
Compose When Useful
Use andThen to build pipelines instead of nesting Consumers inside one another.

Common Pitfalls

Overuse in Pure Pipelines: Don’t rely on Consumers inside transformations (map, filter). They’re meant for effects, not transformations.

Hidden State Mutations: Consumers can easily break functional purity. Use them wisely.

Debugging Complexity: Multiple chained Consumers with side effects may complicate traceability.

Functional Analogy

Think of Consumer as a performer on stage:

It receives a script (T).
Acts it out (accept).
Doesn’t return anything, the impact is observable, not returnable.

Conclusion

Consumer embodies the side-effect boundary in functional Java.
While Predicate filters and Function transforms, Consumer executes actions, crucial for logging, event-driven designs, and orchestrating workflows.

Handled with discipline, Consumers provide e*xpressive, composable, and testable ways to model effects*.

What’s Next

In the next episode, we’ll explore Supplier, the interface for lazy value generation.
Where Function transforms input, Supplier creates values from nothing.

Get ready, we’re about to harness the power of on-demand computation. 🚀

Surfing with FP Java - Mastering Function

André Borba — Mon, 08 Sep 2025 11:00:00 +0000

Introduction

In the previous episode, we mastered Predicate<T>, the functional interface for declarative boolean logic.

Now it’s time to step into the transformer of data: Function<T, R>.

If Predicate answers the question “Is this valid?”, Function answers “How do I transform this into something else?”.

This interface is at the heart of functional programming in Java, powering data mapping, pipelines, and business transformations.

What Is Function?

The definition is straightforward:

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);

    // Composition methods
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) { ... }
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) { ... }

    // Utility
    static <T> Function<T, T> identity() { ... }
}

Input: an object of type T.
Output: an object of type R.
Purpose: transform input into output.

Why Use Function?

Before Java 8, transformations often required inline logic tied directly to loops or service calls:

List<String> names = new ArrayList<>();
for (User user : users) {
    names.add(user.getName().toUpperCase());
}

With Function, transformation becomes first-class and composable:

Function<User, String> toUpperName = user -> user.getName().toUpperCase();

List<String> names = users.stream()
    .map(toUpperName)
    .toList();

Now, transformation logic is explicit, reusable, and testable.

Practical Examples

Basic Transformation Transform Integer to String:

Function<Integer, String> intToString = i -> "Number: " + i;

System.out.println(intToString.apply(10)); // Number: 10

2. Mapping Over Collections

With streams, map works directly with Function:

List<String> names = List.of("Hob", "André", "Borba");

Function<String, Integer> nameLength = String::length;

List<Integer> lengths = names.stream()
    .map(nameLength)
    .toList();

System.out.println(lengths); // [3, 5, 5]

3. Composing Functions

Use andThen or compose for pipelines:

Function<Integer, Integer> multiplyBy2 = x -> x * 2;
Function<Integer, Integer> square = x -> x * x;

Function<Integer, Integer> pipeline = multiplyBy2.andThen(square);

System.out.println(pipeline.apply(3)); // (3 * 2) ^ 2 = 36

andThen: apply first, then the next.
compose: apply in reverse order.

4. Using Identity

Sometimes we need a no-op function:

Function<String, String> identity = Function.identity();

System.out.println(identity.apply("Hello")); // Hello

Useful in generic pipelines when you don’t want transformations.

Real-World Patterns

1. DTO Mapping

Convert domain objects into Data Transfer Objects (DTOs).

Function<User, UserDTO> toDTO = user -> new UserDTO(user.getId(), user.getName());

2. Pipelines in Data Processing

Chain multiple transformations (e.g., ETL systems, stream processors).

Domain-Specific Rules

Represent calculations or policies declaratively (price -> price * discount).

Best Practices

Name Functions by Transformation: Good names communicate the intent: toDTO, toUpperName, calculateTax.
Leverage Composition: Build pipelines using andThen and compose rather than nesting lambdas.
Prefer Pure Functions: Keep Function free of side effects, this ensures predictability and testability.

Common Pitfalls

Hidden Side Effects: Don’t log, mutate state, or throw unchecked exceptions inside functions.
Over-Complex Pipelines: Too many composed functions can obscure readability. Split into intermediate named functions.
Type Mismatches: Remember Function is generic, mismatched types in composition often cause compilation errors.

Functional Analogy

Think of Function as a transformer in a factory line:

It takes raw material (T).
Transforms it into a finished product (R).
Can be chained with other transformers to build a pipeline.

Conclusion

Function is the backbone of data transformation in functional Java. By externalizing transformation logic, you can build declarative pipelines, clean business rules, and reusable mappings.

It elevates Java from imperative loops to functional, composable workflows.

What’s Next

In the next episode, we’ll explore Consumer, the interface for actions without return values.
If Predicate validates and Function transforms, Consumer executes.

Stay tuned, the FP toolbox is just getting started! 🚀

Surfing with FP Java - Mastering Predicate

André Borba — Thu, 21 Aug 2025 01:20:39 +0000

Introduction

Welcome to the first practical episode of Surfing with FP Java. Today, we’ll explore Predicate, the functional interface that introduces declarative boolean logic in Java.

At first glance, Predicate seems simple, it takes a value and returns true or false. But its impact is profound: it allows us to externalize conditions, compose business rules, reduce coupling, and write code that is reusable and testable.

What Is Predicate?

In its pure form:

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);

    // Default methods for composition
    default Predicate<T> and(Predicate<? super T> other) { ... }
    default Predicate<T> or(Predicate<? super T> other) { ... }
    default Predicate<T> negate() { ... }

    // Handy static method
    static <T> Predicate<T> isEqual(Object targetRef) { ... }
}

Input: an object of type T.
Output: a boolean indicating if the condition is satisfied.

Why Use Predicate?

Traditionally, conditions in Java were written in an imperative style:

if (user.getAge() > 18 && user.isActive()) {
    // allowed
}

With Predicate, we transform this into a first-class function. This means we can pass, compose, and reuse the logic more elegantly:

Predicate<User> isAdult = user -> user.getAge() > 18;
Predicate<User> isActive = User::isActive;

Predicate<User> canAccess = isAdult.and(isActive);

Now canAccess is a reusable and composable rule, decoupled from the control flow.

Practical Examples

1. Filtering Collections

One of the most common uses is with Streams:

List<String> names = List.of("Andre", "Borba", "John", "Amanda", "Vlad");

Predicate<String> startsWithA = name -> name.startsWith("A");

List<String> filtered = names.stream()
    .filter(startsWithA)
    .toList();

System.out.println(filtered); // [Andre, Amanda]

2. Composing Conditions

Predicates let us create declarative business rules:

Predicate<User> isAdult = u -> u.getAge() >= 18;
Predicate<User> isActive = User::isActive;
Predicate<User> canAccess = isAdult.and(isActive);

List<User> usersAllowed = users.stream()
    .filter(canAccess)
    .toList();

This separates business rules from imperative control, improving clarity.

3. Negating Conditions

With negate(), you can easily invert logic:

Predicate<String> empty = String::isEmpty;
Predicate<String> notEmpty = empty.negate();

List<String> nonEmptyNames = names.stream()
    .filter(notEmpty)
    .toList();

4. Using isEqual

Predicate also provides a handy equality check:

Predicate<String> isEqualToAdmin = Predicate.isEqual("admin");

System.out.println(isEqualToAdmin.test("admin")); // true
System.out.println(isEqualToAdmin.test("user"));  // false

Real-World Patterns

Input Validation
Compose multiple predicates to validate DTOs or commands before persistence.
Feature Flags
Represent feature enablement logic declaratively.
Dynamic Filters
Build predicates at runtime to support dynamic API filters.

Best Practices

Name Predicates Clearly
Use domain-oriented names like isEligible or hasPermission instead of p1 or p2.
Prefer Composition Over Nesting
Combine with and, or, negate rather than writing nested if blocks inside lambdas.
Domain Isolation
Store reusable predicates as constants in utility classes or within domain services.

Common Pitfalls

Overuse: Not every condition needs to be extracted into a predicate.
Complexity: Too many chained predicates can hurt readability. Consider specialized classes if logic becomes too complex.
Performance: Each predicate in a chain is executed sequentially. Watch out in large pipelines.

Functional Analogy

Think of Predicate as the gatekeeper in your code:

It receives someone (T).
Decides if they are allowed in (boolean).
Can work alone (test) or cooperate with other gatekeepers (and, or).

Conclusion

Predicate is much more than a simple boolean function, it is the building block of declarative logic in Java. By mastering it, you can externalize rules, compose conditions, and write code that is more expressive, reusable, and clean.

What’s Next

In the next episode, we’ll explore Function<T, R>, the "transformer" of data.
Where Predicate answers “Is this valid?”, Function answers “How do I transform this into something else?”.

From here, functional composition becomes even more powerful. 🚀

Surfing with FP Java - The Beginning

André Borba — Thu, 24 Jul 2025 15:00:00 +0000

Welcome to Surfing with FP Java, a series crafted for developers who want to ride the waves of functional programming (FP) in Java with confidence and mastery. If you're passionate about writing cleaner, more expressive, and robust code, this journey is for you. Whether you're a seasoned Java engineer or a curious developer looking to deepen your understanding of functional paradigms, this series will equip you with the knowledge and practical skills to harness Java's functional interfaces to their fullest potential.

Who Is This Series For?

This series is designed for Java developers who are ready to elevate their craft by embracing functional programming. You might be:

A backend engineer building scalable, maintainable systems and seeking to leverage FP for cleaner designs.
A curious coder intrigued by how functional interfaces like Predicate, Function, or Consumer can transform your codebases.
A tech enthusiast who wants to understand the why, when, and how of functional programming in Java, with a focus on real-world applicability.

No matter your experience level, this series assumes you have a working knowledge of Java (preferably Java 8 or later) and a desire to explore functional programming with rigor and enthusiasm. We'll start with the fundamentals and progressively dive into advanced concepts, ensuring you gain a deep, practical understanding.

Why Functional Programming in Java?

Java, traditionally an object-oriented powerhouse, embraced functional programming with the introduction of Java 8's lambda expressions and functional interfaces. These tools allow us to write code that is more concise, declarative, and resilient to change. By adopting functional programming, we can:

Reduce Boilerplate: Replace verbose constructs with expressive lambda expressions and method references.
Enhance Readability: Write code that clearly communicates intent, making it easier for teams to collaborate.
Improve Maintainability: Leverage immutability and stateless operations to minimize side effects and bugs.
Boost Scalability: Design systems that are easier to parallelize and reason about, especially in modern, concurrent applications.

Functional interfaces are the backbone of this paradigm in Java. They provide a structured yet flexible way to apply functional programming principles, enabling us to create robust, reusable, and testable code. In this series, we'll explore how these interfaces can transform your projects, making them more modular, performant, and enjoyable to work on.

What Will We Cover?

In Surfing with FP Java, we’ll take a deep dive into Java’s functional interfaces, covering their theoretical foundations, practical applications, and real-world impact. Our journey will include:

Core Functional Interfaces: We’ll explore the building blocks of Java’s functional programming capabilities, including:
- Predicate<T>: Testing conditions with boolean logic.
- Function<T, R>: Transforming inputs into outputs.
- Consumer<T>: Performing actions without returning results.
- Supplier<T>: Generating values on demand.
- UnaryOperator<T>: Specializing functions for single-input transformations.
- BinaryOperator<T>: Combining two inputs of the same type.
- BiFunction<T, U, R>: Handling two inputs to produce a result.
- BiPredicate<T, U>: Testing conditions with two inputs.
- BiConsumer<T, U>: Performing actions on two inputs.
Foundational Concepts: We’ll establish a solid theoretical base, explaining why functional programming matters, how it aligns with principles like immutability and referential transparency, and when to apply these interfaces effectively.
Practical Applications: Each episode will include idiomatic Java code examples, showcasing how to use these interfaces in real-world scenarios, from stream processing to event-driven architectures.
Best Practices: We’ll discuss when to use each interface, common pitfalls to avoid, and how to balance functional programming with Java’s object-oriented roots.
Impact on Projects: We’ll highlight the tangible benefits of using functional interfaces, such as improved code quality, easier testing, and better performance in concurrent systems.

Why This Matters

Using functional interfaces isn’t just about writing “cool” code—it’s about building systems that are easier to reason about, maintain, and scale. By mastering interfaces like Predicate, Function, and Consumer, you can:
Streamline Data Processing: Combine functional interfaces with Java Streams to write declarative, efficient pipelines.

Enhance Modularity: Create reusable, composable components that adhere to SOLID principles and Domain-Driven Design (DDD).

Reduce Bugs: Minimize side effects by favoring stateless operations and immutability.

Future-Proof Your Code: Prepare your projects for modern paradigms like reactive programming (e.g., with Spring WebFlux) and event-driven systems.

Whether you’re working on microservices, data pipelines, or enterprise applications, functional programming in Java empowers you to write code that is both elegant and robust.

What to Expect in This Series

Each episode of Surfing with FP Java will blend theory, practical examples, and real-world insights. We’ll start with foundational episodes that introduce each functional interface, then progress to advanced topics like combining interfaces, optimizing performance, and integrating FP with frameworks like Spring or Akka. Expect:

Step-by-Step Explanations: We’ll break down complex concepts with clear, rigorous reasoning (Chain-of-Thought style).
Idiomatic Code: All examples will be written in Java, following best practices and emphasizing security, readability, and performance.
Real-World Scenarios: From filtering data with Predicate to building reactive pipelines with Function, we’ll show how these interfaces solve practical problems.
Community Engagement: This series is for the tech community, so we’ll encourage feedback to refine and expand our content.

Let’s Ride the Wave!

Surfing with FP Java is more than a tutorial, it’s a journey to unlock the full potential of Java’s functional programming capabilities. In the upcoming episodes, we’ll dive into each functional interface, starting with Predicate and building toward advanced compositions and patterns. By the end of this series, you’ll have a comprehensive understanding of how to wield these tools to create elegant, high-performance systems.

Ready to catch the functional programming wave? Let’s dive in and start surfing with FP Java!

Next Episode: Stay tuned for “Surfing with FP Java - Mastering Predicate”, where we’ll explore the power of boolean logic in functional programming and how to use Predicate to write declarative, reusable code.

Clojure Is Awesome!!! [PART 23]

André Borba — Tue, 22 Jul 2025 15:00:00 +0000

But What If KISS? 👀

(ns clojure-is-awesome.kiss
  (:require [clojure.spec.alpha :as s]))

(s/def ::id string?)
(s/def ::type #{"work" "break"})
(s/def ::duration (s/and int? pos?))
(s/def ::start-time #(instance? java.time.Instant %))
(s/def ::end-time #(instance? java.time.Instant %))
(s/def ::status #{:running :completed :paused :cancelled})
(s/def ::session (s/keys :req-un [::id ::type ::duration ::start-time ::end-time]))
(s/def ::sessions (s/coll-of ::session :kind vector))

(defn create-session
  "Creates a Pomodoro session with computed end-time."
  [id type duration]
  (let [start-time (java.time.Instant/now)
        end-time (.plusSeconds start-time (* duration 60))
        session {:id id
                 :type type
                 :duration duration
                 :start-time start-time
                 :end-time end-time}]
    (if (s/valid? ::session session)
      session
      (throw (ex-info "Invalid session" {:errors (s/explain-data ::session session)})))))

(defn set-session-status
  "Sets a session’s status (e.g., paused, cancelled)."
  [session status]
  {:pre [(s/valid? ::status status)]}
  (assoc session :status status))

(defn session-status
  "Returns session status and remaining time as data, given current time."
  [session now]
  {:pre [(s/valid? ::session session)
         (instance? java.time.Instant now)]}
  (if (:status session)
    {:status (:status session) :remaining-minutes 0}
    (let [end-time (:end-time session)
          remaining-secs (max 0 (- (.getEpochSecond end-time) (.getEpochSecond now)))]
      {:status (if (pos? remaining-secs) :running :completed)
       :remaining-minutes (int (/ remaining-secs 60))})))

(defn format-session
  "Formats a session’s status for display."
  [session now]
  (let [{:keys [status remaining-minutes]} (session-status session now)]
    (str (:id session) ": " (:type session) " "
         (case status
           :running (str "running, " remaining-minutes " minutes remaining")
           :completed "completed"
           :paused "paused"
           :cancelled "cancelled"))))

(defn generate-report
  "Generates a status report for all sessions."
  [sessions now]
  {:pre [(s/valid? ::sessions sessions)
         (instance? java.time.Instant now)]}
  (str "Pomodoro Status Report\n"
       (apply str
              (map #(str (format-session % now) "\n") sessions))))

(comment
  (def sample-sessions
    [(create-session "s1" "work" 25)
     (create-session "s2" "break" 5)])

  (session-status (first sample-sessions) (java.time.Instant/now))
  ;; => {:status :running, :remaining-minutes 25} (or less, depending on timing)

  (generate-report sample-sessions (java.time.Instant/now))
  ;; => "Pomodoro Status Report\ns1: work running, 25 minutes remaining\ns2: break running, 5 minutes remaining"

  ;; Simulate paused and cancelled states
  (def paused-session (set-session-status (first sample-sessions) :paused))
  (session-status paused-session (java.time.Instant/now))
  ;; => {:status :paused, :remaining-minutes 0}

  ;; Simulate completed session (adjust start-time for testing)
  (def completed-session
    (assoc (second sample-sessions)
           :start-time (.minusSeconds (java.time.Instant/now) (* 6 60))))
  (session-status completed-session (java.time.Instant/now))
  ;; => {:status :completed, :remaining-minutes 0}
)

Clojure Is Awesome!!! [PART 22]

André Borba — Mon, 21 Jul 2025 15:00:00 +0000

What If DRY? 👀

(ns clojure-is-awesome.dry
  (:require [clojure.spec.alpha :as s]
            [clojure.string :as str]))

(s/def ::id string?)
(s/def ::amount (s/and number? pos?))
(s/def ::date #(instance? java.time.LocalDate %))
(s/def ::category #{"income" "expense"})
(s/def ::description (s/and string? #(not (str/blank? %))))
(s/def ::transaction (s/keys :req-un [::id ::amount ::date ::category ::description]))
(s/def ::transactions (s/coll-of ::transaction :kind vector))

(defn create-transaction
  "Creates a transaction with centralized spec validation."
  [id amount date category description]
  (let [transaction {:id id :amount amount :date date :category category :description description}]
    (if (s/valid? ::transaction transaction)
      transaction
      (throw (ex-info "Invalid transaction" {:errors (s/explain-data ::transaction transaction)})))))

(defn calculate-by-category
  "Calculates totals for a given category."
  [transactions category]
  (->> transactions
       (filter #(= (:category %) category))
       (map :amount)
       (reduce + 0)))

(defn format-transaction
  "Formats a transaction for display."
  [transaction]
  (str (.toString (:date transaction)) " - " (:category transaction) " - " (:description transaction) ": $" (:amount transaction)))

(defn generate-report
  "Generates a financial report with reusable, composable functions."
  [transactions]
  {:pre [(s/valid? ::transactions transactions)]}
  (let [income (calculate-by-category transactions "income")
        expenses (calculate-by-category transactions "expense")
        balance (- income expenses)
        formatted-transactions (map format-transaction transactions)]
    (str "Financial Report\n"
         "Total Income: $" income "\n"
         "Total Expenses: $" expenses "\n"
         "Balance: $" balance "\n"
         "Transactions:\n"
         (str/join "\n" formatted-transactions))))

(comment
  (def sample-transactions
    [(create-transaction "t1" 1000 (java.time.LocalDate/of 2025 7 1) "income" "Salary")
     (create-transaction "t2" 200 (java.time.LocalDate/of 2025 7 2) "expense" "Groceries")
     (create-transaction "t3" 500 (java.time.LocalDate/of 2025 7 3) "income" "Freelance")
     (create-transaction "t4" 150 (java.time.LocalDate/of 2025 7 4) "expense" "Utilities")])

  (calculate-by-category sample-transactions "income")  ;; => 1500
  (calculate-by-category sample-transactions "expense") ;; => 350
  (generate-report sample-transactions)
  ;; => "Financial Report\nTotal Income: $1500\nTotal Expenses: $350\nBalance: $1150\nTransactions:\n2025-07-01 - income - Salary: $1000\n2025-07-02 - expense - Groceries: $200\n2025-07-03 - income - Freelance: $500\n2025-07-04 - expense - Utilities: $150"
)

🚀🚀

André Borba — Mon, 26 May 2025 13:46:45 +0000

ByteHide

Dec 9 '24

F# 9: Nullable Reference Types and Advancing Null Safety

#dotnet #fsharp #development #tutorial

Comments

4 min read

Clojure Is Awesome!!! [PART 21]

André Borba — Sat, 05 Apr 2025 15:00:00 +0000

The Origins and Foundations of Clojure

Welcome to Part 21 of the Clojure Is Awesome series! Today, we’re taking a step back from code to explore the roots of Clojure—where it came from, when it was born, what inspired it, and the principles that make it tick. If you’ve ever wondered how this functional gem came to be or why it feels so unique, this deep dive into its history and foundations is for you.

Let’s travel back to the beginnings of Clojure and uncover what makes it special!

The Birth of Clojure and Its Creator

Clojure was created by Rich Hickey, a seasoned software developer with a passion for simplicity and practical design. Before Clojure, Rich had extensive experience in the industry, working with languages like C, C++, and Java, and building complex systems. His frustration with the verbosity and complexity of mainstream programming languages—especially in the context of concurrent programming—drove him to design something new.

Rich began working on Clojure in 2005, spending two years developing it as a personal project. He wasn’t just tinkering; he was rethinking how programming languages could better address modern challenges like concurrency, data manipulation, and maintainability. In 2007, he publicly announced Clojure at the JVM Language Summit, introducing it to the world as a fresh take on Lisp for the Java Virtual Machine (JVM).

Year of Creation: 2007

Officially, 2007 marks Clojure’s debut, though its development started earlier. The first stable release, Clojure 1.0, came in 2009, solidifying its place as a production-ready language. By launching on the JVM, Clojure tapped into a massive ecosystem while offering a radically different approach compared to Java, the dominant language of that platform at the time.

The timing was significant: the mid-2000s saw growing interest in functional programming, multi-core processors were becoming mainstream, and developers were grappling with concurrency issues in traditional languages. Clojure arrived as a timely solution, blending Lisp’s heritage with modern needs.

Inspirations Behind Clojure

Clojure didn’t emerge in a vacuum—it’s deeply inspired by several languages and ideas:

Lisp
Clojure is a dialect of Lisp, one of the oldest high-level programming languages (born in 1958 by John McCarthy). From Lisp, it inherits:
- Homoiconicity: Code is data, and data is code, enabling powerful macros.
- Parentheses-heavy syntax: A hallmark of Lisp that prioritizes simplicity and consistency.
- REPL-driven development: Interactive coding that speeds up experimentation. Rich Hickey has cited Lisp as a major influence, calling it a "beautiful language" that got many things right but needed modernization.
Java
Running on the JVM, Clojure borrows Java’s vast ecosystem and
interoperability. It was designed to coexist with Java, not replace it,
allowing developers to leverage existing libraries while writing
concise, functional code.
Functional Programming Languages
ML and Haskell: Clojure adopts immutable data structures and a
preference for pure functions, hallmarks of functional programming.
Scheme: A minimalist Lisp dialect, Scheme influenced Clojure’s
focus on simplicity and clean design.
Concurrent Programming Ideas
Rich was inspired by the need for better concurrency models. He looked
at languages like Erlang, which excels at concurrency with its
actor model, and adapted those ideas into Clojure’s unique approach
(e.g., atoms, agents, and STM).
Data-Oriented Design
Clojure’s emphasis on data as a first-class citizen draws from Rich’s
philosophy that programs should focus on manipulating data, not just o
bjects or procedures. This contrasts with object-oriented paradigms
dominant in the 2000s.

The Technical Base: JVM and Beyond

Clojure’s foundation is the Java Virtual Machine (JVM), a choice that gives it portability, performance, and access to Java’s libraries. However, it’s not limited to the JVM:

ClojureScript: Introduced in 2011, it compiles Clojure to JavaScript, running in browsers and Node.js.
ClojureCLR: A port to the .NET Common Language Runtime (CLR), though less popular.

The JVM base means Clojure inherits Java’s garbage collection, threading model, and cross-platform capabilities. But Rich built Clojure to transcend Java’s limitations, adding features like immutable persistent data structures (lists, vectors, maps, sets) and a REPL for live coding.

Core Principles and Fundamentals

Clojure isn’t just a mashup of influences—it’s built on deliberate design principles that define its identity:

Simplicity
Rich Hickey famously said, “Simplicity is hard work, but complexity
kills.” Clojure avoids unnecessary abstractions (e.g., no complex class hierarchies) and favors straightforward data structures and functions.
Immutability by Default
Data in Clojure is immutable—once created, it can’t change. This
eliminates a whole class of bugs (e.g., race conditions) and makes
reasoning about code easier. Persistent data structures ensure
efficient updates without mutation.
Functional Programming
Clojure encourages pure functions—functions with no side effects—and
treats functions as first-class citizens. This aligns with its Lisp
roots and functional inspirations.
Concurrency Made Easy
With multi-core CPUs in mind, Clojure provides tools like:
- Atoms: For uncoordinated, synchronous updates.
- Refs: For coordinated updates via Software Transactional Memory (STM).
- Agents: For asynchronous tasks. These make concurrent programming safer and simpler than traditional locks and threads.
Data as Code
Thanks to its Lisp heritage, Clojure’s code is written as data (e.g., lists of symbols), enabling macros that transform code at compile time. This metaprogramming capability is a superpower for creating domain-specific languages (DSLs).
Pragmatism
While rooted in theory, Clojure is designed for real-world use. Its JVM integration, dynamic typing, and focus on developer productivity reflect a practical balance.

Why Clojure Matters Today
Since its debut in 2007, Clojure has grown into a respected language in the programming world. Here’s why it remains relevant:

Concurrency: Its tools for handling multi-threaded programs are still ahead of many languages.
Data-Driven Development: In an era of big data and microservices, Clojure’s focus on data manipulation shines.
Ecosystem: Libraries like core.async, ring, and reagent power modern applications.
Community: A passionate community keeps it evolving, with events like Clojure/conj and a thriving open-source scene.

Clojure’s influence can be seen in newer languages and frameworks that adopt immutability and functional paradigms. It’s a testament to Rich Hickey’s vision of a language that’s both timeless and forward-thinking.

Thoughts

What do you think about Clojure’s origins? Does its design philosophy resonate with your coding style? Share your thoughts in the comments—I’d love to hear from you! Stay tuned for Part 22, where we’ll dive back into Clojure’s practical wonders. Until then, keep exploring the awesome world of Clojure!

Clojure Is Awesome!!! [PART 20]

André Borba — Fri, 04 Apr 2025 15:00:00 +0000

Deep Dive into Clojure's reduce Function

What is reduce?

In Clojure, reduce is a fundamental function in functional programming that processes a collection by iteratively applying a function to an accumulator and each element, "reducing" the collection into a single result. Its basic signature is:

(reduce f init coll)

f: A function of two arguments: the accumulator (the running result) and the next element.
init: The initial value of the accumulator (optional).
coll: The collection to process.

If init is omitted, reduce uses the first element of the collection as the initial accumulator and starts processing from the second element. This flexibility makes reduce a powerful tool for a wide range of tasks.

Why reduce Matters

Unlike imperative loops (for or while in other languages), reduce offers a functional approach to iteration and accumulation. It can:

Aggregate data (e.g., summing numbers).
Transform collections into new structures (e.g., building maps or lists).
Handle complex logic in a clean, declarative way.

Let’s explore its capabilities with examples, starting simple and moving to a sophisticated real-world scenario.

Basic Examples

Here are some straightforward uses of reduce to illustrate its mechanics:

1!. Calculate the Factorial of a Number

(defn factorial [n]
  (reduce * 1 (range 1 (inc n))))

(factorial 5)

2!. Build a Sentence from Words

(def words ["Clojure" "are" "Awesome!!!"])
(reduce (fn [sentence word] (str sentence " " word)) (first words) (rest words))

3!. Find the Oldest Person

(def people [{:nome "Andre" :idade 30}
             {:nome "Borba" :idade 28}
             {:nome "John" :idade 35}])

(reduce (fn [oldest person]
          (if (> (:idade person) (:idade oldest))
            person
            oldest))
        (first people)
        (rest people))

4!. Count the Frequency of Elements

(def fruits ["Apple" "Banana" "Apple" "Orange" "Banana" "Apple"])
(reduce (fn [freq fruit]
          (update freq fruit (fnil inc 0)))
        {}
        fruits)

5!. Apply Sequential Discounts

(def discount [0.1 0.05 0.2])
(def original-price 100)
(reduce (fn [price discount] (* price (- 1 discount))) original-price discount)

hese examples show how reduce adapts to different operations by changing the function (f).

A Sophisticated Real-World Example: Analyzing User Activity Logs

Let’s move beyond trivial examples to a professional, high-value use case. Imagine you’re a data engineer working with a system that tracks user activity logs for a web application. You need to process a collection of log entries to calculate key metrics (total session time, page views per user) and generate a summary report. Here’s how reduce can tackle this:

Scenario

You have a list of log entries, where each entry is a map containing:

:user-id: The user’s unique identifier.
:timestamp: When the action occurred (in milliseconds).
:action: The type of action (:login, :page-view, :logout).

Your goal is to:

Calculate the total session duration per user (time between :login and :logout).
Count the number of page views per user.
Produce a structured summary.

Data

(def activity-logs [{:user-id "u1" :timestamp 1698000000000 :action :login}
                    {:user-id "u1" :timestamp 1698000001000 :action :page-view}
                    {:user-id "u1" :timestamp 1698000002000 :action :page-view}
                    {:user-id "u1" :timestamp 1698000005000 :action :logout}
                    {:user-id "u2" :timestamp 1698000003000 :action :login}
                    {:user-id "u2" :timestamp 1698000004000 :action :page-view}
                    {:user-id "u2" :timestamp 1698000007000 :action :logout}])

Solution
We’ll use reduce to process the logs and build a summary map where each user’s data includes session duration and page view count.

(defn process-logs [logs]
  (reduce
    (fn [acc {:keys [user-id timestamp action]}]
      (case action
        :login
        (assoc-in acc [user-id :start-time] timestamp)

        :logout
        (let [start-time (get-in acc [user-id :start-time])
              duration (when start-time (- timestamp start-time))
              page-views (get-in acc [user-id :page-views] 0)]
          (-> acc
              (assoc-in [user-id :duration] duration)
              (assoc-in [user-id :page-views] page-views)
              (update user-id dissoc :start-time)))

        :page-view
        (update-in acc [user-id :page-views] (fnil inc 0))

        acc))
    {}
    logs))

(process-logs activity-logs)

Explanation

Accumulator: A map where each key is a user-id and the value is a nested map tracking :start-time, :duration, and :page-views.
Logic:
- :login: Stores the start timestamp.
- :page-view: Increments the page view count (using fnil to handle nil as 0).
- :logout: Calculates the session duration, finalizes the page view count, and cleans up the temporary :start-time.
Result: A concise summary of user activity, ready for reporting or further analysis.

Conclusion

Clojure’s reduce is a Swiss Army knife for functional programming. From simple aggregations to complex state transformations like processing user activity logs, it provides a clean, powerful way to handle collections. Its elegance lies in its ability to abstract away explicit loops while delivering high-value results in real-world applications.

How might you use reduce in your projects? Whether it’s analyzing logs, transforming data, or computing metrics, it’s a tool worth mastering.

Clojure Is Awesome!!! [PART 19]

André Borba — Thu, 03 Apr 2025 15:00:00 +0000

We’ll dive into pattern matching using the core.match library in Clojure

This powerful tool allows you to handle complex data structures in a declarative and concise way, making your code more readable and maintainable. Let’s explore what pattern matching is, how to use core.match, and why it’s a valuable addition to your Clojure toolkit, complete with practical examples.

What Is Pattern Matching?

Pattern matching is a technique where you match data against predefined patterns, extracting components or triggering actions based on the match. It’s a staple in functional programming languages like Haskell and Scala, and in Clojure, the core.match library brings this capability to the table. Unlike basic conditionals like if or cond, pattern matching lets you express "what" you want to happen rather than "how" to check conditions step-by-step. It’s especially useful for:

Parsing structured data (e.g., JSON or EDN).
Handling data variants or tagged unions.
Simplifying nested conditional logic.

Setting Up core.match
To get started, you’ll need to add core.match to your project. The latest version available is 1.1.0 (as per the GitHub repository). Here’s how to include it:

For Leiningen (in project.clj): :dependencies [[org.clojure/core.match "1.1.0"]]

For deps.edn:
{:deps {org.clojure/core.match {:mvn/version "1.1.0"}}}

Once added, require it in your namespace:

(ns clojure-is-awesome.pattern-matching
  (:require [clojure.core.match :refer [match]]))

With the setup complete, let’s see core.match in action.

Basic Usage: Matching Values

The match macro takes an expression and pairs of patterns and results. Here’s a simple example matching numbers:

(match 42
  0 "Zero"
  1 "One"
  _ "Other")

The _ acts as a wildcard, matching anything. Now, let’s match a list:

(match [1 2 3]
  [1 2 3] "Exact match"
  [_ _ _] "Three elements"
  :else "Default")

You can also bind variables:'

(match [1 2 3]
  [a b c] (str "Values: " a ", " b ", " c))

This is destructuring made more powerful and flexible.

Practical Example: Parsing Commands

Let’s apply pattern matching to a real-world scenario—parsing commands. Suppose we have commands like [:add 5] or [:mul 2 3]:

(defn process-command [cmd]
  (match cmd
    [:add x] (str "Adding " x)
    [:sub x] (str "Subtracting " x)
    [:mul x y] (str "Multiplying " x " by " y)
    :else "Unknown command"))

(println (process-command [:add 5]))
(println (process-command [:mul 2 3]))

This is much cleaner than a chain of cond statements, and the intent is immediately clear.

Advanced Features: Guards and Nested Patterns

core.match goes beyond basics with features like guards ":guard fn" and nested pattern matching. Here’s an example with a guard:

(match {:type :user :age 25}
             ({:type :user :age age} :guard #(> (:age %) 18)) "Adult user"
             {:type :user :age age} "Minor user"
             :else "Other")

The :guard #(> (:age %) 18) ensures the pattern only matches if the condition holds. Now, let’s tackle a nested structure:

(match {:data [{:id 1 :name "Borba"} {:id 2 :name "John"}]}
             {:data [{:id id :name name} & rest]} (str "First user: " id ", " name))

The & rest captures remaining elements, showcasing how core.match handles complex data effortlessly.

Why Use core.match?

Compared to Clojure’s built-in cond or case, core.match offers:
Nested matching: Easily handle complex structures.
Variable binding: Extract values directly in patterns.
Guards: Add conditions for precise control.
Clarity: Replace verbose logic with declarative patterns.

It shines in scenarios like parsing DSLs, managing state machines, or simplifying conditional code.

Example: Traffic Light State Machine

(defn next-state [current]
  (match current
    :red {:state :green :action "Go"}
    :green {:state :yellow :action "Slow down"}
    :yellow {:state :red :action "Stop"}
    :else {:state :red :action "Invalid, stopping"}))

(println (next-state :red))
(println (next-state :yellow))

This declarative approach makes the state transitions crystal clear.

What do you think? Have you tried core.match in your projects? Let me know in the comments—I’d love to hear your experiences! Stay tuned for the next part of our series, where we’ll uncover more Clojure awesomeness.

Clojure Is Awesome!!! [PART 18]

André Borba — Wed, 02 Apr 2025 15:00:00 +0000

Clojure and Java Interoperability

Hey everyone! Welcome back to Clojure Is Awesome! After a bit of a break, I’m thrilled to be back with Part 18, diving into one of Clojure’s superpowers: interoperability with Java. If you’ve ever worked with Java or wondered how Clojure can leverage the vast Java ecosystem, this post is for you. We’ll explore how Clojure seamlessly uses Java libraries, frameworks, and even builds graphical interfaces—all while keeping things functional, clean, and practical.

What is Interoperability and Why Does It Matter?

Interoperability is the ability of a language or system to interact smoothly with another. In Clojure, this means it can:

Import and instantiate Java classes.
Call methods on Java objects.
Integrate with JVM libraries and frameworks.

Why is this important? Clojure runs on the JVM (Java Virtual Machine), giving it access to a mature ecosystem filled with battle-tested tools. This enables:

Reusing existing Java code.
Leveraging robust libraries for tasks like data manipulation, logging, or processing.
Integrating Clojure into legacy Java projects or using it alongside modern systems.

In short, interoperability makes Clojure a versatile choice for everything from simple scripts to complex enterprise applications.

Importing and Using Java Classes in Clojure

Let’s start with the basics: importing Java classes and creating instances in Clojure.

Example 1: Working with java.util.Date

Here, we import the Date class and create a function to get the current date.

(ns clojure-is-awesome.interop
  (:import [java.util Date]))

(defn get-current-date
  "Returns the current date using java.util.Date."
  []
  (Date.))

(println "Current date:" (get-current-date))

(:import [java.util Date]): Imports the Date class from the java.util package.
(Date.): Creates a new instance by calling the default constructor.

Example 2: Manipulating an ArrayList

Now, let’s create an ArrayList, add elements, and interact with its methods.

(ns clojure-is-awesome.interop
  (:import [java.util ArrayList]))

(defn create-and-populate-list
  "Creates an ArrayList, adds elements, and returns the list."
  []
  (let [lista (ArrayList.)]
    (.add lista "Clojure")
    (.add lista "Java")
    lista))

(println "List:" (create-and-populate-list))

(ArrayList.): Instantiates a new ArrayList.
(.add lista "Clojure"): Calls the add method on the lista instance.

Using Popular Java Libraries

Clojure can integrate with widely used Java libraries. Let’s use Apache Commons Lang for string manipulation.

Example 3: Reversing Strings with Apache Commons
First, add the dependency to your project.clj (if using Leiningen):

:dependencies [[org.apache.commons/commons-lang3 "3.12.0"]]

Now, create a function that reverses a string using StringUtils.

(ns clojure-is-awesome.interop
  (:import [org.apache.commons.lang3 StringUtils]))

(defn reverse-string
  "Reverses a string using Apache Commons' StringUtils."
  [s]
  (StringUtils/reverse s))

(println "Reversed string:" (reverse-string "Clojure Is Awesome!!!"))

StringUtils/reverse: Calls the static method reverse from StringUtils.

Integrating with Java Frameworks: Spring Boot

Clojure also integrates with frameworks like Spring Boot, enabling robust web applications. Let’s create a simple REST endpoint.

Example 4: REST Endpoint with Spring Boot and Clojure

Create a Spring Boot project with a Java class that delegates to a Clojure function.
Define the Clojure function to be called.
Clojure function (src/clojure/myapp/core.clj):

(ns myapp.core)

(defn greet
  "Returns a greeting message."
  [name]
  (str "Hello, " name "!"))

Spring Boot Java class (src/java/com/example/demo/DemoApplication.java):

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import clojure.java.api.Clojure;
import clojure.lang.IFn;

@SpringBootApplication
@RestController
public class DemoApplication {

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

    @GetMapping("/greet")
    public String greet(@RequestParam String name) {
        IFn require = Clojure.var("clojure.core", "require");
        require.invoke(Clojure.read("myapp.core"));
        IFn greetFn = Clojure.var("myapp.core", "greet");
        return (String) greetFn.invoke(name);
    }
}

How it works:

Spring Boot calls the greet function from the myapp.core namespace using the clojure.java.api.
The /greet?name=John endpoint returns "Hello, John!".

This basic example shows how Clojure can be used within a Spring Boot application.

Building Graphical Interfaces with Swing

Clojure can also create graphical interfaces using Java libraries like Swing. Let’s make a simple window with a button.

Example 5: Window with Button in Swing

(ns clojure-is-awesome.interop
  (:import [javax.swing JFrame JButton]
           [java.awt.event ActionListener]))

(defn create-gui
  "Creates a window with a button that prints a message when clicked."
  []
  (let [frame (JFrame. "Clojure Example")
        button (JButton. "Click Here")]
    (.addActionListener button
                        (reify ActionListener
                          (actionPerformed [_ _]
                            (println "Button clicked!"))))
    (.add frame button)
    (.setSize frame 300 200)
    (.setVisible frame true)))

(create-gui)

reify: Implements the ActionListener **interface to react to button clicks.
**Result: A window appears with a button that prints a message to the console when clicked.

Practical Tips for Interoperability

To wrap up, here are some useful tips when working with Clojure and Java:

Dependency Management:
Add Java libraries in project.clj or deps.edn. Example:
:dependencies [[org.apache.commons/commons-lang3 "3.12.0"]]
Exception Handling:
Use try/catch to capture Java exceptions:

(try
  (.methodThatMightFail object)
  (catch Exception e
    (println "Error:" (.getMessage e))))

Type Hints: Improve performance by avoiding reflection:

(defn my-function [^String s]
  (.toUpperCase s))

Static Methods:
Call them directly with Class/method, like StringUtils/reverse.
Documentation:
Refer to Java documentation to understand the classes and methods used.

Conclusion

In Part 18, we’ve explored the interoperability between Clojure and Java, showcasing how Clojure leverages the Java ecosystem elegantly. We’ve covered everything from using simple classes like Date and ArrayList to integrating with libraries like Apache Commons, frameworks like Spring Boot, and building graphical interfaces with Swing. Interoperability is one of Clojure’s key strengths, bringing the best of both worlds together.

What about you—have you tried combining Clojure and Java in your projects? Share your experiences in the comments! Next time, we’ll dive into another exciting corner of Clojure’s universe. Until then, keep coding with style!