Developing a Mini Calculator Part -4

Hello, this is the final part of article on Developing a Mini Calculator. Here we will see how different modules interact with each other and the importance of central module called “Core” in detail.

About Core module in detail

As I mentioned in the previous topics this module is most important part of our calculator application, because it maintain the application state and do connect other modules with each other using messaging system. Input service, output service, calculation logic and history recorder send message to and receive message from core module. Core module do the state change using the messages received from input service and calculation logic.

How Core and other modules work together ?

Input Service generate message based on the key pressed by the user and send the message to core module. The message will have identifier to identify the message, key details. Core will process the message, do some state change and send required messages based on the state change to other modules. Below I will give you a example simple scenario.c

Example: “65+56=”

So once user press “=” operator key calculator should display result “121”.

  1. User enter key 6: This will send message to core module. It will be store as first operand
  2. User enter key 5: Since no operator is entered, core will append “5” to previously entered number “6” and make “65” the first operand
  3. User enter “+” operator key: When processing this key press, core will do a state ¬†that tell operator is entered now it will accept the second operand. If user press any other operator key to change the operation, this will be taken care by core module using the previous state change.
  4. The same way “56” will be accepted
  5. Now core have first operand, operator and second operand. If user press the next operator key (-,+,*,/), core will send a message to calculation logic including this details. Calculation logic do the required calculation and send back the result to core.
  6. The result given by calculation logic will be the new first operand. The same can be treated as final result as well based on the past input.
  7. In the above steps, core will send the state changes to output service. Output service will display the state changes received to screen.


Hope you liked the final part ūüôā .

Please access the previous topics here
Developing a Mini Calculator Part – 1
Developing a Mini Calculator Part – 2
Developing a Mini Calculator Part – 3

Developing a Mini Calculator Part-3

Hello, this is third part of Developing a Mini Calculator. Today’s topic will cover Input Service and Output service module. Please read Developing a Mini Calculator Part-2 for understanding about Calculation logic.

Input Service

Like I said in the first section, input service is responsible for two things and they are accepting right input and preventing user from entering an input that may cause application behavior inconsistent. Input service alone can take some decisions for preventing user inputs. But sometimes it is not possible and that decision making require application state.

Consider an example scenario “user pressing period or dot key”. I will explain how the decision making works

How input service alone take decisions?

  • When application start input service will unlock period key
  • If user press period key¬†input service will lock the period key
  • When user press period key it will send a message to core module saying user pressed period key

How input service take decision with the help of core module

  • When user press backspace key after pressing period key, input service will send a message to core module. Core module will understand that user pressed backspace key and so do a state change and send back a message to input service. So by identifying this message from core, input service can enable or unlock the period key.

Output Service

Output service is responsible for managing the screen and doing this by showing allowed application state to the screen. Output service will do this with the help of core, because core manage the application state.

Consider an example scenario “user¬†entering number ‘6.’ and press backspace key to delete the dot character”

Hitting backspace key will initiate a message from input service to core. Core do the necessary state change and send a message to input service. After this core will send a message to output service  to delete the dot character from screen.


  • Once messages are defined we can use it uniquely across all modules
  • Each module can be managed independently
  • Since communication across modules are achieved using messages, so maintenance is easy


Here ends the third session on mini calculator development. Hope you liked it ūüôā . In next topic I will explain about core module and communication between different modules using messages ūüôā

Developing a Mini Calculator Part-2

Hello, this is a continuation of article on Developing a Mini Calculator Part-1. In the first part I have explained about the components required for this application. Today we will see the implementation of Calculation Logic.

Note: I will be using Java programming language to demonstrate the examples

Calculation Logic

Since our calculator only support four operations and each of them take two operands and one operator it will be easy for us to write one single procedure or method which do all the necessary operation and return the result

