John Justin's blog

10 tools for a software developer

noreply@blogger.com (Unknown) — Fri, 3 Mar 2023 09:38:00 +0530

1.Integrated Development Environments (IDEs) - An IDE is an essential tool for software engineers, providing a comprehensive environment for writing, testing, and debugging code. IDEs like Eclipse, Visual Studio Code, and IntelliJ IDEA provide features like code highlighting, auto-completion, and code navigation, making it easier for developers to write high-quality code efficiently.

2.Version Control Systems (VCS) - VCS tools like Git and SVN are crucial for managing code versions, enabling developers to track changes, collaborate on code, and revert to earlier versions if necessary. VCS tools also provide features like branching and merging, allowing developers to work on multiple versions of code simultaneously.

3.Debuggers - Debuggers like GDB and Visual Studio Debugger are essential tools for identifying and fixing errors in code. They allow developers to step through code, set breakpoints, and inspect variables, making it easier to pinpoint the source of a problem and fix it quickly.

4.Profilers - Profiling tools like JProfiler and VisualVM help developers identify performance issues in code, allowing them to optimize code for maximum efficiency. Profilers provide insights into memory usage, CPU time, and other performance metrics, making it easier to identify bottlenecks and improve code performance.

5.Build Tools - Build tools like Maven and Gradle automate the process of building, testing, and deploying software, making it easier for developers to manage complex projects with multiple dependencies. These tools provide features like dependency management, unit testing, and artifact generation, simplifying the build process and reducing the likelihood of errors.

6.Continuous Integration (CI) and Continuous Deployment (CD) Tools - CI/CD tools like Jenkins and Travis CI automate the process of building, testing, and deploying code, ensuring that changes are tested and deployed quickly and efficiently. These tools provide features like automated testing, code analysis, and deployment pipelines, making it easier to maintain a high level of code quality and reliability.

7.Code Editors - Code editors like Sublime Text and Atom provide a lightweight alternative to IDEs, providing basic features like code highlighting and auto-completion without the overhead of a full IDE. Code editors are useful for quick code changes or for working on small projects where a full IDE might be overkill.

8.Package Managers - Package managers like npm and pip provide a convenient way to manage and install software packages and dependencies. They simplify the process of adding third-party libraries and modules to a project, reducing the amount of time and effort required to manage dependencies manually.

9.Containerization Tools - Containerization tools like Docker and Kubernetes are essential for deploying and managing complex applications in a distributed environment. Containers provide a lightweight, portable way to package and deploy applications, making it easier to manage dependencies and scale applications as needed.

10.Task Automation Tools - Task automation tools like Ansible and Chef automate routine tasks like server configuration and software installation, reducing the amount of time and effort required for routine maintenance tasks. These tools provide features like configuration management, infrastructure as code, and task scheduling, making it easier to manage complex environments and systems efficiently.

Pros and cons of apache camel

noreply@blogger.com (Unknown) — Fri, 3 Mar 2023 09:15:00 +0530

Apache Camel is a lightweight integration framework that allows developers to easily integrate various systems and protocols using a set of predefined patterns.

Here are some pros and cons of using Apache Camel

Pros:

Flexibility: Apache Camel supports a wide range of integration patterns and protocols, making it a flexible tool for integrating diverse systems and applications.


from("jms:queue:myQueue")
    .to("http://localhost:8080/myRestEndpoint");

Ease of use: Apache Camel's DSL (Domain Specific Language) is designed to be intuitive and easy to use, allowing developers to quickly build and deploy integration solutions.


from("jms:queue:myQueue")
    .filter(header("status").isEqualTo("pending"))
    .to("jms:queue:pendingQueue");

Extensibility: Apache Camel is highly extensible, allowing developers to easily add custom components and processors to support specific integration requirements.


public class MyProcessor implements Processor {
    public void process(Exchange exchange) throws Exception {
        String body = exchange.getIn().getBody(String.class);
        String transformed = transform(body);
        exchange.getIn().setBody(transformed);
    }

    private String transform(String body) {
        // custom transformation logic here
    }
}

from("jms:queue:myQueue")
    .process(new MyProcessor())
    .to("jms:queue:transformedQueue");

Testability: Apache Camel's test framework allows developers to easily test integration routes and patterns, improving the overall quality and reliability of integration solutions.


public class MyRouteTest extends CamelTestSupport {
    @Test
    public void testRoute() throws Exception {
        template.sendBody("jms:queue:myQueue", "Hello, world!");
        assertMockEndpointsSatisfied();
    }

    @Override
    protected RoutesBuilder createRouteBuilder() throws Exception {
        return new RouteBuilder() {
            public void configure() {
                from("jms:queue:myQueue")
                    .to("mock:result");
            }
        };
    }
}

Cons:

Steep learning curve: While Apache Camel's DSL is designed to be easy to use, it can still take some time for developers to become proficient in using the various patterns and components available in Camel. Eg below for Implementing a complex routing scenario:


from("jms:queue:myQueue")
    .choice()
        .when(header("priority").isEqualTo("high"))
            .to("jms:queue:highPriority")
        .when(header("priority").isEqualTo("medium"))
            .to("jms:queue:mediumPriority")
        .otherwise()
            .to("jms:queue:lowPriority")
    .end();

Debugging: Debugging Camel routes and patterns can be challenging, particularly when dealing with complex integration scenarios.


from("jms:queue:myQueue")
    .process(new MyProcessor())
    .to("jms:queue:transformedQueue")
    .to("http://localhost:8080/myRestEndpoint")
    .process(new AnotherProcessor())
    .to("file:/outputDirectory")
    .log("Message processed successfully!");

Resource usage: Apache Camel can be resource-intensive, particularly when handling large volumes of data or when integrating with systems that require a lot of processing power or memory.

Handling large volumes of data using Camel's splitter:


from("jms:queue:myQueue")
    .split(body().tokenize("\n"))
    .to("jms:queue:splitQueue");

Scenarios to use Apache Camel:

Integration between diverse systems and applications

Real-time data processing and streaming

Message-driven architecture and event-driven architecture

Batch processing and data orchestration

Protocol translation and mediation

Scenarios to avoid Apache Camel:

Simple integration scenarios that can be easily handled using simpler tools or libraries

Integration scenarios where performance is a critical concern and the overhead of using Apache Camel may be too high

Integration scenarios where the required protocols or systems are not supported by Apache Camel and implementing custom components would be too complex or time-consuming.

Apache Storm a real world use case and solution for the problem

noreply@blogger.com (Unknown) — Fri, 3 Mar 2023 09:05:00 +0530

A common use case for Apache Storm is real-time stream processing of social media data. For example, a company may want to analyze Twitter data in real-time to monitor brand sentiment, track trending topics, or detect emerging issues. Apache Storm can be used to process this data as it is generated, allowing the company to quickly respond to changes in customer sentiment or market conditions.

step-by-step design for a system that uses Apache Storm for real-time stream processing of social media data:

Data Ingestion:

The first step is to ingest data from Twitter's API. This can be done using a Python library like Tweepy. The data can be filtered by keywords, hashtags, and other criteria to ensure that only relevant data is processed.



import tweepy

# Twitter API credentials
consumer_key = "YOUR_CONSUMER_KEY"
consumer_secret = "YOUR_CONSUMER_SECRET"
access_token = "YOUR_ACCESS_TOKEN"
access_secret = "YOUR_ACCESS_SECRET"

# Create a stream listener
class StreamListener(tweepy.StreamListener):
    def on_status(self, status):
        # Process the status here
        pass

# Authenticate and create the stream listener
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
listener = StreamListener()
stream = tweepy.Stream(auth=auth, listener=listener)

# Start the stream
stream.filter(track=["keyword1", "keyword2", ...])

Apache Storm Topology: The Apache Storm topology will be responsible for processing the incoming social media data in real-time. This can be done using a combination of bolts and spouts. A spout can be used to read the data from the Twitter API and pass it to a bolt that performs sentiment analysis or topic modeling.



from nltk.sentiment import SentimentIntensityAnalyzer
from storm import BasicBolt

