SBM, that’s not how you design forms. Seriously, we don’t all have a degree in banking to know what your “Payee Id” is, what’s the difference between a Payee name and a Beneficiary Name and why you need four fields of Payment Details, intuitively called “Payment Details 1″ to “Payment Details 4″. The sparse help messages are not helpful. At all.

Anyway, what’s Beneficiary Bank Address 2 and 3?! Come’on! It’s ridiculous! Fix your thing, before you can even claim to offer “online banking” on your adverts. It’s not useful.

Oh btw? The said friend? She’s decided to go in person to a bank branch to do the transfer. So much for your online services.

How it should be done? How about:

• Meaningful form names? Payment Details 1 is not helpful.
• Contextual help when you hover on the forms?
• Auto complete? Data-specific fields? Why should the user enter date? Can’t they choose from a dropdown?
• Information overload! Use a couple of screens, with steps and a “next” button?
• Or you know, just something like this

Hopefully someone will see this and fix this, or at least suggest a better design proposal. :p

This article comes from GeekScribes

SBMNet Transfer Woes

In this part, we consider another fundamental building blocks of programs: Loops. What are they? Simply, a method for telling your computer to do the same thing a bunch of times. Nothing too hard huh? Let’s get on with it!

As I said, a loop is a cycle, where the ending point is also the starting point. I.e. when you reach the end, you actually find yourself at the start.

A loop in programming is pretty much the same: You tell your computer execute a set of instructions for a number of times or until some condition is met. Then stop repeating and proceed with other stuff.

Say you want to write a program that models a bunny. The bunny only knows how to jump. Now, you want that bunny to jump 5 times. How would you do that?

You can write it like this:

Jump
Jump
Jump
Jump
Jump

That is, you write your instructions 5 times. If you want 10 jumps, you write 10 jump instructions. If you want 100 jumps, you write 100 jumps instructions. If you want 10,000? Ugh… You see the problem? You don’t want to have to write that instruction 10,000 times! And that’s why you’d use a loop. Wouldn’t it be nice to just tell the program “do this 10,000 times”? Something like:

do 10,000 times{
	jump
}

That would be nice huh? Well, you just wrote a loop! It’s not exactly written like above, but the true ways of writing loops look just like that.

There are 3 main ways of writing loops, and we’ll go through each of them in turn, and I’ll tell you when to use them.

For Loop

The first way, but probably the weirdest way of writing a loop is the For loop. Sorry, but it really doesn’t look like the loop above! The other kinds of loops do look friendlier though! If I want to write that loop above as a For loop:

for (int i = 0; i < 10000; i++){
    jump
}

WHAT IS THAT THING?!! It’s so hard to read! Lol… no it isn’t. Wait, we’ll go through it in parts.

“for” is perhaps the easiest thing to read. It’s a keyword indicating a For loop and in the end, you will come to just read it as “for 10,000 times”.

(int i = 0; i < 10000; i++) ouch… But hey, do you see this consists of 3 parts? Let’s break it down, it’s not that hard!

int i = 0; We are just saying, initialize variable i as an Integer, and set its value as zero to begin with. This is done only ONCE in the loop, i.e. the start!

i < 10000; If you have read the part on Conditions, this is familiar to you now. It’s just a check to see if the value of i is LESS than 10000. This check is performed at EVERY RUN of the loop. Hence, we’ll check the value of i 10,000 times during execution.

i++ that’s new! It’s the short form of “i = i + 1″, i.e. add 1 to the current value of i. The incrementing is done ONCE every run, so we increment the value of i 10,001 times! What? Yep, 10,001 times! Remember, 0 to 9999 is 10,000 times! But see, the loop stops at 10,000 times right, so the value of i has to become 10,000 at some point. 0 to 10,000 is? 10,001!

So if we read the whole thing now:

for (int i = 0; i < 10000; i++) means, "do the following instructions for 10,000 times". The variable i is what we call a loop counter. It keeps track of how many times we have executed the loop so far, i.e. how many times we have run our instructions in a loop. The loop counter acts as our memory, so we remember how many times we’ve done that loop.

Why do we need 3 parts? We need a starting point (i = 0). We also need to know when to stop (i < 10000). Finally, we need to update our count of how many times we’ve run so far (i++). With those 3 elements together, we’re able to know where we start, how many times we looped and when we stop.

We start counting at zero and every time the loop executes, we increment the value of i (i++) once. We continue running the loop until i is no longer less than 10,000 i.e. i = 10,000 stops the loop. After those checks and whatnot, our bunny jumps! Then we restart, check the value of i, increment it, bunny jumps, check value of i, increments it, bunny jumps etc… until 10,000.

While Loop

So that was one way of doing looping. We can also use a While loop. This one looks simpler, but beware, it has a trap!

while (i < 10000){
    jump
}

As before, “while” is a keyword indicating that a loop should be done.

(i < 10000) is a check, so we know when to stop. So we read "while i is less than 10,000, do these instructions"

