This seems to be an appropriate time to introduce anorganisational construct which is integral to today’s
programming languages - the notion of a block. We will
start with introducing a simple view of a block and
expand it gradually later on.

As you may have observed, our programs are getting larger
in the sense of number of statements and more complex.
When you write long documents, you dont string every
sentence one after another in a series in a flat list;
we gather sentences into paragraphs, paragraphs into
subsections, subsections into sections, sections into
chapters, and so on. This helps us to comprehend the
structure of a document relatively easily. Imagine figuring
out where is something if a 200 page book was just one
paragraph. A block in a program is like a paragraph.

Normally a paragraph denotes one idea. Though there are
no laws in this regard, it is the recommended practice.
Good documents follow this. Similarly, what you put in
a block must be related set of statements. Neither the
programming language, nor the compiler would do anything
to enforce this. But programs that dont follow this tend
to be nightmares for those who need to deal with it later
on - including the developer who wrote it!

More than convenience, there are situations where such
grouping is necessary. Let us look back at our if-statement.
Suppose, there are more than one action to do when the
condition is true/false. For example, if k > 10, then
set i and j to 1. We may write this as:

    if (k > 10)
       i = 1;
       j = 1;

This actually won’t work, because this does not indicate
that j = 1 is to be done when i = 1 is done, and not otherwise.
The system assumes that i = 1 is to be done when (k > 10) is
true. But j = 1 is assumed to be a statement following the
if-statement.

In other words, the ‘then’ part of the if-statement is
assumed to be a single statement. To put multiple statements there,
we need a grouping device. A block is best suited for this.

What does a block look like? It is a collection of statements,
surrounded by a start and end indicator. Java uses ‘{’ and ‘}’
as the block start and end indicators. So,

  { i = 1;
    j = 1;
  }

is a block. In general, in Java, as well as in most languages, a
block is allowed wherever a single statement is allowed. So, our
if-statement should be written as:

    if (k > 10)
       { i = 1;
         j = 1;
       }

The choice of where to put the braces is left to you. Choose a
convenient convention, and use it consistently. Readability, space
usage, etc are some of the considerations in choosing a convention.
Here are some common variants, in the case of an if-statement:

 if (k > 10) {
       i = 1;
       j = 1;
 }

 if (k > 10)
 {     i = 1;
       j = 1;
 }

 if (k > 10)
     {
       i = 1;
       j = 1;
     }

Coming back to our if-statement, with the block structure, the statement
does what we wanted it to do. See the two code segments together and
understand the difference.

 if (k > 10) {                if (k > 10)
       i = 1;                     i = 1;
       j = 1;                     j = 1;
 }

There is more to block structure, that we will see later.

In the previous post, we saw the basic nature of conditionals in programming languages. Some way to handle conditional is essential in any programming language. And most of the languages represent them as some variant of if-then-else. Some languages abbreviate “else if” as “elif”, etc as another convenience. Note that these are just decorations, and does not add any power or flexibility to languages.Compare the sequences (A):

if c1 then a1
if c2 then a2

and (B):

if c1 then a1
else if c2 then a2

These are not equivalent. This is a common mistake most beginners make. The equivalent version of (B), without using “else” is:

if c1 then a1
if not c1 and c2 then a2

Similarly, when there is a series of “else if”s, the last else actually corresponds to “(not c1) and (not c2) and (not c3)…”.

A special case of these conditionals often occurs in programming, for which most languages have introduced a special construct: the switch statement.

One of the clauses in the income tax law states: a standard deduction of 10000 Rupees is allowed on the income, for males and 15000 for females. So, after you compute the total income, you need to deduct this amount before computing tax. You can write:

if (sex is male) then sded = 10000
else if (sex is female) then sded = 15000

Let me take a moment”s diversion here. Take a closer look at this statement, and in particular, the second if-condition.

Assuming that sex is either male or female, one does not need the second condition check. The else indicates that sex is not male, and hence it must be female. However, in general, it is useful to put that condition there. One purpose is clarity. It makes the law very explicit. This is very handy, when you update these statements when the rules change next year, where these categories may be revised.

However, when you include this condition, semantically the statement is incomplete. What if both conditions are false? What happens to standard deduction? But, can both conditions become false? In computer programming parlance, it is possible. Someone when entering data, may have entered a wrong value for “sex”. It could be a mistake in typing, or filling in some other column value for this column in the form, and so on. So, it is a good idea to address these by extending the statement as:

if (sex is male) then sded = 10000
else if (sex is female) then sded = 15000
else print “illegal sex value”

Such small precautions can save you days of effort in tracking down bugs. Without this, it is possible, you will happily go ahead calculating sded, using an illegal value and get, say, the total tax wrong. And you will wonder what went wrong. Alert messages as given above, get you to the root of the problem much faster and with less pain.

Coming back to the notion of switch statement, this kind of branching depending on the different values of a variable is what a switch statement facilitates. Another example:

print “choose your language: 1 - English, 2-Hindi, 3-Tamil, ..”.

You can see such directions in ATM machines, telephone answering services. You need to choose one out of a set of options provided. (We will see later how to read a user’s choice - for now, let us assume we know). And you have to perform different actions depending on the choice made. Unlike in the tax computation example, here the choice is dependent on different values of a single variable as in:

if (lang == ‘E’) then ….
else if (lang == ‘H’) then ….
else if (lang == ‘T’ ) then ….

Or

if (option == 1) then ….
else if (option == 2) then ….
else if  (option == 3) then …

A switch statement provides a short hand for these kinds of code segments:

switch (option) {
  case 1: …..; break;
  case 2: …..; break;
  case 3: ….; break;
  default: print “illegal option”;
}

Against switch you specify the variable on which you want to branch on, and against ‘case’, you specify the possible values. In place marked ‘…..’, insert the code corresponding to different values.

Compare this template with the if-then-else template given before, and you can see the mapping. In principle, you can convert any switch statement to  if-then structure (of course, not vice versa!).

In the template you see two new entities: break and default. Let us try to understand why they are there and what they do.

The ‘default’ is like the catch-error else part we had introduced in if-then earlier. A way to specify some action, in the event of the value not matching with any of the listed values. So you can write our sex-tax code as:

switch (sex) {
  case ‘M’: sded = 10000; break;
  case ‘F’ : sded = 15000; break;
  default : sded = 0; print “illegal sex value”;
}

The value not matching can arise in two cases. One is the error condition, we have sketched here. Another is a scenario like this:

switch (sex) {

  case ‘F’ : sded = 15000; break;

  default : sded = 10000;

}

This captures the rule ‘for females, the exception is 15000; for everyone else it is 10000”. This is same as the above, if we are sure that the only sex values are ‘m’ and ‘f’. Thus, you can use ‘default’ to pull together all values that need not be given special attention.

What is the ‘break’ about? ‘Break’ is a general construct - not specific to switch - with the meaning ‘break free’. We will discuss this in a later post. For now, just make sure to put a ‘break’ after handling each possible value in a switch.

Practice writing in if-then-else form and switch form, the various conditionals that you can think of. Write them in as many different ways as possible, and see how they differ in readability, efficiency, correctness, etc.

What we saw in the last blog was a simple tax calculator - perhaps too simple to be useful. We made a lot of assumptions to ensure that we can complete the program, with constructs we know. One major assumption was the flat tax rate. Typical tax rate specification would be something like this:Income upto Rs A : no tax
Income over A but less than B: 30% of income
Income over B but less than C: 30% of B + 50% of (Income - B)
Income over C : 30% of B + 50% of (C-B) + 70% of (Income - C)

The number of slabs may vary, but you see that the computation depends on which income slab your income falls in. So, you want to write your program as:

if income less than A then tax = 0
if income greater than A and less than B then tax = income * 30/100
if income greater than B and less than C then tax = B * 30/100 + (income - B) * 50/100
and so on

This is where conditionals are useful. A construct which allows you to do something only when a specific condition is true, is a necessary part of any programming language. In Java, the conditional construct looks like the informal notation above. More formally, we would write the same in Java as:

if (total_income < 100000) income_tax = 0;
if ((total_income > 100000) &&' (total_income < 200000))
'' income_tax = total_income * 30/100;
and so on.

Despite the remarkable similarity with the English notation, note some important differences.

“then” word is not used to indicate the action to be performed. This is the case in many of the programming languages, though some languages do mandate it to be used. One problem when you omit “then” is the difficulty in identifying the end of the condition and the beginning of the action part. Therefore, it is customary to expect that the entire condition part be enclosed in brackets as shown in the example above.

Secondly instead of English terms like less than, we use symbols for them. The standard set of symbols for common conditions are as follows. This set is also followed quite the same way in most languages.

less than <''''''' less than or equal to' <=
greater than >'' greater than or equal to >=
equal to =='''' not equal to <>

Of particular importance is to note the symbol for “equal to”. Remember the symbol used to assign a value to a variable. We used “=” to denote that. In order to avoid confusion with this, a comparison check between two values is denoted with two consecutive equal signs. Common mistakes in programming is to interchange these two symbols. Some of these may be detected when the compiler compiles the program; but not all such cases can be reliably detected. So be careful with these symbols.

Also note that “>=” and “=<" are not equivalent. While languages differ on what is the symbol for 'greater or equal', they will allow only one of these for this purpose. Often, the other symbol may be used for some other purpose. For example, '=>” is often used as an arrow or as implication operator, and hence has nothing to do with “>=”.

As in the case of comparisons, we use specific symbols for logical operators. && for ‘and’, || for or, ! for not, etc. Again, the English terms are not acceptable. Single & and single | are used for other purposes (we will see later), and hence the use of symbol-pairs here. [order of evaluation of conditional: tbd].

If we look at our daily usage, we use conditionals in two distinct ways. One is to do something only if a condition is true. If it is likely to rain, take an umbrella. If the condition is false, nothing is to be done. The second case is where we use a condition to choose between two alternatives. If your score is less than 45, your status is fail, otherwise your status is pass. There is something to be done irrespective of the condition being true. For this case, it would be useful to have an ‘otherwise’ construct. And most languages provide you an ‘else’ companion to the ‘if’ statement.

if (condition) do-something
else do-something-else

Look at this for a minute. Strictly speaking, you dont need this. You can always write this as:

if (condition) do-something
if (not condition) do-something-else

In some cases, the former is more intuitive. It also means the condition will be evaluated only once. So, when there is a choice, use if-then-else. Otherwise, use if-then.

And you can extend this further. What if we have a choice between three options, as in our tax computation case. We had three or four slabs, and we need a different tax formula for each of them. We can nest the if-else structure.

if (income < A) something
else if (income < B) something-else
else if (income < C) something-different
else error

…..

So, we can now start writing some useful programs. Let us take some practical application. We want to compute the income tax payable by a salaried employee. For now, let us make some assumptions, so that the world fits in what little we know of programming.For computing tax, we need to compute the total income first. For salaried employees, the core element of income is one”s basic pay. Using the concept of variables, let us define this as a variable, since we may need to change this for different persons, and we may want to use this figure for computing various other aspects of his income and tax. So,

'' basic_pay = 8000

This is monthly basic pay. For tax purpose, we need annual figures. So:

' annual_basic = basic_pay * 12

You can see that we dont write 8000*12, but basic_pay * 12. So, when we change the basic pay, the computation of annual_basic will not become wrong.

Another major component of income is the “dearness allowance”, generally called DA. DA is a percentage of basic. This percentage will vary from time to time, based on some government notification. So, it is useful to make this explicit, to allow easy change.

' DA_percentage = 83

Now the DA can be computed.

' annual_DA = basic_pay * 12 * DA_percentage/100.

In a similar way, we can define house rent allowance (HRA).

' annual_HRA = basic_pay * 12 * 30/100

HRA is 30% of the basic; not something that changes often, and hence we have opted to keep it a part of the ex-pression. Let us assume there is no other income. So, we have the total income.

'total_income = annual_basic + annual_DA + annual_HRA

In the simple case, the tax is a simple fraction of the income, say 20%. So, tax is:

' income_tax' = total_income * 0.20

Note that 0.20 is 20/100 - we can write it either way. In one case, we make the computer do this computation; in the other, we do it ourselves. Here, the difference is not important for two reasons. First the ex-pression is so simple, the cost of computation is low for us and also for the computer. So, it perhaps does not matter, who computes it. Second, both the forms are adequately intuitive - so there is no loss of readability. Whenever, you have a choice of such a decision, apply both these criteria. For example, if you have to multiple something with PI/7, it is better to write it as pi/7, instead of 0.448. The latter form is not intuitive and a reader will wonder what this number is! Even you may not remember after a while. So, it is generally a good idea to give most of these ‘magic numbers’, a relevant name and use a variable of that name in your program.

Now, here is the consolidated program, which you can replace ‘YOUR PROGRAM’ in our template with. We have added the relevant declarations for the variables we have introduced.

int basic_pay, annual_basic;
float DA_percentage, annual_DA, annual_HRA;
float total_income;
basic_pay = 8000;
DA_percentage = 83;
annual_basic = basic_pay * 12;
annual_DA = basic_pay * 12 * DA_percentage/100;
annual_HRA = basic_pay * 12 * 30/100;
total_income = annual_basic + annual_DA + annual_HRA
income_tax' = total_income * 0.20
System.out.print(”Total income is “); System.out.println(total_income);
System.out.print(”Tax payable is “); System.out.println(income_tax);

Try it out with different basic_pay and other parameters. Can you modify this program by adding Rs 800 as a fixed conveyance allowance per month, and Rs 10000 as an annual allowance.

We will follow this example in the next section to introduce conditionals.

The name ‘computer’ means something that can compute, usually refering to numerical computations. One simple application of this is demonstrated by a normal desk calculator. You can use it to make arithmetic calculations, 30*0.6, (100+3)/4, etc. You can, thus,use it to compute total expense for a project, monthly installment, total saving in a day, and so on.
It is easy to use any programming language as a rudimentary calculator. Remember the System.out.print instruction we saw earlier. We, there, gave it a string to print - a piece of text. We can put in any expression to print.

Consider the problem of computing service tax on a set of items purchased from the shop. You know the rate of service tax is 2.4% (hypothetical), and the tax is computed by finding the total amount payable and taking its 2.4%. Assume we bought 5 items costing 10, 15, 20, 50 and 60 Rs. So the tax would be = (10+15+20+50+60) * 0.024. We can turn this into a Java program quite easily:

 System.out.println((10+15+20+50+60) * 0.024);

Note that there is no quote marks around what is to be printed. Try the same with quotes:

System.out.println(”(10+15+20+50+60) * 0.024″);

Instead of the tax, you get the same expression back. That is because, the quote told the system to treat the expression as a string - as a sequence of characters. It did not interpret them as an expression.

For this reason, numbers are treated differently by all languages - the difference between “2″ and 2. The former is a string and the latter is a number. You can do 2+3 to add two numbers to get 5, but you will not get
5 from “2″+”3″. [This summation actually produces "23", since the plus sign is interpreted as concatenation operator - more on this later].

The print instruction can take a number, apart from a string. The number can be a direct number as in: System.out.println(3), or a result of an expression.

So, System.out.println((10+15+20+50+60) * 0.024), does indeed produce the tax amount.

Try different expressions and see if everything works fine. You can use, + for addition, - for subtraction, * for multiplication and / for division.

It is possible that the tax calculation may need to be done multiple times in the program. It is also possible that the tax rate may change from place to place, and time to time. Modifying the program by changing the number everywhere is an error prone task, and too time consuming. Remember that all occurences of 0.024 may not be referring to service task percentage, and there is no way to distinguish?

Yes, there is a way. We can give names to these numbers, using variables. These can be visualised as named containers. Instead of the number 0.024, we can say, ‘the content of service_tax container’. We need to define these containers, assign contents and use them. Since we are now dealing with numbers, we define service_tax as a number:

   float service_tax;

floats are decimal pointers, those with an explicit decimal point. There is another kind of numbers - integers, what we call whole numbers. 1, 2, 20, 120, etc are integers. 1.3, 5.6, 10002.2, etc are floats. We can define another container named ‘n_items’ to denote number of items purchased. This would be an integer container and will be defined as:

  int n_items;

int is short for integer (Java has something called ‘Integer’ - we will see that later on).

You assign values to a container by an assignment statement. We will need:

  service_tax = 0.024;

The right side can be any number or an expression which evaluates to a number. If we are used to seeing the service tax as a percentage, we can write the same as:

 service_tax = 2.4/100;

Now, we can modify the print statement as:

  System.out.println((10+20+25+50+60)* service_tax);

This produces the same output. Check it out. If you get any error, you may have typed the variable name incorrectly somewhere. Make sure that your definition, assignment and use has exactly the same name.

Now, if the service_tax need to be changed, you can just change the line assigning 0.024 to whatever is appropriate, and the change will be consistently applied throughout your program.

What if you want the service tax on each item individually? You can write:

System.out.println(10 * service_tax);
System.out.println(20 * service_tax);
System.out.println(25 * service_tax);
System.out.println(50 * service_tax);
System.out.println(60 * service_tax);

So, with variables, you can re-use an item any number of times.

Use of variables is a major aspect of programming - though it appears to be a very simple concept. As we will see later on, things are not that simple as we make our requirements more and more complex. Keep your questions ready…

Exercise:
Print the annual interest on various deposit amounts, 1380, 49850, 40000, etc at an interest rate of 9%.
Print the annual interest on an amount of 14300 at various interest rates of 7.5%, 8%, 9% and 10.3%.
Which numbers are worth being assigned to variables, and why?

From the days of the famous book on C language by Kernighan and Ritchie, it is customary in teaching a programming language to start with a hello to the world. It is also perhaps the simplest program to write, so we will not violate this tradition.
To produce some output from your program, you use the notation

 System.out.println(”Hello, world!”);

Type everything including the dots as it is. You can recognise the “print” word there reminding you that it is going to print something on your screen. The “ln” following indicates that the next output will start on a fresh line.

Replace the “YOUR PROGRAM” in the template with the above line, and try compiling and running the program. The program will look like:

public class Myclass {
    public static void main (String arg[]) {
         System.out.println(”Hello, World!”);
    }
}

Instead of “Hello, World!”, you can put any text inside. Text enclosed in double quotation marks is called a String in Java. Do not use text containing quotation marks - they need a little special treatment. So, dont try: “Should I try ” in the string”

Try, “Welcome, World” and other variants. Only simple text.

As I mentioned above, the ‘ln’ indicates that the next output on the screen will start on a new line. Let us try this:

    System.out.println(”Hello, “);
    System.out.println(”World!”);

You will see that “Hello” and “World” are coming on two different lines. Try this now:

    System.out.print(”Hello, “);

    System.out.println(”World!”);

Note that the first line is now just “print”, and not “println”. This tells the system not to move to the next line. This code will produce “Hello, World!” in one line.

That is our first little program….

We begin our journey here. We will spend a few minutes getting ready - setting up our rules and norms for the journey, making sure we have the needed resources, and the like.
First of all, this is a course on programming. It is like swimming - no amount of reading will make you good at swimming. You need to swim. You may not succeed at first. You may sink into the water, may drink a lot of water - much beyond your liking - it is all part of the learning process. But dont drawn - that is where systematic learning comes in. It is foolish to jump into deep sea, and try to learn swimming. It is foolish to go and practice with no security devices (floating devices, the guards on duty, etc). The lessons and specific targets play that role - so that you dont get hurt too much. Given that, dont be afraid to try. You will develop confidence - you will know what works well for you and what does not. You will know where your weakness is and where your strengths. Slowly you can build your own style of swimming (read, programming).

So, it is important you have a programming environment to practice. In the beginning I would suggest not using any development environment. The programs will be really simple, and an IDE will hide important details. As we go further, you can try them. For now, just make sure you have a simple text editor (the classic vi, notepad, and so on). Do not use word processors - they do not store the files in plain text format. They have to store formatting and the like, and hence makes it impossible for the compiler to read your program. So, ensure you have a simple plain text editor. And ensure you have Java installed. You can download and install it from java.sun.com. It will give you two commands: javac and java.

javac is the command which turns our Java programs into a format that the Java interpreter understands. For now, dont worry too much about what this means. And the command java executes your program. You provide inputs and receive outputs, at this stage.

So,

• You write a program using the text editor. Let us say, the file is called pgm1.java; note that the extension is important. You can name the file in anyway you like. You can name them based on the chapter in which the program is described, or based on the nature of the program. Eventually, you should it more along the latter lines. Eg. chap1ex1.java (first exercise in first chapter), hello.java (program to print hello), etc.
• Then you compile the program using javac. “javac pgm1.java”. This will create a file called pgm1.class in your directory. Watch for any errors, etc. As a practice, make sure no warning is left. Even though some warnings may appear harmless, fix them. It is a good practice - like stopping swimming, when you notice mild discomfort. It prevents major problems later on.
• And then you can run the program with “java pgm1″ - it will run the compiled .class file.

For every exercise, do all these, and ensure you test out your program well that it works for a number of different inputs. Dont stop with one input. Programs can surprise you - working well for 99 inputs and failing on the 100th. We will later see such errors.

The second part of the preparation is to prepare some skeleton for us to start. For, even the simplest Java program to work, we need a few lines of code. Whenever you write a program (we will withdraw this restriction, later on), include this in your .java file exactly as it is. And your program will be written in the part marked “YOUR PROGRAM”. Some examples in next chapter will make this convention clear. The significance of this skeleton part will become clear as we go along. For now, just trust me and come along.

'public class Myclass {
'' public static void main (String arg[]) {
''''' YOUR PROGRAM
'' }
}

The name “Myclass” should be replaced with the name of the file you are going to save the program in.

We are now set to write our journey.