# Initialize the sentiment analyzer
sia = SentimentIntensityAnalyzer()

# Define the bolt that performs sentiment analysis
class SentimentAnalysisBolt(BasicBolt):
    def process(self, tup):
        # Get the tweet text from the tuple
        tweet_text = tup.values[0]

        # Perform sentiment analysis on the tweet text
        sentiment = sia.polarity_scores(tweet_text)

        # Emit the sentiment score
        self.emit([sentiment["compound"]])

# Define the topology
from storm import TopologyBuilder

builder = TopologyBuilder()
builder.setSpout("twitter", TwitterSpout())
builder.setBolt("sentiment", SentimentAnalysisBolt()).shuffleGrouping("twitter")

Storage: The processed data needs to be stored in a suitable data store for further analysis. In this case, we can use a MongoDB database to store the sentiment scores.



from pymongo import MongoClient

# Connect to MongoDB
client = MongoClient("mongodb://localhost:27017/")

# Get the database and collection
db = client["mydatabase"]
collection = db["sentiment_scores"]

# Define the bolt that stores the sentiment scores
class MongoBolt(BasicBolt):
    def process(self, tup):
        # Get the sentiment score from the tuple
        sentiment_score = tup.values[0]

        # Insert the sentiment score into MongoDB
        collection.insert_one({"score": sentiment_score})

Visualization: The processed data needs to be visualized in a meaningful way to the end-users. In this case, we can use a web application to display the sentiment scores in real-time.



from flask import Flask, render_template
from pymongo import MongoClient

# Connect to MongoDB
client = MongoClient("mongodb://localhost:27017/")

# Get the database and collection
db = client["mydatabase"]
collection = db["sentiment_scores"]

# Define the web application
app = Flask(__name__)

@app.route("/")
def index():
    # Get the latest sentiment score from MongoDB
    sentiment_score = collection.find_one(sort=[("_id", -1)])["score"]

    # Render the sentiment score in a template
    return render_template

java code for magic square

noreply@blogger.com (Unknown) — Thu, 2 Mar 2023 10:19:00 +0530

The user is prompted to enter the size of the magic square. If the size is even, the program terminates because magic squares can only be generated for odd sizes.
An empty 2D array of the given size is created to hold the magic square.
The starting position for the first number is set to the last row and middle column of the square.
A loop runs from 1 to n^2, with each iteration placing the current number in the current row and column, and then moving the position diagonally down and right by one cell.
If the position goes beyond the edges of the square, it wraps around to the opposite edge.
If the position is already occupied, it moves up two rows and left one column instead.


  
  import java.util.Scanner;

public class MagicSquare {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter the size of the magic square: ");
        int n = sc.nextInt();

        if (n % 2 == 0) {
            System.out.println("The size must be odd.");
            return;
        }

        int[][] magicSquare = new int[n][n];
        int row = n-1;
        int col = n/2;

        for (int i = 1; i <= n*n; i++) {
            magicSquare[row][col] = i;
            row++;
            col++;

            if (row == n && col == n) {
                row = 0;
                col = n-2;
            }
            else if (row == n) {
                row = 0;
            }
            else if (col == n) {
                col = 0;
            }
            else if (magicSquare[row][col] != 0) {
                row -= 2;
                col--;
            }
        }

        // Print the magic square
        System.out.println("The magic square is:");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(magicSquare[i][j] + " ");
            }
            System.out.println();
        }
    }
}

Design a software system for a smart city that can manage and optimize the city's transportation system.

noreply@blogger.com (Unknown) — Thu, 2 Mar 2023 09:17:00 +0530

Define the requirements: Determine the requirements of the transportation system, such as the number of vehicles, routes, and schedules, as well as the needs of the city's residents, such as accessibility and convenience.

Design the architecture: Select an appropriate architecture for the software system, such as a distributed system or a microservices architecture, to ensure scalability, reliability, and efficient communication between components.

Develop a data management system: Develop a data management system that can handle large volumes of real-time data from various sources, such as traffic sensors, public transit vehicles, and GPS devices, and store the data in a distributed database.

Implement machine learning algorithms: Develop machine learning algorithms that can analyze the data to identify patterns and optimize the transportation system, such as predicting traffic congestion, optimizing transit schedules, and dynamically adjusting traffic signals.

Develop a user interface: Design a user interface that allows city officials to monitor the transportation system in real-time, view analytics, and make data-driven decisions to improve the system's performance.

Implement security measures: Ensure that the system is secure by implementing measures such as data encryption, access controls, and secure APIs.

Optimize performance: Implement measures to optimize the system's performance, such as using caching mechanisms and load balancing techniques to distribute the load across servers.

Ensure compatibility: Test the system on a variety of platforms and devices to ensure compatibility and consistent performance.

Collaborate with developers: Coordinate with developers to ensure effective integration of code and smooth workflow processes.

Test and debug: Conduct thorough testing and debugging to ensure that the software system is free of bugs and errors.

Functional Requirements:

Real-time data collection from various sources (traffic sensors, public transit vehicles, GPS devices, etc.)

Data storage and management in a distributed database

Machine learning algorithms to analyze the data and optimize the transportation system

User interface to monitor and control the transportation system

Ability to adjust transit schedules, traffic signals, and other variables in real-time

Integration with third-party systems, such as emergency response and public safety systems

Generation of reports and analytics to evaluate the transportation system's performance

Non-functional Requirements:

High availability and reliability to ensure the system is always operational

Scalability to handle increasing volumes of data and users

Security measures to protect sensitive data and prevent unauthorized access

Fast response times to ensure real-time adjustments to the transportation system

Compatibility with various platforms, devices, and operating systems

User-friendly and intuitive interface for city officials to manage and monitor the transportation system

Benefits of using AI in day today business

noreply@blogger.com (Unknown) — Sun, 12 Feb 2023 01:02:00 +0530

AI, or artificial intelligence, is the ability of computers to perform tasks that normally require human intelligence, such as visual perception and speech recognition.

It's the future of business. According to a recent survey from Harvard Business Review, 84% of companies are using AI in some form today.

You can find AI everywhere these days: in your car, on your TV and even in your fridge. It's also been used by businesses for years as a way to boost efficiency, reduce costs and improve decision-making processes.

AI is transforming the way we use technology in our day-to-day lives. It has become so popular that it’s hard to imagine not using it.

But how exactly does AI fit into your business?

Here are some benefits of using AI in your business:

1. Automated customer service and marketing campaigns

AI can help automate your customer service team and marketing campaigns, giving you more time for other important tasks such as developing new products or improving existing ones. This will give you an edge over competitors who may be spending more time on these tasks than yours.

2. Improved quality of data analysis

With the help of machine learning, AI can analyze large amounts of data much faster than humans can. This means that you won’t have to spend as much time analyzing data manually if you choose to use AI instead of humans for this purpose.

AI is the next wave of innovation, and it’s already shaping how you do business.

AI is a natural extension of humans’ innate drive to learn and make sense of the world. It can be used to identify patterns in data, predict outcomes, and improve customer experiences.

In the past year alone, we’ve seen AI creep into our lives in more ways than ever before. From ride-hailing services like Uber and Lyft, to Amazon’s Alexa, to Facebook Messenger bots and Google Home devices, AI is changing how we interact with technology on a daily basis.

AI can be used by businesses to help with a variety of different tasks. Some of the most common ways AI is used are:

1. AdWords: Google’s advertising system is built on machine learning, and the search giant uses it to track the behavior of its users. It can use this data to determine what kind of ads are most likely to be clicked on, thus improving ad revenue and increasing conversion rates.

2. Customer service: AI can help you manage your customer service agents more effectively by automating some of their tasks and increasing efficiency through automation. For example, you could use AI to automatically respond to emails or text messages in order to save time for your employees while also ensuring that customers receive their responses as quickly as possible.

3. Sales: By using AI tools like predictive analytics, you can improve sales cycles by predicting when customers will buy based on their previous behavior and making sure they don’t miss out on any opportunities that may arise during this time period.

