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!

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!

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!

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.

3. 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.

4. 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();
    }

}

5. 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!

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

1. 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.
2. Interactive presentations: Marp supports the use of JavaScript and HTML to create interactive elements, such as quizzes, forms, and animations, to enhance user engagement.
3. 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.
4. 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.
5. 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.
6. 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.
7. Official Toolset: Marp provides an official toolset that has the Visual Studio Code extension and Marp CLI for command line usage.
8. 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:

1. 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.
2. 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.
3. 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.
4. 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 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!

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!

"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:

1. 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.

2. 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.

3. Real-time updates: Changes to the file system, like adding new files, deleting files updates the index in real-time

4. Regex Support For advanced users, "Everything" supports regular expressions, allowing you to create complex search queries with ease.

5. Content Search: It has the ability to search within the contents of the files too!

6. Quick Access: You can use custom keyboard shortcuts to access "Everything" from anywhere, enhancing your productivity.

7. Easy to use: Everything has a simple and intuitive user interface.

How to Get Started:

1. Download and Install: Visit the official Voidtools website to download and install "Everything". You can choose between an installer and a portable version too!

2. 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.

3. 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.

• 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

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:

1. 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.

2. Team Building: Bringing teams together for intensive coding sessions fosters collaboration and strengthens team bonds. It promotes a sense of belonging and shared achievement.

3. Accelerated Development: Code-athons are excellent for rapidly developing and prototyping new features or products, helping companies stay competitive in fast-paced markets.

4. 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.

5. Problem Solving: Code-athons provide a platform to address complex problems that may have been lingering, offering fresh perspectives and innovative solutions.

Cons:

1. 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.

2. 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.

3. 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.

4. Sustainability: Maintaining the frequency of code-athons can be challenging in the long run. Teams may struggle to sustain enthusiasm and participation.

5. 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.

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.

The Priority Quadrant, also called the Eisenhower Important/Urgent Principle or Eisenhower Matrix, is a simple rule for classifying the tasks in hand. It is based on the Urgency and Criticality or Importance of the task.

Urgency implies whether the task needs to be addressed at one or the earliest possible

Criticality/Importance means completion of the task is significant to achieving the goal

The Priority Quadrant requires one to classify the tasks based on the following

• Urgent, Important
• Urgent, Not-Important
• Not-Urgent, Important
• Not-Urgent, Not-Important

The classifications themselves should be pretty self-explanatory. The following image illustrates on how to handle each of those category of tasks.

Sometimes, one may find tasks as all urgent and important or have difficulty in categorizing them. In such cases, it would be better to get the help of the superior, who assigned the tasks, to prioritize.

There are a lot of tools available for free that can be use to prioritize the tasks - Microsoft To-Do, Trello, Asana etc.

Initially, getting hang of the priority quadrant might seem a bit tough but over time, it makes life easier.

• Mermaid - A diagramming and charting tool that uses Markdown-inspired text definitions. Supports drawing of Flowchart, Sequence Diagram, Graphs, Class Diagrams, ER Diagrams and much more
• Graphviz - A graph visualisation software to represent structural information as a diagram of abstract graphs and networks
• Ditaa - a small command-line utility written in Java, that can convert diagrams drawn using ascii art
• PlantUML - A component that allows to write Sequence diagram, Usecase diagram, Class diagram, Object diagram, Activity diagram, Component diagram, Deployment diagram, State diagram, Timing diagram and more
• BlockDiag - A Group of projects that has other diagramming tools - BlockDiag, SeqDiag, ActDiag, NwDiag, PacketDiag, RackDiag

The list goes on. Almost all of them are open source and free. Each of these tools are written in different programming languages like Mermaid is written in JavaScript, BlockDiag in Python, PlantUML in Java and so on.

Having all of them under a single roof does have its advantages, but setting them up and having the prerequisites can be a considerable task. That's where Kroki comes to the rescue. It is both an open source software that can be installed locally and a service that is free as well.

It is astonishing to see the support for various diagramming tools all at one place. Kroki provides support for BlockDiag (BlockDiag, SeqDiag, ActDiag, NwDiag, PacketDiag, RackDiag), BPMN, Bytefield, C4 (with PlantUML), Ditaa, Erd, Excalidraw, GraphViz, Mermaid, Nomnoml, Pikchr, PlantUML, Structurizr, SvgBob, UMLet, Vega, Vega-Lite, WaveDrom. It is constantly updated to add more tools as well.