Have you noticed the trap yet? It may not be that obvious, so compare with the For loop above. Tip: i++

The incrementing of the counter i is missing! What happens if you do that? You have a bunny that never stops jumping! An infinite loop!

Since you're never incrementing the value of i, the check will always return true since every time we compare, i is still zero. The loop never stops and in the end, you have a very tired bunny.

You have to be really careful about not missing the incrementer if you're using While loops. If you're not counting, or doing some other kind of check, you need to make sure there's a stopping condition for the loop. Otherwise, you will in most cases, have a non-responding program to deal with while it's stuck in the loop.

Infinite loops do have their uses though. For example, you can keep repeating your program to read an unknown number of inputs from the user, until they enter "quit" for example. Since you don't know when to stop, you just run infinite number of times and implement a manual stop condition. We'll see about that in the ending section of this part!

Here's a correctly written While loop that behaves as we expect:

int i = 0
while (i < 10000){
    jump
    i++
}

But why do you ever need a While loop? A For loop works perfectly well for this task! It happens that you're performing actions that don't rely on a counter. Or you don't really know when you have to stop. A For loop runs for a finite number of times. A While loop can run for as long as you want it to, maybe depending on some external condition or some user action. Here's an example:

while ( isUserPresent() ){
    jump
}

In this loop, we're using a function isUserPresent. You can ignore it for now. Just know that it'll return true if the user is currently sitting at their desk. It returns false if the user is not present. Functions come in the next part.

This loop will have our bunny jump if the user is there to see it. If the user leaves, the check becomes "false" and the loop stops. The bunny then stops jumping and the loop ends.

As you can see, this While loop depends on an external condition that's not related to counting. You don't know for how long the user will be at their desk and so in effect, you're executing the loop until the user leaves, potentially executing an infinite number of times (user never leaves). You can't easily do this with a For loop, since it's finite.

A While loop gives you more flexibility to control when to start, how many times to execute and when to stop. Or if you wish, you can continue as long as you want (infinite loop).

Do While Loop

A third way of writing loops is the Do While loop, also called Repeat Until loop. This is not present in all languages, but can be quite useful in some conditions. Let's compare with a While loop.

int i = 10000
while (i < 10000){
    jump
    i++
}

What happens in this case? Check the initial value of i (10,000)? while (i < 10000) never executes because i is NOT less than 10,000. It is EQUAL to 10,000! So your loop never runs!

There are cases when you want the loop to run at least once before the check is made. Say for example, you want the bunny to jump at least once, even if there may not be any user. You would not be able to do this with the While loop without extensive checking and tricking the program. But you can very easily do this with a Do While loop:

do{
    jump
}while (isUserPresent());

Note how we shifted the check AFTER the instructions. So no matter what, we'll still execute the "jump" instruction at least once before we reach the first check for user presence.

This kind of loop is less frequently used as compared to the above two, but am including it just so you know it exists. One realistic scenario where you might want to use a Do While loop is to check that the user's input is what you expect, and if it's not, keep asking for an input until you get what you want. Here is a non-language-specific example:

do{
    Output "Say Y or N: "
    Get user input
}while (input != "Y" || input != "N");

I chose to give a non-language-specific example to keep it as simple as possible.

This block of code will execute at least once and ask the user to either type "Y" or "N". We then read what the user typed. Finally, we check if the input was either "Y" or "N". If the value input was neither of these, we basically drop into an infinite loop until we get what we want. That is, we keep asking the user until they say either "Y" or "N" and then stop the loop.

This illustrates an example of where you need to get the input first, then decide what to do. You could have used a While loop too:

Output "Say Y or N: "
Get user input
while (input != "Y" || input != "N"){
    Output "Say Y or N: "
    read input
}

Notice how you're repeating the instructions? That's something you want to avoid in programming. Stick to the Don't Repeat Yourself (DRY) principle in programming. The Do While is a simpler alternative here.

Break and Continue

Before we end, there are two important keywords that you need to know. If you read Part 6 on Conditions, you've already seen "break" used inside a Switch block.

"break" tells your program to "break out" of the structure it current is in. It's mainly used in loops, where you want to manually stop the loop, especially if you're using an infinite loop and want to manually stop at some point.

"continue" tells your loop to ignore the rest of the instructions in the loop and restart with the next cycle of the loop.

Let's see examples of these keywords:

int i = 1
while (true){

    jump
    i++

    if (i == 10000){
        break
    }

}

The loop above is a complex way of just stopping when i is 10,000. We're using an infinite While loop. Notice while (true)? Well, the check will always return true since we're saying it's "true"! There is no stopping condition there. Instead, we use an If condition to do the check, and "break" the loop when we want. So when i reaches 10,000, we break out of the loop and stop it. Fairly stupid way to do it, but it's just to illustrate "break".

do{
    output "Say Y or N: "
    read input

    if (input == "N"){
        continue
    }

    output "Hello!"
}while(true);

