1. Java Style

Java is a language (sort of anyway) and languages come with a culture. One such cultural aspect is the way you format your code, like placing your brackets, parenthesis, spaces and curly braces. This coding style is intended to help you read the code, recognize the structure at a glance and find the interesting details easily and spot on.

The official Java style is derived from the Kernighan and Ritchie (K&R) style for the C programming language. Since syntactically Java inherits quite a lot from C, that would be logical choice.

The current and preferred way of using this java style is best described in the Google Java Style Guide.

1.1. Where have you put your Curly Braces.

Most holy wars are fought over the placement of the curlies '{}', and in some cases other brackets [] or parenthesis () and <> too. In particular: Put them at the beginning of the line or at the end. The Java Style Guide is quite clear about that: Braces.

My personal motivation would be: If your understand that C and Java are block oriented languages, then you immediately will understand that placing a brace at the beginning of a line can only mean that you start a new block. This allows you to define a local scope. This is what you already know from for loops. Well the loop need not be there to allow yourselves to have some very local variables, like in the example below.

If you understand this block aspect of the K&R style, you know that you do not have to search for the name of a method, a class start or anything else. The block is just a block with local scope. It helps readability, because you can define your local variables at the place your need them and confine them there, without having the locals interfere with anything else in the method or class.

example of block with scoped local variable
        {
            int i=0;
            // do something with i
        }

This often overlooked feature can help big time to help improve the readability of your code, in particular when the method is getting big. But since having big methods is a bit of a no go area in a modern programming style.[1], your rarely see it in practice.

In Java there is also another reason. You can have blocks at the class level, which allow you to define some kind of anonymous constructor. Remember Anonymous Inner Classes? Well, sometimes you want to have a constructor, just to initialise things. Here is an examples from the Java FX binding chapter.

initialize a binding in an 'Anonymous' constructor, lines 10..12, which is a block with no name…​
    public static void main( String[] args ) {

        final DoubleProperty a = new SimpleDoubleProperty( 1 );
        final DoubleProperty b = new SimpleDoubleProperty( 2 );
        final DoubleProperty c = new SimpleDoubleProperty( 3 );
        final DoubleProperty d = new SimpleDoubleProperty( 4 );

        DoubleBinding db = new DoubleBinding() {

            { (1)
                super.bind( a, b, c, d );
            } (2)

            @Override
            protected double computeValue() {
                return ( a.get() * b.get() ) + ( c.get() * d.get() );
            }
        };

        System.out.println( db.get() );
        b.set( 3 );
        System.err.println( db.get() );
    }
1 Start of anonymous block in line 10.
2 End of anonymous block in line 12.

So whenever you find a closing bracket, you only have to look up in the same column to find what it belongs to. If you find the start of a method, then that’s what its is, if you find an opening bracket, stop looking, you have found its meaning, a block.

2. Code Coverage in NetBeans IDE

2.1. What is Code Coverage?

To see if your tests use all the code your write, you can add a plugin to netbeans that can show so called coverage data. Coverage is the percentage of lines and branches that is executed, shown in a report and in the IDE.

In this case a red (red background) means the code was not executed.

workercoverage
Figure 1. coverage when testing only the lucky path

2.2. How to install a code coverage plugin in NetBeans

The plugin is called TikiOne JaCoCoverage and can be installed form NetBean’s default plugin repository. Read JaCoCoverage as Java Code Coverage.

Use the NetBeans Plugin Dialog to add it to your own installation.

tikioneplugin
Figure 2. plugin dialog of installed TikiOne JacocCoverage plugin

A plugin like this will be available on the exam stick as well, so use to your advantage.

3. Adding your own code templates to NetBeans IDE

Productivity can be helped big time, if you add code templates to netbeans. Quite a few are predefined but you can add your own too.

Go to Tools > Options > Editor > Code Templates.

You get this dialog:

codetemplatedialog

You can add one with the new buttpn, Duh.

I find this one quite convenient:

definition of my codetemplate jutm
@Ignore("//TODO Think TDD")
@Test
public void test${Method}() {
    ${cursor}
    Assert.fail("test method test${Method} reached its end, you can remove this line when you agree.");
}