The beauty of Kroki is that it also provides HTTP APIs to create diagrams that can be accessed using tools like cURL. In addition to the services, it also has a CLI - Command Line Interface - that uses kroki.io as the backend.

Try Kroki for a happy diagramming!

Databases come in a wide variety solving different problems and scenarios, that include

• Relational Databases

  • PostgreSQL - Free & Open source
  • MySQL - Free & Open source
  • MariaDB - Free & Open source
  • SQLite - Free, Embedded & Open source
  • H2 - Free, Embedded & Open source
  • HSQLDB - Free, Embedded & Open source
  • DuckDB - Free & Open source
  • Oracle - Commercial
  • SQL Server - Commercial

• NoSQL Databases

  • MongoDB
  • CouchDB
  • Cassandra

• Key / Value Stores

  • Redis
  • Memcached
  • Project Voldemort

• Multi-model & Graph Databases

  • OrientDB
  • ArangoDB
  • Neo4J

A lot more and this list can go on. However, there is a comprehensive database of databases that are/were used so far.

Enter dbdb.io, the Database of Databases created and maintained by Carnegie Mellon Database Group. The catalog has entries of 841 databases (at the time of writing this article). It is fascinating to see the number of databases that have existed, the history about them and their technical details.

The list provided about is just a tip of the iceberg and the quite popular ones!

The site provides nice search feature. It also has leaderboards grouped under different parameters.

Visit the "database of databases" to learn more!

These effects/injuries are commonly referred to Repetitive Strain Injury (RSI). It is a gradual build up of damage to muscles and nerves that it tends to cause

• Pain
• Tightness
• Numbness
• Tingling Sensation
• Dull ache

and similar symptoms.

It is common among people who have a sedentary job, sitting almost all day. This includes

• Programmers
• People playing computer games for a long time
• People on their Smartphone for a long time
• Office Assistants
• Office Managers
• Call support engineers

and the likes. The early people take remedial measures, when they start to see early symptoms will help avoid complications. Even better, is to use tools or software that help avoid RSI. There are many available but in this post we will look at a few that are free and cross-platform

Most of these RSI preventing software use the Pomodoro Technique - a time management method invented by Francesco Cirillo where work is split into smaller tasks separated by short breaks. All of these software have similar functionality of prompting for breaks at configured time intervals

Workrave

First in the list is Workrave. A portable version is available from PortableApps. Workrave monitors mouse movements and keyboard typing and provides the following features

• Microbreaks - A short break every 10-20 mins typically for about 15-30 seconds.During a microbreak you can let go of keyboard and mouse, look away from the screen, and relax a bit.
• Rest breaks - A break away from your computer every 1 to 2 hours typically for about 5-10 minutes.
• Daily Limit - The amount of time you use your computer. When you have reached the configured daily computer usage limit, you are prompted to stop using the computer for the day.

Workrave presents a gentle Break warning before the break starts

The beautiful feature is Exercises at the start of the restbreak. Each exercise takes about 30 seconds, and the number of exercises that are shown is configurable.

Workrave also provides a number of statistics like breaks taken, skipped etc.

BreakTimer App

The next app is the BreakTimer App, that is a cross platform app. The installation is simple and it sits in the system tray. It allows configuration of break frequency and break length. It also provides customization of work hours.

It shows a nice pop-up window or notification before the break and displays the configured break message. It does not have micro-breaks, rest-breaks or daily limit like Workrave but does the breaking timing aspect well. It doesn't gather any statistics, just plain simple break timer.

All breaks can be postponed by a preconfigured time and can also be skipped.

Stretchly

The last app in this post is Stretchly which is also a cross-platform app. There is a portable option available, just download and extract it to a directory and run the application, as simple as that. Like the other two programs, this one also sits in the tray and displays notifications during breaks.

Like Workrave, Stretchly has minibreaks and long breaks, however, it neither has daily limits nor collects any statistics. It does its function in a plain simple manner - display break notifications. One just 10 seconds (configurable) before the break and a bigger almost full screen notification.

Another nice feature is Stretchly suggests a small exercise or a workout during each break. The entire program is Apple macOS themed even in Microsoft Windows.

All three programs are quite good and do their jobs well. It is just a matter of preference on who likes what. But it is definitely great softwaree to avoid a bad conditions.

Try it yourself and stay healthy!

One of the other great features is its ability to create stunning HTML presentations along with another utility called RevealJS

Below is the sample presentation that is an asciidoctor markup file.

= Stunning Presentations
Prabhu R
:imagesdir: images
:title-slide-background-image: sea.jpg
:title-slide-transition: fade
:title-slide-transition-speed: fast
:experimental: true

