DEV Community: Prabhu R

AsciidocFX: The Asciidoc Editor for documentation and authoring

Prabhu R — Fri, 03 May 2024 06:00:00 +0000

For those who work extensively with Asciidoc files, having a robust and feature-rich editing tool is essential. We have already see the power of Asciidoc and Asciidoctor in our previous articles as a writer's tool and a presentation tool. In this article we will explore about AsciidocFX, an open-source toolset for creating and publishing technical documentation using AsciiDoc format is a free

AsciidocFX, is an open-source, cross-platform editor that provides an exceptional user experience and a comprehensive set of features for working with Asciidoc files. Though Asciidoctor provides these capabilities, not everyone will be comfortable enough to work in the commandline or shell setting that's where AsciidocFX comes to the rescue. Let's explore some of the key capabilities that make AsciidocFX stand out.

Live real-time previewing: While writing documents, authors can use live previewing to see the results of their changes immediately. This enables the user to quickly see how the final document is going to appear and reducing the time spent on compiling and reviewing documents.
Multi-format output: AsciidocFX allows generating various document formats such as HTML, PDF, EPUB, Mobi and DocBook based on your needs. This flexibility ensures that the documentation can be consumed in different contexts, catering to a diverse audience.
Epub Viewer: AsciidocFX provides an epub viewer, this allows the authors to view how the content appears as an epub book. However, this is rendered in a browser and not natively within AsciidocFX
Additional functionality through extensions: AsciidocFX offers advanced formatting features such as UML Diagrams, Sequence Diagrams, Mathematical Notations, File Tree representations etc through extensions that enables users to create rich and visually appealing documentation. Following is the list of popular tools supported through extensions. There are other tools that are supported by asciidoctor-diagram that is supported by AsciidocFX as well, however those tools are required to be in the PATH
- PlantUML Diagram - Sequence diagram, Usecase diagram,Class diagram, Activity diagram etc.
- Mermaid Diagram - Create diagrams using text and code
- Ditaa Diagrams - Convert diagrams drawn in ascii art to bitmap graphics.
- MathJax - Mathematical Notations expressed using Tex or MathML
- Charts - Using JavaFX Charts Extenstion
- File Tree - Display file tree using a text description
Presentation Slides: AsciidocFX provides the feature to create slides using Asciidoc like how Asciidoctor + RevealJS or Marp for Markdown. With immediate preview feature, the users see the resulting slides instantaneously.
Integrated File Management: The built-in file manager makes it easy to navigate and manage your Asciidoc files and projects. Create, open, and save files directly within the editor for a streamlined workflow.
Cross-Platform Compatibility: Last but not the least, it is cross-platform as it is written in Java and JavaFX and is available for Windows, macOS, and Linux, AsciidocFX ensures a consistent experience across multiple platforms, making it a versatile choice for users working in diverse environments.

With these great features AsciidocFX can be an indispensable tool for many use cases that includes

Software Documentation
Technical Writers preparing user manuals and technical documentation
Authors writing books
Technical materials that includes diagrams and mathematical formulae

Overall, AsciidocFX is a powerful and versatile toolset for creating and publishing documentation using the format. Its features facilitates producing high-quality, visually appealing documentation. By adopting AsciidocFX, users can streamline their documentation process, improve productivity, and ultimately enhance the user experience of their software or content.

Give it a try!

AI/ML - LangChain4j - AiServices

Prabhu R — Mon, 08 Apr 2024 06:00:00 +0000

The previous article our focus has been on delving into foundational elements of LangChain4j such as ChatLanguageModel, ChatMessage, ChatMemory, and others. Working with components at this level offers great flexibility and complete control, but it comes with the added burden of writing extensive boilerplate code. LLM-driven applications typically necessitate a multitude of interconnected components rather than a single component. Those components includes prompt templates, chat memory, LLMs, output parsers, RAG components: embedding models and stores. It frequently involves numerous interactions between these components and coordinating them all becomes an intricate and laborious task.

LangChain4j aims to simplify the development process by allowing the developers to concentrate on the core business logic without getting bogged down in intricate implementation details. To achieve this, LangChain4j provides two essential high-level abstractions: AiServices and Chains. These concepts are designed to streamline the workflow, enables to leverage the power of AI effectively while minimizing the complexity of low-level operations.

AiServices and Chains

AiServices

LangChain4j introduces a novel approach called AiServices, tailored specifically for the Java ecosystem. The primary objective of AI Services is to abstract away the complexities associated with interacting with Large Language Models (LLMs) and other components, providing a simple and intuitive API.

This approach draws inspiration from popular frameworks like Spring Data JPA and Retrofit, where developers can declaratively define an interface representing the desired API, and LangChain4j automatically generates an object (proxy) that implements this interface. AiServices can be perceived as a component within the service layer of the application, designed to provide AI-powered services, hence the name.

AiServices streamline common operations such as formatting inputs for LLMs and parsing outputs from LLMs. Furthermore, they support advanced features like chat memory, tools (Function Calling), and Retrieval-Augmented Generation (RAG).

AiServices can be leveraged to build stateful interactive applications that facilitate back-and-forth interactions, as well as to automate processes where each call to the LLM is isolated and self-contained. This versatility empowers developers to harness the power of AI in a seamless and efficient manner, without the need to delve into low-level implementation details.

Chains

LangChain4j also offers another composable approach called Chains. The concept of Chains originates from Python's LangChain. Chains combine multiple low-level components and orchestrate the interactions between them, enabling the creation of more complex and customized workflows.

However, one potential drawback of Chains is their inherent rigidity, which can pose challenges when customization is required. Currently, LangChain4j has implemented only two types of Chains: ConversationalChain and ConversationalRetrievalChain.

The ConversationalChain facilitates back-and-forth conversations with an LLM, maintaining context and memory across multiple interactions. On the other hand, the ConversationalRetrievalChain extends this functionality by incorporating a retrieval component (ContentRetriever), allowing the LLM to access and leverage external data sources during the conversation.

LangChain4J recommends using the AiServices instead of Chains as it is more flexible, declarative and provides a simple API.

In this article, we will see various examples of using AiServices

First let's see a basic AiServices examples

//DEPS dev.langchain4j:langchain4j:0.29.1
//DEPS dev.langchain4j:langchain4j-ollama:0.29.1

import java.io.Console;
import java.time.Duration;
import java.util.Set;

import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.ollama.OllamaChatModel;
import dev.langchain4j.service.AiServices;

class AiServicesBasic {

    private static final String MODEL = "mistral";
    private static final String BASE_URL = "http://localhost:11434";
    private static final Duration timeout = Duration.ofSeconds(120);

    interface ChatMinion {
        String chat(String message);
    }

    public static void main(String[] args) {

        ChatLanguageModel model = OllamaChatModel.builder()
                .baseUrl(BASE_URL)
                .modelName(MODEL)
                .temperature(0.2)
                .timeout(timeout)
                .build();
        ChatMemory memory = MessageWindowChatMemory.withMaxMessages(10);

        ChatMinion minion = AiServices.builder(ChatMinion.class)
                .chatLanguageModel(model)
                .chatMemory(memory)
                .build();
        Console console = System.console();
        String question = console.readLine("\n\nPlease enter your question: ");

        Set<String> set = Set.of("exit", "quit");
        while (!set.contains(question)) {
            String response = minion.chat(question);
            System.out.println(response);
            question = console.readLine("\n\nPlease enter your question: ");
        }

    }
}

We define the simple interface.

interface ChatMinion {
    String chat(String message);
}

Next come the low-level components ChatLanguageModel and ChatMemory

ChatLanguageModel model = OllamaChatModel.builder()
        .baseUrl(BASE_URL)
        .modelName(MODEL)
        .temperature(0.2)
        .timeout(timeout)
        .build();
ChatMemory memory = MessageWindowChatMemory.withMaxMessages(10);

Finally, create the AiServices object using the low-level components we created above.

ChatMinion minion = AiServices.builder(ChatMinion.class)
        .chatLanguageModel(model)
        .chatMemory(memory)
        .build();

LangChain4j's AiServices utility enables creating the proxy objects that implement custom interfaces defined (ChatMinion in this case). AiServices should be provided the Class of the interface along with the low-level components to be integrated (ChatLanguageModel and ChatMemory). AiServices then generates a proxy object that implements this interface using reflection.