Note that @Ignore is a tag that is only used when writing all test bodies beforehand. Once you start writing the test, you should remove or comment (best) the @Ignore to make the test effective.


Adding Code templates

4. Maven

From week two onwards we will use Maven as the preferred build tool. The link in the previous sentence points to the very readable complete reference manual, which also has some pointers for beginners, might you categorize yourselves as one.

4.1. Maven Repositories

A maven repository is a server that provides ready built maven 'artifacts', such as (binary) jar files containing libraries, frameworks or APIs and in many (but not all) companion jar files containing the javadoc (often) and sources of the same binary. A maven repository is NOT a source code.[2] management system (CMS), although it typically holds several versions of a binary, and there are tools, such as Nexus Repository Manager.

There is a default repository, called maven central. You (as a team or company) can have your own repository. We at sebi Venlo did that, too. Our repository lives at https://www.fontysvenlo.org/repository.

Our sebi Venlo maven repository at fontysvenlo is the simplest of simple: A plain (apache2) web server that does automatic indexing. Users with write access, such as your dear teachers (:P), can simply publish their maven artifacts using maven itself, which, with the help of secure copy, places the artifact in the appropriate directory structure, considering names and versions.

If you look at a maven repository you will see that it is organized along the three axes: groupId, artifactId and version.

4.2. Maven Settings

To make the sebi Venlo repository available for your own projects, add the following to your ~/.m2/settings.xml in the profiles section. You may also want to make that profile active.

If you create or open a maven project in NetBeans and open the Project Files folder, it should show a settings.xml file. If not, you can easily create your own in the proper spot on you platform (Linux, Windows, Mac OS-X) by right-clicking on the folder and choose create settings.xml. The settings file applies to all your maven projects, irrespective of the fact of using maven from the IDE or the command line.

create setting xml
Figure 3. creating settings.xml
adding fontysvenlo repo to your maven settings.xml file.
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
    <profiles>
        <profile>  (1)
            <id>sebivenlo</id>
            <repositories>
                <repository>
                    <id>fontysvenlo.org</id> (2)
                    <url>https://www.fontysvenlo.org/repository</url> (3)
                </repository>
            </repositories>
        </profile>
    </profiles>
    <activeProfiles>
        <activeProfile>sebivenlo</activeProfile> (4)
    </activeProfiles>
</settings>
1 You define a profile inside the profiles section of your settings.xml.
2 Give the profile a name.
3 Specify the URL.
4 Use the given name to make it an active profile by default.

You could of course also simply copy (ctrl-C) the xml above and slam (ctrl-V) it into your newly created settings.xml file.

4.3. Sebipom

Spelled all lower case: sebipom, is a super pom to use in Fontys Venlo projects. It keeps your own pom.xml file simple and focused to declare just the dependencies you need. Niceties to do proper Test Drivern Development are provided for in the sebipom definitions, including things as being able to create javadoc in a professional way, including code snippets, checkstyle, reporting, code coverage with maven etc. Sebipom is hosted on github as part of statewalker.

Note that I am using a separately installed maven (3.5.3 at the time of writing) which you can download from apache maven, not the one bundled with netbeans. You can tell netbeans (via tools→ options →java→maven) to use the installed one instead of the bundled one.

Doing this gives you the access to sebipom, which defines a parent pom for projects. This again provides some goodies that you would otherwise have to provide yourselves.
Such a parent pom is similar to a super class in Java; your pom inherits all the traits of the parent.
Including that parent is simple. See below for the sebipom (version 1.3.4).

setting sebipom as parent.
    <parent>
      <groupId>nl.fontys.sebivenlo</groupId>
      <artifactId>sebipom</artifactId>
      <version>1.4.2</version>
    </parent>

Some of the starter projects we provide already use this parent. To get those working, apply the settings above.

If you want to use sebipom in your own project, either copy the parent definition into the pom file or start by replacing the NetBeans provided pom.xml file in your project by the basic one below. Add dependencies as required.