== A Great Story

image::galaxy.jpg[background, size='cover']
Press kbd:[s] for Speaker View that displays notes  

[.notes]
--
* tell anecdote
* make a point
--

[transition='convex']
== Transition Convex

This slide has a `convex` effect

[background-color="gray"]
[transition='zoom']
== Transition Zoom

This slide has a `zoom` effect,

[background-color="teal"]
[transition='zoom']
== Vertical Slides

This is a Vertical slide,  click kbd:[↓] to see vertical slides

[background-color="crimson"]
[transition='slide']
=== Vertical Slide 1

Vertical slide 1

[background-color="brown"]
[transition='slide']
=== Vertical Slide 2

Vertical slide 2

[background-video="orca.mp4",options="loop,muted"]
[transition='concave']
== Background Video

Background looping video

[%notitle]
[transition='concave']
== THE END

image::end.jpg[background, size=cover]

To see how this stunning it gets rendered, visit here

Pressing Esc shows the thumbnail view of all the slides. Clicking on any of the slides jumps to that slide

The complete source is available in GitHub, and can be used as a starter template for your presentations

With a little of CSS knowledge more amazing effects can be brought it to the presentations. For more details look at the asciidoctor-revealjs site

Benjamin Schmid has an even more amazing presentation, a nice example of what asciidoctor and revealjs combination could produce.

• have a steep learning curve
• are expensive
• get hard to maintain especially when there are more assets like images, diagrams and videos
• exporting to other formats suitable for web, ebook might require a lot of work
• documenting software technical documentation gets cumbersome
• hard to maintain and check the changes in a source control system

Enter text-based markups! Recently text-based mark-ups became popular especially among the software technical documentation writers. That includes

• Markdown
• ReStructedText
• Asciidoc

Each one has their own pros and cons, but the beauty of each of them is that they are plain text file with some formatting that enables easy transformation to other formats like HTML, PDF etc. The most popular one is Markdown and the one that has the most features and less quirky is the Asciidoc.

The toolchain that brings power of Asciidoc is Asciidoctor. It parses Asciidoc files and helps in converting them to various formats - HTML5, PDF, DocBook, ePub, man pages etc.

A typical Asciidoc file looks like

= Hello, AsciiDoc!
Doc Writer <doc@example.com>

An introduction to http://asciidoc.org[AsciiDoc].

== First Section

* item 1
* item 2

It gets transformed into HTML as

Hello AsciiDoc!

An introduction to AsciiDoc.

First Section

• item 1
• item 2

It allows code snippets to be embedded that are syntax highlighted too. Following is the Asciidoc block of Java code snippet and how it gets rendered

[source,java]
----
class Java {
    public static void main(String[] args){
        System.out.println("Hello World!")
    }
}
----

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

It also enables text-based diagramming like Mermaid, Graphviz, BlockDiag etc inside the text so that the output renders as a nice diagram. For example, the following mermaid diagram text within the block gets rendered as the diagram below.

[mermaid]
----
graph LR
A --> B
A --> C
B --> D
C --> D
----

Asciidoctor is powerful in many ways because of the plugins in its ecosystem. The plugins enable transforming the content to different formats including PDF, ePub, Stunning HTML5 based presentations and more. We will talk about the presentations in a subsequent post.

Some of the features that Asciidoctor supports are

• Lists
• Tables
• Videos - Background & Foreground
• Images - Background & Foreground
• Admonitions
• Keyboard Macros
• Custom Styles
• Automatic Table of Contents based on Headings

Many of the features can be activated and customised using attributes

The most important and great feature is the ability to include other asciidoc files. This enables teams to work separately on each of the topics independently and when the final output is generated, Asciidoctor puts them all in the right order.

= Program Documentation

include::topic1.adoc[]
include::topic2.adoc[]
.
.
.
include::topicn.adoc[]

As mentioned earlier, the final output could be a html document, pdf file, epub and much more.

It has many more features than what can be covered in this article. It is more of a publishing toolchain that is simple and easy to use.

Head on to Asciidoctor page for more!

Happy writing!

• The crew slowly starts to behave strangely and stops functioning normally
• They tend to quarrel and start internal fights
• They have difficulties in remembering and doing even the simplest of things
• They start hallucinating and go out of control.

The story finally ends on how they escaped the rift and got back to normalcy.

Sleep deprivation is one of the major reasons for people becoming chronically ill. People at a young age might not realise the effects immediately but it accumulates over the years and starts to show up as we age. The body could not take it any more that it weakens. As a result, there will be