The loop above is again, an infinite loop. We want the user to type "Y" or "N". If they type "N", we don't greet them since "continue" is activated and the loop restarts, skipping the output line. If they say "Y", the If condition doesn't trigger and we say "Hello!" to them.

P.s. Normally, you don't compare Strings like that. You don't do input == "N" for e.g. but would use some function. We'll see about that later.

That's all for this part on loops. Remember, they just allow you to tell the computer to do a set of actions multiple times. There are multiple ways of writing them, and you'll use different ways depending on what you want to achieve. For finite loops where you know how many times you want to execute, use For. For more flexibility, use While. If you want to run at least once before checking, use Do While.

I hope you found this part interesting. If you have questions, please ask in the comments section below. Suggestions welcome!

In the same series:

• Fundamentals of Programming: Part 7 - Loops (This post)
• Fundamentals of Programming: Part 6 - Conditions
• Fundamentals of Programming: Part 5 - Data Types
• Fundamentals of Programming: Part 4 - Variables and Arrays
• Fundamentals of Programming: Part 3 - Style, Indentation and Comments
• Fundamentals of Programming: Part 2 - Pseudo Code and Batch Jobs
• Fundamentals of Programming: Part 1 - Introduction

This article comes from GeekScribes

Fundamentals of Programming: Part 7 – Loops

In this long series, we’ll cover condition blocks using if-else and if-else if-else. We cover checks using AND, or and NOT (! symbol). We finally end with the switch statement. I doubt you’ll be able to grasp everything in one go as a beginner, so go slow, maybe a section at a time, try to understand how it works before moving on.

What are conditions?

It happens that you need your program to take decisions based on checks and conditions. That is, you want your program to perform a set of actions in case A, but perform another set of actions in case B. That’s where conditions come in. It allows you to implement decision points in your programs.

Associated with a condition is a check. Usually, you will be checking what the value of a variable is. Then based on this value, you will branch out and do different things.

Conditions start with the keyword if, followed by a check. There may be another section, called else which gets executed if the condition check turns out to be false. Within these two sections, there can be other conditions too. These are called nested conditions.

Let’s see a blank, simple condition block:

if (condition){
	do this
}
else{
	do that
}

This is perhaps, your first serious encounter with a block of code, so let’s devote some time to how it is structured.

First notice the { and } braces. These indicate where a block starts and ends. I.e. they tell which statements are part of which blocks. Think of those as boundaries. Everything within the first set of { } is for the if-block and everything in the second { } is for the else-block. Not all languages use braces to separate blocks like these; Python for e.g. uses indentation to indicate blocks. So you just indent lines under an if and these lines are considered under the control of the if-block. Other languages use keywords, such as  “end if”. It’s all programming-language dependent, so when programming, you will use the method your language imposes.

Just for clarity, here is this same example, but in those different ways I just mentioned:

if (condition):
	do this
else:
	do that

if (condition)
	do this
else
	do that
end if

So that’s structure. Let’s focus on the if line: if (condition). The condition is the check which will determine which block gets executed. You will normally decide what to do based on a variables’ values. This is an actual example:

if (x > 0){
	output "X is positive"
}
else (x < 0){
	output "X is negative"
}

Here, we want to check if x is positive or negative, and tell the user what it is. Let’s consider three cases:

• x is 2: The if statement’s condition will see what value x has. It sees 2. Is 2 greater than 0? True, so we go into the if-block and execute the output line. The user sees “X is positive”. After executing that, we DO NOT execute the else part. The else-block is only executed if the condition was not matched. So after outputting the line, we finish.
• x is -1: The if statement’s condition checks the value of x. It sees -1. Is -1 greater than 0? False. We skip over to the else part since we didn’t get a match. The if-block is NOT executed. We go inside the else-block and execute the output line. The user sees “X is negative”. After this, we finish.
• x is 0: The if statement’s condition is checked. Is 0 > 0? False! (It’s not greater! It’s greater or equal, but we’re only checking greater here). Since the if-block condition failed, we go to the else part and output “X is negative”. That’s probably not what we wanted. Did we really want to tell the user that zero is negative? (Oh by the way, in computing, you can have positive-zero and negative-zero!)

You can see that we’re missing a condition here, for the case where x is zero. There are multiple ways to do that, one is not available in all languages. Let’s see 3 ways:

First:

if (x > 0){
	output "X is positive"
}

if (x < 0){
	output "X is negative"
}

if (x == 0){
	output "X is zero"
}

This works, but normally, you don’t want to do that because it increases the number of lines of code unnecessarily. Programmers like compact code and you may get a few stares if you do that while working as a programmer. Do note that you can have if-blocks on their own too. You don’t always need an else-part.

Second, nested blocks or if-ception if you want. If inside if:

if (x > 0){
	output "X is positive"
}
else{

	if (x < 0){
		output "X is negative"
	}
	else{
		output "X is zero"
	}

}

Can you understand what we did here? We check if x is positive. If it is not, we do the else-block. In there, we find another condition check, so we again check the if part. This time, is x negative? If not, we do the else. Well, if the number is not positive (first if) and not negative (first if in else-block), we guess that it has to be zero (else in else-block).