4. Marketing: By analyzing customer data and using it to target specific audiences, marketers can create content that speaks directly to their audience’s interests and needs while also increasing conversions

Spring's ApplicationContext.getBean considered bad?

noreply@blogger.com (Unknown) — Sat, 4 Feb 2023 09:18:00 +0530

ApplicationContext.getBean() is a method in Spring framework that allows you to retrieve a bean from the Spring application context. The method is considered to be an anti-pattern by some developers because it can lead to tight coupling between the calling code and the Spring context. This tight coupling can make it difficult to test the code in isolation and can also make it harder to change the implementation of the beans in the future.

Here is an example of how ApplicationContext.getBean() can lead to tight coupling:

public class MyService {

public void doSomething() {

MyDependency dependency = (MyDependency) ApplicationContext.getBean("myDependency");

dependency.performTask();

}

In the example above, the MyService class is tightly coupled to the Spring application context, as it directly accesses the ApplicationContext to retrieve a bean. If you want to test MyService, you will have to set up the entire Spring context, which can make the test more complex and harder to write.

A better approach is to use dependency injection to make the dependencies of MyService available. This way, you can easily provide mock implementations of the dependencies for testing, and you can also change the implementation of the dependencies in the future without having to modify the MyService code.

Here is an example of how you can use dependency injection to achieve loose coupling:

public class MyService {

private MyDependency dependency;

public MyService(MyDependency dependency) {

this.dependency = dependency;

}

public void doSomething() {

dependency.performTask();

}

With the code above, you can easily provide a mock implementation of MyDependency for testing and you can change the implementation of MyDependency without having to modify the MyService code.

How do I test a class that has private methods, fields or inner classes ?

noreply@blogger.com (Unknown) — Sat, 4 Feb 2023 09:06:00 +0530

Testing private methods, fields, or inner classes can be challenging because they are not accessible from outside the class. There are a few approaches you can take to test these elements of your code.

Testing private methods, fields, and inner classes can be challenging because they are not meant to be accessed from outside of the class. However, there are some techniques you can use to test them:

Reflection: You can use the Java Reflection API to access private methods and fields. However, this is not a recommended practice as it can make your tests fragile and reduce the maintainability of your code.

// Example code for accessing private method using reflection in Java

import java.lang.reflect.Method;

public class PrivateMethodTester {

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

MyClass obj = new MyClass();

Class cls = obj.getClass();

Method method = cls.getDeclaredMethod("myPrivateMethod", new Class[] { int.class });

method.setAccessible(true);

int result = (int) method.invoke(obj, new Object[] { 42 });

System.out.println(result);

}

class MyClass {

private int myPrivateMethod(int value) {

return value + 1;

}

Make them package-private: You can change the visibility of the private methods and fields to package-private (no keyword), which makes them accessible from other classes in the same package. This way, you can write test classes in the same package and access the package-private methods and fields.

Use inner test classes: You can write test classes as inner classes of the class being tested and use them to access the private methods and fields. This way, the inner test classes can access the private methods and fields as if they were package-private.

Extract the private logic into a separate class: If the private methods or fields contain complex logic that needs to be tested, you can extract this logic into a separate, publicly accessible class and test it independently.

Use powermock or other similar testing frameworks: PowerMock is a testing framework that allows you to test private methods and fields, among other things. However, it's important to use these types of frameworks sparingly and only when necessary, as they can make your tests more complex and harder to maintain.

In general, it's best to test only the public interface of a class, and if the private methods or fields are complex enough to require testing, it might indicate that they should be refactored into their own class.

Wrapper class: Another option is to create a wrapper class that wraps the private elements you want to test. You can then write tests against the public methods of the wrapper class, which in turn exercise the private elements.

// Example code for testing private method using wrapper class in Java

public class PrivateMethodTester {

public static void main(String[] args) {

MyWrapper wrapper = new MyWrapper(new MyClass());

int result = wrapper.callPrivateMethod(42);

System.out.println(result);

}

class MyWrapper {

private MyClass obj;

public MyWrapper(MyClass obj) {

this.obj = obj;

}

public int callPrivateMethod(int value) {

return obj.myPrivateMethod(value);

}

class MyClass {

private int myPrivateMethod(int value) {

return value + 1;

}

PowerMock or similar frameworks: Another option is to use a testing framework that provides support for mocking and testing private elements, such as PowerMock. These frameworks allow you to override the behavior of private elements and test them in isolation, without the need for reflection or wrapper classes.

// Example code for testing private method using PowerMock in Java import org.junit.Test; import org.junit.runner.RunWith; import org.powermock.api.mockito.PowerMockito; import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.junit4.PowerMockRunner; @RunWith(PowerMockRunner.class) @PrepareForTest(MyClass.class) public class PrivateMethodTester { @Test public void testPrivateMethod() throws Exception { MyClass obj = PowerMockito.spy(new MyClass()); PowerMockito.when(obj, "myPrivateMethod", 42).thenReturn

How to mock void methods with Mockito

noreply@blogger.com (Unknown) — Sat, 4 Feb 2023 08:55:00 +0530

In Mockito, you can mock void methods by using the "doAnswer()" method from the "org.mockito.stubbing.Answer" class. This method allows you to specify a custom implementation for a void method that will be executed when the method is called on a mock.

Here is an example of how to mock a void method using the "doAnswer()" method in Java:

import static org.mockito.Mockito.*;

import org.mockito.stubbing.Answer;

// Create a mock object

MyClass myClass = mock(MyClass.class);

// Use doAnswer to specify a custom implementation for the void method

doAnswer(new Answer<Void>() {

public Void answer(InvocationOnMock invocation) {

Object[] args = invocation.getArguments();

// Perform custom logic here with the arguments passed to the method

System.out.println("Method called with arguments: " + Arrays.toString(args));

return null;

}

}).when(myClass).myVoidMethod(anyInt(), anyString());

// Call the void method on the mock object

myClass.myVoidMethod(123, "hello");

// Verify that the void method was called on the mock object

verify(myClass).myVoidMethod(123, "hello");

In this example, we use the "doAnswer()" method to specify a custom implementation for the myVoidMethod() method of the MyClass mock object. The custom implementation simply prints the arguments passed to the method. Then, we call the myVoidMethod() method on the mock object and verify that it was called using the verify() method.

What are the differences between a mock and stub?

noreply@blogger.com (Unknown) — Sat, 4 Feb 2023 08:51:00 +0530

"Mock" and "Stub" are two commonly used terms in software testing. They are used to simulate the behavior of real objects in order to test other parts of the system.

A "Stub" is a minimal implementation of an object that returns hardcoded responses to method calls. The main purpose of a stub is to provide controlled and consistent responses to method calls in a test environment. Stubs are typically used to replace the behavior of external dependencies, such as a database or a web service, in order to isolate the system under test.

A "Mock" is a more advanced version of a stub that can verify whether a method was called with the expected parameters, and whether it was called the expected number of times. Mocks also allow you to define the behavior of a method when it's called. In addition to returning hardcoded values, mocks can be used to assert that certain methods were called and verify their behavior.

In summary, the main difference between a stub and a mock is that a stub provides a simple, predefined response to a method call, while a mock can verify the behavior of the system under test and assert that certain methods were called with the expected parameters.

Why cant we mock static method in mockito ?

noreply@blogger.com (Unknown) — Sat, 4 Feb 2023 08:49:00 +0530

Mockito is a popular Java testing framework that is used for creating mock objects for testing purposes. However, by default, Mockito does not allow mocking of static methods.

The reason for this is that static methods are considered part of the class and not the instance, so mocking them would require changing the behavior of the entire class, not just a single instance. This can lead to unexpected behavior and can make testing more complicated.

Additionally, mocking static methods can lead to tight coupling between the test code and the production code, which can make the tests less flexible and harder to maintain.

If you need to test code that calls a static method, it's generally better to refactor the code to make the static method callable on an instance. If that is not possible, you can use a technique such as PowerMock to mock static methods, but it's worth noting that using PowerMock can make your tests more complex and harder to maintain.

Differences between Listenablefuture vs Completablefuture in java

noreply@blogger.com (Unknown) — Sat, 4 Feb 2023 08:47:00 +0530

"ListenableFuture" and "CompletableFuture" are both classes in the Java Concurrency API. They are used for asynchronous programming and handling parallelism in Java applications.

The key difference between the two is that "ListenableFuture" is a subclass of "Future" that provides a mechanism for registering callbacks to be notified when a computation is complete, while "CompletableFuture" extends "Future" and provides the ability to complete a computation from another thread.

In other words, "ListenableFuture" allows you to add a callback that will be executed when the future is complete, whereas "CompletableFuture" allows you to programmatically complete a future and provide a result.

Here's a brief summary of the main differences:

"ListenableFuture" is a subclass of "Future" that allows you to register a callback to be executed when the future is complete.

"CompletableFuture" is a subclass of "Future" that allows you to programmatically complete a future and provide a result.

"ListenableFuture" is a passive way of handling futures, while "CompletableFuture" is an active way of handling futures."CompletableFuture" provides a rich set of methods for composing, transforming, and combining Futures, whereas "ListenableFuture" is more focused on being notified when a future is complete.

More AI powerful tools to explore

noreply@blogger.com (Unknown) — Fri, 3 Feb 2023 11:08:00 +0530

This guide has more than 100+ AI Tools & Prompts to help you learn how to use ChatGPT to enhance your life.

For programming

Tabnine: https://www.tabnine.com/
OpenAI Codex: https://openai.com/blog/openai-codex/
GitHub Copilot: https://github.com/features/copilot
AI Commit: https://github.com/abi/autocommit
DeepCode: https://www.deepcode.ai/
AI2Sql: https://www.ai2sql.io/
Replit: https://replit.com/site/ghostwriter
Akkio: https://www.akkio.com/
Httpie: https://httpie.io/blog/ai
Mutable: https://mutable.ai/
Sheetplus: https://sheetplus.ai/
ExcelFormulaBot: https://excelformulabot.com/

Marketing Tools.

Frase: https://www.frase.io/
Bertha: https://bertha.ai/
ContentEdge: https://www.contentedge.com/
ChatGPT3: https://chat.openai.com/
Hemingwayapp: https://hemingwayapp.com/
Surfer SEO: https://surferseo.com/
Ponzu: https://www.ponzu.ai/
Jasper: https://www.jasper.ai/
Copy Smith: https://copysmith.ai/
PepperType: https://peppertype.ai/
Scalenut: https://www.scalenut.com/
Mutiny: https://www.mutinyhq.com/
Simplified : https://simplified.com/ai-writer/
MoonBeam: https://www.gomoonbeam.com/
Smartly: https://www.smartly.io/
Seventh Sense: https://www.theseventhsense.com/
Copy AI : https://www.copy.ai/
MarketMuse: https://www.marketmuse.com/
WriteSonic: https://writesonic.com/
Phrasee: https://phrasee.co/

Sales Tools.

Creatext: https://www.creatext.ai/
Exceed: https://exceed.ai/
Creaitor: https://www.creaitor.ai/
Twain: https://www.usetwain.com/
Lavender: https://www.lavender.ai/
Regie: https://www.regie.ai/
People: http://people.ai/
Smartwriter: https://www.smartwriter.ai/
Octane: https://www.octaneai.com/
Warmer: http://warmer.ai/

Writing AI Tools.

Copy AI : https://www.copy.ai/
Jasper: https://www.jasper.ai/
WriteSonic: https://writesonic.com/
ChatGPT3: https://chat.openai.com/
Headlime: https://headlime.com/
PepperType: https://peppertype.ai/
MarkCopy: https://www.markcopy.ai/
Quillbot: https://quillbot.com/
Rytr: https://rytr.me/
MoonBeam: https://www.gomoonbeam.com/
Simplified : https://simplified.com/ai-writer/
Lex Page: https://lex.page/
Copy Smith: https://copysmith.ai/
Subtxt: https://subtxt.app/
Ellie Email Assistant: https://tryellie.com/
Wordtune: https://www.wordtune.com/
Sudowrite: https://www.sudowrite.com/
Novel: https://novelai.net/
Compose: https://www.compose.ai/

Chatbots Tools.

Daily Workplace Tools.

Notion AI: https://www.notion.so/product/ai
Craft: https://www.craft.do/
Mem: https://mem.ai/
Taskade: https://www.taskade.com/
You: https://you.com/
Todoist: https://todoist.com/integrations/apps/ai-assistant

Design Tools.

Diagram: https://diagram.com/
Vizcom: https://www.vizcom.ai/
Namelix: https://namelix.com/
Aragon: https://www.aragon.ai/
Interior Design: https://interiorai.com/
Visualize: https://visualise.ai/
Lexica: https://lexica.art/
Poly: https://poly.ai/
Looka: https://looka.com/
Stock AI: https://stockimg.ai/

Speech Tools.

Resemble: https://www.resemble.ai/
Broadn: https://www.broadn.io/
Podcast: https://podcast.ai/
Fliki: https://fliki.ai/
Wellsaidlabs: https://wellsaidlabs.com/
Voicemod: https://www.voicemod.net/ai-voices/
Otter: https://otter.ai/
TLDR This: https://tldrthis.com/
Glasp AI: https://glasp.co/ai-summary
Sembly: https://www.sembly.ai/
Summari: https://www.summari.com/products/chrome
Coqui: https://coqui.ai/

Leisure Time Tools.

HairStyle: https://www.hairstyleai.com/
AI Detector: https://crossplag.com/detecting-if-a-text-is-ai-generated/
AI Community: https://huggingface.co/
Talk to Books: https://books.google.com/talktobooks/

Workplace Tools.

Designs: https://designs.ai/
Beautiful: https://www.beautiful.ai/
Slides: https://www.slidesai.io/
Synthesia: https://www.synthesia.io/
Pitch: https://pitch.com/
Poised: https://www.poised.com/
Lalal: https://www.lalal.ai/
Krisp: https://krisp.ai/
Murf: https://murf.ai/
Jukebox: https://openai.com/blog/jukebox/
Narakeet: https://www.narakeet.com/
Big Speak AI: https://bigspeak.ai/
Descript: https://www.descript.com/
Assembly: https://www.assemblyai.com/
Article Audio: https://article.audio/
BeyondWords: https://beyondwords.io/
Lumen5: https://lumen5.com/
Supercreator: http://supercreator.ai/
Movio: https://www.movio.la/
Zoomscape: https://zoomscape.ai/
Presentation: https://presentations.ai/

Text to SQL Tools.

AI2sql: https://www.ai2sql.io/
Seek: https://www.seek.ai/

Image Generating & Processing Tools.

Profile Picture: https://www.profilepicture.ai/
Photosonic: https://photosonic.writesonic.com/
Remove BG: https://www.remove.bg/
Artbreeder: https://www.artbreeder.com/
Magiceraser: https://magicstudio.com/magiceraser
Krea: https://www.krea.ai/
Lexica: https://lexica.art/
Removal: https://removal.ai/
Image Enlarger: https://imglarger.com/
Watermark Removal : https://www.watermarkremover.io/
Rodebudai: https://www.rosebudai.com/
Hypotenuse: https://www.hypotenuse.ai/
Nyx: https://nyx.gallery/
AI Avatar: https://avatarai.me/
Cutout Pro: https://www.cutout.pro/
Passport Photo: https://passphoto.ai/
Picso: https://picso.ai/
Playground: https://www.playgroundai.com/
Runway: https://runwayml.com/
Profile Pic Maker: https://pfpmaker.com/
HotPot: https://hotpot.ai/
Mage: https://www.mage.space/

Twitter Tools.

Tribescaler: https://tribescaler.com/
Postwise: http://postwise.ai/
TweetHunter: https://tweethunter.io/
TweetGPT: https://github.com/yaroslav-n/tweetGPT

Blog Writing Prompts.
1. "I'm looking for a [type of blog post] that will speak directly to my [ideal customer persona] and persuade them to take [desired action] on my [website/product]."
2. "I'm looking for a [type of blog post] that will establish trust and credibility with my [ideal customer persona] by highlighting the successes and testimonials of previous customers who have used my [product/service]."
3. "I need a [type of blog post] that will convince my [ideal customer persona] to purchase my [product/service] by highlighting its unique benefits and addressing any potential objections."
4. "I need a [type of blog post] that will make my [ideal customer persona] feel [emotion] about my [product/service] and persuade them to take [desired action] with a sense of urgency."
5. "I need a [type of blog post] that will overcome objections and concerns my [ideal customer persona] may have about my [product/service] and convince them to take [desired action]."
6. "I'm looking for a [type of blog post] that will showcase the unique features and benefits of my [product/service] to [ideal customer persona] and persuade them to make a purchase."
7. "I'm looking for a [type of blog post] that will clearly explain the features and benefits of my [product/service] to [ideal customer persona] and persuade them to make a purchase with a strong call-to-action."
8. "I'm looking for a [type of blog post] that will draw in my [ideal customer persona] with a strong headline and hook, and then convince them to take [desired action] with persuasive language and compelling evidence."
9. "I need a [type of blog post] that will address the pain points and needs of my [ideal customer persona] and show them how my [product/service] is the solution they've been searching for."
10. "I need a [type of blog post] that will speak directly to the needs and pain points of my [ideal customer persona] and persuade them to take [desired action] with a sense of urgency and strong offer."
11. "I'm looking for a [type of blog post] that will showcase the value and benefits of my [product/service] to [ideal customer persona] and convince them to take [desired action] with social proof and credibility-building elements."
12. "I'm looking for a [type of blog post] that will educate my [ideal customer persona] on a specific [topic] and persuade them to take [desired action] on my [website/product]."
13. "I need a [type of blog post] that will tell a story about my [product/service] and how it has helped [ideal customer persona] achieve their [goal] in a relatable and engaging way."
14. "I'm looking for a [type of blog post] that will engage my [ideal customer persona] with a unique and compelling perspective on [subject] and persuade them to take [desired action] on my [website/product]."
15. "I need a [type of blog post] that will provide valuable and relevant information to my [ideal customer persona] and persuade them to take [desired action] on my [website/product]."
YouTube Ad Scripts Prompts.

"I need a YouTube ad script that will provide valuable and relevant information to my [ideal customer persona] and persuade them to take [desired action] on my [website/product]."
"I need a YouTube ad script that will showcase the unique features and benefits of my [product/service] to my [ideal customer persona] and persuade them to make a purchase with social proof and credibility-building elements."
"I need a YouTube ad script that will overcome objections and concerns my [ideal customer persona] may have about my [product/service] and convince them to take [desired action] with a sense of urgency."
"I'm looking for a YouTube ad script that will introduce my [product/service] to my [ideal customer persona] and persuade them to take [desired action] with a strong call-to-action and compelling visuals."
"I'm looking for a YouTube ad script that will showcase the value and benefits of my [product/service] to my [ideal customer persona] and persuade them to take [desired action] with a strong offer and clear call-to-action."
"I'm looking for a YouTube ad script that will clearly explain the features and benefits of my [product/service] to my [ideal customer persona] and persuade them to make a purchase with a sense of urgency."
"I need a YouTube ad script that will tell a story about my [product/service] and how it has helped [ideal customer persona] achieve their [goal] in a relatable and engaging way."
"I'm looking for a YouTube ad script that will draw in my [ideal customer persona] with a strong headline and hook, and then convince them to take [desired action] with persuasive language and compelling evidence."
"I'm looking for a YouTube ad script that will speak directly to the needs and pain points of my [ideal customer persona] and persuade them to take [desired action] with a sense of urgency and strong offer."
"I need a YouTube ad script that will address the pain points and needs of my [ideal customer persona] and show them how my [product/service] is the solution they've been searching for."
"I'm looking for a YouTube ad script that will establish trust and credibility with my [ideal customer persona] by highlighting the successes and testimonials of previous customers who have used my [product/service]."
"I need a YouTube ad script that will educate my [ideal customer persona] on a specific [topic] and persuade them to take [desired action] on my [website/product]."
"I need a YouTube ad script that will showcase the unique selling points of my [product/service] and persuade my [ideal customer persona] to make a purchase with a sense of urgency and exclusive offers."
"I'm looking for a YouTube ad script that will draw in my [ideal customer persona] with a relatable and authentic message, and then persuade them to take [desired action] with a strong call-to action and compelling visuals."
"I'm looking for a YouTube ad script that will engage my [ideal customer persona] with a unique and compelling perspective on [subject] and persuade them to take [desired action] on my [website/product]."

YouTube Video Ideas Prompts.
1. "I need a YouTube video idea that will both go viral and persuade my [ideal customer persona] to take [desired action] on my [website/product] with a strong call-to-action and compelling visuals."
2. "I'm looking for a YouTube video idea that will tell a unique and relatable story about my [product/service] and how it has helped [ideal customer persona] achieve their [goal]."
3. "I need a YouTube video idea that will showcase the unique features and benefits of my [product/service] in a fun and creative way, and persuade my [ideal customer persona] to make a purchase."
4. "I'm looking for a YouTube video idea that will showcase the value and benefits of my [product/service] to my [ideal customer persona] and persuade them to take [desired action] with a strong offer and clear call-to-action."
5. "I'm looking for a YouTube video idea that will provide valuable and relevant information to my[ideal customer persona] about [subject] and persuade them to take [desired action] on my [website/product]."
6. "I need a YouTube video idea that will overcome objections and concerns my [ideal customer persona] may have about my [product/service] and convince them to take [desired action] with a sense of urgency."
7. "I'm looking for a YouTube video idea that will go viral and showcase my [product/service] to my [ideal customer persona] in a creative and entertaining way."
8. "I need a YouTube video idea that will showcase the success stories of previous customers who have used my [product/service] and persuade my [ideal customer persona] to make a purchase."
9. "I need a YouTube video idea that will engage my [ideal customer persona] with a unique and compelling perspective on [subject] and persuade them to take [desired action] on my [website/product]."
10. "I need a YouTube video idea that will provide a behind-the-scenes look at my [company/brand] and persuade my [ideal customer persona] to take [desired action] with a sense of authenticity and relatability."
11. "I'm looking for a YouTube video idea that will provide a step-by-step guide on how to use my [product/service] and persuade my [ideal customer persona] to make a purchase with clear and compelling instructions."
12. "I'm looking for a YouTube video idea that will draw in my [ideal customer persona] with a relatable and authentic message, and then persuade them to take [desired action] with a strong call-to-action and compelling visuals."
13. "I'm looking for a YouTube video idea that will showcase the unique selling points of my [product/service] and persuade my [ideal customer persona] to make a purchase with a sense of urgency and exclusive offers."
14. "I need a YouTube video idea that will demonstrate how my [product/service] can solve the specific pain points and needs of my [ideal customer persona] in a relatable and engaging way."
15. "I need a YouTube video idea that will compare my [product/service] to similar options on the market and persuade my [ideal customer persona] to choose us with clear and compelling evidence."

java threadpool executor with kafka consumer

noreply@blogger.com (Unknown) — Fri, 3 Feb 2023 10:56:00 +0530

using java program with spring I need to create a java threadpool executor and this threadpool executor in application level. I have multiple kafka consumers reading records as batches from kafka topic. These consumers should run inside the threadpool executor and we need to shutdown the executor while application stops

First, create a configuration class with the thread pool executor configuration:

@Configuration public class ExecutorConfig { @Bean public Executor taskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(10); executor.setMaxPoolSize(20); executor.setQueueCapacity(50); executor.setThreadNamePrefix("ConsumerThread-"); executor.initialize(); return executor; } }

In your main class, create the kafka consumers and run them inside the thread pool executor:

@SpringBootApplication public class Application { private final Logger logger = LoggerFactory.getLogger(Application.class); @Autowired private Executor taskExecutor; public static void main(String[] args) { SpringApplication.run(Application.class, args); } @PostConstruct public void runConsumers() { for (int i = 0; i < 5; i++) { taskExecutor.execute(new KafkaConsumer("topic" + i)); } } class KafkaConsumer implements Runnable { private final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class); private final String topic; KafkaConsumer(String topic) { this.topic = topic; } @Override public void run() { logger.info("Running Consumer for topic: " + topic); //Code to run the kafka consumer for the topic } } }

To shutdown the thread pool executor while application stops, we can add a shutdown hook in the main class:
@SpringBootApplication
public class Application { private final Logger logger = LoggerFactory.getLogger(Application.class); @Autowired private Executor taskExecutor; public static void main(String[] args) { SpringApplication.run(Application.class, args); } @PostConstruct public void runConsumers() { for (int i = 0; i < 5; i++) { taskExecutor.execute(new KafkaConsumer("topic" + i)); } } @PreDestroy public void shutDownExecutor() { if (taskExecutor instanceof ThreadPoolTaskExecutor) { ((ThreadPoolTaskExecutor) taskExecutor).shutdown(); } } class KafkaConsumer implements Runnable { private final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class); private final String topic; KafkaConsumer(String topic) { this.topic = topic; } @Override public void run() { logger.info("Running Consumer for topic: " + topic); //Code to run the kafka consumer for the topic } } }
To shutdown the thread pool executor while application stops, we can add a shutdown hook in the main class:
@SpringBootApplication public class Application { private final Logger logger = LoggerFactory.getLogger(Application.class); @Autowired private Executor taskExecutor; public static void main(String[] args) { SpringApplication.run(Application.class, args); } @PostConstruct public void runConsumers() { for (int i = 0; i < 5; i++) { taskExecutor.execute(new KafkaConsumer("topic" + i)); } } @PreDestroy public void shutDownExecutor() { if (taskExecutor instanceof ThreadPoolTaskExecutor) { ((ThreadPoolTaskExecutor) taskExecutor).shutdown(); } } class KafkaConsumer implements Runnable { private final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class); private final String topic; KafkaConsumer(String topic) { this.topic = topic; } @Override public void run() { logger.info("Running Consumer for topic: " + topic); //Code to run the kafka consumer for the topic } } }

Java program for finding the smallest element in an arraylist

noreply@blogger.com (Unknown) — Sun, 15 Jan 2023 09:03:00 +0530

This program also creates an ArrayList called "numbers" and adds some integers to it.

It then uses a for loop to iterate through the ArrayList, and compares each element to

the current smallest element. If a smaller element is found, it

is assigned to the variable "smallest". Finally, the smallest element is printed to the console.

import java.util.ArrayList;

public class SmallestElementArrayList {

public static void main(String[] args) {

ArrayList<Integer> numbers = new ArrayList<>();

numbers.add(3);

numbers.add(2);

numbers.add(5);

numbers.add(1);

numbers.add(4);

int smallest = numbers.get(0);

for (int i = 1; i < numbers.size(); i++) {

if (numbers.get(i) < smallest) {

smallest = numbers.get(i);

}

System.out.println("Smallest element in the ArrayList is: " + smallest);

}

Apache kafka consumer in java simple example

noreply@blogger.com (Unknown) — Sun, 15 Jan 2023 08:54:00 +0530

Here is a simple java program for apache kafka consumer. This java program is ready to use in your code base or project.

import java.util.Collections;

import java.util.Properties;

import org.apache.kafka.clients.consumer.ConsumerConfig;

import org.apache.kafka.clients.consumer.ConsumerRecord;

import org.apache.kafka.clients.consumer.ConsumerRecords;

import org.apache.kafka.clients.consumer.KafkaConsumer;

public class KafkaConsumerExample {

public static void main(String[] args) {

Properties props = new Properties();

props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092"); props.put(ConsumerConfig.GROUP_ID_CONFIG, "myGroupId"); props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer"); props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

KafkaConsumer consumer = new KafkaConsumer<>(props);

consumer.subscribe(Collections.singletonList("myTopic"));

while (true) {

ConsumerRecords records = consumer.poll(100);

for (ConsumerRecord record :

records) {

System.out.println(record.value());

}

This example assumes that Kafka is running on the local machine at port 9092,

continuously poll for new messages on the topic and print the value of each message it receives.

Note that for production use, you should consider adding error

handling and offset committing logic to the consumer code.

How to remove unnecessary characters or imports automatically while saving in eclipse

noreply@blogger.com (Unknown) — Wed, 28 Sep 2016 01:22:00 +0530

Its very easy to remove unnecessary imports and characters while saving a file in eclipse.This will help to avoid sonar issues in our code base.

go to eclipse-> preferences->Java -> Editor->Save Actions and give the below checkbox options as looks in picture below.

also do the advanced level setting by clicking configure button

What is DI in java ? Benefits and usage ( Dependency Injection in Java)

noreply@blogger.com (Unknown) — Mon, 22 Aug 2016 06:48:00 +0530

Lets assume we want to go to a trip to Paris.What we will do ? You have to plan everything

1) Book your flights

2)Book your hotels to stay

3)Book your car rental for travelling in Paris

4)Book your amenity pass for visiting different places

assume that you have done all the booking advance and there is an email from flight authority that the flight scheduled is cancelled and it is rescheduled to next day. What you will do?

you have to reschedule all the above bookings to next day and to communicate all the different agencies(hotel/car rental/amenity pass center). This is a pain for you by this unexpected channges happened right? Now think about a situation that your booking is done by a travel agency including

all the booking and because of flight delay they rescheduled everything by themself without charging

any extra dollar from you and you will be able to travel on the same day without any delay !!

How it will feel ? nice right. You dont bother about the rescheduling and re booking of all your tickets, travel agency will take care of everything. Would that be better than booking tickets by ourselves? If yes, then welcome to dependency injection.

The whole example is easily clonable or download from GitHub repository

Dependency injection is a framework that takes care of creating objects for us without having to worry about providing the right tickets so to say.

Explanation

Consider we have a class Student and this class need to write a test need help on another class WriteTest() which will help us to write a test for a student.

