Who hasn’t heard of them? And if you have experienced what they are, who can forget such a profoundly frustrating experience?

Computer viruses are merely computer programs, designed to self-replicate. They are designed to “infect” other executable programs, by copying the virus code into them. When these infected programs are executed, the virus gets another chance to attack, and will probably try to infect some more uninfected programs, thereby causing some kind of a chain reaction. The virus code remains in memory even after the program terminates, in order to fulfill it’s goal of more infection! As the infected program is copied and used on other uninfected systems, the virus spreads on that system too, infecting many files there.

continue reading "What are Computer Viruses?"

The whole world knows that the whole world presents web content using HTML (HyperText Markup Language). These HTML pages are written by programmers (and if generated by designers, then are at least optimized by programmers), and many programmers are, unfortunately, unprofessional in their approach!
continue reading "Professional HTML using XHTML"

One of our previous blog posts introduced Brainfuck! Programs written in this minimalistic language can be highly unreadable! It can be fun though to put your intelligence to use to create something with these simple instructions. This article is the first part of a tutorial series showing you how this language works and how to write programs in this.

The whole language of Brainfuck comprises of just 8 characters, each with it’s own implicit meaning. Whitespaces are ignored, and can be freely used to improve readability (what’s that?!). In fact, any character apart from these 8 are just ignored! The 8 characters that make up a Brainfuck program are: + – < > . , [ ] .
continue reading "Brainfuck Tutorial: Part 1"

The exact procedure would depend on the compiler, though will not vary widely. Since we work extensively on Linux, we will show you how to do so using the GCC compiler in Linux:

The simplest way of combining multiple C programs to create a single executable is:

$gcc 1.c 2.c 3.c

The files 1.c, 2.c and 3.c will be individually compiled, and the generated object codes will be linked together and with the standard library to create an executable called a.out. Note that on some systems, the command to compile is cc instead of gcc, but without any other difference.

The long cut for doing the same is:

$gcc -c 1.c

$gcc -c 2.c

$gcc -c 3.c

$gcc 1.o 2.o 3.o

In this case, we individually compile (-c stands for ‘only compile’) each of the 3 files, with the object codes being written on to corresponding .o files. We then ask gcc to link these object codes together along with the standard library. An advantage of this long cut is that if we change a few files, we need to only recompile those files we had changed and link the object codes together, without having to unecessarily recompile all files. Of course, an even better technique is to use makefiles, which hopefully will be covered by a separate article in this blog later.

Many IDE allow the user to create a “project” comprising of C files, and a “build” option to compile all changed files and link the object codes together, giving rise to a single executable.

Perl is known for allowing multiple different ways of expressing a solution! This article examines various techniques by which a function/subroutine in Perl can accept and process parameters. As an example, we will stick to a subroutine called add that adds the 2 arguments passed to it and returns the sum.

Method #1:

sub add()
{
	return $_[0] + $_[1];
}

This method is straight-forward: The parameters are elements of the array @_, whose first 2 elements are $_[0] and $_[1]. We add them and return the sum back.

Method #2:

sub add()
{
	my ($x, $y) = ($_[0], $_[1]);
	return $x + $y;
}

In this case, we copy the 2 parameters to locals $x and $y and return their sum. Many people prefer to copy the parameters to locals immediately as the parameters are passed by reference, and any changes made to them can affect the original arguments!

Method #3:

sub add()
{
	my ($x, $y) = @_[0,1];
	return $x + $y;
}

This is an improvisation over the previous one using an array slice instead of 2 individual scalars from within an array.

Method #4:

sub add()
{
	my ($x, $y) = @_;
	return $x + $y;
}

An even more simpler version than the previous one!

Method #5:

sub add()
{
	my @x = @_;
	print $x[0] + $x[1];
}

In this version, we are copying all parameters into the local array @x and then accessing the elements.

Method #6:

sub add()
{
	my $x = shift (@_);
	my $y = shift(@_);
	return $x + $y;
}

The shift function will delete and return the first element of the specified array, using which we extract the parameters into locals $x and $y, and return their sum.

Method #7:

sub add()
{
	my $x = shift;
	my $y = shift;
	return $x + $y;
}

When no array is specified as an argument for shift, it automatically works on @_, making this work just like the previous version.

Method #8:

sub add()
{
	my $y = pop;
	my $x = pop;
	return $x + $y;
}

The pop function also deletes and returns an element from the specified array, but from the end. And just like shift, if the array is not specified, it automatically works on @_.

And this is how every C/C++/Java programmer will write the function:

int add(int x, int y)
{
	return x+y;
}

The world of Perl is colourful!

Q

What would be the size of int and int* on a Linux 64-bit environment? I expect both to be same but am getting different sizes… need some explanation!

-Sumit Maurya

Incidentally, I recently posted an article on our blog about sizes of integral types, with a link posted on our facebook page.

To clarify, the size of int is dependent on the compiler, and is supposed to match the machine word size. The size of that is assumed by the compiler. Compilers may give 4 bytes for int, because long can be 8 bytes wide – it is purely a decision of the compiler vendor!

The size of int*, however, cannot be purely the choice of the vendor. Pointers are addresses, and given the fact that it is a 64-bit environment, addresses have to be 64-bits wide. Thus, the size of int* (or any pointer) will be 8 bytes.

The history of the C++ programming language dates back to 1979, when Bjarne Stroustrup (prounouned By-ar-ne strov-strup) was working on Simula – the world’s first object-oriented programming language. While appreciating the object-oriented programming paradigm, Stroustrup found Simula too slow. When even BCPL (a predecessor of C, see A Brief History of C for more information) did not prove to be fast enough, Stroustrup decided to use C as a base for the new language. The reasons for choosing C were apparantly many:

1. C was general-purpose, and could be used for any programming situation
2. C was more efficient, programs ran faster and would occupy lesser memory
3. C was highly portable, and was available on a variety of machines
4. C was popular, and compilers were readily available along with programmers who knew the language

Stroustrup started by adding support for classes in C (classes being the starting point of object-oriented programming) resulting in the birth of the language “C with Classes”. The first compiler for this language was in fact merely a code converter called Cfront, that converted C++ code to it’s C equivalent, which could then be compiled by a C compiler.

With more improvements to the language, it was renamed to C++ in 1983, the “++” being the famous increment operator of C, and the logic behind the name being that this is the “next one of” C or the future of C. In Stroustrup’s own words: “the name signifies the evolutionary nature of the changes from C”, with the name being proposed by Rick Mascitti.

ISO released a standard for C++ in 1998, called C++98 – the first standard for the language. It was later revised in 2003 (C++03) and 2011 (C++11).

C++ was thought to replace C. In fact, it’s current name (C++) and one of it’s previous names (new C) clearly indicate this intention! Surprisingly however, C++ was not able to replace C, and C continues to be used extensively.

C++ today is not exactly a super-set of C! While it is true that more than 80% of C++ features are additions to features in C, some features of C were modified in C++. Thus, there is no guarantee that all C programs will compile properly using a C++ compiler. However, it is definitely possible to intentionally write C programs in a way that it will compile properly on a C++ compiler. It is also thus possible to mix C and C++ code.

C++ influenced other languages: Perl, Java, C# and C99 (The ISO standard for C released in 1999) to name a few. C++ was supposed to be superceded by D, a language invented by Walter Bright in 2001, based on practical experiences with C++. While D is a re-engineered work of C++, the source code is not backward compatible with C++. D could not become that popular since Java and C# had already made their presence felt!

1. The size of char should be at least 1 byte (most implementations will have sizeof(char)=1)

2. The size of short should be less than or equal to the size of int, and should be at least 2 bytes (most implementations will have sizeof(short)=2)

3. The size of int should be the machine word size (the optimal size that the system can handle at one go). Thus, a 16-bit compiler will have sizeof(int)=2 (16 bits = 2 bytes) whereas a 32-bit compiler will have sizeof(int)=4 (32 bits = 4 bytes)

4. The size of long should be greater than or equal to size of int, and should be at least 4 bytes (most implementations will have sizeof(long=4)

Thus, the following condition will always hold good, no matter which C compiler you use:

sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)