public static double doCalculate(double operand1, char operator, double operand2) {
    double result = 0.0;
    switch (operator) {
        case '+': result = operand1 + operand2; break;
        case '-': result = operand1 - operand2; break;
        case '/': result = operand1 / opernad2; break;
        case '*': result = operand1 * operand2; break;
    return result;

The above given method is seems good but what will happen if you divide a number with zero. Yes of course division by zero is not possible. In that case what we will do. One way is to insert an error handling code that do the required when such and error comes. Again think of other scenario where the result is infinity or not a number. What we will do again insert some logic to handle that scenario.

Instead of keeping all calculations in one method we can separate them, like one method for addition, one four subtraction etc. Each of them will take three arguments and return the expected result.

public static double doCalculate(double operand1, char operator, double operand2) {
    double result = 0.0;
    switch (operator) {
       case '+': result = doAddition(operand1, operand2); break;
       case '-': result = doSubtraction(operand1, operand2); break;
       case '/': result = doDivision(operand1, operand2); break;
       case '*': result = doMultiplication(operand1 * operand2); break;
    return result;

private static double doAddition(double operand1, double operand2) {
    return (operand1) + (operand2);

private static double doSubtraction(double operand1, double operand2) {
    return (operand1) - (operand2);

private static double doDivision(double operand1, double operand2) {
    return (operand1) / (operand2);

private static double doMultiplication(double operand1, double operand2) {
    return (operand1) * (operand2);

Now we can manage each operation logic separately, say for division we can add extra error handling code

private static double doDivision(double operand1, double operand2) {
    double result = 0.0;
    try {
        result = operand1 / operand2;
    catch (ArithmeticException ex) {
        // set some flag to indicate this error
    if (new Double(result).isNaN()) {
        // set some flag to indicate this
        result = 0.0;
    } else if (!Double.isFinite(result)) {
        // set some flag to indicate this
        result = 0.0;
    return result;

If we look at the above program we will see two things. If the division leads to error we will set some flag and return zero. If the result is not a number or infinite we do the same. The flag might be some where else in the program. We have to introduce a state change some where out side the calculation logic. This is okay! because it doesn’t harm anything.

Instead of changing the state out side the calculation logic we can simply return the entire result out side the calculation logic. Say, the result, is it valid?, is it infinite?, is it an error. How we will do this?

public class Result {
    private double value;
    private boolean error;
    private boolean finite;
    private boolean nan;
    public Result() {
        // initialize to default
    // get and set methods will come here

We can create a new Result object to do this. This object will keep all the information related to the operation carried out. The Calculation Logic simply return the final result with necessary information to process the result. So an external module say Core can process the result as required without worrying about the calculations ūüôā

Calculation Logic: Do the required calculations and return the result
Core: Process the result and take the necessary actions

private static Result doDivision(double operand1, double operand2) {
    Result result = new Result();
    double value = 0.0;
    try {
        value = operand1 / operand2;
    catch (ArithmeticException ex) {
    if (new Double(value).isNaN()) {
    } else if (!Double.isFinite(result)) {
    return result;

Here ends the second part.¬†Hope you like it ūüôā

In the next part we will see the implementation of other modules.

Developing a Mini Calculator Part-1


Hello, today I will be talking about writing a simple mini calculator application which is capable of performing basic operations like addition, subtraction, multiplication and division.

The following are the application requirements

  • Addition, Subtraction, Multiplication and Division
  • Support for negative numbers and fractions
  • Record the operations performed by the user
  • Clear screen or history at any moment

Below is the possible structure of our calculator application based on the above requirement


In the above image we can see five modules and two end points. To give user the expected result a best possible connection or cooperation or communication between this five modules are required. Below we can find the details of each module

Calculation Logic

This is one of the main application modules. It contain a set of calculation logic. Since our calculator only have four operations defined which require two operands and one operator, the calculation logic will have three inputs.This will do the required calculation using the inputs and return the final result to Core module


This is where we maintain the application state. By state we mean the set of variables which makes application functional and so to give expected results. It will tell other modules do that or do this on demand. This is done by the use of state maintained in the core. Next application state will be a result of current application state and current user input. Simply states are memory of this application.

Input Service

This is responsible mainly for two related things, accepting user input and preventing user from giving a bad input. By bad input we mean any key press that will push the application into an abnormal state. Say for example you are entering a real number ‘65.06’. After entering six and five user may enter the period ‘.’ character twice. This is wrong because ’65..06 is not a valid number. So the second period is not valid and so we have prevent this. This service also manage the UI. All are done with the help of Core module.

Output Service

This module manage the state of screen or display and that is where we see the expected output based on our input. Core module will give the content to Output Service. By content we mean the state changes that are allowed to be on the display. Output Service is responsible to filter this public information from the content given by Core module

History Recorder

Responsible for recording the calculator history or simply it logs every right input which end up giving an expected result. Say ‘a + b = c’. it will record this as an entry in the log table

Here ends the first part. Hope You like it ūüôā

In the next part we will see¬†how to represent this things in¬†to object oriented program ūüôā


SQLite Programming in Java (Part 1)

This tutorial is an introduction to SQLite programming in Java and it explains how we can establish a connection to SQLite database from Java application.

About SQLite
SQLite is a software library which implements SQL database engine, which is self-contained and serverless means no server that needs to be started, stopped or configured and is zero configuration means no setup or installation required.

Using SQLite with Java
The below given program demonstrate the steps required to establish connection to the sqlite database. For the sake of simplicity i have divided the program into different parts.

import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.SQLException;

About DriverManager class
It is responsible for managing Java DataBase Connectivity (JDBC) drivers.

About Connection class
To establish connection with the database, java applications which make use of JDBC API has to obtain instance of Connection class first. The DriverManager class provides getConnection(String url) method which will create and return a Connection object. The url provides a way to identify the database using a protocol. The URL format for SQLite is given below.


In the above url you can replace string “dbname” with your database¬†name. SQLite database is a file which ends with a “.db” extension and it¬†will be cross platform.

About Statement class
Once you obtain connection to database, your next job is to create an instance of Statement class. Statement objects are used to obtain results by executing static SQL statements and they can be used to execute both Data Definition Language (DDL) commands and Data Manipulation Language (DML) commands. Statement class provides executeQuery(command) method to execute DML commands and executeUpdate(command) method to execute DDL commands.Simply statement object send the commands to the database and get results back.

The below given code block shows, how we can integrate this two together.

connection = DriverManager.getConnection("jdbc:sqlite:test.db");
statement = connection.createStatement();

Why do we use forName(url) method
The forName(url) method is used to load any class whose complete name is specified as the url at run time. Here this will load the JDBC class from org.sqlite package.

What goes wrong and how should we treat them

  • When we call the forName(url) method, if the class is not available at run time it will throw ClassNotFoundException
  • When we call getConnection() method, if the url is null or any access error occur this will throw SQLException
  • When we call createStatement() method, if there are any access error occur or a¬†closed connection this will throw SQLException

So we must write this three statements inside the try-catch-finally block.

How to close the connection and quite the application
Its simple, we close active statement and connection. Both Connection class and Statement class have a method called close() which releases connection or statement object’s JDBC and database resources once called. First you should close the statement by calling¬†close() method of statement object and then close() method of connection object. The reverse order is not recommended.

Please find below the complete sample program

import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.SQLException;

public class SQLiteJavaDemo {
    public static void main(String[] args) {
        try {
            Connection con = DriverManager.getConnection("jdbc:sqlite:demo.db");
            Statement st = con.createStatement();
            System.out.println("Connection created.");
            System.out.println("Connection closed.");
        } catch (SQLException | ClassNotFoundException ex) {

In Part-2 we will see how to use statement object to execute sql commands.