   package com.johnjustin;

public class AttendExam {
 
 public void writeTest(final String ExamName, final String subject) {
     System.out.printf("writeTest : %s, %s%n", ExamName, subject);
   }

}

package com.johnjustin;

public class Student {
  private AttendExam attendExam = new AttendExam();

  public void writeTest(){
    attendExam.writeTest("Engineering", "Mathematics");
  }
}

This is the simplest way to fulfill the requirement but we know that this has some limitations

1)There is a tight dependency on AttendExam class on Student class.
2) if there is a design change planned on writeTest() method with different parameters and there might be changes happened for different types of exams like online exam and offline written exam
we should go to all the places wherever this AttendExam written will be changed.
3)After sometimes there is new requirement came and we have to implement 2 types of tests.Online assessment and offline written test at this scenario it will be difficult for us to maintain same AttendExam class.
These limitations can be improved by changing the way we think and refactor our code in a modular way.We can avoid these limitations by implementing dependency injection by modular way.

1)Create Interface
2)Implement Interface
3)integrate DI using any(Spring/Guice) framework

these three steps will help to decouple the tight dependencies between classes and it will be easy to migrate newer version of changes and updation of existing features without changing the current codes.

Create Interface

We will create an interface AssessmentService where we define a common method writeTest with parameters.So there must be different types of test either online test or written test both classes will inherit this AssessmentService and implement writeTest for their own exam implementation.

package com.johnjustin;

public interface AssessmentService {
 