basic pom.xml file setting sebipom as parent.
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>nl.fontys.sebivenlo</groupId>
    <artifactId>basicsebimaven</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>
    <parent>
        <groupId>nl.fontys.sebivenlo</groupId>
        <artifactId>sebipom</artifactId>
        <version>1.4.2</version>
    </parent>
    <!-- The name in the IDE -->
    <name>My App</name>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>

        <!-- change mainClass to the proper starting point of your program, if any.-->
        <mainClass>basicsebimaven.Hello</mainClass>
        <pitTargetClasses>shoppingcart.*</pitTargetClasses>
        <excludedMethod>**.#hashCode</excludedMethod>

    </properties>
    <dependencies>
      <!--example  -->
      <dependency>

      </dependency>
    </dpendencies>
</project>

4.4. sebipom and Java FX

If you want to use semipom to build a JavaFX project, you need to activate the fx-profile. In the commandline that would be

mvn withfx profile
Figure 4. commandline]. Real software engineers can use the command line.

In netbeans you can do that by setting the configuration like in this picture:

fx profile nb
Figure 5. activate a profile in netbeans

5. Maven on Steroids or: use it properly

Sometimes you think, maven is not your thing because it is slowing you down, certainly if you are trying to work your way through your code TDD style: Write test, run test red, implement code, run test green, be happy.

But reconsider: Maven takes it’s job very serious, but since it is a computer program it stubbornly stupid, so it might be that you are using it in a wrong way.

Let me explain what maven does:

  • maven uses build phases: initialize, compile, compile tests, run tests, package the application etc., when you build your application. It will check if all is in order, look if any updates are needed etc. This keeps maven busy and you waiting.

Packaging (which is what you do when you click build in the IDE) the application and
is only useful when your are really done: all tests are complete and the code turns them a nice green.

  • So do not mvn build, but instead mvn test, then maven will do the minimum required.

So if you are in the habit of clicking build and then run your tests, you might want to change you habit.

5.1. Maven the proper way, when still in the TDD phase

As long as you are writing test and writing code, just do:

mvn test, or the equivalent in you IDE (click the test button, not the build button)
or mvn clean and then mvn test. (click clean, click test).

Only when you are done with all your tests, do

  1. clean (mvn clean)

  2. build (mvn package mvn -P fx package for fx projects)

and then run your application.

Then maven can do all of it’s serious work of assembling your application for deployment

TODO maven tweaking…​..


6. Maven Modules

Many projects will have more than just one component (jar or war file).

It is a good idea to reflect this design in the way your structure you source code: Use multiple modules.

6.1. Module

A module is just a maven project. Has a pom.xml which defines the relation with other modules.

mavenmodules
Figure 6. modules and parent.

As you see in the figure, the parent lists its children. The children may have inter-dependencies. Otherwise it is just plain maven.

snippet from a parent pom
    <groupId>nl.fontys.sebivenlo</groupId>
    <artifactId>parentpom</artifactId>
    <version>1.0</version>
    <packaging>pom</packaging>
    <properties>
      <version>1.0</version>
    </properties>
    <modules>
        <module>entities</module>
        <module>db</module>
        <module>app-logic</module>
        <module>ui</module>
        <module>restserver</module>
    </modules>

As is usual between parents and children, there is an inheritance relationship. The children inherit setting and groupid, and version, if defined as a property.

Do not declare dependencies of the children in the parent pom, because that introduces a cycle in the dependencies: parent depends on child, which depends on parent, which depend …​. etc.

The parent pom can declare all external dependencies, that are shared between the children, such as the testing frameworks, any other external dependencies. The parent can declare its own parent, allowing it to inherit and pass on anything that inherits from such parent.

The parent defines the packaging as pom, the children what ever is required, typically jar, war, or ear.

example pom for rest server.
<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>nl.fontys.sebivenlo</groupId>
        <artifactId>parentpom</artifactId>
        <version>1.0</version>
        <relativePath>..</relativePath>
    </parent>
    <artifactId>restserver</artifactId>
    <version>${version}</version>
    <packaging>war</packaging>
    <name>Rest server</name>
</project>

