Diary of Sasikumar M

Initiative for research and innovation in science

Sun, 09 Dec 2007 13:29:42 +0530

I was a judge for the national IRIS fair this year in Pune. It is a joint initiative between CII, DST (GoI) and Intel, and continuing for
many years now. I have been associated with it in one way or other for
4-5 years now, but the first time I am going as a judge in the national
fair. There were about 15 of us in the Judges category covering various
subjects ranging from computer science and environmental science to
maths and physics. The participants are either class 5 to 7 students or
class 8 to 12 students. There is a fairly rigorous process to enter,
starting from submission of synposis, its screening, feedback,
mentoring, etc. There are subject category prizes and special mention
prizes, and the main prize of representing India in the international
version of the fair, this time in Atlanta. I think, Intel bears all the
expenses for the trip for the child and a guardian.

It is interesting to see the enthu among the kids. There is a lot of grooming
- so most of them talk polished English, well rehearsed. Unfortunately,
there is too much pressure being applied on the system, with parents
and guides desperate to win the prize at any cost. So, cut and paste
from the net is not uncommon - and it takes away a good part of the
judging time to eliminate them from the short list. Guides/parents
doing bulk of the work is also not very rare.

It is unfortunate that these events are not reaching the vast number of schools in India. No institution can spend
enough money to enhance the outreach beyond a
point. We need more ambassadors of this program at every nook and
corner. Interesting and brilliant ideas do come from all of these
places. The Metro culture tend to think in an imitating style, bringing
in more of the same type of projects. For example, every year, there is
a class of extraction projects. Take some natural substance say X
(plants, paper (wasted), weeds, fruit peels, etc) and extract some
useful chemical Y from it (mosquito repellent, cockroach control,
thermocol, plastic, various chemical compounds, etc). You will see them
in various X-Y combinations. Energy is another popular topic with
various innovations in exploiting solar power (as electricity, heat,
etc) and wind power. There was even a project which gathers the heat
generated by the burning coconuts in Sabarimala temple and produce
electricity from that.

At times due to the pressure factor,
there is a tendency to defend things without knowing - something that
gets me irritated often! And lack of adequate mentoring is also often
seen - resulting in a lot of effort being put in, but not reaching any
useful results. If someone could get these kids to think further, probe
further, etc by asking them the right questions, they would go far. I
found this in many cases - if you point out a flaw in their work, they
are open to think over and suggest, often sensible, solutions. We need
to do this more often...

On the whole a nice experience.... The
enthu on the students" faces is nice to see, coupled with the innocence
of their age. Wonder how many of them will retain! This year the theme
was the power of "Q" - questioning. "Einstein had the power of Q" - say
posters in the halls. Of course, they also had big banners on all
vehicles and roads declaring "geniuses inside - drive carefully" or
"geniuses on the move" -� I thought this was going far. We should
reward, recognise and encourage - but in a limit appropriate to the
nature of achievement. Overdoing it will create negative impact.

Notion of a Block

Sat, 01 Dec 2007 11:42:04 +0530

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.

PP: More on Conditionals (incl Switch)

Sun, 25 Nov 2007 15:03:24 +0530

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.

PP: Conditionals

Tue, 13 Nov 2007 18:55:35 +0530

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

.....

PP: Tax Exercise

Mon, 12 Nov 2007 13:59:49 +0530

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.

PP: Calculator

Sat, 10 Nov 2007 14:16:03 +0530

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?

PP: Hello

Sat, 10 Nov 2007 12:30:54 +0530

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....

PP: Building the background

Sat, 10 Nov 2007 11:45:09 +0530

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.

Programming Progressively....

Sat, 10 Nov 2007 11:39:33 +0530

With this post, I am starting a little journey making an attempt to teach programming. Quite too often, programming is taught from the language point of view - showing the data types, the control structures, the libraries, etc. Here, we will take a different approach - or rather we will try to!I dont know how much my enthu will last for this adventure. It will also depend on how people (you, the readers/friends) react to this. Feel free to comment on the posts, I will try to absorb them into the writing as I go along.

I will use Java as the programming language. But I dont think, my approach and content will depend too much on the language. The attempt is not to make you a master of Java (or whatever language); but rather to make you understand programming. Introducing constructs, as we need them. Showing how the constructs help you solve problems.

Ready? Fasten your seat belt and come along....

Index to posts on this thread:
Preparing background
Hello World
Calculator
Tax exercise
Conditionals
More on conditionals (incl switch)

e-learning

Wed, 17 Oct 2007 10:04:27 +0530

Teatrix: virtual environment for story creation, R Prada, Machado I, Paiva A. ITS-2000
PUPPET: a virtual environment for children to act and direct interactive narratives. Marshall P, Rogers Y, Scaife M. 2nd International workshop on narrative and interactive learning environments, 2002
Review of E-learning theories, frameworks and models. T Mayers and S de Freitas. http://www.htk.tlu.ee/icamp/articles/elearningmodels.pdf/view

Interesting threadsPLEs - personal and personalised learning environments [anyone has some good online reading material on this?]