Third, else if:

if (x > 0){
	output "X is positive"
}
else if (x < 0){
	output "X is negative"
}
else{
	output "X is zero"
}

This way is similar to the nested-block one (second) but it’s just shorter to write. Programmers like shorter-to-write. It just has an “else if” keyword which is additional condition checks if the first if fails. So here, we check the first if to see if X is positive. Nope? Check the second if (else if). Is x negative? Nope. We go to the else block then and output “X is zero”.

There is a short way for checking the values of booleans:

if (isSunny)
	go out
else
	stay indoors

isSunny is a boolean variable. For boolean variables. you don’t need to write if (isSunny == true) or if (isSunny == false). You just write if (isSunny) and it’s sufficient to get the condition block working. It’s just a short, recommended way to check for boolean variables’ values.

Oh to check if it’s false? if (!isSunny). ! operator reverses the value, so true becomes false, false becomes true. This check is frankly, weird but heavily used once you understand it. Prepare for weirdness!

Two cases happen. We want to execute the if statements only if isSunny is TRUE!

For simplicity, read !isSunny as NOT-is-sunny or is-NOT-sunny if you wish.

• isSunny is true: So if (!isSunny) will reverse the value, hence we get if (false). The if-block is skipped.
• isSunny is false: if (!isSunny) will flip the value again, and we get if (true) this time. The if-block is now executed. That’s what we wanted. Execute only when the boolean is false.

Did you notice the lack of { and } in this example? It’s not a mistake. If your condition blocks if and else have only a single line within, you can leave out the brackets, again for making programs shorter. Personally, I just put them in, single-line or not. Just makes things clearer for me. But what you do is your decision!

Multiple condition checks

What happens if you want to check for multiple conditions at once before deciding whether to go into a block? For that, there is AND and OR operators. They are usually represented using symbols && for AND and || for OR. Those are two ampersands and two “pipe” symbols. Look for it on your keyboard. It’s usually to the left of “Enter” or the Z key.

Quick recap: For AND, all conditions must be true for the whole check to be true. If any condition fails, we have false. For OR, at least one condition has to be true for the whole check to be true.

Here you have 2 examples:

if ( isSunny && (day == "Saturday") ){
	go out
	buy groceries
	meet friends
}
else{
	stay indoors
}

The if-condition now has the && (AND) symbol, so we’re checking for 2 conditions here. First, isSunny has to be true AND it has to be saturday. If it’s not sunny or it’s not saturday, we go to else. If it’s both sunny and saturday, then we go to the if-block.

You will also notice that the different conditions can be put in their own brackets. These brackets help with ordering which operations are performed first. You’ve seen that at work in the previous post. The second example shows this:

if ( isFree || (day == "Saturday" && isSunny) ){
	go out
	buy groceries
	meet friends
}
else{
	stay indoors
}

Here we see the OR and AND both at work. Due to brackets being used, we consider the second check as a compound check. So if I’m free OR if it’s both saturday AND it’s sunny, then I go out, buy groceries and meet friends.

If isFree alone is true, it’s sufficient to do the if-block i.e. go out. But if I’m not free, the second part has to be true. Thus if I’m not free, but it’s both saturday AND sunny, then I go out.

Those AND and OR conditions take some getting used to, so don’t worry too much if you don’t completely understand them here. You will, with practice.

To summarize:

Conditions allow you to take decisions in your programs. You will check values of variables and if these are true or false, you take different actions. There are multiple ways to write conditional blocks and the one you choose depends on the programming language you’re writing in. You can have if checks nested in other if or else blocks for extended checks or you can use else if constructs if the language supports it. If you want to check for multiple conditions, use AND and OR.

Just before we end, what happens if you have lots of checks to perform. Well, you can use lots of if-blocks and face the anger of other programmers! Or you can use the switch statement, also known as the select statement.

Switch statement

The switch statement (or select statement) is really language-dependent. Some languages allow you to do comparisons, others just pure equality. Others vary the way the blocks are ordered. It’s just varied. Java for example, has only introduced switch equality checks for strings recently (Java 7) 15 years after the feature was requested. I’ll stick to one language-independent version here just to illustrate how it works. This one only supports equality check on numbers.

Here goes:

switch (dayOfWeek){

	case 1:
		output "Monday"
		break
	case 2:
		output "Tuesday"
		break
	case 3:
		output "Wednesday"
		break
	case 4:
		output "Thursday"
		break
	case 5:
		output "Friday"
		break
	case 6:
		output "Saturday"
		break
	case 7:
		output "Sunday"
		break
	default:
		output "Wrong day!"
		break
}

Ooooh that was long! Basically, we tell the switch statement which variable we want to examine, so here “dayOfWeek”. The various “case” lines represent possible values for the dayOfWeek variable.

Notice, it only supports equality checks! You can’t for example check if dayOfWeek > 6 in the switch statement!