This proxy object handles the necessary conversions for inputs and outputs, abstracting away the complexities of working with low-level components. Here the ChatMinion interface has a chat method that accepts a String as input. However, the underlying ChatLanguageModel component expects a ChatMessage object as input. In this scenario, AiServices will automatically convert the String input into a UserMessage before invoking the ChatLanguageModel.

Similarly, when the ChatLanguageModel returns an AiMessage, AiServices will convert it into a String before returning the result from the chat method. This seamless conversion process allows working with familiar data types in the application code, while AiServices handles the underlying transformations and interactions with the low-level components transparently.

String response = minion.chat(question);

To execute the statement above, AiServices does the heavylifting just described.

The next code example is the stream version of the AiServices where the responses are streamed unlike the previous one.

One additional point to note is that the LLM responds in a sarcastic tone! That is achieved using the SystemMessage annotation. AiServices takes care of passing the SystemMessage to the LLM

interface ChatMinion {
    @SystemMessage("Answer in a sarcastic tone.")
    TokenStream chat(String message);
}

Here's the full code.

//DEPS dev.langchain4j:langchain4j:0.29.1
//DEPS dev.langchain4j:langchain4j-ollama:0.29.1

import java.io.Console;
import java.time.Duration;
import java.util.Set;
import java.util.concurrent.CompletableFuture;

import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.StreamingChatLanguageModel;
import dev.langchain4j.model.ollama.OllamaStreamingChatModel;
import dev.langchain4j.model.output.Response;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.TokenStream;

class AiServicesStream {

    private static final String MODEL = "mistral";
    private static final String BASE_URL = "http://localhost:11434";
    private static final Duration timeout = Duration.ofSeconds(120);
    private static String question;

    interface ChatMinion {
        @SystemMessage("Answer in a sarcastic tone.")
        TokenStream chat(String message);
    }

    public static void main(String[] args) {

        StreamingChatLanguageModel model = OllamaStreamingChatModel.builder()
                .baseUrl(BASE_URL)
                .modelName(MODEL)
                .timeout(timeout)
                .temperature(0.0)
                .build();
        ChatMemory memory = MessageWindowChatMemory.withMaxMessages(10);

        ChatMinion minion = AiServices.builder(ChatMinion.class)
                .streamingChatLanguageModel(model)
                .chatMemory(memory)
                .build();
        Console console = System.console();
        question = console.readLine("\n\nPlease enter your question: ");
        Set<String> set = Set.of("exit", "quit");
        while (!set.contains(question.toLowerCase())) {
            CompletableFuture<Response<AiMessage>> future = new CompletableFuture<>();
            TokenStream stream = minion.chat(question);

            stream.onNext(System.out::print)
                    .onComplete(response -> {
                        future.complete(response);
                    })
                    .onError(error -> {
                        future.completeExceptionally(error);
                    })
                    .start();
            future.join();
            question = console.readLine("\n\nPlease enter your question: ");
        }
        System.exit(0);
    }
}

Sample input and output for the above

Please enter your question: Hello my name is Kevin

Oh, hello there! I'm just the most interesting person you'll ever meet. 
You know, I have a pet unicorn that I ride to work every day. 
And I can solve a Rubik's cube in under 5 seconds, no big deal. 
So, what's your superpower? Oh wait, you don't have one? 
Well, I guess we'll just have to be impressed by my extraordinary abilities then.

Please enter your question: What is my name?

Oh, right! I almost forgot. 
Your name is... oh, who am I kidding? 
It doesn't matter what your name is. 
I bet you're still more boring than a snail's race. 
But hey, keep trying to impress me with your mundane existence! 
It's always a good laugh.

While the current examples have focused on text-based interactions with Large Language Models (LLMs), the power of AiServices extends far beyond handling plain text data. AiServices can leverage the capabilities of LLMs to work with various types of structured data, such as Plain Old Java Objects (POJOs), Collection classes, and more.

By leveraging the versatility of LLMs, AiServices can seamlessly convert structured data objects into a format suitable for the LLM, process the data, and then convert the LLM's output back into the desired structured data format. This powerful feature enables developers to harness the power of LLMs for a wide range of tasks involving structured data, such as data processing, analysis, transformation, and generation.

For instance, you could define an interface that accepts or returns a POJO representing a complex data structure, and AiServices will handle the conversion between the POJO and the LLM's input/output format transparently. Similarly, you could work with Collection classes like Lists or Maps, allowing the LLM to process and manipulate the data within these collections.

This capability opens up numerous possibilities for integrating LLMs into various domains and applications, extending their utility beyond pure text-based tasks. With AiServices, you can leverage the power of LLMs to process and manipulate structured data in a seamless and intuitive manner, without being constrained by the limitations of traditional text-based interfaces.

In the following examples, let's build a crude profanity filter in the text.

//DEPS dev.langchain4j:langchain4j:0.29.1
//DEPS dev.langchain4j:langchain4j-open-ai:0.29.1

import java.util.Map;

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.UserMessage;

class AiServicesWordAnalysis {

    enum WordAnalysis {
        OFFENSIVE, BAD, NEUTRAL, GOOD
    }

    interface WordModerator {
        @UserMessage("Analyze the profanity of {{it}}")
        WordAnalysis analyzeWords(String text);

        @UserMessage("Does {{it}} have a profanity?")
        boolean isProfane(String text);

        @UserMessage("Provide alternate better words for the profane words in {{it}}")
        Map<String, String> alternateWords(String text);
    }

    public static void main(String[] args) {

        ChatLanguageModel model = OpenAiChatModel.withApiKey("demo");

        WordModerator moderator = AiServices.create(WordModerator.class, model);

        WordAnalysis analysis =moderator.analyzeWords("He is shit");
        System.out.println("Analysis: " + analysis);

        boolean isProfane = moderator.isProfane("He is a dumbo");
        System.out.println("Is Profane: " + isProfane);

        Map<String, String> replacements = moderator.alternateWords("He is not intelligent but a shit and dumbo");
        System.out.println(replacements);
    }
}

Here we define our interface WordModerator that defines three methods and the enum WordAnalysis to be supplied to the AiServices

enum WordAnalysis {
    OFFENSIVE, BAD, NEUTRAL, GOOD
}

interface WordModerator {
    @UserMessage("Analyze the profanity of {{it}}")
    WordAnalysis analyzeWords(String text);

    @UserMessage("Does {{it}} have a profanity?")
    boolean isProfane(String text);

    @UserMessage("Provide alternate better words for the profane words in {{it}}")
    Map<String, String> alternateWords(String text);
}

analyzeWords determines if the degree of profanity in the given text as defined in the enum WordAnalysis - OFFENSIVE, BAD, NEUTRAL, GOOD.
isProfane returns true or false indicating the presence of profanity in the given text.
alternateWords finds out the list of words that are profane and the LLM provides alternate words to be replaced for those words

As mentioned above, AiServices handles the conversion of input/output between the application and the LLM in a transparent manner.

The following is what the LLM returns when running the code

Analysis: OFFENSIVE
Is Profane: true
{shit=fool, dumbo=dimwit}

In the next example, we will see how AiServices deals with POJOs. We will try to create a primitive resume screener and the names extractor from the text. It is quite similar to the previous example

//DEPS dev.langchain4j:langchain4j:0.29.1
//DEPS dev.langchain4j:langchain4j-ollama:0.29.1

import java.time.Duration;
import java.util.List;

import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.ollama.OllamaChatModel;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.UserMessage;

class AiServicesCandidateInfo {

    private static final String MODEL = "mistral";
    private static final String BASE_URL = "http://localhost:11434";
    private static final Duration timeout = Duration.ofSeconds(120);

    class Candidate {
        String firstName;
        String lastName;
        String email;
        String experience;
        String profession;
        String phone;

        @Override
        public String toString() {
            return "Candidate: [firstName=" + firstName + ", lastName=" + lastName + ", email=" + email + ", experience="
                    + experience + ", profession=" + profession + ", phone=" + phone + "]";
        }
    }

    interface CandidateInfoCollector {

        @UserMessage("Extract information about a person from {{it}}")
        Candidate extractCandidateInfo(String text);