Typical values are shown below:

Yes!

Most people seem to think that these two terms are inter-changeable: they are not! There is a very clear distinction between a variable definition and variable declaration.

A variable definition defines the variable to the compiler. In the process, it specifies the data type, storage class and initialization. Most importantly, a variable definition results in memory allocation by the compiler. Thus, a variable once defined can never be re-defined.

Examples of variable definition:

int x;
int x=10;
auto int x;
register int x;
static int x;
extern int x=10;

A variable declaration merely declares the existence of a variable to the compiler and documents it’s data type. Thus, the compiler realises that there will be a variable of that name and data type defined elsewhere. The declaration does not result in any memory allocation, and hence declarations can be repeated multiple times without any problem, though there is no need to.

There is only one way a variable can be declared in C:

extern int x;

This declaration tells the compiler that there is a variable called x of type int which will be defined elsewhere (probably even in a different C program).

Summary: variable definitions result in memory allocation and cannot be repeated whereas variable declarations do not result in memory allocation and can be safely repeated.

Dennis Ritchie (1941-2011)

C has an enormous history before it could become popular, and has already become perhaps the most popular language on this planet! A very small percentage of developers and students seem to know how the language evolved, and hence this article.

We start from the early 1960s, when the University of Cambridge invented a language called Cambridge Programming Language (CPL). With the involvement of the University of London, it was then renamed Combined Programming Language, though the abbreviation remained unchanged. In fact, it was also nicknamed Cambridge Plus London, retaining the same abbreviation! Even though the language was announced in 1963, it’s compiler was ready only by 1970 due to slow development. History did not wait till 1970 though, and the language slowly and silently disappeared in the 1970s.

In 1966, Martin Richards from University of Cambridge modified CPL in order to make it easy to develop compilers, and that resulted in the birth of BCPL (Basic Combined Programming Language). BCPL is also history and is no longer used. BCPL is also nicknamed Before C Programming Language.

In 1969, when MULTICS was dropped by AT&T Bell Labs, Ken Thompson and Dennis Ritchie tried their hand at developing a scaled-down version of MULTICS, which was named UNICS by Brian Kernighan, and later spelled UNIX – the very famous operating system. In order to develop MULTICS and UNIX, Ken Thompson stripped down BCPL, inventing a language called B. While the first version of UNIX was written in assembly language, it was rewritten in B.

Due to the frustrating experiences of writing UNIX in B, Dennis Ritchie proceeded to improvise B, inventing a highly portable language in 1972 which was called C, because it was an improvement over B! UNIX was then rewritten all over again in C, and remains that way till this day. While B is almost history, C is very popular and a variety of programming languages have been invented based on it since then.

When the language was originally developed, there were no standard rules that all compilers for the language had to implement. Guidance was taken from the popular book “The C Programming Language” written by Dennis Ritchie and Brian Kernighan. This formed an unofficial standard called K&R C. The first formal standard for C was published by the American National Standards Institute in 1989 called ANSI C (also called C89). International Organisation for Standardization then passed it as an international standard in 1990 under the name C90. This was then revised in 1999 (C99) and again in 2011 (C11).

The successor of C was supposed to be C++, designed by Bjarne Stroustrup in 1983. The name was so given because of the “++” increment operator of C, as an indication that this is the next version of C and the future of C. The most important feature added in C++ was support for Object Oriented Programming. The previous names for this language were C with classes and new C. While there was a lot of expectation that C will get replaced by C++, C continues to exist on it’s own despite C++’s success and popularity, probably because C continues to be more efficient, some of C++’s non-OOP features were incorporated in C and OOP is not required in all situations.

C++ was supposed to be superseded by D, a language invented by Walter Bright in 2001 that boasts of Java and C# like features, making it easier for programmers to code and improving the reliability of the code, but again D could not challenge C++, partly due to the fact that the area was already taken up by Java and C#.

This was a brief and most pertinent history and future of C. There were many more incidents, people and languages involved, and a lot of politics too! With the level of permeation that C has shown, it is currently very difficult to visualise a day when C becomes history!