DEV Community: Aldo Telese

Use Git Stash and you won't regret it

Aldo Telese — Sun, 17 Mar 2024 18:53:04 +0000

Let's say we are working on a feature branch called feature/human where we have to build a representation of humans. We are almost done with our development but not ready to commit yet as something is still missing.

At the same time, we need to do an urgent fix on a previously developed feature (about animals), for which we need to switch back to the main branch and start a new fix branch (fix/animal).

We might end up with carrying around incomplete changes that were made for a given purpose, on other branches that have nothing to do with it, causing confusion at the moment of the commit, as we will be forced to select from the changelist only the relevant files for the current scope. The more the changes, the more the confusion.

Here is when Git Stash comes to our aid by allowing us to freeze and save the state of our changes in the "stash" for a later retrieval, keeping the changelist clean and consistent on each involved branch.

Let's see the example in action. For simplicity, we are going to limit the number of changes made.

This is the initial state of the project on the main branch:

that is printing to the console:

Lion makes Meow
Cat makes Roar
Dog makes Foow

As you might have noticed, there are two bugs: the sounds of lion and cat should be inverted, and the dog's sound is not spelled correctly.
Let's imagine we did not notice the bugs yet and already started the new feature about humans.

This is the feature/human branch we are currently working on:

and here is the changelist:

We already made a bunch of changes but the development is incomplete as we still need to implement the sayHello method.
However, someone made us notice the bugs on the animal package, and we need to fix them urgently (they are live in production!) before going ahead with humans.
We cannot operate on the current feature branch as it won't compile. What's more, the fix is not consistent with the scope of the branch and we don't want to create confusion by messing up the working tree.

Using Git Stash will solve our problems.

From the terminal, let's type the following command:

git stash save "human - TODO sayHello"

that will save our changes to the stash with a custom message, cleaning up the changelist so that we can switch branches without carrying around incomplete developments.

Now we can switch back to our main branch, start a new fix branch for animals, fix the bugs and merge it.

When finished, we can get back to the feature/human branch we were working on and type on terminal:

git stash list

that will print:

stash@{0}: On human: human - TODO sayHello

as you see, the stash area contains the changelist that we saved before and On human indicates we saved them from the feature/human branch.

to apply the changes again, we can use two alternative commands:

git stash pop

will retrieve the changes and remove them from the stash.

git stash apply

will retrieve the changes and keep the copy on the stash.

This second option is useful especially when we want to save specific "states" of the project before going ahead with other changes that will potentially break up things. It can be a lifesaver for delicate and complex developments as it allows to re-apply different versions of the changelist.

For example, let's say we want to try a different approach for the development to see if it works better. We might save the previous version of the changes, start the new approach and save the relative changelist as well on the stash.
Here is how our stash area might look like after that:

stash@{0}: On human: human - new approach
stash@{1}: On human: human - TODO sayHello

Let's imagine we showed both approaches to a senior developer for a review and we realise that the original approach actually works better than the new one. We can re-apply the first version state by typing:

git stash pop stash@{1}

if we also want to remove it from the stash list, otherwise:

git stash apply stash@{1}

if we want to keep a copy instead.

As you can see, the stash@{...} identifies specific states, and we need to specify it only if we are not aiming at the most recent state change.

To conclude with the basics of git stash, another command is worth mentioning:

git stash drop

that is used to remove a state change from the list. As for the pop and apply operations, without specifying the stash@{...} identifier it will remove the most recent changelist, otherwise we must specify it.

We came to the end of this brief explanation of a real world scenario where git stash can help you keeping your workflow cleaner, saving you from confusion and potential compiling errors as well.

As the title of this article states, use it and you won't regret.

Hope you enjoyed the article, feel free to leave a comment, your feedback is very welcome.

See you soon and keep stashing!

Polymorphism and abstract class easily explained in Java

Aldo Telese — Thu, 14 Mar 2024 18:22:47 +0000

Polymorphism is one of the main concepts behind OOP, together with encapsulation and inheritance. Despite its definition being pretty straightforward, you might struggle in understanding the reasons why it is used and the benefits it can lead to.

