State is a term used in computer science that describes the current information of a system. A system is deemed “stateful” if it has the capacity to remember information from proceeding operations and user interactions. Examples of stateful systems include automata, computer programs, and digital circuits.<\/p>\n
That definition is analogous to the more formal version provided by Wikipedia.<\/a> It’s my opinion that such formal explanations often lack utility. State, as I’ve come to recognize it, is one of those topics that are so fundamental and broadly applicable that definitions are often tricky. That is; one can understand state<\/em> easily by example but putting formal words to it is tough. With that in mind, let’s consider some examples of stateful systems<\/strong>.<\/p>\n Social media applications typically allow the creation of user profiles. Let’s say we have an application called FaceBox (an obvious knock-off) that displays a list of all current users on the homepage. Fortunately, there are only 5 users currently.<\/p>\n When we log on we see a list of these 5 user profiles as deemed fit by the application’s front-end team. This is a visual representation of the application’s current data\u2014which can be recognized as its current State<\/em>. Here’s where things get tricky though.<\/p>\n The application’s State can be affected by any number of things<\/strong> including user interaction, network conditions, data corruption, or even inconsistencies in hardware running the system. At some point, one has to draw a line in the sand to determine what degree of state one is considering. Here are some examples that could change the state of our fictitious social media application:<\/p>\n These changes are but a few of many that could cause a state change in the FaceBox application. Modern systems, especially web-facing user-interacting ones, have a myriad of possible streams to initiate a state change. Extracting a definition of state can still be difficult here. Let’s consider an example with slightly more basic and fundamental components.<\/p>\n Functional programming can be defined as a declarative system by which all actions are purely deterministic and mathematical<\/a>. That means, given an identical input, a system will produce an identical output every time. Simply put; there is no state.<\/p>\n Imperative programming can be defined as an approach by which a series of statements are used to alter the state of a program<\/a>. This would include the updating of variables, associations, and even dependencies in an environment such as those provided by modern object-oriented programming languages<\/a>.<\/p>\n Consider the following Stateful class, having both functional and imperative methods:<\/p>\n In this example code, the Let’s walk through some of this code to illustrate the key portions demonstrating state.<\/p>\n In this line, we are displaying to the console the result of a simple a + b summation function. This line uses a static method, negating our need to have instantiated a That is; provide the system with the same input and one will get the same output each time. To solidify this concept consider re-running this line multiple times: the output will always be the result of the a + b values (3 & 6) defined just above it.<\/p>\n In this line, we are displaying to the console the result of a simple That is; changes in the With a brief understanding of how our Stateful object is designed, we can distill some meaning from seeing it in action. That is, we can understand how the state of the object influences the output in some cases. The code above generates the following output:<\/p>\n Note that on line 3 our program adds the values of a + b (6 + 9) and returns the value of 15. We wouldn’t actually need a method for this as Java (and any other programming language) provide built-in functions for simple mathematical operations like this.<\/p>\n On line 5, after announcing our magic number of 3, we use the On line 6, the value of the Line 7 reflects the output generated having used the Line 8 is where the magic happens. This number reflects the added value of 3 that has been added to our original A Social Media Application<\/h2>\n
\n
Objects & Functions<\/h2>\n
public class Stateful {\r\n\r\n \/\/ Declare a magic value\r\n int magicNumber;\r\n\r\n \/**\r\n * Basic constructor requiring an integer to be used as the magic number.\r\n * @param a int - value to be used as the object's magic number.\r\n *\/\r\n public Stateful(int a){\r\n this.magicNumber = a;\r\n }\r\n\r\n \/**\r\n * Returns the current value used as the objects magic number\r\n * @return int - an integer value\r\n *\/\r\n public int getMagicNumber() {\r\n return magicNumber;\r\n }\r\n\r\n \/**\r\n * Updates the current value used as the object's magic number\r\n * @param magicNumber int - the value to use during update.\r\n *\/\r\n public void setMagicNumber(int magicNumber) {\r\n this.magicNumber = magicNumber;\r\n }\r\n\r\n \/**\r\n * A simple function that calculates the sum of two integer values.\r\n * @param a int - the first integer\r\n * @param b int - the second integer\r\n * @return int - the sum of a and b, as an integer.\r\n *\/\r\n public static int addIntegers(int a, int b){\r\n return a + b;\r\n }\r\n\r\n \/**\r\n * A simple function that calculates the sum of two integers and\r\n * the current value used by the object as its magic number.\r\n * @param a int - the first integer\r\n * @param b int - the second integer\r\n * @return int - the sum of a + b + magicNumber, as an integer.\r\n *\/\r\n public int addIntegersStatefully(int a, int b){\r\n return a + b + getMagicNumber();\r\n }\r\n}<\/pre>\naddIntegers<\/code> method is static (a sign of being functional) and the addIntegersStatefully<\/code> is non-static (a sign of being imperative). These two functions can be further contrasted in that the use of addIntegersStatefully<\/code> requires an object of type Stateful<\/code> to be instantiated whereas the addIntegers<\/code> method can be accessed without such dependency. Consider the following code illustrating a possible usage of this class:<\/p>\n\/**\r\n * Driver class to illustrate the functionality of Stateful, its methods,\r\n * and how they represent a non-Stateful (functional) and Stateful (imperative)\r\n * design.\r\n *\/\r\npublic static void main(String[] args) {\r\n\r\n \/\/ Define our integers\r\n int a = 6;\r\n int b = 9;\r\n\r\n \/\/ Test functional method\r\n \/\/ Note use of static method here.\r\n System.out.println(\"a + b = \" + Stateful.addIntegers(a, b));\r\n\r\n \/\/ Test imperative method\r\n \/\/ Note use of object instantiation here, with specified magic number.\r\n Stateful stateObject = new Stateful(3);\r\n System.out.println(\"Current Magic Number = \" + stateObject.getMagicNumber());\r\n System.out.println(\"a + b = \" + stateObject.addIntegersStatefully(a, b));\r\n\r\n \/\/ Change the magic number\r\n stateObject.setMagicNumber(6);\r\n System.out.println(\"Current Magic Number = \" + stateObject.getMagicNumber());\r\n\r\n \/\/ Test functional method again\r\n System.out.println(\"a + b = \" + Stateful.addIntegers(a, b));\r\n\r\n \/\/ Test imperative method again\r\n System.out.println(\"a + b = \" + stateObject.addIntegersStatefully(a, b));\r\n}<\/pre>\nUsing a Static Method (functional)<\/h3>\n
System.out.println(\"a + b = \" + Stateful.addIntegers(a, b));\u00a0<\/code><\/p>\nStateful<\/code> object prior. Such use cases are strong indicators of aspects of a program that do not have state.<\/p>\nUsing a Bound Method (imperative)<\/h3>\n
System.out.println(\"a + b = \" + stateObject.addIntegersStatefully(a, b))<\/code><\/p>\na + b<\/code> summation as well, but this time we’re doing so via a method bound to the stateObject<\/code> instance of our Stateful class. Such use cases hint at the involvement of state such that our output will now be subject to changes in the state of our stateObject<\/code> instantiation.<\/p>\nstateObject<\/code> instantiation may alter the output of the addIntegersStatefully<\/code> method, even when given identical input (our a & b variables.) In the case of this particular object, we know that the instances magicNumber<\/code> will be added in succession with the supplied arguments a & b\u2014a change in that number (representing our object’s state) will alter the output.<\/p>\nExample Output<\/h3>\n
Value of a = 6\r\nValue of b = 9\r\na + b = 15\r\nCurrent Magic Number = 3\r\na + b = 18\r\nCurrent Magic Number = 6\r\na + b = 15\r\na + b = 21<\/pre>\n
addIntegersStatefully<\/code> and produce an output of 18, which represents a + b + 3; a value influenced by the\u00a0state<\/em> of our program.<\/p>\nmagicNumber<\/code> variable has been changed from 3 to 6.<\/p>\naddIntegers<\/code> method again, which ignores any state of our stateFul object. As expected, identical<\/code> output is produced from that prior to updating the magicNumber variable.<\/p>\nmagicNumber<\/code> value of 3. This is reflected in our final calculated output of 21 (15 + 6 instead of 15 + 3) and represents the impact of our object’s state on the resulting output given identical input.<\/p>\n