The first thing that we need to understand is that how methods receive and return inputs and outputs (IO). This is very important. The working of a method can be broadly divided into two types of tasks. One is to handle IO. The other is to manipulate inputs to generate outputs. This article particularly reflects on the first part i.e. how a method deals with IO.

To understand this, it will be very nice to remind ourselves that in Java all arguments to a method are passed by value. What this literally means is that if we have a variable ‘x’ to which we have assigned a value of ‘6’, and if we pass this variable as an input argument to some method (e.g. insertX(x)), then its value (6) is passed to the method call insertX(x);.

This is true about all sorts of method calls in Java, and all sorts of data types including primitive and abstract. But we need to understand a few more things about abstract or user-defined data types.

Consider the following variable declaration in Java:

int x=5;

The above declaration creates a variable of type int and assigns it a value of 5. x goes on the stack.

Now consider the following variable declaration:

MyDataType data;

The above declaration creates a variable of type MyDataType, which is essentially a user-defined data type. What is ‘data’? Well, data is a variable. Where is it located? It is located on the stack. What is its value? It hasn’t been assigned any value yet. How to assign a value to it? Following is the procedure for that.

data= new MyDataType();

What we have done above essentially is that we have created an object of type MyDataType (on the right-hand side of the expression). This object is allocated memory on heap since this is dynamic memory allocation (all dynamic memory allocation is done on the heap). The object does not have any name as such. However, it does have an address. And its address gets assigned to ‘data’ (left-hand side of the expression).

So the value of ‘data’ now is the address of the newly created object of type MyDataType.

Now, consider a method that accepts an object of type ‘MyDataType’. Let us consider the following method, for instance.

public class Example{
//
//

public MyDataType insertData(MyDataType data){
//
//
return data;
}
}

The method ‘insertData’ accepts an argument of type ‘MyDataType’. It also returns an argument of type MyDataType.

Now consider the following method call.

MyDataType data2=insertData(data);

where data is the variable mentioned and explained two paras above. Since Java is pass-by-value,  when we pass ‘data’ to ‘insertData()’, essentially we are passing the value of ‘data’ to the latter. But what is the value of ‘data’? Its value is the address of the object of type ‘MyDataType’, to which it is referring.

So the crux of the story is that when you are passing arguments of user-defined data types to Java methods, you are not passing the objects as such. In stead of this, you are actually always passing references to those objects. The actual objects keep on lying on the heap. Their references, that are stored in variables of the same type that are on stack get passed to methods. Same is true about return values. Objects are never returned. Instead, their references are returned. Through the references, objects can be manipulated as they keep lying on the heap.

This idea and its understanding can have a profound impact on your programming skills. Once you have developed skeleton code, the next thing you have to deal with is IO in methods. Once this is understood, rest of the stuff becomes easier to comprehend and implement.

Photo by Plutor

The idea I have is to port this to GroovyLab. Groovy is a java-like scripting language. Moreover, all valid java code is also valid groovy code. Add to this the fact, that despite being a scripting language, and requiring an interpreter, Groovy code can also be pre-compiled and run on JRE.

Once GEVA is ported to GroovyLab, the resulting package can be run on Octave or Matlab. It is not necessary, however, to port the code to GroovyLab. GEVA can be wrapped into Groovy and pre-compiled. The code can then be called in Octave or Matlab. Having GE available in Matlab would mean that it would be easier to use it for research.

No Title

Grammatical evolution | IEEE Journals & Magazine | IEEE Xplore

Click to access tutorial.pdf

UCD NCRA – Software – GEVA

GEVA is no longer maintained. We keep the page below for archival reasons. PonyGE is the implementation of choice in our group. GEVA is an implementation of Grammatical Evolution in Java developed at UCD’s Natural Computing Research & Applications group. As well as providing the characteristic genotype-phenotype mapper of GE a search algorithm engine, and GUI are also provided.

Groovy

The latest innovations from dozens of Apache projects and their communities in a collaborative, vendor-neutral environment. There is a 2-day Groovy track covering latest news, testing and functional programming with Groovy, Spock, Grails, Micronaut, GORM, Gradle, DSLs, using Groovy for data science, with Apache Ignite, with Kubernetes, and more.

Photo by steve p2008

A long time ago I came across tools that generate code through UML diagrams. Using such tools, you design the software using a computing tool with drag and drop features. Once you are done with the visual design, you could generate the corresponding code using clicks of a few buttons. I was wondering what is the state of the art right now.

The truth is that there is a whole bunch of tools and plugins available that integrate with famous IDEs like Netbeans and Eclipse. You simply have to drag and drop a visual design and they produce the corresponding skeleton code. The only job you are left with is to plumb the code together. Here are a few nice links.

http://plugins.netbeans.org/plugin/55435/easyuml

Here is a nice video tutorial about using easyUML.

Here is another nice UML plugin that works with earlier versions of Netbeans. It might not be very useful though.

http://plugins.netbeans.org/plugin/1801/netbeans-uml

https://blogs.oracle.com/JavaFundamentals/entry/generating_uml_from_the_netbeans

How to Draw UML Diagrams in NetBeans?

Quick NetBeans tutorial for modeling, code engineering and ERD design. Learn it today, with this step-by-step NetBeans tutorial. Feature rich and awarding-winning tool, try free!

Here is a plugin that works with Eclipse.

https://marketplace.eclipse.org/content/uml-java-generator

Photo by mikie t

This tutorial on tutorials-point is possibly the best thing I have come across about JUnit.

JUnit Tutorial

JUnit Tutorial – JUnit is a unit testing framework for Java programming language. JUnit has been important in the development of test-driven development, and is one of a family of unit testing frameworks collectively known as xUnit, that originated with JUnit.

This is a very nice tutorial that tells you how to use JUnit in netbeans. This will make your life a lot more easier.

https://netbeans.org/kb/docs/java/junit-intro.html#Exercise_31

Photo by Kieran Clarke

I was reading about design patterns and abstract classes came up. I thought that I should read more about abstract classes. And as I read about them, I thought why, then, do we need interfaces. So this article basically contains links that I found useful about abstract classes and interfaces.

A fair comparison between abstract classes and interfaces is in the following tutorial.

Abstract Methods and Classes

This beginner Java tutorial describes fundamentals of programming in the Java programming language

Photo by Thorsten Haustein