• Anxiety
• Anger / Irritability
• Stress
• Hypertension
• Diabetes
• Heart Related Ailments
• Nervous issues
• Loss of appetite
• Heartburn / Acidity
• Hormonal issues
• And more

Millions of years of evolution made the human race a diurnal species, meaning the ones that are active during the day. It was mostly obeyed until the invention of electricity and light. That's when humans broke their circadian rhythm by allowing to be awake 24/7. These days, the smartphones also attribute to the loss of sleep because people endlessly stare at their phones for a very long time.

Organizations started working in multiple shifts putting people even in night shifts. As a result, the diurnal natural cycle went for a toss. Moreover, prolonged violations of the circadian rhythm also adversely affects the other two rhythms - ultradian rhythm (within a day) and infradian rhythm (more than a day) too.

In most people, the immediate indication or sign that the body is getting affected would be Heartburn / Acidity. Ignoring that and taking medication to suppress that will result in other side-effects over time.

Likewise, people lose their cognitive ability, find hard to focus/ concentrate or even remember the simplest of things. For example, you go to a grocery to buy some vegetables. Once there, you start thinking, "Why did I come here...? Ah, yes... Vegetables..."

It slowly starts to impair the productive work hours because people tend to become drowsy at unusual hours, say, like after eating lunch. It will be uncontrollable for them to stay awake then.

The effects are cumulative that, sometimes it goes to a point when you realize the problem and start to take remedial steps, it would already caused irreversible damage or condition to the body, say, a nervous system issue or a weaker heart etc.

The best way to avoid the effects and stay productive is get a good night sleep everyday. Let the whole system rejuvenate!

Sleep well and be productive!

• IDEs
• Source Control
• Project Management Tools
• Communication
• Knowledge-base

It is great to know that these tools are available for zero cost.

IDE - Integrated Development Environment

Nowadays, all software development companies know the need for IDE. IDEs come with a lot of features that include language support, syntax highlight, code completion, code suggestions, indentation and a lot more. Some of the popular IDEs are

• Visual Studio Code
• Eclipse
• Apache Netbeans

These IDEs support multiple languages. There are language focused IDEs IntelliJ Idea for Java, Atom for Web, Codeblocks for C++ and so on.

Source Control

Source Control is the heart of any development team. It would be surprising if a team did not use one. Unlike the old centralized source control systems like CVS and SVN, the modern distributed source control systems like Git, Mercurial, Bazaar etc., offer a wide array of features that include workflows, feature branches and many more. Those features enable integration with CI/CD tools, containerization etc.

Some of the popular cloud providers of version control are

• GitHub
• Gitlab
• Bitbucket - Free up to 5 users

The following self-hosted softwares

• Rhodecode - supports Git, Mercurial & SVN
• Gitea
• Bazaar

There is one underrated distributed version control that provides a wide array of features - bug tracking, wiki, forum etc - in a self-contained single executable is Fossil SCM

Project Management

Though GitHub and Gitlab provide issue tracking, milestones etc., a complete project management system goes a long way, especially in following well-established methodologies like Agile, Scrum and Kanban. Most are commercial but for small teams they provide a free option. The following are quite popular

• Atlassian JIRA - free up to 10 users
• Jetbrains YouTrack - free up to 10 users
• Trac Project - Free, Open Source, Self-hosted. Provides issue management, source control integration, wiki etc.
• Redmine - Free, Open Source, Self-hosted. Provides issue management, source control integration, wiki, forums etc.

Communication

Remote working and Work-from-home being the norm these days. Having a common communication channel is essential. The following are the popular ones

• Slack
• Zulip
• Zoho Cliq
• Microsoft Teams

Knowledge base

Having an organized knowledge base like Project internal documents, Requirements and other related information is crucial to any project. As the project progresses, people don't remember the details where each document is resulting in confusion. To avoid such chaos later, it is better to document and update the details in a documentation system such as a wiki. The source control and the project management systems mentioned earlier provide options for wikis, however, sometimes it is preferable to have them separate. In such cases, the following could be used

• Atlassian Confluence - Free up to 10 users
• WikiJS - Free, Open Source, Self-hosted
• BookStack - Free, Open Source, Self-hosted

Having the right tools is one part of professional software development. The next part is to have the processes right that include having the right coding standards, Source control workflows and branching strategy, Development/Production Environments, Project Management process, Deployment Process and others.

We will see those in the upcoming articles. Happy Software Development till then!