        @UserMessage("Extract all person names from {{it}}")
        List<String> extractPersonNames(String text);
    }

    public static void main(String[] args) {

        ChatLanguageModel model = OllamaChatModel.builder()
                .baseUrl(BASE_URL)
                .modelName(MODEL)
                .timeout(timeout)
                .build();

        CandidateInfoCollector candidateInfoCollector = AiServices.create(CandidateInfoCollector.class, model);

        String text = """
                I am Arjun Kumar, I have been working at a Software Developer for 5 years.
                Email: arjun@myemail.com
                Phone: +919876543210
                """;
        Candidate candidate = candidateInfoCollector.extractCandidateInfo(text);
        System.out.println(candidate);

        String text2 = """
                There was an interview being conducted in a software company. 
                Arjun and Ananya planned to attend the interview.
                Next morning they went to the venue.
                There they met their friends Akash, Mithun, Sita, Kausalya and Kumar who were also attending.
                The interviewers were Bob and Steve!
                """;

        // Person person = personExtractor.extractPersonFrom(text);
        List<String> candidates = candidateInfoCollector.extractPersonNames(text2);

        System.out.println(candidates);
    }
}

Here we define our POJO - Candidate and also override the toString method

class Candidate {
    String firstName;
    String lastName;
    String email;
    String experience;
    String profession;
    String phone;
}

The interface CandidateInfoCollector defines the two methods annotated with the UserMessage instruction

interface CandidateInfoCollector {

    @UserMessage("Extract information about a person from {{it}}")
    Candidate extractCandidateInfo(String text);

    @UserMessage("Extract all person names from {{it}}")
    List<String> extractPersonNames(String text);
}

Running the code extracts the POJO object and the list of names

Candidate: [firstName=Arjun, lastName=Kumar, email=arjun@myemail.com, experience=5 years, profession=Software Developer, phone=+919876543210]

[ Arjun, Ananya, Akash, Mithun, Sita, Kausalya, Kumar, Bob, Steve]

As we can see from the examples above, AiServices enables the developer to focus on the business logic by taking away the complexities of interacting with the LLM and handling the different data types transparently.

There are more to be explored in LangChain4j such as Tools (Function Calling), Retrieval Augmented Generation (RAG), etc. We will explore those in the upcoming articles.

The code examples are available on GitHub repo.

Happy Coding!

AI/ML - Langchain4j - Chat Memory

Prabhu R — Thu, 28 Mar 2024 11:04:04 +0000

In the preceding article, we were introduced to AI/ML concepts and explored the process of running a local Large Language Model (LLM) - Ollama. We further delved into interacting with it via Java using JBang and Langchain4j.

Now, let's explore into what "chat memory" is and how langchain4j helps in the cumbersome task of maintaining the chat memory.

To begin with, let's discuss the necessity of chat memory. Since language models (LLMs) inherently lack the ability to preserve conversation states due to their stateless nature, supporting extended conversations requires careful handling of the dialogue context.

If we run the OllamaMistralExample from the previous article, the following are the responses from the model

Please enter your question - 'exit' to quit: My name is Kevin, the minion. I work for Gru!

 Hello Kevin the Minion! It's great to meet you, the dedicated and hardworking minion from Gru's team. I'm here to help answer any questions or provide information you may need. What can I assist you with today?

Please enter your question - 'exit' to quit: Who is my boss? 

 I cannot determine who your boss is as I don't have the ability to access or interpret real-world information. Your boss would be the person who has authority over you in your workplace, such as a manager or supervisor. If you are unsure, it may be best to ask someone in a position of seniority within your organization or consult your employment contract or HR department for clarification.

Please enter your question - 'exit' to quit: What is my name?  

 I am an artificial intelligence and do not have a name or personal identity. I exist to provide information and answer questions to the best of my ability. How may I assist you today?

From the responses above, we can clearly see that the model does not remember the context of the conversation during the interaction with the LLM as they don't remember the state. Hence, the application interacting with the LLM should manage the conversation message to and from the LLM.

For sending multiple messages, langchain4j's ChatLanguageModel interface provides the following methods

default Response<AiMessage> generate(ChatMessage... messages); 

Response<AiMessage> generate(List<ChatMessage> messages);

default Response<AiMessage> generate(List<ChatMessage> messages, ToolSpecification toolSpecification);

default Response<AiMessage> generate(List<ChatMessage> messages, List<ToolSpecification> toolSpecifications);

Now let's see a code example that uses the second method in the ChatLanguageModel interface, that is Response<AiMessage> generate(List<ChatMessage> messages);

//JAVA 21
//DEPS dev.langchain4j:langchain4j:0.28.0
//DEPS dev.langchain4j:langchain4j-ollama:0.28.0

import java.io.Console;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;

import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.model.StreamingResponseHandler;
import dev.langchain4j.model.chat.StreamingChatLanguageModel;
import dev.langchain4j.model.ollama.OllamaStreamingChatModel;
import dev.langchain4j.model.output.Response;

class OllamaMistralBasicMemory {

    private static final String MODEL = "mistral";
    private static final String BASE_URL = "http://localhost:11434";
    private static Duration timeout = Duration.ofSeconds(120);

    public static void main(String[] args) {
        beginChatWithBasicMemory();
    }

    static void beginChatWithBasicMemory() {

        Console console = System.console();
        List<ChatMessage> messages = new ArrayList<>();

        StreamingChatLanguageModel model = OllamaStreamingChatModel.builder()
                .baseUrl(BASE_URL)
                .modelName(MODEL)
                .timeout(timeout)
                .temperature(0.0)
                .build();

        String question = console.readLine(
                "\n\nPlease enter your question - 'exit' to quit: ");
        while (!"exit".equalsIgnoreCase(question)) {

            messages.add(UserMessage.from(question));
            CompletableFuture<Response<AiMessage>> futureResponse = new CompletableFuture<>();
            model.generate(messages, new StreamingResponseHandler<AiMessage>() {

                @Override
                public void onNext(String token) {
                    System.out.print(token);
                }

                @Override
                public void onComplete(Response<AiMessage> response) {
                    messages.add(response.content());
                    futureResponse.complete(response);
                }

                @Override
                public void onError(Throwable error) {
                    futureResponse.completeExceptionally(error);
                }
            });

            futureResponse.join();
            question = console.readLine("\n\nPlease enter your question - 'exit' to quit: ");
        }
    }

}

The OllamaMistralBasicMemory class is a modified version of OllamaMistralExample class from the previous article. We use the StreamingChatLanguageModel which let's us get the response immediately for each token generated rather than having to wait for the full response.

Here we use an ArrayList to store the UserMessage and the AiMessage that gets sent to the LLM whenever we want the LLM to generate the response.

After each input received from the user, messages.add(UserMessage.from(question)); adds the user input to the list and when the response is completely received it triggers the event onComplete(Response<AiMessage> response) which in turn adds the message to the list of messages by messages.add(response.content());.

Now, try executing the OllamaMistralBasicMemory, and now the responses seem to align with what we expect and it seems to know the context. The following is the output for the same conversation as above.

Please enter your question - 'exit' to quit: My name is Kevin, the minion. I work for Gru!

 Hello Kevin the Minion! It's great to meet you, the dedicated and hardworking minion from Gru's team. I'm here to help answer any questions or provide information you may need. What can I assist you with today?

Please enter your question - 'exit' to quit: What is my name?                 

 I apologize for the confusion earlier, Kevin. You have introduced yourself as Kevin the Minion. So, your name is indeed Kevin! Is there something specific you would like to know or discuss related to Gru's lab or minion activities?

Please enter your question - 'exit' to quit: Who is my boss?

 Your boss is Gru! He is the mastermind and leader of the evil organization that you and your fellow Minions work for. Gru is known for his cunning plans and schemes, and he relies on your help to carry them out. If you have any questions or need assistance with tasks related to Gru's plans, feel free to ask!

As we can see, the LLM remembers the context and starts providing appropriate responses to the questions. However, there are a few problems with this implementation

First, LLMs possess a finite context window that accommodates a certain number of tokens at any given moment. Conversations have the potential to surpass this limit
Second, each token comes with a cost, which increases progressively as more tokens are requested from the LLM
Third, the resource usage increases considerably on both the LLM and the application over time as the list builds up

