Pass a parameter to all JVMs in a machine at the same time

Posted on August 23, 2021 | by josedacruz | Leave a Comment

JAVA_TOOL_OPTIONS

Imagine a scenario where you need to change a JVM parameter, but you can’t or is not a good solution to changing the start script of your server(s).

One of the challenges we had, when we were working with containers, was a way to change a parameter to a JVM without building the docker image again.
The application at the start time should read a JVM parameter where a _user profile_was defined.
For specific reasons we sometimes need to change this profile, for instance, to use a more controlled user where we can debug an issue. In these situations, we want to stop the container/pod, change the profile and start again, or even start a different container with a different profile.

As you know, the way to pass a JVM parameter to an application is
java -Dprofile=myValue com.some.Application appParameter1 appPaparameter2

What if I don’t have access, or is not viable to rewrite the above line?
You can add to the Environment variables of your operating system

JAVA_TOOL_OPTIONS=‘-Dvar1=value1 -Dvar2=value2’

Yes, you can add multiple values, since it is not a parameter, but an environment variable whose values will be injected into the JVM at starting time.

When the JVM starts it searches for this environment variable and uses it. You can check the output of the JVM displaying a message with the values found.

JDK_JAVA_OPTIONS

This environment variable has a different purpose, it adds its values as a prefix to the Java other values

Example

export JDK_JAVA_OPTIONS=‘-Dparam=value @someFile

When we execute this
java @otherFile

The real execution is
java -Dparam=value @somefile @otherFile

Code complexity: Cyclomatic vs Cognitive

Posted on August 21, 2021 | by josedacruz | Leave a Comment

As the name suggests, code complexity measures how complex is your code. If you consider the number of possible paths your code produces, the measure is called cyclomatic. If you want other angle to measure the complexity, such as how difficult is to be read by a human, we call it cognitive.

Why is this measure important

If we take the following code

public int crazySum(int x, int y) {
    int sum = 0;
    if(x > y) {        
        sum = x + y;    
    }    
    if(y > x) {
        sum = y;
    }
    return sum;
}

public int crazySum(int x, int y) {

int sum = 0;

if(x > y) {

sum = x + y;

}

if(y > x) {

sum = y;

}

return sum;

}

a graph like this one can be produced

From this graph we can deduce the number os possible paths an application can follow during its execution M=6-5+2x1, or 3. (Check the formulas below)
If you develop unit tests, you easily reach the conclusion that exists a strong correlation between the number of possible paths and the number of unit tests necessary to reach a coverage of 100% of the code!
Now, if your method, is too complex, or/and has a lot of possible paths of execution, you will need to develop and maintain a lot of unit tests, and, for sure, difficult for another person to understand and continue your work.
You want to have a low value for this metric. Usually, Sonar proposes a maximum value of 15. For any value above this one, you should consider refactoring your code.
By the way, the recommended value is 4 or 5.

Cyclomatic complexity

This measures how difficult is your code to be tested.
If you consider a graph generated from code, you can use the formula

E -> the number of edges in the graph
N -> the number of nodes in the graph
P -> the number of connected components (a method is considered a component, so in these cases P = 1)

For Java like languages another way to calculate exists

assign one point for the start of the method
Add one point for each conditional statement, such as an if
Add one point for each iterative statement
Add one point for each case or default in a switch
Add one point for each Boolean condition &&, ||
Sometimes it is added one point for each throws, throw, catch, and finally blocks, but it is advised to not use these points since Java has a very verbose code regarding exceptions

Cognitive complexity

This measures how difficult is your code to be read and understood.
There isn’t a specific formula to apply, but usually what is done is to take the regular formula for the Cyclomatic complexity and take into consideration how hard is to assess mentally the code

add points for catch, switch
Ignores the number of Boolean operator in an if, because mentally the effort is the same to read a && b and the a && b && c
Add points for each recursion (the Cyclomatic ignores this)
Increments for nested flows-break structures

Tools to measure the complexity

These are the ones I use most

Google for complexity metrics and several plugins for several languages and IDEs will be displayed.

Observer pattern

Posted on August 20, 2021 | by josedacruz | Leave a Comment

The observer pattern is one of the most used patterns when developing current web technologies.
For instance, in the interface when you change a value, such as a date, and something changes immediately in another place of the UI, it is the Observer pattern working behind the scenes.
When you make a REST API in an angular application, you register a method that will process the result after receiving the response, it is the Observer pattern.
In applications with buttons and dropdowns that affect other controls, it is again the Observer pattern.

what is the main idea of this pattern

You want to use this pattern when a component should be immediately notified when something changes its state or a specific behaviour happens.
By the way, this pattern is not the same as “publisher-subscriber”, but that’s a subject for another article.

An example

