The state of things

Implementing behavior using state machines.

Systems sometimes have to exhibit some kind of behavior that is different observable output over time. This is different from a pure function, which will always produce the same output for the same input. The behavior differs depending on the 'history' the system experienced, typically in the form of 'events' or method calls that happened over time. Such method calls change the state the system is in. We call such behavior state-full and this way of operating is often implemented using a 'state machine'. In this week and in the AADE course we will be using two concepts:

A state machine is a software concept used to implement the behavior of something whose 'reaction' or outcome depends on the events that happened over time. A very simple example is a lamp and a switch. When properly connected and none of the parts is defect, the bulb will light up when the switch is in the on state. As state machine: the switch passes current when it has been turned on, which can be expressed as a turn-on event, making the bulb light up. From the diagram it should be obvious that a current can only flow if the switch is in the on (or closed) state.

In software we model this as the path the code takes, which then depends on some condition or value.

The state diagram is a way to express the behavior in a graphical manner. Each state of the system is drawn as a box with rounded corners, like in the diagram above. In the GoF State pattern, which is an object oriented way of modeling state behavior, one uses different objects to realize the effect of changing the software path. The objects all implement the same interface, but have a different implementation. Then, whenever a state switching event occurs, the current state object is replaced by the state object for the new state.

From AADE course, we learned that a life cycle of a system changes throw using by so called transitions. To change the state from wait to lock, trigger event was needed with a guard (condition) and then we did some activity.

As another analogy, you can think of a railway switch. The active state object will always have the same behavior. One makes the train go straight, the other makes it go right. Each state on itself always does the same, like a pure function, so with the same input (train) the same output is produced. The switching between states makes it possible to control the direction of the train traffic.

State machines or state charts can be implemented in several ways. In this week we will apply an OO approach using the well known State Pattern , combined with enums and some Java 8 features, in particular default methods.

The State Pattern has the following UML class diagram:

We deal with a context, an abstract state and multiple concrete state implementations that do the work and represent the state elements in the diagram. In the diagram above there would be a state instance for both ConcreteStateA and ConcreteStateB. In the implementation of the exercise of this week we will be using enum as the basic construct for our work.

Using a functional state approach by using enum has the following advantages:

The disadvantage of using functional states in this way is that they cannot keep information themselves, such as counting something. But quite often the counting involves only a few possible values, which can be states themselves, or can be realized in the context. As an example for few counting states you might consider a traffic light which counts green, yellow, red.

    StateMachine(){
      this.initialState = State.IDLE;
      this.initialState.enter( this ); 1

    }

The problem is that the constructor may not yet be complete, in particular when fields are defined and initialized later in the constructor or even after the constructor definition.

To avoid this problem, you typically have some init() method that should be called after construction or use a factory method that does something similar. In the gumball machine we chose the later. You can find the details in the javadoc documentation of the exercise.

StateMachine(){
  this.initialState = State.IDLE;

}

StateMachine init(){
  this.initialState.enter( this ); 1
  return this;
}

    StateMachine sm = new StateMachine().init();

State machines and regular expressions

You can find a lot on the relation between state machines and regular expressions. In most cases, including in Java, the regex is translated or compiled into a statemachine (just) before matches are attempted.

A nice illustration is given by the REGEXPER website, that turns a regex into a railroad diagram. This make the understanding of a regular expression way easier.

A simple regex : Dutch postal code: "\d{4}\s[A-Z]{2}"

GitHub for simple regex tester

The postcode railroad diagram reads as a digit followed by 3 more digits, a space, a letter and one more letter.

// note that you can break off the regex in java and intersperse it with comments.
String emailRegex=
      // quite some rubbish before the at sign
     "^[a-zA-Z0-9.!#$%&''*+/=?^_`{|}~-]+"+
     "@"+ // the at sign followed by a more restricted set of chars,
          //  with some lengths restrictions
     "[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?"+ // optional non capt grp
     // any number of letter-number combos
     "(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$";

Note that there is not one TRUE regex for email addresses. If you want to know the nitty-gritty details of valid email addresses look at RFC 8398 or RFC 5322, or ask in CSAR class.

Regular expressions

An often heard saying is: When you have a problem that can be solved with a regular expression, you actually have two problems, the problem and how to write the expression.

There is indeed some truth in the saying: Regular expressions can be hard to read (and hence maintain), and sometimes hard to write as well.

The problem lies in the fact that the format of the most popular form, the Perl dialect, is quite terse. However you can do quite a few things to improve at least their readability.

Matches, Matchers, match Groups, and group names.

The java.util.regex package contains the classes to work with regular expressions. The most important are the Pattern and Matcher classes.

A Pattern is a compiled representation of a regular expression. It is used to create a Matcher object that will match the regular expression against an input string.

In a pattern you can define groups of interest, for instance values that you want to extract from the input string. The Matcher object will then contain the groups that were found in the input string. You create a group by surrounding the part of the pattern with parenthesis.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        String input = "The quick brown fox jumps over the lazy dog";
        String pattern = "The (\\w+) brown (\\w+) jumps over the (\\w+) dog"; 1
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(input);
        if (m.find()) { 2
            System.out.println("Found a match");
            System.out.println("Group 0: " + m.group(0)); 3
            System.out.println("Group 1: " + m.group(1));
            System.out.println("Group 2: " + m.group(2));
            System.out.println("Group 3: " + m.group(3));
        } else {
            System.out.println("No match found");
        }
    }
}

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        String input = "The quick brown fox jumps over the lazy dog";
        String pattern =
                      "The (?<first>\\w+)" // comment 1
                      +" brown (?<second>\\w+)" // comment 2
                      +" jumps over the (?<third>\\w+) dog"; // comment 3
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(input);
        if (m.find()) {
            System.out.println("Found a match");
            System.out.println("Group 0: " + m.group(0));
            System.out.println("Group first: " + m.group("first"));
            System.out.println("Group second: " + m.group("second"));
            System.out.println("Group third: " + m.group("third"));
        } else {
            System.out.println("No match found");
        }
    }
}