 void writeTest(String subject, String testName);

}

Implement Interfaces

We have listed some limitations above and there is requirement to implement 2 types of tests online assessment and offline written tests. We have created 2 different classes OnlineExamService and WrittenExamService for these tests and it will inherit the feature of AssessmentService interface's writeTest method.

    package com.johnjustin;

/**
 * @author John Justin
 *
 */
public class WrittenExamService implements AssessmentService{
 
 public void writeTest(final String ExamName, final String subject) {
     System.out.printf("Written Exam for : %s, %s%n", ExamName, subject);
   }


}

    package com.johnjustin;

/**
 * @author John Justin
 *
 */
public class OnlineExamService implements AssessmentService{
 
 public void writeTest(final String ExamName, final String subject) {
     System.out.printf("Online Exam for : %s, %s%n", ExamName, subject);
   }

}

Use interfaces to reduce loosely couple the classes. We have to use this AssessmentService in our Student class and implement required type of assessment(Online/Written) according to the need.This is a key element in the design. It improves modularity, extendibility.

  
     package com.johnjustin;
import com.johnjustin.AssessmentService;
import com.google.inject.Inject;

/**
 * @author John Justin
 *
 */
public class Student {

 private final AssessmentService assessmentService;
 
 @Inject
 private Student(AssessmentService assessmentService){
  
  this.assessmentService = assessmentService;
 } 
 