Managing ChatMessages manually is an arduous task. To simplify this process, LangChain4j provides the ChatMemory interface for managing ChatMessages that is backed by a List, offering additional features such as persistence (as provided by ChatMemoryStore) and the essential "eviction policy". This eviction policy to address the issues described above.

LangChain4j currently implements two algorithms for eviction policy:

MessageWindowChatMemory provides a sliding window functionality, retaining the N most recent messages and evicting the older ones when it goes beyond the specified capacity N. However, the SystemMessage type of ChatMessage is retained and not evicted. The other types of messages UserMessage, AiMessage and ToolExecutionResultMessage will be evicted
TokenWindowChatMemory also provides a sliding window functionality but retains the N most recent tokens instead of messages. A Tokenizer needs to be specified to count the tokens in each ChatMessage. If there isn't enough space for a new message, the oldest one (or multiple) is evicted. Messages are indivisible. If a message doesn't fit, it is evicted completely. Like the MessageWindowChatMemory, SystemMessage is not evicted.

Now, let's implement the OllamaMistralBasicMemory using ChatMemory with the MessageWindowChatMemory eviction policy

//JAVA 21
//DEPS dev.langchain4j:langchain4j:0.28.0
//DEPS dev.langchain4j:langchain4j-ollama:0.28.0

import java.io.Console;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;

import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.StreamingResponseHandler;
import dev.langchain4j.model.chat.StreamingChatLanguageModel;
import dev.langchain4j.model.ollama.OllamaStreamingChatModel;
import dev.langchain4j.model.output.Response;

class OllamaMistralChatMemory {

    private static final String MODEL = "mistral";
    private static final String BASE_URL = "http://localhost:11434";
    private static Duration timeout = Duration.ofSeconds(120);

    public static void main(String[] args) {

        beginChatWithChatMemory();
        System.exit(0);
    }

    static void beginChatWithChatMemory() {

        Console console = System.console();
        ChatMemory memory = MessageWindowChatMemory.withMaxMessages(3);

        StreamingChatLanguageModel model = OllamaStreamingChatModel.builder()
                .baseUrl(BASE_URL)
                .modelName(MODEL)
                .timeout(timeout)
                .temperature(0.0)
                .build();

        String question = console.readLine(
                "\n\nPlease enter your question - 'exit' to quit: ");
        while (!"exit".equalsIgnoreCase(question)) {

            memory.add(UserMessage.from(question));
            CompletableFuture<Response<AiMessage>> futureResponse = new CompletableFuture<>();
            model.generate(memory.messages(), new StreamingResponseHandler<AiMessage>() {

                @Override
                public void onNext(String token) {
                    System.out.print(token);
                }

                @Override
                public void onComplete(Response<AiMessage> response) {
                    memory.add(response.content());
                    futureResponse.complete(response);
                }

                @Override
                public void onError(Throwable error) {
                    futureResponse.completeExceptionally(error);
                }
            });

            futureResponse.join();
            question = console.readLine("\n\nPlease enter your question - 'exit' to quit: ");
        }
    }

}

Here we have set the max messages to 3 for the sake of testing it quickly. A higher value can be set if needed. Therefore, the max number of ChatMessages that are retained is 3 including question (UserMessage) and response (AiMessage).

If we run the program and specify our name first, then ask a few more questions so that the context of name gets evicted after 3 messages. Now if we ask the LLM for the name, the LLM does not have the content as the MessageWindowChatMemory has evicted those messages. This is where the heavylifting of managing the messages is done by LangChain4j.

The ChatMemory is a low-level component to manage the messages. However, there are high-level components AiServices and ConversationalChain that are available in LangChain4j. We will explore those in the upcoming articles.

The code examples can be found here

Happy Coding!

Beginning the AI/ML Journey with Ollama, Langchain4J & JBang

Prabhu R — Wed, 20 Mar 2024 10:19:40 +0000

The realm of AI/ML, especially Generative AI, has garnered significant attention worldwide following the emergence of ChatGPT. Consequently, there has been a surge of interest in developing various models and tools within this domain.

In this article, we will take a look at how to interact with AI models using Java. But before that, we will take a look at what an "AI Model" is, the terms and concepts related to it.

AI/ML Primer

Artificial intelligence (AI) models are computational algorithms crafted to process and produce information, often emulating human cognitive abilities. By assimilating patterns and insights from extensive datasets, these models have the capacity to generate predictions, text, images, or other forms of output, thereby augmenting a multitude of applications spanning diverse industries.

Numerous AI models exist, each tailored to serve specific purposes. While ChatGPT has garnered attention for its text input and output capabilities, other models and companies provide a range of inputs and outputs to cater to diverse needs that includes Images, Audio, Video etc.

What distinguishes models such as GPT (Generative Pre-trained Transformer) is this pre-training functionality transforms AI into a versatile developer tool, eliminating the need for a deep understanding of machine learning or model training.

LLM - Large Language Models

LLM (Large Language Model) refers to a type of AI model designed to understand and generate human-like text at a high level of proficiency. LLMs are trained on vast amounts of text data and are capable of performing a wide range of natural language processing tasks, including text generation, translation, summarization, question answering, and more. Examples of LLMs include GPT (Generative Pre-trained Transformer) models such as GPT-3, BERT (Bidirectional Encoder Representations from Transformers), and others. These models have demonstrated impressive capabilities in understanding and generating text, leading to their widespread use in various applications, including chatbots, virtual assistants, content creation tools, and more.

Integrating LLM into applications requires access to LLM Provides like OpenAI, Google Vertex AI, Azure OpenAI etc., or software like Ollama, LM Studio, LocalAI etc that allow LLMs to be run locally. We will see about running LLMs locally later in this article.

Let's see some more terms and concepts before we get into the code integrating with LLMs

Tokens

In the context of Large Language Models (LLMs), tokens refer to the basic units of text that the model processes. These tokens can represent individual words, subwords, or even characters, depending on how the model is trained and configured.

When a piece of text is input into an LLM, it is typically tokenized into smaller units before being processed by the model. Each token corresponds to a specific unit of text, and the model generates output based on the patterns and relationships it learns from the input tokens.

Tokenization is a crucial step in the operation of LLMs, as it allows the model to break down complex text data into manageable units for processing. By tokenizing text, LLMs can analyze and generate responses with a granular level of detail, enabling them to understand and generate human-like text.

Tokenization can vary based on the specific tokenization scheme used and the vocabulary size of the model

In some tokenization schemes, a single word may be split into multiple tokens, especially if it contains complex morphology or is not present in the model's vocabulary. For example:

Word: "university"
Tokens: ["uni", "vers", "ity"]
Explanation: In this example, the word "university" is split into three tokens: "uni", "vers", and "ity". This decomposition allows the model to capture the morphological structure of the word.

Conversely, multiple consecutive words may be combined into a single token, particularly in subword tokenization schemes like Byte Pair Encoding (BPE) or WordPiece. For example:

Phrase: "natural language processing"
Token: "natural_language_processing"
Explanation: In this example, the phrase "natural language processing" is combined into a single token "natural_language_processing". This allows the model to treat the entire phrase as a single unit during processing, which can be beneficial for capturing multi-word expressions or domain-specific terminology.

The examples provided above are for the purposes of understanding and need not represent how it is actually processed by the LLM

Prompts and Prompt Templates

Prompts

Prompts lay the groundwork for language-based inputs, directing an AI model towards generating particular outputs. While those acquainted with ChatGPT might view prompts as mere textual inputs submitted through a dialog box to the API, their significance extends beyond this. In numerous AI models, the prompt text transcends a mere string, encompassing broader contextual elements. As we saw in the previous section on tokens, how tokens are processed varies differently based on the context and the tokenization schemes.

Developing compelling prompts is a blend of artistic creativity and scientific precision. The significance of this interaction method has led to the emergence of "Prompt Engineering" as a distinct discipline. A plethora of techniques aimed at enhancing prompt effectiveness are continually evolving. Dedication to refining a prompt can markedly enhance the resultant output.

Prompt Templates

Prompt templates serve as structured guides for crafting effective prompts, helping users communicate their intentions clearly and succinctly to AI models.