So we check the value of dayOfWeek. Then jump to the appropriate “case” line and execute its statements. Say dayOfWeek is 3. We check case 1, which is equivalent to if (dayOfWeek == 1). Nope. Case 2, if (dayOfWeek == 2). Nope. Case 3, if (dayOfWeek == 3)? Yes. We then go into it and execute output “Wednesday”. Then break? What is break?!

“break” is a keyword you will use in the future series on looping. It tells your program to “break out” of the block it’s currently in. Hence, when we hit the “break” statement, we go directly to the closing bracket and we finish.

That “break” keyword in all those case statements is critically important. If you don’t have them, you will “fall through” the other case statements and execute everything, irrespective of the cases’ values being checked, until a “break” is encountered. I.e. you may get unexpected results! Try it for fun and see someday.

You can use that as “feature” too if you wish:

switch (x){

	case 0:
		do something
	case 1:
	case 2:
	case 3:
		do that too
		break
	case 5:
		do other
		break
	default:
		do something else
		break
}

In this case, if a zero is encountered, the switch statement will “do something”. Since there is no break, it’ll also “fall through” 1,2,3 and “do that too” and finally break. This could be useful in situations where you want zero to execute one statement in addition to what 1,2,3 normally do. Maybe zero is a slightly special case or something.

If either 1, 2 or 3 is encountered, they all lead to “do that too” and break”. I.e. 1,2,3 are the same thing and lead to the same action being performed.

Finally “default” represents a case where nothing was matched. Think of it as a last-resort case that’s useful to handle errors like invalid inputs from users.

Phew! That was a long part, eh! You now know how to make your program take decisions! I recommend that you re-read this part if you don’t understand it at one go. It’s quite a mouthful to chew at once. I hope you got something out of it. As usual, post your questions and suggestions in the comment section, and see you in the next part.

Note: Technically, you don’t compare strings’ values directly like day == “Saturday”. You would use a function or method such as equals(), like day.equals(“Saturday”). I left those out for simplicity here as these come in a future part. Also, I tried to keep using pseudo-code here, so there are no semi-colons on statements. Just so you know!

In the same series:

• Fundamentals of Programming: Part 7 - Loops
• Fundamentals of Programming: Part 6 - Conditions (This post)
• Fundamentals of Programming: Part 5 - Data Types
• Fundamentals of Programming: Part 4 - Variables and Arrays
• Fundamentals of Programming: Part 3 - Style, Indentation and Comments
• Fundamentals of Programming: Part 2 - Pseudo Code and Batch Jobs
• Fundamentals of Programming: Part 1 - Introduction

This article comes from GeekScribes

Fundamentals of Programming: Part 6 – Conditions

What are Data Types? Well, they are a way for you to tell the computer what kind of data you are referring to. In English, you have two basic kinds of data types: numbers and letters. To a computer, those would be “char” and “integer”. Char is short for “character” and integer means a whole number, without fractions or decimal points.

Unlike humans, computers are not so intelligent (yet!) and need to be told exactly what kind of data they are dealing with. For us, numbers are “3″ and “3.24″. For a computer, you’d need to specify “integer” for whole numbers, “float” or “double” for decimal numbers and even specify the sign! Talk about smart!

Just how many data types are there?!

Lots! And they have specific uses too. We have to start somewhere, so let’s start with numbers.

• Integers: They are whole numbers. E.g. “3″, “210″ and even “4521″ are all integers. They are represented as 2 bytes (16 bits) in most programming languages. They can be signed (positive/negative) or unsigned.

• Float: These are “floating point” numbers. Fancy term for “decimal numbers” or fractions if you want. E.g. “2.35″, “30.16″ are floating point numbers. Floating point numbers are actually stored in a quite complex, as a sign bit, an exponent, a fraction and a bias. You don’t need to know all that, but if you want to… Floats are stored on 4 bytes.

• Double: For a rather obscure reason, floating point numbers are not precise enough. Computers have troubles dealing with the fractional part and after a number of digits after the decimal, you lose precision. So for high-precision decimal numbers, you use double. It’s stored on a massive 8 bytes for high-precision numbers e.g. used in scientific data.

Various languages define other data types e.g. Date or Currency, but the 3 above are almost universal.

What about text? Here it’s easier.

• Char: This represents a single character. Note, characters include letters, numbers and symbols, but you can’t make calculations using char. They’re the literal representation of the number. For e.g. ‘n’, ‘N’ and ’7′ are chars. Note the single quotes.

• String: Basically, you can think of them as an array of chars. They are just sequences of characters. E.g. “Hello” is a string. Note, double quotes.

Normally, to avoid confusion, chars are represented inside single quotes while string are within double quotes.

How would you represent true or false?

• Booleans: It’s a “true” or “false” value that can only be one at a time. Programs don’t have a separate data type for that. They normally just represent true as “1″ and false as “0″.

There are a few other data types you may want to know of, although per-se, they are not necessarily “primitive” data types:

• Enumerations: Sometimes you want data that only comes from within a list of values which you define (or enumerate). For example, “Days of the week” would be “Monday, Tuesday, Wednesday… Sunday”. You can then make checks to see if some value falls within your list.

• Array: This is a sequence of other data types. As I stated before, arrays have data types in most languages i.e. they are typed. You can such as, have arrays of integers, floats, or chars – strings basically.

• Map: This is a abstract type that allows you to store a number of key-value pairs as mappings. For e.g. you can map Strings to Integers or Integers to Strings or even Strings to Strings. For e.g. “John – Doe” would be a mapping of “Forename-Surname”. The key is “John” and the value is “Doe”. I could ask the map for “John” and it would give me the corresponding value, which is “Doe”, if I was looking for surnames.

• Set: A set can be thought of as an array that does not allow duplicates. You cannot have a set like [2][3][2] for example. If you tried that, it’d just store it as [2][3] and ignore duplicates, in most cases. It could also complain about duplicates in some languages.

• Queue: This structure is like an array, but you read from one side and put new things from the other. It’s like a queue in real life: people join at the end of the queue and leave from the head. It is a First-In-First-Out (FIFO) structure.

• Stack: Data is read and written to from the same end. Think of a pile of plates. The last one you put is the first one you will take off the pile. It’s is a Last-In-Last-Out (LILO) structure. Or First-In-Last-Out (FILO) if you want.

• Pointer: A pointer points to a memory location. For example, you can have a pointer that references the memory location where an integer is stored for e.g. Or have a pointer to indicate at which point you have reached in an array.

Why are there all these data types? Why do you need them at all? That’s because computers represent data and use them differently. You cannot do calculations with strings directly. You cannot addition two booleans. The different types are useful when you want to do type-checking, for example, the user has not input letters when you’re trying to do calculations with numbers. Or you are trying to put letters in an array for floats for example. The compiler in strict languages will complain bitterly and prevent you from committing mistakes, so your programs break less often.

Operators

There are different operators you can use on different data types. Here are the most commonly used operators:

• = :Not equal to! Yep! Not Mathematics! This sign means “assignment“. It is used to assign values to variables!

• == :This one is what you know as “equal to“. It compares equality and returns “true” or “false” depending on what it finds.

• === :Some languages have this sign. It compares both values and data types. If both are same, then “true” is returned, otherwise “false”.

• + :Normally represents addition. I.e. the sum of two numbers. In some languages however, it can also represent joining two strings. For e.g. “2+2″ will give “4″. But, “Hello” + “World” will give “HelloWorld”.

• - :Subtraction. Simple. “5-3″ will give “2″.

• * :Unlike Mathematics, where x represents multiplication, in programming, you use asterisk. “2*2″ gives “4″.

• / :This one is division. “4 / 2″ gives “2″.

• % :Modulo operator. It gives the remainder of a division operation. E.g. “5 % 2″ would give 1. It is useful to check if a number is even or odd. Even number % 2 would give zero. Odd numbers give 1.

• .  :That’s a dot. Some language use it to join (concatenate) two strings, instead of + to avoid confusion. So, “Hello” . “World” gives “HelloWorld”.

Below are comparison operators. They return true or false (boolean data type) depending on what the condition is.

• > :Greater than sign. Used in comparisons.

• >= :Greater or equal to sign.

• < :Less than sign

• <= :Less than or equal to sign.

• ! :Represents “not“. I.e. it inverses other operations. For example !(x>2) is “not x greater than 2″ or “x not greater than 2″ which is equivalent to saying (x<=2), or “x is less or equal 2″. E.g. != is not-equal. Careful here, != is not equal. It’s not !==. Strange, but that’s how it is!

• AND: The boolean AND operation. Please see below.

• OR: The boolean OR operation. Again, please see below.

The last 2 operators are mainly used with Boolean data types. You use them to make a series of checks to see what the values are. For AND, all the conditions must be true for the final result to be true. If a single condition is false, the net result is false. For OR, at least ONE condition must be true for the end result to be true. If any is false, you don’t care. It’s still true. If none are true, then you get false.

Here are some examples of comparison operators and their boolean outputs:

• 2 > 3  :False

• 3 > 2  :True

• 2 >= 2  :True

• 2 == 2  :True

• 1 != 2  :True (1 is not equal to 2? Yep)

• 2 != 2  :False (2 is not equal 2? It is. Hence, false)

Here are boolean AND and OR comparisons:

• (2 > 3) OR (2 == 2)   :True since (2==2 is true)

• (2 > 3) AND (2 == 2)  :False. All conditions must be true and (2 > 3) isn’t true.

• (1 == 1) OR ( (2>3) AND (4>3) )  :True. This one is tough! First, you check the inner-brackets. (2>3) is false, and without needing to check the rest, you know AND will now return false. (1==1) OR (false) is how the expression looks now. So (1==1) OR (false) returns TRUE since (1==1) is true, while the other is false, so you don’t care.

• (2>3) AND ( (1==1) OR (2==2) )  :False. Why? Because even if the inner OR returns true for both, the first part of AND, (2>3) is false, so the whole thing becomes false.