 public void attendExam() {
   assessmentService.writeTest("Engineering", "Mathematics");
    }
  
 
}

The Student class is not dependent on any implementation, but on a service defined by an interface. This means that we can use the Student class without having to worry about the underlying implementation of the assessment service. Furthermore, different Student instances can be instantiated using different assessment services.

Integrate DI using any(Spring/Guice) framework

dependency injection can help us initializing objects and provide these objects all the necessary resources . For example, the Student class requires an instance of AssessmentService. The dependency injection framework( Guice here) will provide that for us. So to create an instance of Student class.

The dependency injection framework(Guice) will create an instance of the Student class and provide an instance of the AssessmentServiceto the Student object.

How to integrate google Guice dependency frame work in our programe?

how does the dependency injection framework knows how to initialise the AssessmentService?

Usage of Dependency Injection requires that the software we write to declare the dependencies, and lets the framework or the container work out the complexities of service instantiation, initialization, sequencing and supplies the service references to the clients as required. To decouple Java components from other Java components the dependency to a certain other class should get injected into them rather that the class itself creates / finds this object.

The general concept between dependency injection is called Inversion of Control. A class should not configure itself but should be configured from outside.

We need to tell the dependency injection framework how to create an instance of AssessmentService. With Guice we do that by creating a module (a class that extends AbstractModule class) as illustrated below.

We should tell the Guice dependency framework to how to create an instance of AssessmentService class.We should add an annotation in Student class in order to allow the dependency injection framework to inject the necessary parameters.

 
     package com.johnjustin;

import com.google.inject.AbstractModule;

/**
 * @author John Justin
 *
 */
public class ProjectModule extends AbstractModule {
 