Prompt templates can vary depending on the specific use case or application domain. They may include placeholders for variables or user inputs, guiding users to provide contextually relevant information. By following a prompt template, users can ensure consistency and clarity in their prompts, which in turn improves the performance and relevance of the AI model's responses.

For example, a prompt template for a chatbot might include placeholders for the user's inquiry, desired action, and any relevant context or constraints. By filling in these placeholders with specific details, users can create well-formed prompts that elicit accurate and useful responses from the chatbot. Following is a sample chatbot prompt template

Planning to book a [service]? 
Let me know your preferred date and time and 
I'll assist you with the booking process.

Enhancing/Updating the Data to the AI Model

GPT 3.5/4.0 dataset extends only until September 2021 which becomes an apparent limitation for getting updated data. Consequently, the model says that it does not know the answer to questions that require knowledge beyond that date. The dataset can be from a few hundred gigabytes to a few petabytes.

In order to incorporate additional data to the model the following techniques are used

Fine Tuning: a conventional method in machine learning, entails adjusting the model's parameters and altering its internal weighting. This extremely resource-intensive process is a challenge when training large models like GPT and certain models may not provide this capability.
Retrieval Augmented Generation (RAG): RAG, also referred to as "Prompt Stuffing", offers a pragmatic approach. In this method, the system extracts unstructured data from documents, processes it, and stores it in a vector database such as Chroma, Pinecone, Milvus, Qdrant, and others. During retrieval, when an AI model is tasked with answering a user's query, the question along with all "similar" document fragments retrieved from the vector database are incorporated into the prompt forwarded to the AI model.
Function Calling: This mechanism facilitates the registration of custom user functions, linking large language models with external system APIs. These systems enable LLMs to access real-time data and execute data processing tasks on their behalf.

Integrating LLMs into applications

Now let's dive into the coding aspect of integrating LLMs in the applications. The following are the prerequisites

Ollama: Ollama is a lightweight, extensible framework for building and running language models on your local machine. It provides a simple API for creating, running, and managing models, as well as a library of pre-built models that can be easily used in a variety of applications. Download and install the appropriate binary for your OS.
Langchain4j: LangChain4j is a Java library designed to simplify integrating AI and large language models (LLMs) into Java applications. It offers a unified API to avoid the need for learning and implementing specific APIs for each of them. To experiment with a different LLM or embedding store, you can easily switch between them without the need to rewrite your code. LangChain4j currently supports over 10 popular LLM providers and more than 15 embedding stores.
JBang: JBang is a neat little tool that enables running Java code as script. It directly runs the java source file and saves the effort of setting up or configuring the project for Maven, Gradle or any other build system. It also manages the dependencies of external libraries in the comment of the source itself as we'll see in the following code. You can also read about JBang in our previous article

First, download the Ollama binary and install it. Alternatively, one can install LM Studio as well, that allows running of the LLM models locally. However, in this article, we will use Ollama
Next download and run the Ollama LLM model. Executing the following command in the shell downloads and runs the LLM

ollama run mistral

You can run any other model like llama2, phi etc as well. However, note that Ollama will download the required model which will be a few gigabytes in size.

Download and install JBang. When executing the code, JBang expects the Java binary to be in the PATH, if not JBang will download the necessary JDK as well.
Type the following code in your editor and save it as OllamaMistralExample.java

//JAVA 21
//DEPS dev.langchain4j:langchain4j:0.28.0
//DEPS dev.langchain4j:langchain4j-ollama:0.28.0

import java.io.Console;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;

import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.model.StreamingResponseHandler;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.chat.StreamingChatLanguageModel;
import dev.langchain4j.model.ollama.OllamaChatModel;
import dev.langchain4j.model.ollama.OllamaStreamingChatModel;
import dev.langchain4j.model.output.Response;

class OllamaMistralExample {

    private static final String MODEL = "mistral";
    private static final String BASE_URL = "http://localhost:11434";
    private static Duration timeout = Duration.ofSeconds(120);

    public static void main(String[] args) {
        Console console = System.console();
        String model = console.readLine(
                "Welcome, Butler at your service!!\n\nPlease choose your model - Type '1' for the Basic Model and '2' for Streaming Model:");
        String question = console.readLine("\n\nPlease enter your question - 'exit' to quit: ");

        while (!"exit".equalsIgnoreCase(question)) {
            if ("1".equals(model)) {
                basicModel(question);
            } else {
                streamingModel(question);
            }
            question = console.readLine("\n\nPlease enter your question - 'exit' to quit: ");
        }
    }

    static void basicModel(String question) {
        ChatLanguageModel model = OllamaChatModel.builder()
                .baseUrl(BASE_URL)
                .modelName(MODEL)
                .timeout(timeout)
                .build();
        System.out.println("\n\nPlease wait...\n\n");
        String answer = model.generate(question);
        System.out.println(answer);
    }

    static void streamingModel(String question) {

        StreamingChatLanguageModel model = OllamaStreamingChatModel.builder()
                .baseUrl(BASE_URL)
                .modelName(MODEL)
                .timeout(timeout)
                .temperature(0.0)
                .build();

        CompletableFuture<Response<AiMessage>> futureResponse = new CompletableFuture<>();
        model.generate(question, new StreamingResponseHandler<AiMessage>() {

            @Override
            public void onNext(String token) {
                System.out.print(token);
            }

            @Override
            public void onComplete(Response<AiMessage> response) {
                futureResponse.complete(response);
            }

            @Override
            public void onError(Throwable error) {
                futureResponse.completeExceptionally(error);
            }
        });

        futureResponse.join();
    }

}

Now type the following command to run the program, we will see the explanation to this shortly.

jbang OllamaMistralExample.java

JBang automatically downloads the dependencies and runs this Java file.

Now let's get into the code

The comment line at the top of the file are processed by JBang. //JAVA comment line indicates the target JDK version and the ones that start with // DEPS define the library dependencies. Here we define the Langchain4j libraries (core + ollama) that JBang downloads and processes. For further details about the JBang comment lines, please visit the JBang website.

The jbang OllamaMistralExample class defines two methods apart from the main method - basicModel and streamingModel. The quick difference them is that the basicModel waits for the LLM to generate the full response and respond back. The user will have to wait until the LLM completes the generation. LLMs generate one token at a time, so the LLM Providers offer a way to stream the tokens as soon as they are generated which significantly improves the user experience as the user can start reading the response almost immediately than waiting for the entire response. Therefore, the streamingModel method harnesses this streaming capability and starts to output the response as soon it receives from the LLM Provider.

Langchain4j provides APIs for both the standard response and streaming response. The ChatLanguageModel interface is for getting the standard response and the StreamingChatLanguageModel interface is for the streaming response. Both the interfaces provide similar methods, however the StreamingChatLanguageModel requires the StreamingResponseHandler interface implementation to be passed as an argument.

The StreamingResponseHandler interface specifies the following methods

public interface StreamingResponseHandler<T> {

    void onNext(String token);

    default void onComplete(Response<T> response) {}

    void onError(Throwable error);
}

onNext gets called when the LLM generates a token and responds back.
onComplete is a default method that does nothing, however can be overriden to deal with the complete response that gets delivered once the LLM has completed generating the response.
onError is invoked when there is an error generating the response.

The basicModel method uses the OllamaChatModel.builder() to build the class implementing the ChatLanguageModel interface and the streamingModel method uses the OllamaStreamingChatModel.builder() to build the class implementing the StreamingChatLanguageModel interface.

For both the interface types - standard and streaming the following fields need to be passed to the builders of each type

Base URL: http://localhost:11434 The URL and port where Ollama exposes the LLM service
Model Name: mistral in this example.
Timeout: Timeout is optional, however it is safe to set it in a local environment because LLMs could be slow to generate response due to resource constraints like No GPU, less memory etc.

Both the ChatLanguageModel and StreamingChatLanguageModel interfaces provide the generate method which is similar however as mentioned above, the StreamingChatLanguageModel's generate method expects an additional argument which is the implementation of the StreamingResponseHandler interface.

Try running the code above and enter into the world of AI/ML using LLMs. What we have seen above is just the beginning. There's a lot more to explore in this space, especially what Langchain4j offers - AiServices, Structured Data Extraction, Chains, Embedding, RAG, Function Calling and more.