I understand that the above is a bit hard to understand for beginners. Do try a few other examples on your own or re-read this section if you are having troubles. Don’t worry too much if you don’t understand it at first. It comes together with practice and familiarity with programming languages.

Here are the truth tables for AND and OR, if you are interested:

AND: Only true if ALL conditions are true.

True-True = True
True-False = False
False-True = False
False-False = False

OR: True if AT LEAST ONE condition is true.

True-True = True
True-False = True
False-True = True
False-False = False

I end this post on Data Types and Operators here. I hope it was not too hard to understand and you now have a fairly good grasp of what data types do and why they are needed. If you have questions, please ask in the comments section below. Other programmers’ views are welcome too. See you in the next series!

In the same series:

• Fundamentals of Programming: Part 7 - Loops
• Fundamentals of Programming: Part 6 - Conditions
• Fundamentals of Programming: Part 5 - Data Types (This post)
• Fundamentals of Programming: Part 4 - Variables and Arrays
• Fundamentals of Programming: Part 3 - Style, Indentation and Comments
• Fundamentals of Programming: Part 2 - Pseudo Code and Batch Jobs
• Fundamentals of Programming: Part 1 - Introduction

This article comes from GeekScribes

Fundamentals of Programming: Part 5 – Data Types

So let’s begin this fairly short part, shall we?

Variables

If you’ve studied Mathematics before, you should already know what variables are. You must have encountered questions that involved X and Y. For example, “X apples cost 10. How many do 2X apples cost?” or much more complex questions involving “dy/dx” etc.

Variables in Maths, as the name suggests, represents a piece of information that can change i.e. it is variable. It acts as a place-holder for various values and you can plug-in different values in a variable and it will change  the result at the end.

For example, “X + 2″. If I say, X = 1. The result is 3. If now X = 8, the result is 10. If X = 20, the result is 22. The result will change depending on the value you give to the variable X.

Similarly in programming, you need those “placeholders”. For example, if you ask the user to input two numbers, you need somewhere to store those. You’d put them in two variables, which you can use later. You don’t really care which values the user inputs. Whatever they will input, they will go in two variables you define, say A and B.

Then in your calculation, you can use the inputs directly, without caring about their values. Variables can be used at all stages of a program. They can store user inputs, store intermediate results during processing or store results of processing before output. They are an essential component of any program.

What to add them? A+B. Multiply them? A*B. Divide? A/B. Did you notice something? The symbols are a bit different from normal mathematics. Let’s check that for a moment:

Addition is +. Subtraction is -. Those two are same as in Maths. However, multiplication is represented by an asterisk, *. Division is represented by a slash. Power is represented by ^. And depending on context, % can either represent percentage, or more often, modulo (the remainder of a division operation).

Back to our variables. So just to make it clear, variables are placeholders that will eventually store values or results of operations. You name variables and can then access their values by this name. Do notice, YOU name variables so be sure to use meaningful names for your variables! This is really important if you don’t want to get lost in your program. Unless in very specific cases, don’t use names like A, B or X. Instead, use names like “firstinput”, “second input” and “result”. It makes this clearer when you’re reading code. This is called “self-documenting” code, code which is clear just by reading it.

Here’s an example where variables are used:

Define variables: firstnum, secondnum

Input two numbers: firstnum, secondnum

resultadd = firstnum + secondnum

resultsub = firstnum - secondnum

resultmult = firstnum * secondnum

resultdiv = firstnum / secondnum

Output resultadd, resultsub, resultmult, resultdiv

We made use of 6 variables, two numbers and four to store the result of four operations. We then output them to the user.

Check the first line. We used a line: define. Before you use variables, you have to define them, i.e create them. It’s like that in most programming languages: you define variables before you can use them otherwise the compiler will complain bitterly! Not all languages force this, but it’s good-practice to define all your variables before you use them. Normally you will also specify the data type of the variable too, but we’ll see that in the next part.

Do you notice something? The variable names are rather hard to understand. “resultmult”? “secondnum”? There are conventions for variable formats, and most programming languages consider variables to be case-sensitive. That is, if you write a variable name all in caps and the same variable all in lower-case, they’d be two different variables. “NAME”, “name”, “Name”, “nAmE” would all be different variables. Therefore, there should be conventions to make sure everyone is writing the same way.

The two most commonly used ways are: camel-casing and underscore:

Here’s how you name variables for camel-casing: the first letter of the first word is lowercase. All other words have their first letter as uppercase. There are no spaces. E.g. “thisIsAVariable”, “anotherVariable”. If there is a single word, it starts with just a lowercase e.g. “variable”.

If you’re using underscore, you use all lowercase letters and separate multi-words with underscores. Thus, “this_is_a_variable”, “another_variable”, “variable”.

Whichever you use, stick to it. Normally, most people use camel-casing since it takes less space and is generally easier to type than having to reach the underscore button. But again, your choice unless imposed by a project.