 @Override
   protected void configure() {
     bind(AssessmentService.class).to(OnlineExamService.class);
   }

}

        package com.johnjustin;
import com.johnjustin.AssessmentService;
import com.google.inject.Inject;

/**
 * @author John Justin
 *
 */
public class Student {

 private final AssessmentService assessmentService;
 
 @Inject
 private Student(AssessmentService assessmentService){
  
  this.assessmentService = assessmentService;
 } 
 
 public void attendExam() {
   assessmentService.writeTest("Engineering", "Mathematics");
    }
  
 
}

Now we can create the main class and create its injection in it.

package com.johnjustin;

import com.google.inject.Guice;
import com.google.inject.Injector;

/**
 * @author  John Justin
 *
 */
public class Main {
 
 
  public static void main(final String[] args) {
      final Injector injector = Guice.createInjector(new ProjectModule());
      final Student student = injector.getInstance(Student.class);
      student.attendExam();
    }

}

Advantages of DI

Dependency injection is a pattern used to create instances of classes that other classes rely on without knowing at compile time which implementation will be used to provide that functionality.

Easily changing the the exam type from online exam service to written exam service.We only need to change the ProjectModule class to map the AssessmentService class to the WrittenExamService class as highlighted below.This one change will affect all classes initialised with the dependency injection framework without having to change any of these classes.

package com.johnjustin;

import com.google.inject.AbstractModule;

/**
 * @author John Justin
 *
 */
public class ProjectModule extends AbstractModule {
 
 @Override
   protected void configure() {
     bind(AssessmentService.class).to(WrittenExamService.class);
   }

}

The whole example is easily clonable or download from GitHub repository.Enjoy !!!!!

References:

Stack overflow discussion

Wikipedia

Martinfowler definition

nice blog from Javacreed

How Set in java collection maintaining uniqueness - how HashSet in java implement unique values

noreply@blogger.com (Unknown) — Thu, 21 Jul 2016 06:27:00 +0530

In your collection implementation how you will make sure the unique values without implementing set/hashSet interface? otherway how you implement set interface in your java collection data?

For example

public class Test {
    
    public static void main(String[] args)
    {
       
        HashSet<Object> testSet= new HashSet<Object>();
        testSet.add(100);
        testSet.add("hello");
        System.out.println("Result "+testSet);
    }
}

The result will be : Result [100, hello ]

Now we will add some duplicate elements in the same collection list

public class Test {
    