Putting things in modules has the following advantages:

  • It promotes loose coupling.

  • It can avoid the hen and egg problem: In a normal build, it wants all tests to pass, to be able to continue. For business code that is correct, but things like integration tests need a built war file, which cannot be built with failing tests.
    Solution: Put the integration tests in a separate module of its own, which can be run at any time and will not slow you down or worse, disable testing or not having any tests.

7. Flex Your Java Muscles

No, it is not about heavy lifting. It is about reconfiguring your Java environment easily. It also assumes that you are in the habit of using the command line over the GUI.

Sure, a GUI is 'user friendly' if you are willing to look for the things your want to use, and know where you need to look for it. But what about the computer listening to you for a change, instead of you having to scroll through its wealth of options and other stuff you may have installed.

This is a POSIX hack, meaning that it applies to Linux and to Mac OS-X (with a little tweaking) alike. It may also apply to Windows when using git-bash, MINGW, Powershell or the 'Linux extensions for windows'. You mileage may vary though.

7.1. Concepts used

  • $PATH The PATH environment variable that determines the way programs are found in the command line.
    all commands that you can enter on the commandline are found using the $PATH variable.

  • $JAVA_HOME The environment variable that tells where your java installation lives. It is used by apache-ant (ant) and apache-maven (mvn) alike.

  • You set these variables in your start-up script, like .bashrc.

  • You use aliases to abbreviate your commands.

  • You start the IDE from the command line. Always, so YOU are in control of where and how it’s started.

The whole operation involves three modifications:

  1. Set the variables in your ~/.bashrc.

  2. Add a helper script, called J, put it in a directory in your PATH. ${HOME}/bin is a good place, if that is on your path.

  3. Create aliases, to make typing the command simple, like j8 to switch to Java 8 and j12 to do the same for Java 12.

7.2. Setting in startup script

setting JAVA_HOME and PATH in ~/.bashrc
## DEFAULT IS JAVA 8 HERE
export JAVA_HOME=/usr/lib/jvm/java-8-oracle
export PATH=${JAVA_HOME}/bin:$PATH

7.3. Switching to other Java version

updating JAVA_HOME and PATH to switch java version.
#!/bin/bash

## This script assumes that the JAVA_HOME environment variable is set
##   and that the PATH contains ${JAVA_HOME}/bin
## The java variant that is to be put in JAVA_HOME and PATH is determined
##   by how what this script is called.
## J8 for Java 8, J11 for Java 11 and J12 for Java 12. It could easily be
##   extended to include Java 9 and 10 too, buy at the time of writing I see
##   little point because 12 is the current open JDK and 11 the LTS version.
##   J8 is in because it is the default for many still.
##
## You typically have (sym) links pointing to this script, so it appears
##   to have different names, changing its meaning.
##
## Usage: eval $(scriptname) e.g. eval $(J12)
## By using  bash aliases, such as alias j8='eval $(J8)' the use of
##   this script will become a feast.


## get this script name
thisname=$(basename $0)
## get the current path setting
OPATH=${PATH}

## Let my name do the choosing
case ${thisname} in
    J8)
	NJAVA_HOME=/usr/lib/jvm/java-8-oracle;;
    J11)
	NJAVA_HOME=/usr/lib/jvm/jdk-11.0.2;;
    J12)
	NJAVA_HOME=/usr/lib/jvm/jdk-12;;
    *)
	echo call me as 'eval $(J8)', 'eval $(J11)' or 'eval $(J12)'
	exit 1
	;;
esac

## edit path to use the new java_home
p=$(echo ${OPATH} | sed -e "s@${JAVA_HOME}/bin@${NJAVA_HOME}/bin@")

##
echo export JAVA_HOME=${NJAVA_HOME}
echo export PATH=${p}

7.4. All made simple with aliases

You can tie this all together with some aliases which classically are stored in a file called ${HOME}/.bash_aliases and are loaded on login and each time you open a terminal.

using aliases to switch with simple command. Excerpt from my .bash_aliases file.
alias j12='eval $(J12)'
alias j11='eval $(J11)'
alias j8='eval $(J8)'
j8j11 terminal
Figure 7. see it all work

As you will notice, switching Java versions in this way is very fast.




1. if your method gets big, you should break it up in smaller parts, like private methods
2. Guess why