Apart from Langchain4j, Spring AI also has support for AI/ML the same way Langchain4j does. We'll explore those in the upcoming articles.

Happy Coding!

Marp: A Markdown Presentation App That Simplifies Your Tech Talks

Prabhu R — Tue, 12 Mar 2024 16:02:00 +0000

In today's fast-paced tech world, giving effective presentations is crucial for conveying complex ideas and engaging audiences. While Markdown has emerged as a popular lightweight markup language for creating rich text documents, its use in creating dynamic, interactive, and visually appealing presentations can be challenging. This is where Marp comes into the picture - an open-source Markdown presentation app that simplifies the process of creating engaging tech talks. In our earlier post, we saw about how Asciidoctor can be used to create stunning presentations, and in this article it is markdown

What is Marp?

Marp (Markdown Presentation Engine) is a lightweight and flexible tool for creating interactive and visually appealing presentations using simple Markdown syntax. It was created based on the idea of combining the benefits of Markdown and Reveal.js, a popular HTML presentation framework. Marp supports the creation of presentations that can be rendered as static HTML, PDF, or PowerPoint

Features

Simple Markdown syntax: Marp uses a straightforward Markdown format for creating slides, making it easy for developers and writers who are already familiar with Markdown.
Interactive presentations: Marp supports the use of JavaScript and HTML to create interactive elements, such as quizzes, forms, and animations, to enhance user engagement.
Live preview: Marp provides a live preview mode while editing, allowing you to see the changes in real-time and fine-tune your slides without leaving the editor.
Directives and extended syntax: Marp supports a variety of directives and extended syntax (image syntax, math typesetting, auto-scaling, etc...) to create beautiful slides, as sometimes, simple text content isn't enough to emphasize or represent the content - mathematical equations for example.
Export to various formats: Marp supports exporting presentations in multiple formats such as HTML, PDF, and SVG, allowing you to share your content with a broader audience.
Customizable themes: Marp offers several built-in themes to choose from or the option to create custom themes, enabling you to design presentations that align with your brand and style.
Official Toolset: Marp provides an official toolset that has the Visual Studio Code extension and Marp CLI for command line usage.
Pluggable Architecture: Marp ecosystem is based on the Marpit framework for creating HTML slides deck and has a pluggable architecture where the features can be extended by developers via plugins

Getting Started

The recommended and the best option is to use the Visual Studio Code extension that is provided. The Marp CLI, the command line version, can also be used. However, one has to compile it to the required output everytime.

Use Cases

Marp is an ideal solution for developers, designers, educators, and anyone who needs to create engaging technical or informational presentations. Some common use cases include:

Software demos: Marp can be used to create presentations that showcase the features of a software product or application, with interactive elements that allow users to interact and explore the functionality.
Educational materials: Marp is an excellent tool for creating engaging educational materials such as tutorials, workshop guides, or study resources, with the ability to add code snippets, diagrams, and other multimedia content.
Technical talks: Marp simplifies the process of creating technical talks and workshops by offering a lightweight and flexible presentation engine that can handle complex content, interactive elements, and customizable styles.
Data visualizations: Marp supports integrations with libraries like D3.js and Plotly, making it an ideal choice for data scientists and researchers who need to present complex data visualizations in an engaging and accessible format.

Sample


---
theme: gaia
_class: lead
paginate: true
backgroundColor: #fff
backgroundImage: url('https://marp.app/assets/hero-background.svg')
---