    public static void main(String[] args)
    {
       
        HashSet<Object> testSet= new HashSet<Object>();
        testSet.add(100);
        testSet.add("hello");

        testSet.add(100);
        testSet.add("hello");
        System.out.println("Result "+testSet);
    }
}

The result will be : Result [100, hello ]

Eventhough when we add duplicate element in this collection set with add method why the duplicated data not inserted? because add method returs false when we try to add duplicate elements. How the add method returns false?
The HashSet implementation of the add() method in java is internally implemented by HashMap implementation.

Whenever we tries to create an object of HashSet , it internally create an object of HashMap

public class HashSet
extends AbstractSet
implements Set, Cloneable, java.io.Serializable

{
private transient HashMap map;

private static final Object PRESENT = new Object();

public HashSet() {
map = new HashMap<>();
}


public boolean add(E e) {
return map.put(e, PRESENT)==null;
}



}

The key is unique in hashmap , when we are calling add(Element E) this element E will be added as key in HashMap and the value for key will be added by the java developer api by using the variable PRESENT , it will create ( new Object() ) which is a dummy value referred by Object reference PRESENT

when you are adding a line in HashSet like hashset.add(100) what java does internally is that it will put that element E here 100 as a key in the HashMap(created during HashSet object creation) and some dummy value that is Object's object is passed as a value to the key .

The main point to notice in above code is that put (key,value) will return

1. null , if key is unique and added to the map
2. Old Value of the key , if key is duplicate

So , in HashSet add() method , we check the return value of map.put(key,value) method with null value
i.e.

public boolean add(E e) {
return map.put(e, PRESENT)==null;
}

So , if map.put(key,value) returns null ,then
map.put(e, PRESENT)==null will return true and element is added to the HashSet.

So , if map.put(key,value) returns old value of the key ,then
map.put(e, PRESENT)==null will return false and element is not added to the HashSet .

Java Collection framework tips

noreply@blogger.com (Unknown) — Thu, 14 Jul 2016 05:37:00 +0530

What is a Collection?
• An object that groups multiple elements into a single unit.
• Sometimes called a container

img courtesy - http://javahungry.blogspot.com/

There are two ways to traverse collections:
1) using Iterators.
2) with the (enhanced) for-each construct

Iterators

• An Iterator is an object that enables you to traverse through a collection and to remove elements from the collection selectively, if desired.

• You get an Iterator for a collection by calling its iterator method.

• Suppose collection is an instance of a Collection. Then to print out each element on a separate line:

Iterator it = collection.iterator();
while (it.hasNext())
System.out.println(it.next());

• Note that next() does two things:
1. Returns the current element (initially the first element)
2. Steps to the next element and makes it the current element.

Levels of Abstraction

• Recall that Java supports three levels of abstraction: –

- Interface

• Java expression of an ADT
• Includes method declarations with arguments of specified types, but with empty bodies

– Abstract Class

• Implements only a subset of an interface.
• Cannot be used to instantiate an object.

– (Concrete) Classes

• May extend one or more abstract classes
• Must fully implement any interface it implements
• Can be used to instantiate objects.

Iterating Over a Map

• Because Map does not extend Iterable, but Collection (hence Set) does extend Iterable, you can (only) iterate over a Map using one of its three views:
– Keys: Set keySet()
– Values: Collection values()
– Pairs: Set> entrySet()

What is the root interface in collection hierarchy ?

Root interface in collection hierarchy is Collection interface . Few interviewer may argue that
Collection interface extends Iterable interface. So iterable should be the root interface. But you should reply iterable interface present in java.lang package not in java.util package .It is clearly mentioned in Oracle Collection docs , that Collection interface is a member of the Java Collections framework. For Iterable interface Oracle doc , iterable interface is not mentioned as a part of the Java Collections framework .So if the question includes collection hierarchy , then you should answer the question as Collection interface (which is found in java.util package).

What is the difference between Collection and Collections ?

Collection is an interface while Collections is a java class , both are present in java.util package and part of java collections framework.

Which collection classes are synchronized or thread-safe ?

Stack, Properties , Vector and Hashtable can be used in multi threaded environment because they are synchronized classes (or thread-safe).

Apache Camel some tips and tricks

noreply@blogger.com (Unknown) — Tue, 12 Jul 2016 06:10:00 +0530

Camel Book in one page

Camel books Camel in action

It enables easy integration of different applications which use several protocols and technologies.Synchronous remote procedure calls or asynchronous messaging is used to communicate via several technologies such as RMI, SOAP Web Services, REST or JMS. A lot of software silos exists. Nevertheless, all applications and products of these decades have to communicate with each other to work together perfectly.

What is Apache Camel?

Apache Camel is a lightweight integration framework which implements all EIPs. Thus, you can easily integrate different applications using the required patterns. You can use Java, Spring XML, Scala or Groovy. Almost every technology you can imagine is available, for example HTTP, FTP, JMS, EJB, JPA, RMI, JMS, JMX, LDAP, Netty, and many, many more (of course most ESBs also offer support for them). Besides, own custom components can be created very easily.

You can deploy Apache Camel as standalone application, in a web container (e.g. Tomcat or Jetty), in a JEE application Server (e.g. JBoss AS or WebSphere AS), in an OSGi environment or in combination with a Spring container.

If you need more information about Apache Camel, please go to its web site as starting point: http://camel.apache.org. This article is no technical introduction J

When to use Apache Camel?

Apache Camel is awesome if you want to integrate several applications with different protocols and technologies. Why? There is one feature (besides supporting so many technologies and besides supporting different programming languages) Every integration uses the same concepts! No matter which protocol you use. No matter which technology you use. No matter which domain specific language (DSL) you use – it can be Java, Scala, Groovy or Spring XML. You do it the same way. Always! There is a producer, there is a consumer, there are endpoints, there are EIPs, there are custom processors / beans (e.g. for custom transformation) and there are parameters (e.g. for credentials).

sample working example here

What is the difference between enrich() and pollEnrich()?

Content enricher here ( Link)

Content enrichment using the enrich DSL element Camel comes with two flavors of content enricher in the DSL enrich pollEnrich enrich uses a Producer to obtain the additional data. It is usually used for Request Reply messaging, for instance to invoke an external web service. pollEnrich on the other hand uses a Polling Consumer to obtain the additional data. It is usually used for Event Message messaging, for instance to read a file or download a FTP file.

enrich assumes you want to use an incoming Exchange as a parameter to an another service request. for example, your incoming Exchange could be a userID, but you really need the entire User object, so you could enrich it by passing the userID to a REST service that returns the User object which becomes the Exchange, etc.
pollEnrich assumes the incoming Exchange is a simple trigger that tell a PollingConsumer to look for data and create an Exchange (ignoring the contents of the incoming Exchange). For example, you could have a timer or other business process event that requires picking up a file for processing, etc. that said, the incoming Exchange data is NOT used to dynamically configure the PollingConsumer...only the URI is used for this.

What are different message exchange patterns in Camel, which one of these is synchronous?
A: There are two types of message exchange patterns in Camel:

In Only: In this exchange pattern, consumer creates a exchange which only contains an In message.
In Out: In this exchange pattern, consumer creates a exchange which also contains reply message for the caller.

Out of above two, InOut pattern is synchronous because caller expects for an acknowledgement or reply for each exchange sent.

What is camel exchange? Explain its structure?
A: A Camel Exchange can be called as an holder for holding message during routing. A exchange supports various message exchange patterns, like InOnly and InOut.
Following are the contents of camel exchange:

ExchangeId: A unique identifier for each exchange
Message Exchange Pattern: This field denotes whether you are using InOnly or InOut exchange pattern.
Exception: If any exception occurs during routing, it will be available in this field.
Properties: These are the properties that are available for entire duration of exchange.
In Message: This is mandatory field which contains the input message.
Out Message: This is optional message which exists only if MEP is InOut.

nice discussion from stack overflow

perl script to get interwoven teamsite dcr path

noreply@blogger.com (Unknown) — Sun, 25 Nov 2012 13:35:00 +0530

function to get dcrpath in perl for interwoven teamsite

sub getDcrPath{
    debug("getDCRPATH CALLED");
    my $currentDcrName=shift;
       debug("dcr path: $currentDcrName");
    $currentDcrName=~ s/(.*WORKAREA\/)(.*?\/)/$1$2/;
    my $workareaName=$2;
    $workareaName=~s/\///g;
    #my $dcrPath="$iwmount/default/main/$branchName/$subBranchName/WORKAREA/$workareaName/templatedata/content/Fragments/data/";
    debug("WORKAREA ".$workareaName."==".$currentDcrName);
    return $workareaName;
}

how to read a datacapture template in interwoven teamsite using perl

noreply@blogger.com (Unknown) — Sun, 25 Nov 2012 13:26:00 +0530

hi friends here iam sharing a subroutine for reading a datacapture template in interwoven teamsite using perl script. hope this subroutine will help your requirement.

sub readDatacapture
{

    debug("ENTERING READ DATACAPTURE FUNCTION");
    my $dctFile = shift;

    open INPUT, "<$dctFile";
    my @output_string = ;
    close INPUT;
    #debug("\n\n");
    foreach my $line(@output_string) {

        if ( $line =~ /.*command.*/ ) {

            #grab just the command itself
            my @fields2 = split /=/, $line;
            my $inlineCmd = @fields2[$#fields2] ;
            $inlineCmd =~ s/\/\>//; #strip off trailing tag
            $inlineCmd =~ s/\"//g; #strip off quotes

            #print "XXX" . $inlineCmd . "XXX\n";
            my @Results = `$inlineCmd 2>&1`;
            my $Result = join ('', @Results);
            chomp ($Result);

            #remove the double substitution tags, since it maybe a normal inline that has substitution on it
            $Result =~ s/\//;
            $Result =~ s/\<\/substitution\>//;

            #remove xml declaration that would normally come across an inline
            $Result =~ s/\<\?xml.*\>?//;

            #Now substitute result for inline command
            print $Result;
            #debug("The result of $inlineCmd ");
            #debug("$Result");


        }
        else
        {
            #print " IN ELSE ========== > $line\n";
            print $line;
            #debug("$line");


        }
    }
    #debug("\n\n");
    debug("EXITING READ DATACAPTURE FUNCTIONNNNNNN");
}

interwoven teamsite cms

noreply@blogger.com (Unknown) — Sun, 20 May 2012 12:59:00 +0530

in interwowen teamsite we can able to integrate java applications with content.Teamsite content management system is more efficient than other different cms available now.Today i will explain how we can create html pages with content and how we are storing that content in cms and how we integrating that pages with java applications.

in teamsite , for creating a html we need that html data(data contains any information together with page contents and html tags).first we need to capture this data/content in an xml format.For capturing data in teamsite we are using some templates ,called datacapture template.
With the help of datacapture template we are storing our content in xml format.

The points to be remebered before starting page generation in teamsite.

1)create entry in templating.cfg for the new datacap

JESUS YOUTH JUBILEE INTERNATIONAL CONFERENCE

noreply@blogger.com (Unknown) — Sat, 8 Jan 2011 21:32:00 +0530

hai friends here iam sharing some pictures which i take during the Jesus Youth International Jubilee conference 2010.

JESUS YOUTH JUBILEE CONFERENCE 2010 PHOTOS

jesus youth jubilee conference photos