To avoid the common examples, imagine we have a class that every time a record is sent to a database a set of other classes want to know about, for instance, a logger and an audit class.
Let’s write a simple draft to understand a possible implementation.

We have a CustomerDao, the class responsible to send data to the database and the class that has information of utility to others classes
We have an interface for Subscriber to allow any class to be notified if it implements this interface
And we have 2 other classes to be Subscibers DatbaseLoggerObserver and DatabaseAuditObserver, to be notified from the CustomerDao every time a new Customer is inserted, but since they are decoupled from the CustomerDao they can receive from anywhere

Usually a possible flux would be
1. create the instances of the classes
2. Add the subscribers to the CustomerDao
3. Execute!

this is just a snippet to understand the pattern, a production code can and should do so much better. For instance you can extract the subscribers list and operations to add and remove them to another class, and so on

public class CustomerDao {	
    List<subscriber> subs = new ArrayList<>();	
    public void addSubscriber(Subscriber sub) {		
        subs.add(sub);  
    }	
    public void insertCustomer(Customer customer) {		
        // ...some useful code. About database		
        // notify the subscribers		
        subs.forEach(s -> s.notify(customer.getEmail());	
    }  
}

interface Subscriber {	
    void notify(String email);
}

class DatabaseLoggerObserver implements Subscriber {	
    public void notify(String email) {		
        System.out.println(“I will log to another database the email: “ + email);	
    }
}

class DatabaseAuditObserver implements Subscriber {	
    public void notify(String email) {		
        System.out.println(“I will audit and do some verifications and alerts for “ + email);	
    }
}

public class CustomerDao {

List<subscriber> subs = new ArrayList<>();

public void addSubscriber(Subscriber sub) {

subs.add(sub);

}

public void insertCustomer(Customer customer) {

// ...some useful code. About database

// notify the subscribers

subs.forEach(s -> s.notify(customer.getEmail());

}

interface Subscriber {

void notify(String email);

}

class DatabaseLoggerObserver implements Subscriber {

public void notify(String email) {

System.out.println(“I will log to another database the email: “ + email);

}

class DatabaseAuditObserver implements Subscriber {

public void notify(String email) {

System.out.println(“I will audit and do some verifications and alerts for “ + email);

}

Advantages and disadvantages

Advantages

Allows to send data to other objects without knowing them
If it is well implemented the objects interact in a loosely coupled way
Observers can be added and removed at any time without changing the code

Disadvantages

Look for performance issues since each notification waits for each observer
What happens if an observer throws an exception?

Conclusions

This is a great pattern and is widely used at the code level, such as events in the interface, trigger behaviour in specific classes and methods and so on.
This pattern is not a good option if you need this behaviour at the architecture level, since it doesn’t have mechanisms regarding performance, scalability, reliability, etc. For these cases consider to use publisher-subscriber

Parâmetros JVM – Java Básico

Posted on June 12, 2020 | by admin | Leave a Comment

O que são parâmetros JVM ou também designados por propriedades do System

Java Parameters (pt-pt)

Posted on June 10, 2020 | by admin | Leave a Comment

RegExTool – The Android App in town

Posted on January 4, 2019 | by josedacruz | Leave a Comment

RegExTool

A new Android App was deployed to the Android Play Store.

This application is very useful for developers or people from operations who need to use regular expressions. Just try it!

Write and visualize the matchs in real time!

Wrap Class – Refactor Legacy Pattern

Posted on January 4, 2019 | by josedacruz | Leave a Comment

Wrap Class

When using a wrap method, we want to add a new behavior that can be added around the method, such as before or after the existing code.
However, there are times when we need to add behavior in more than one method, like logging before or after some, or all public methods.

Description and how to apply

There are at least 2 ways of doing it:

1. Using the Decorator Pattern

When using the **Decorator Pattern**, we want to make sure both classes implement the same interface or inherit from the same base class, because we want the subclass to have the same “public” interface. This is because a Decorator class can be used interchangeably between the other Decorators. For instance, having a logging decorator or a performance decorator should be as easy as just pass one instance or the other in a class constructor, and its use should be transparent.

2. Aggregating the current class

If you think you want to be more specific about the class being refactored,
then a Wrap Class just wrapping the existing one should be enough. In this case, you don’t need to *extract interface* since the class is passed in the constructor parameters and used in the method. In this approach, you can do a “method rename”, for instance, if the original method was called *process*, the new exposed method could be *processWithLogging*. Another advantage is that in the constructor, you can pass other information useful for the new behavior, something that in the Decorator Pattern can “violate” the Decorator Pattern principle.

Which one?

From the examples below you can observe the Aggregating solution is more specific than the Decorator. Both will work, but if you need help choosing, choose the Decorator if you think that other changes will happen in the future that can be added creating more Decorators, and/or the updates are just adding new behavior, and probably you expect changes in multiple methods, like logging every public method. Use the Aggregating solution if the change is very specific, just in a few places and you don’t expect great changes in the future for these methods.

Examples

Imagine the following business existing code:

//
// Existing code
//
public interface PaymentProcessor {
    void pay();
}

public class CustomerPaymentProcessor implements PaymentProcessor {

    public void pay() {
        System.out.println("Pay it forward!");
    }

}

// Existing code

public interface PaymentProcessor {

void pay();

}

public class CustomerPaymentProcessor implements PaymentProcessor {

public void pay() {

System.out.println("Pay it forward!");

}

Using the Decorator Pattern

You just have to replace the calls to CustomerPaymentProcessor with the Decorator, sice both implement the same interface.

Probably when refactoring you will need to *Extract Interface* or create an *Abstract Class* to implement this pattern.

//
// Now the decorator (from the code is easy to observe how easy is to create any decorator)
//
public class LogPaymentDecorator implements PaymentProcessor {

    private PaymentProcessor paymentProcessor;

    public LogPaymentDecorator(PaymentProcessor paymentProcessor) {
        this.paymentProcessor = paymentProcessor;
    }

    public void pay() {
        System.out.println("You are starting to pay");
        
        paymentProcessor.pay();

        System.out.println("Ok, now we are even ;)");

    }

}

// Now the decorator (from the code is easy to observe how easy is to create any decorator)

public class LogPaymentDecorator implements PaymentProcessor {

private PaymentProcessor paymentProcessor;

public LogPaymentDecorator(PaymentProcessor paymentProcessor) {

this.paymentProcessor = paymentProcessor;

}

public void pay() {

System.out.println("You are starting to pay");

paymentProcessor.pay();

System.out.println("Ok, now we are even ;)");

}

Using a Wrapper Class

Here, the solution is specific to the code refactoring being done, it cannot be reused.

//
// The Warp Class
// - You can observe this solution as more specific to the target class than the Decorator
//
public class LoggingCustomerPaymentProcessor 

    private CustomerPaymentProcessor customerPaymentProcessor;

    public LoggingCustomerPaymentProcessor(CustomerPaymentProcessor cpp) {
        CustomerPaymentProcessor = cpp;
    }

    // You can give the name you want to the method
    public void loggedPayWithStars() {
        System.out.println("You are starting to pay");
        customerPaymentProcessor.pay();
        System.out.println("Ok, now we are even ;)");
    }
}

// The Warp Class

// - You can observe this solution as more specific to the target class than the Decorator

public class LoggingCustomerPaymentProcessor

private CustomerPaymentProcessor customerPaymentProcessor;

public LoggingCustomerPaymentProcessor(CustomerPaymentProcessor cpp) {

CustomerPaymentProcessor = cpp;

}

// You can give the name you want to the method

public void loggedPayWithStars() {

System.out.println("You are starting to pay");

customerPaymentProcessor.pay();

System.out.println("Ok, now we are even ;)");

}

Android Adventures – Development Tips – Part 5

Posted on January 2, 2019 | by josedacruz | Leave a Comment

How to add the back button on the Activity Action Bar

// in the OnCreate....
supportActionBar!!.setDisplayHomeAsUpEnabled(true)

// and override
override fun onSupportNavigateUp(): Boolean {
finish()
return true
}

If the character space stops working with EditBox when using Listeners
Probably it is the google keyboard trying to impose words instead of characters
The one solution that worked for me was to disable the text suggestions

android:inputType="textMultiLine|textNoSuggestions"

1	android:inputType="textMultiLine\|textNoSuggestions"

Android Adventures-Development Tips-Part 4

Posted on December 28, 2018 | by josedacruz | Leave a Comment

How to remove the divider in a ListView?

android:divider="@null"

1	android:divider="@null"

What if my text doesn’t fit in a TextView?

android:ellipsize="marquee" -– it will scroll horizontally
android:ellipsize="end" – it will display “…”

1 2	android:ellipsize="marquee" -– it will scroll horizontally android:ellipsize="end" – it will display “…”

How to return values from to the caller Activity?

Main Activity:

{
    val intent = Intent(this, SecondActivity::class.java)
    intent.putExtra("someparametertosendkey", true)

    // call the activity like this
    startActivityForResult(intent, "akeytoidentifytheresult")
}

// This method is called when the second activity finishes
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {
    super.onActivityResult(requestCode, resultCode, data)

// Check that it is the SecondActivity with an OK result
    if (requestCode != USE_REGEX_RESULT_KEY) return

   if (resultCode == Activity.RESULT_OK) {

    // Get String data from Intent
    someview1.setText(data.getStringExtra("aresultfromsecondactivity1"))
    someview2.setText(data.getStringExtra("aresultfromsecondactivity2"))
    }
}
...
//
// Second Activity:
//

    // return the result
    val intent = Intent()
    intent.putExtra("aresultfromsecondactivity1", selectedItem.expression)
    intent.putExtra("aresultfromsecondactivity2", selectedItem.example)
    setResult(Activity.RESULT_OK, intent)
    finish()

{

val intent = Intent(this, SecondActivity::class.java)

intent.putExtra("someparametertosendkey", true)

// call the activity like this

startActivityForResult(intent, "akeytoidentifytheresult")

}

// This method is called when the second activity finishes

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent) {

super.onActivityResult(requestCode, resultCode, data)

// Check that it is the SecondActivity with an OK result

if (requestCode != USE_REGEX_RESULT_KEY) return

if (resultCode == Activity.RESULT_OK) {

// Get String data from Intent

someview1.setText(data.getStringExtra("aresultfromsecondactivity1"))

someview2.setText(data.getStringExtra("aresultfromsecondactivity2"))

}

...

// Second Activity:

// return the result

val intent = Intent()

intent.putExtra("aresultfromsecondactivity1", selectedItem.expression)

intent.putExtra("aresultfromsecondactivity2", selectedItem.example)

setResult(Activity.RESULT_OK, intent)

finish()

Highlight an item in a ListView

&lt;ListView
         android:id="@+id/regExListView"
         android:layout_width="match_parent"
         android:choiceMode="singleChoice" // choose 1 item only
         android:dividerHeight="3dp" // the space between items
         android:layout_height="wrap_content"&gt;

<ListView

android:id="@+id/regExListView"

android:layout_width="match_parent"

android:choiceMode="singleChoice" // choose 1 item only

android:dividerHeight="3dp" // the space between items

android:layout_height="wrap_content">

// and in the code if you want to only change the background
for (a in 0 until parent.childCount) {
    val item = parent.getChildAt(a)
    item.setBackgroundColor(Color.TRANSPARENT)
}

view.setBackgroundColor(resources.getColor(R.color.colorPrimaryUltraLight))

// and in the code if you want to only change the background

for (a in 0 until parent.childCount) {

val item = parent.getChildAt(a)

item.setBackgroundColor(Color.TRANSPARENT)

}

view.setBackgroundColor(resources.getColor(R.color.colorPrimaryUltraLight))

Android Adventures–Development Tips-Parte 3

Posted on December 28, 2018 | by josedacruz | Leave a Comment

How to shrink activity layout when virtual keyboard is displayed and hides some of the views?

There are several different solutions, one of them is:

– In the AndroidManifest.xml, for the target activity

android:windowSoftInputMode=”adjustResize”

If you use Database Room framework for SQLite management and Kotlin:

plugins {
id "org.jetbrains.kotlin.kapt" version "1.3.11"
}

buildscript {
  repositories {
    maven {
      url "<a href="https://plugins.gradle.org/m2/">https://plugins.gradle.org/m2/"</a>
    }
  }

  dependencies {
    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.11"
  }
}

apply plugin: "org.jetbrains.kotlin.kapt"
kapt "android.arch.lifecycle:compiler:1.1.1"
// instead of
annotationProcessor "..."

plugins {

id "org.jetbrains.kotlin.kapt" version "1.3.11"

}

buildscript {

repositories {

maven {

url "<a href="https://plugins.gradle.org/m2/">https://plugins.gradle.org/m2/"</a>

}

dependencies {

classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.11"

}

apply plugin: "org.jetbrains.kotlin.kapt"

kapt "android.arch.lifecycle:compiler:1.1.1"

// instead of

annotationProcessor "..."

If you are using Kotlin don’t create a new method, you can have compilation errors on the generated class

@Insert
fun new(vararg regexs: RegEx)
// use
@Insert
fun save(vararg regexs: RegEx)

java.lang.IllegalStateException: Cannot access database on the main thread since it may potentially lock the UI for a long period of time.

Solution 1: add allowMainThreadQueries

MyApp.database = Room.databaseBuilder(this, AppDatabase::class.java, “MyDatabase”).allowMainThreadQueries().build()

Solution 2: Use another thread

Solution 3: If you use Kotlin 1.3+ you can use coroutines

private fun saveSomething(e: Entity) = runBlocking {

  val job = GlobalScope.launch {
    database.myDao().save(e)
  }
  job.join()

Toast.makeText(applicationContext,"Saved",Toast.LENGTH_LONG).show()
finish()
}

How to explore a database in Android Emulator?

– You can copy the db files from the device to your computer and use a sqlite browser

– I use: Android Debug Database: https://github.com/amitshekhariitbhu/Android-Debug-Database