Polymorphism literally means that an object can take on many forms.

Here is a very simple example of a scenario where we can benefit from using polymorphism. We are going to make use of an abstract class for the purpose, taking the opportunity to explain this concept as well.

Let's say we want to make a class representing a human saying hello in its own language.

Since saying hello is very specific to the language spoken by the person, a good candidate to start with would be in fact an abstract class called Person, containing a method called sayHello to be implemented by concrete classes extending it (an EnglishPerson, an ItalianPerson, a SpanishPerson, etc.)

Here is our Person class:

public abstract class Person {
    public abstract void sayHello();
}

As you can see an abstract class generally contains one or more methods declared without an implementation.
Why? Because the class is too generic to have a single implementation, and it is expected to be extended by other classes that will then be required to implement such abstract method(s).

Let's create two more classes now: SpanishPerson and ItalianPerson:

public class SpanishPerson extends Person {
    @Override
    public void sayHello() {
        System.out.println("Hola");
    }
}

public class ItalianPerson extends Person {
    @Override
    public void sayHello() {
        System.out.println("Ciao");
    }
}

We have created two concrete classes extending our abstract class and implementing the single abstract method that was declared.

Now we can leverage polymorphism by writing this:

public class HelloDemo {
    public static void main(String[] args) {
        Person mattia = new ItalianPerson();
        Person dolores = new SpanishPerson();

        mattia.sayHello();
        dolores.sayHello();
    }
}

that will print:

Ciao
Hola

Basically with polymorphism we are able to assign a reference of a superclass to an instance of a subclass.
In our case, mattia and dolores are two references of the superclass Person, but in practice they are pointing to objects of type ItalianPerson and SpanishPerson, respectively.

To better understand the power of such concept let's introduce a new Greeter class containing a method that accepts an argument of type Person that will invoke its sayHello method as before.

public class Greeter {
    public void greet(Person person) {
        person.sayHello();
    }
}

Instead of creating two (or more) different greet methods, one with a parameter of type ItalianPerson and the other one with a parameter of type SpanishPerson, we can leverage polymorphism by using a single method with a parameter of the abstract superclass Person to which we can pass either an ItalianPerson or a SpanishPerson instance, just as shown below:

public class HelloDemo {
    public static void main(String[] args) {
        Person mattia = new ItalianPerson();
        Person dolores = new SpanishPerson();

        Greeter greeter = new Greeter();
        greeter.greet(mattia);
        greeter.greet(dolores);
    }
}

that again will print:

Ciao
Hola

making our code more extensible, reusable and clean.

Hope you enjoyed this short explanation of one of the core concepts of object oriented programming.
Please feel free to leave a comment for any feedback.

See you soon

A Simple Way to Check if a Word is Palindrome in Java

Aldo Telese — Wed, 08 Nov 2023 16:54:52 +0000

Racecar, Civic, Radar, Level, Kayak.

What do all these words have in common?
Try to read them backwards... did you notice anything? Of course you did!

A palindrome word is a word that reads the same backwards as forwards.

The scope of this article is to illustrate you a very simple yet effective way to recognize a palindrome word, using Java.

Let's first create a Palindrome class with a main method and an input string from above:

What we want now is to pass our input string to a method that will return a boolean: true if the word is palindrome, false otherwise.
We'll make this method static:

The logic we are going to use is very straightforward: we will divide the length of the input string by 2, and iterate over the string both forwards and backwards to compare, at each iteration, the couple of characters that we find. We will do that as many times as the number we obtained from the previous division.
What if the length is odd? We will round it down!

Let's pick for example the word kayak:
the length is 5. Dividing 5 by 2 will give us 2.5, namely 2 (we always round it down).
Since the result of the division is 2, we will do 2 iterations. At each iteration, we compare the two characters to the left and to the right of our string. If the two characters are not the same, it means the word is not a palindrome and we return false.
If the whole loop terminates without returning false, then we return true: the word is a palindrome.

Here is the code:

Note: in the case of a string with an odd length, just as in our example, the middle character will not be compared to anything, since there is no need to do so.
In our example, the code executed two iterations:

in the first iteration, character at index 0 ("k") was compared with character at index 4 ("k")
in the second (and last) iteration, character at index 1 ("a"), was compared with character at index 3 ("a").

An additional iteration would have compared the character at index 2 with itself, which is not needed. Therefore, the code we wrote makes the loop stop before this unnecessary computation.

Please remember to pay attention to case and word separators (in case of sentences). If we used Kayak as our input string, then the method would have returned false as "K" and "k" are different. The same applies when using sentences with whitespaces and punctuation, as they will affect the result. In these cases you need to take into account such additional elements, depending on the specific requirements.

Hope you found this article useful!
See you soon, and keep coding!

OOP fundamentals: what is a Class? The Talking Dog example

Aldo Telese — Sun, 02 Oct 2022 20:26:44 +0000

Understanding the meaning of Class is perhaps the very first step to take when diving into Object-Oriented Programming.

In this article we will use a very basic example written in Java to explain the concepts of Class, Object, methods and variables.

Let's consider the following sentence:

a dog called Muffin is talking.

In our fictional world, we know that:

there is a dog, our "actor"
the dog's name is Muffin
the dog is doing an action: talking

we can use Object-Oriented programming to describe the previous scenario in terms of code.

Breaking the scenario into actor and action, as we did, can help us better understand the meaning of Class and class method.

We can usually refer to the Class as being our actor, while the method describes some kind of action. Lastly, the variable can be seen as something that "belongs" to our actor.

Let's now convert into code what we have seen before, step-by-step, starting from our actor:

public class Dog {
}

we just created a class called Dog.
Forget about the public keyword, for now. Just assume that it means our class will be accessible from anywhere in our program.

Let's go ahead. We want to make it possible, for a dog, to have a name:

public class Dog {
    String name;
}

finally, our dog will be able to talk:

public class Dog {
    String name;

    public void talk() {
        System.out.println("Hello, I am " + name + " and I am a talking dog.");
    }
}

As for the public keyword, do not focus too much on the void keyword, it just means that our method does not return anything, it only prints something to the console. However, this will be covered more in-depth in another tutorial.

Here is a view of our project so far:

We are not finished yet! The thing is, what we did so far was only designing a blueprint for real-life dogs, without actually creating any of them.
And here comes the concept of Object.

An Object is a class instance.

In our example, it would be a dog "coming alive" with his own name.

Let's create a new class that we will call DogDemo.
This class will be responsible of using our Dog class to create actual dogs, making them talk as well.
The class will have a single main method to perform these operations.

Try to only focus on the content inside the main method (don't worry about all that strange keywords public static void String[] args, for now):

public class DogDemo {
    public static void main(String[] args) {
        Dog muffin = new Dog();
        muffin.name = "Muffin";
        muffin.talk();
    }
}

Inside the main method of our demo class, we just made a dog called Muffin come alive.
We created a new Dog() and assigned the name Muffin to his instance variable name.
Finally, we invoked the talk() method on the class instance.

Here is our updated project:

At this point, to see the output of our program, we need to run the main method of our DogDemo class.

Let's do that by using the command line.

From the root directory of the project, launch these:

cd src --> to place yourself on the source code directory
javac DogDemo.java --> to compile the source code
java DogDemo --> to execute the compiled code

Here is the result of running them from the integrated IntelliJ terminal:

As you can see, the final output is the one we were expecting: our dog talking.

Note that two new files appeared within our project: Dog.class and DogDemo.class. These were generated by the compilation command, and executed in the third step.

One last thing...

This example was intentionally simplified in order to convey the meaning of Class and Object. There are a few concepts that are missing, in addition to the mentioned ones, and above all: constructor, getters and setters, that will be covered very soon in another tutorial, by following the same example. They will specifically impact the way we created the Dog instance and assigned the name to our dog.

And that was our first dive into the world of Object-Oriented Programming!

Let me know if you found this example useful to grasp some of the basic OOP concepts, any feedback is welcome, just leave a comment below!

Happy coding