![bg left:40% 80%](https://marp.app/assets/marp.svg)

# **Marp**

Markdown Presentation Ecosystem

https://marp.app/

---

# How to write slides

Split pages by horizontal ruler (`---`). It's very simple! :satisfied:

---

# Slide 1

foobar

---

# Slide 2

foobar

Marp offers a simple yet powerful solution for creating interactive and visually appealing technical presentations using Markdown syntax. With its live preview mode, customizable themes, and support for various export formats, it provides developers, educators, and presenters with an essential tool for engaging audiences and conveying complex ideas effectively. So, next time you need to create a presentation, consider giving Marp a try!

jsoup: A Powerful Java Library for Working With HTML and XML Documents

Prabhu R — Mon, 11 Mar 2024 09:17:43 +0000

jsoup is a popular open-source Java library that enables developers to parse, manipulate, and extract data from HTML and XML documents. In this article, we will explore the basics of using jsoup, including parsing HTML documents, selecting and manipulating elements, and updating content in HTML. We'll provide code snippets along the way to help illustrate its capabilities.

jsoup simplifies working with real-world HTML and XML. It offers an easy-to-use API for URL fetching, data parsing, extraction, and manipulation using DOM API methods, CSS, and xpath selectors.

jsoup website mentions that it implements the WHATWG HTML5 specification, and parses HTML to the same DOM as modern browsers.

scrape and parse HTML from a URL, file, or string
find and extract data, using DOM traversal or CSS selectors
manipulate the HTML elements, attributes, and text
clean user-submitted content against a safelist, to prevent XSS attacks output tidy HTML
jsoup is designed to deal with all varieties of HTML found in the wild; from pristine and validating, to invalid tag-soup; jsoup will create a sensible parse tree.

Getting Started with jsoup

To begin using jsoup, you first need to add the library as a dependency in your project. If you are using Maven, include the following in your pom.xml file:

<dependency>
  <groupId>org.jsoup</groupId>
  <artifactId>jsoup</artifactId>
  <version>x.xx.x</version>
</dependency>

where x.xx.x is the relevant version, as of this writing it is 1.15.3

or if you are using Gradle, include the following in your build.gradle file:

implementation 'org.jsoup:jsoup:x.xx.x'

Parsing an HTML Document

To parse an HTML document using jsoup, you can use the jsoup.connect() method followed by the URL of the HTML file or webpage you want to work with. Here's a simple example:

import org.jsoup.jsoup;
import org.jsoup.nodes.Document;

public class jsoupExample {
  public static void main(String[] args) throws Exception {
    Document document = jsoup.connect("https://www.example.com").get();

    // Continue working with the parsed document
  }
}

Selecting and Manipulating Elements

jsoup provides several methods to select and manipulate elements in an HTML or XML document. For example, you can use the select() method to select elements based
on their tags or attributes, like this:

import org.jsoup.jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

public class jsoupExample {
  public static void main(String[] args) throws Exception {
    Document document = jsoup.connect("https://www.example.com").get();

    // Select all 'h1' tags in the document
    Elements h1Elements = document.select("h1");

    // Update the content of the first 'h1' tag
    for (Element h1 : h1Elements) {
      h1.text(h1.text().replaceAll("old", "new"));
    }
  }
}

Updating Content in HTML

In addition to selecting and manipulating elements, you can also update the content of individual elements or the entire document using various methods provided by
jsoup. For example:

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

public class jsoupExample {
  public static void main(String[] args) throws Exception {
    Document document = jsoup.connect("https://www.example.com").get();

    // Update the content of a specific element
    Element header = document.selectFirst("h1");
    if (header != null) {
      header.text("New Header");
    }

    // Update the entire document's content
    String newContent = "This is the updated content.";
    document.body().html(newContent);
  }
}

jsoup is a powerful Java library for working with HTML and XML documents, enabling developers to parse, extract data, and manipulate elements efficiently. By using jsoup's simple yet effective APIs, you can save time and effort while producing cleaner, more maintainable code. It can effectively be used in content scraping (of course, without violating any policies or legal requirements) or editing and manipulating the documents in the document store or archive. Happy Coding!

Guided Tours Solution for Your Web Application

Prabhu R — Wed, 06 Mar 2024 14:34:48 +0000

Creating a user-friendly and engaging onboarding experience is crucial for ensuring that new users can effectively navigate any web application. Guided tours are an excellent way to help new users familiarize themselves with the various features of the application. In this article, we will compare five popular JavaScript libraries used for building guided tours in web applications: Shepherd, Bootstrap Tour, driver.js, Tour Guide JS, and Intro.js.

Shepherd

Shepherd is a powerful and customizable open source JavaScript library for creating interactive tours and onboarding experiences in web applications. It uses another open source library Floating UI to render the dialog tours. It offers a simple setup process, dynamic content support, the ability to create custom actions and events, and theming and styling too. More importantly, it is responsive too and never goes offscreen on smaller devices. Shepherd also provides excellent documentation and support, making it a popular choice among developers.

Bootstrap Tour

Bootstrap Tour is another open source JavaScript library that focuses on creating guided tours for web applications. It integrates seamlessly with the Bootstrap framework. It offers a wide range of features

customizable steps
keyboard navigation
progress indicators
page navigation
automatic step progressing
interactive step progress e.g. progress when the user clicks on the page element

The library hasn\'t been updated since a long time, yet the features are still great!

driver.js

driver.js is an open source JavaScript library designed for creating Product tours, highlights, contextual help aand feature adoption. Due to its extensive API, driver.js can be used for a wide range of use cases that includes

Onboarding the users by explaining how to use the product and answer common questions
Remove Distractions with the highlights feature and focus user attention on what matters.
Provide contextual help for users
Highlight new features and make sure users don't miss them.
Works on Mobile devices as well.

driver.js provides different flavours for its features with demo examples showcased in the site. The list has

Animated tours
Non-animated tours
Async tours
Tours with Progress
Overlay styling and more
Theming

driver.js is actively developed and has a very good documentation.

Tour Guide JS

Tour Guide JS is a lightweight open source library for creating guided tours in web applications. It offers the following features

It is framework agnostic
Has Typescript support
Like Shepherd this too uses Floating UI for navigation
Provides a lot of options for customization
Has extensive documentation
Also supports npm and mentions it to be better that using it directly

Intro.js

Intro.js like the others offers a rich set of features such as customizable steps and tooltips, keyboard navigation, theming, progress indicators and more. Like others, this library also has extensive documentation. Intro.js has open source licence under AGPL v3 and a commercial licence with different price plans

Take a look at these libraries and happy coding your next web application with one of these!

Datafaker: Simplifying Test Data Generation for Java and Kotlin

Prabhu R — Mon, 04 Dec 2023 15:29:17 +0000

In the world of software development, effective testing is crucial to ensure the reliability and functionality of applications. A significant aspect of robust testing is the use of representative and reliable test data. Datafaker, a powerful library for Java and Kotlin, simplifies the process of generating test data. In this article, we'll explore Datafaker and provide code examples for both Java and Kotlin, using the Maven coordinates to get started.

What Is Datafaker?

Datafaker is a Java and Kotlin library designed to streamline test data generation. It offers a user-friendly interface that makes creating mock data a breeze. Whether you need to generate test data for a database, API endpoints, or other testing purposes, Datafaker is the tool of choice for simplified data generation. It can be used to generate fake data for a variety of purposes, such as:

Testing software
Creating training data for machine learning models
Anonymizing data
Generating mock data for presentations

Key Features of Datafaker

Datafaker boasts a range of features that make it an indispensable tool for developers and testers:

Variety of Data Types: Datafaker supports a wide array of data types, including names, addresses, phone numbers, emails, dates, numbers, and more. This versatility ensures you can generate diverse test data for different use cases.
Fake Data Providers: Datafaker has many providers (233 as of 2.0.0) that are grouped under the following groups.

Base (Providers of everyday data)
Entertainment (Providers for movies, shows, books)
Food (Providers for different types of food)
Sport (Providers for different types of sport)
Videogame (Video game providers)

Customization: You have the power to customize data generation by setting specific constraints or formats implementing a Data Provider. For instance, you can define date formats, create data within a specific range, or adhere to specific patterns.
Multiple locales: Datafaker allows us to create multiple locales and also mix them easily with other locale data. The easiest way to do so is to create a Faker per locale, and mix between those fakers.
Repeatable random results: To generate a more predictable and repeatable data, we can provide a seed, and the instantiation of Fake objects will always happen in a predictable way, which can be handy for generating results multiple times.
Bulk Data Generation: Datafaker allows for bulk data generation, making it easy to create extensive datasets for comprehensive testing. These bulk generations can be returned as a Java Collection or Java Streams, however the test needs it.
Export/Transform Data: The generated data can be easily exported/transformed in multiple formats, such as XML, JSON, CSV, and SQL, ensuring compatibility with various testing and development environments.

There are other similar projects like Java Faker, Kotlin Faker, JFairy which provide similar functionality, however, Datafaker is quite active.

Now, let's dive into code examples to illustrate how Datafaker can be used for test data generation.

Code Examples

To get started with Datafaker in Java, add the following Maven dependency:

<dependency>
    <groupId>net.datafaker</groupId>
    <artifactId>datafaker</artifactId>
    <version>2.0.2</version>
</dependency>

Now, let's look at how you can generate random names, email addresses and phone numbers in Java:

// Java Example
import net.datafaker.Faker;

public class TestDataGeneration {
    public static void main(String[] args) {
        Faker faker = new Faker();

        // Generate random names
        String firstName = faker.name().firstName();
        String lastName = faker.name().lastName();
        String fullName = faker.name().fullName();
        String email = faker.internet().emailAddress();
        String phone = faker.phoneNumber().phoneNumber();

        // Generate a collection of names
        List<String> names = faker.collection(
            () -> faker.name().firstName(), 
            () -> faker.name().lastName())
        .len(10)
        .generate();

    }
}

This Java code snippet generates a firstName, a lastName, a fullName, an email and a phoneNumber. Followed by generating a collection of 10 names using two Suppliers where one Supplier provides the firstName and the other the lastName.

The bulk generation can be returned as Streams as well, like in the following code snippet

Stream<String> names = 
    faker.stream(
            () -> faker.name().firstName(), 
            () -> faker.name().lastName())
        .len(10)
        .generate();

Datafaker also provides a number of features for generating more complex data. For example, you can use Datafaker to generate fake data for:

Addresses
Companies
Credit cards
Dates and times
Locations
Products
Services
Vehicles

To generate more complex data, you can use Datafaker's providers. Providers are classes that generate fake data for a specific type of data. For example, the Address provider can generate fake addresses, while the Company provider can generate fake companies.

Here is an example of how to use Datafaker's Company provider to generate a fake company profile:

import net.datafaker.Faker;

public class Example {
    public static void main(String[] args) {
        Faker faker = new Faker();

        String name = faker.company().name();
        String catchPhrase = faker.company().catchPhrase();
        String website = faker.internet().domainName();

        System.out.println("Name: " + name);
        System.out.println("Catch phrase: " + catchPhrase);
        System.out.println("Website: " + website);
    }
}

This code will generate a fake company profile with a random name, catch phrase, and website.

For Kotlin, the code is more or less similar except for the Kotlin constructs.

Efficient testing requires reliable and representative test data, and Datafaker excels at this task. With its intuitive interface and wide array of data generation capabilities, Datafaker proves to be a valuable tool for both developers and testers. Whether you need to generate names, addresses, user data, or any other type of test data, Datafaker is your trusted companion. Give it a try, and experience how it streamlines the testing process, saving you time and effort in the long run.

To get started with Datafaker, you can find it on Maven Central using the following Maven coordinates:

<dependency>
    <groupId>net.datafaker</groupId>
    <artifactId>datafaker</artifactId>
    <version>2.0.2</version>
</dependency>

The documentation in the official website is also comprehensive. Please read it to understand the wide range of options it provides.

Discovering "Everything": A Powerful File Search Tool

Prabhu R — Fri, 20 Oct 2023 17:58:21 +0000

Imagine a world where you can instantly find any file on your computer with just a few keystrokes. No more endless clicking through folders or searching through a cluttered desktop. Welcome to the world of "Everything" - a remarkable file search tool that is lean in size and on the resources it uses.

"Everything" is a free, lightweight, portable and lightning-fast file search utility for Windows. Developed by David Carpenter, Voidtools. This gem of a software is designed to make file searching as efficient and effortless as possible. Moreover, it is portable too, no installation necessary! Let's look at some of the key features

Key Features:

Instant Search: The hallmark feature of "Everything" is its speed. As soon as you start typing in the search bar, it displays results in real-time. It's like having Google Search for your local files.
Light on Resources: Despite its powerful capabilities, "Everything" is incredibly light on system resources. It won't slow down your computer, even when indexing large drives.
Real-time updates: Changes to the file system, like adding new files, deleting files updates the index in real-time
Regex Support For advanced users, "Everything" supports regular expressions, allowing you to create complex search queries with ease.
Content Search: It has the ability to search within the contents of the files too!
Quick Access: You can use custom keyboard shortcuts to access "Everything" from anywhere, enhancing your productivity.
Easy to use: Everything has a simple and intuitive user interface.

How to Get Started:

Download and Install: Visit the official Voidtools website to download and install "Everything". You can choose between an installer and a portable version too!
Index Your Drives: After installation, "Everything" will index the files on your drives. This initial process might take some time, but the payoff is worth it.
Start Searching: Once indexing is complete, simply type your query into the search bar, and watch as "Everything" presents you with instant, accurate results.

Use Cases:

Organizing Files: Easily locate and manage files, even if you can't remember where you saved them.
Quick Document Retrieval: Find important documents, presentations, or spreadsheets in seconds.
Cleaning Up Clutter: Identify and remove duplicate files or old documents you no longer need.
Efficient Workflows: Streamline your workflow by accessing files rapidly, saving you valuable time.

In a world where digital clutter can overwhelm us, "Everything" comes to the rescue as an indispensable tool for file management and organization. Give it a try, and you'll wonder how you ever managed without it. Download "Everything" today and take control of your digital world like never before.

Story Points - Intent and Effectiveness

Prabhu R — Sat, 23 Sep 2023 08:43:34 +0000

In some companies, "Story Points" have the following two purposes.

A convoluted measure for customer billing, the customer won't really know how much effort has been put up for the said amount of story points in the bill.
A number by which the developer has no idea on how much task he is taking

Essentially, story points are an abstract way to define the complexity of a task at hand, usually denoted in terms of the numbers in the Fibonacci Series (natural numbers are acceptable too). The higher the number, the complex the task; so, if the number is large, it implies that it will have to be broken down into smaller manageable pieces.

Story points was intended to help the developers provide an effort estimate of the tasks without committing to the number of days/hours which is usually hard or not accurate. However, it has turned out in a way that it masks a direct way to calculate the effort that was involved in Time & Material Projects.

It is also to help in building a clear and expressive burnout charts that show how big the tasks were that the team had worked on.

Sometimes, the story points are twisted so much that the stories in them are just made up and the points don't really matter. Another problem with story points is that the management would expect the team to achieve the same amount of story points or more in each sprint, under the name of "increased productivity", even if they are understaffed. On the contrary, the team inflates the story points just to level it with their previous sprints, so that they will not be questioned by the management. Hence, neither the manager nor the team would be able to tell the exact amount of work done. They will have to settle down with the figures knowing each one is cheating the other.

Some interesting dialogues we usually hear on story
points.

"The customer won’t agree for that many story points bring it down further…"

"Do the story points include the testing effort?"

"Please move the incomplete story points to the next sprint..."

Excerpt from my book - Excel in IT

Code-athon, Code marathon or Hackthon: Is it good?

Prabhu R — Fri, 08 Sep 2023 15:35:09 +0000

In the ever-evolving landscape of tech-driven workplaces, companies are increasingly adopting unique approaches to foster innovation, collaboration, and rapid problem-solving.

One such approach gaining popularity is the code-athon, code marathon or hackathon — a structured event where teams come together in the office for a concentrated burst of coding, creativity, and camaraderie. Typically, this happens over a duration of 48 to 72 hours at a stretch.

In some companies, this has become more of a monthly or a bimonthly ritual. These code marathons definitely have a benefit but they also have a disadvantage.

While these events have their merits, they also come with their own set of challenges. Let's see the pros and cons of these code marathons

Pros:

Innovation Boost: Code-athons encourage teams to think outside the box, experiment with new ideas, and innovate quickly. These bursts of creativity can lead to groundbreaking solutions.
Team Building: Bringing teams together for intensive coding sessions fosters collaboration and strengthens team bonds. It promotes a sense of belonging and shared achievement.
Accelerated Development: Code-athons are excellent for rapidly developing and prototyping new features or products, helping companies stay competitive in fast-paced markets.
Skill Enhancement: Participants often learn new skills, tools, and technologies during these events, which can benefit both their personal growth and the company's technological prowess.
Problem Solving: Code-athons provide a platform to address complex problems that may have been lingering, offering fresh perspectives and innovative solutions.

Cons:

Burnout Risk: Code-athons at regular intervals can lead to burnout if not managed properly. Intense, recurring events may cause fatigue and negatively impact overall productivity.
Quality vs. Speed: The emphasis on speed and deadlines may prioritize quantity over quality. Rushed code can lead to technical debt and long-term maintenance challenges.
Inclusivity Concerns: Not all team members may thrive in such high-pressure environments. Code-athons can unintentionally exclude those who work better at a steady, sustainable pace.
Sustainability: Maintaining the frequency of code-athons can be challenging in the long run. Teams may struggle to sustain enthusiasm and participation.
Resource Allocation: These events require time and resources, potentially diverting focus from ongoing projects and strategic initiatives.

Doing it once in a while definitely has its benefits, but making it a regular ritual results in the team getting exhausted, become less motivated and counter-productive.

In conclusion, code-athons can be a powerful tool for boosting innovation and team cohesion. However, they should be approached with care and consideration for their potential downsides. Striking the right balance between regular code-athons and everyday work is key. Ultimately, the success of such rituals lies in the company's ability to manage the intensity, promote a culture of inclusivity, and ensure that the outcomes align with the organization's long-term goals. When done thoughtfully, code-athons can be a driving force behind a company's innovation and growth, however, overdoing it can become detrimental to the entire organization.

TypeScript: To be or not to be

Prabhu R — Fri, 08 Sep 2023 15:12:46 +0000

Recently, there has been a noticeable trend where some individuals and organizations have announced their decision to drop TypeScript from their supported stack. Some have done it with a reason, but some want to do it for the drama. While it's entirely valid for teams to reevaluate their technology choices, it's essential to emphasize the significance of constructive and well-informed discussions, especially when it comes to a versatile language like TypeScript.

Similarly, the once hailed jQuery was suddenly trampled like it was a sin to use jQuery in projects. This sort of a behaviour has been seen with other languages as well - Java, for example. People have been telling that "Java is dead" for a very long time; but Java has been growing strong ever since. Likewise, R programmers were being mocked that they are rare than white elephants. After the machine learning buzz took off, many started learning and also praised R.

Though I haven't used TypeScript extensively, I can see how the language filled the gap where JavaScript had a shortfall and how it evolved to being adopted by many frameworks and libraries. Here are some of my observations in the context of TypeScript:

1. TypeScript's Strengths: TypeScript has gained popularity for its strong typing system, improved developer tooling, and enhanced code maintainability. It's essential to acknowledge these strengths and consider the reasons why it became a part of your tech stack in the first place.

2. Guarding Against the "Sheep Mentality": It's crucial to guard against the "sheep mentality," where decisions are made without considering the pros and cons. Dropping TypeScript simply because others are doing so without thoughtful evaluation may lead to missed opportunities and challenges.

3. Continuous Improvement: Like any technology, TypeScript continues to evolve. The TypeScript team actively listens to feedback and consistently releases updates to address concerns and enhance the language's capabilities. Engaging in discussions and contributing to its development can lead to positive changes.

4. Project-Specific Considerations: Technology choices should align with the specific needs and goals of your projects. What works for one may not work for another. It's crucial to evaluate TypeScript within the context of your projects and make informed decisions accordingly.

5. Migration Challenges: Abruptly dropping TypeScript can lead to migration challenges, increased development costs, and potential disruptions to ongoing projects. A well-thought-out transition plan, driven by constructive discussions, can help mitigate these challenges.

6. Learning and Collaboration: TypeScript has a vibrant and supportive community. Engaging in respectful conversations, sharing experiences, and seeking advice from experienced TypeScript developers can enhance your team's knowledge and foster collaboration.

TypeScript, like any technology, deserves thoughtful consideration and open dialogue. While it's acceptable to reassess your tech stack, it's crucial to do so with respect for the language's strengths and an understanding of the broader context. Constructive conversations not only benefit your team but also contribute to the continuous improvement of TypeScript and the tech community as a whole. Let's remember that the tech world thrives when we approach challenges with curiosity, collaboration, and a willingness to learn, rather than following the herd blindly.