So just to summarize, variables are placeholders for data needed by your program. Name them correcly to make sure it’s clear what they’re storing. Stick to conventions.

Arrays

Now, arrays. What are they? You can think of them as many variables together. Why would you need that? Well, what if I wanted the user to input 100 numbers? Would you create 100 variables, like “firstNum”, “secondNum”, “thirdNum” etc up to “hundredthNum”? Ok good luck if you want to try that. How about adding them all? Will you go re-writing each one?

Nah, you need arrays. Think of arrays as a series of variables stuck together, they’re reachable under a single name.

You can visualize an array like this [ ] [ ] [ ] [ ] [ ]. This would represent an array with 5 slots, and each of those slots can be thought of as a variable in itself. Like variables, arrays also have names and you reference to a particular slot inside an array by number. Array slots usually start from zero up to whatever you define.

So for example, if I create an array of 5 slots, called myArray, its slots will be o, 1, 2, 3, 4. For a total of 5 slots. If I wanted to get the 3rd slot of the array? I’ll reference it like this: myArray[2]. Huh, 2? But you said 3rd slot! It’s correct! Remember, you start from zero! The nth slot is referred to as n-1. Confusing huh? Don’t worry, you’ll get used to it. We are all confused at the start. (Arrays are zero-indexed.)

So if we wanted to re-write that program above, but instead use arrays for the two numbers input and arrays for the results too, it’ll be like this:

Define arrays: myNum[2], result[4]

Input two numbers: myNum[0], myNum[1]

result[0] = myNum[0] + myNum[1]

result[1] = myNum[0] - myNum[1]

result[2] = myNum[0] * myNum[1]

result[3] = myNum[0] / myNum[1]

Output result[0], result[1], result[2], result[3]

Whoa, that’s a lot to write. Copy-paste is your friend! No really, it is. Use it! That’s what I did.

Check the 1st line. We defined our two arrays. The numbers in this case represent the size of the array. That is, we said, we want two arrays, one having 2 slots and one having 4. Just like variables, you will need to define your arrays and their size before you can start using them.

Of course, there are situations when you don’t really how know big an array you need. Languages provide various mechanisms to cover this and we won’t do that here since this is a “fundamentals” series. But if you do want more information, go look for “dynamic arrays” and “arraylists” as a start.

If you want to go into arrays, Inception style, you can have arrays inside arrays… Yes! Arrays inside arrays inside arrays inside arrays inside arrays too if you want, although, that would be a bit too much. Normally, we only use arrays-in-arrays to represent tables. Conceptually, it’d look like this:

       0     1    2              0     1     2
0 [  [ a ]  [ ]  [ ]  ]   1 [  [ b ]  [ ]  [ c ]  ]

or if that helps, vertically:

       0     1     2

0 [  [ a ]  [ ]  [   ]  ]

1 [  [ b ]  [ ]  [ c ]  ]

How would you go about referencing the various slots? Well, two brackets. Let’s say this array is called “myArray”.

To reference “a” you reference the outer array first, then the inner one. Thus:

a would be: myArray[0][0]

b would be: myArray[1][0]

c would be: myArray[1][2]

What you just saw above is an array of size 3 inside an array of size 2.To define it, you’d call: myArray[2][3]. Thus, an array of size 2, with an array of size 3 inside. Want more? myArray[2][3][4]. An array of size 2, containing an array of size 3, containing an array of size 4. That’d be a 3-dimensional table. Too complex for this series! Those are called multi-dimensional arrays and are pretty useful to store, as you can guess, tabular data. E.g. students and their corresponding marks. It’ll be something like this, for simplicity:

[  [ "John" ]  [ 84 ]  ]

[  [ "Ann" ]   [ 89 ]   ]

But above, you see how arrays can be used to store inputs and results for output. They’re not hard to understand and use once you’ve done it a couple of times.

As you can guess, arrays have data types too, and you will need to specify it before you can put any data inside. Some languages restrict arrays so that an array can only contain a single data type. Others don’t care and you can stuff whatever you want in an array. We’ll get to the basics of that in the next part on data types.

Careful when using arrays. If you reference a slot that doesn’t exist or has no data yet, you might either get an error or get junk data. So check where you’re reading from or writing to to avoid weirdness.

Finally, loops are particularly useful when working with large arrays but this will be for another part!

I guess that’s it for this part on Variables and Arrays. If you have questions, suggestion etc, just ask in the comments section below. Hope this section was informational for you, and see you next time.

In the same series:

• Fundamentals of Programming: Part 7 - Loops
• Fundamentals of Programming: Part 6 - Conditions
• Fundamentals of Programming: Part 5 - Data Types
• Fundamentals of Programming: Part 4 - Variables and Arrays (This post)
• Fundamentals of Programming: Part 3 - Style, Indentation and Comments
• Fundamentals of Programming: Part 2 - Pseudo Code and Batch Jobs
• Fundamentals of Programming: Part 1 - Introduction

This article comes from GeekScribes

Fundamentals of Programming: Part 4 – Variables and Arrays