I am not a fan of desktop. I focus on work I need to do and then find methods to accomplish the task in an effcient and faster way without wasting time and energy. This way of thinking had pushed me from Desktop to virtual WMs (window manager), virtual and floating WMs and then to pure tiling WMs. Hence I travelled from KDE, GNOME and Xfce few years back to Fvwm, windowmaker and then to wmii, xmonad and now to Stumpwm and Ratpoison. Still I keep an eye on how different technologies develop in software world and that is how I came to know about new developments in GNOME 3. As per the viewpoint of an average user there are two kinds of interfaces you get on computer: an ugly, hard to use, anti-user black command line and a beautiful, cozy, pleasing and user-friendly graphical-interface a.k.a desktop . Almost all average “Joes” love desktop as it works faster for them (in fact, it is actually opposite). Come to Linux world, we have desktops too, unlike all those average Joes believing otherwise. A desktop usually has menus, folders, windows, icons, supports atractive features like drag and drop, openeing a document/file/folder by double-clicking etc. On Command-Line you have to type commands to do anything and you don’t get icons, windows, menus and or any fancy stuff requiring graphical interface. These are two opposing ways average Joe thinks computers are. Come to Linux world again, here we have X Window System on the top of which a desktop runs. X Window System is the first graphical interface. What I mean by that ? X is the base on the top of which any graphical interface (or GUI) runs as far as Linux is concerned. While Windows XP users only have one kind of desktop, Linux has several as per the likes and needs of the users, GNOME, KDE and Xfce etc. This kind of design gives a lot of flexibility, power and control to Linux users. Like I mentioned earlier a desktop environment consists of several components. Along with menus, icons, panel etc., it has a window manager and a file manager (check Wikipedia for full list). What most users want is to do the necessary work and then get on with life e.g one person wants to write an email and hence uses a browser, one wants to watch a movie, one wants to his office work and others just want to browse the internet and many want to do all of these (and that includes me too). So, they need something which is simple, helps them do tasks in an effective way and finishes tasks fast. That was my motto and that pushed me towards Linux after I was mentally tortured, made insane and almost killed psychologically by Windows’s virus problems, frequent slow downs, weekly-installations and loads of other crap that every Windows user has experienced. Coming back to Linux, now if there is a way to finish the tasks faster then that means current way of doing work must be inferior because if you already doing what is best then there is no way you need anything else. There is another way of saying this: you are doing tasks in an effective way and there is always room for improvement and there is lot of room if what you are doing is being done same way from a decade. . I think that is exactly what GNOME team was thinking when they were lying the foundation for GNOME 3. What is this new foundation ? For that I need to explain tiling WMs. In a tiling WM (I use StumpWM) there is no minimize/maximize/resize when it comes to your windows (when you open an application e.g a video player then it opens in a window. If you open 2 applications e.g. video player (lets say VLC) and a browser (lets say Firefox) then you got 2 windows, Firefox window and VLC window). In a usual desktop you can minimize/maximize/resize any window and each window will have buttons to do that including a button, which looks like leter ‘x’, to close the window, usually these 3 buttons are in upper right corner of a window). A tiling WM does not provide any of these facilities, windows will always be maximized and no buttons. Tiling WMs are based on concept that a user wastes too much time in minimizing/maximizing/resizing windows, changing their locations and sizes across the screen and they are right. Screen is divided into panes, like a Paned-Window, and you will have one window in one pane. There are no menus, no icons, almost nil mouse support (yes, no left-right clicks and tricks), tiling WMs are keyboard driven. You want any application then know its name and run it as a command and you will not waste your time in trying to find it inside menus or searching pseudonym driven icons/shortcuts and finding where that shortcut points to when you accidentlly loose one. When you sit in front of your computer then most of your attention should be on your work, not on distractions and pure tiling WMs make you do exactly that.

Sadly almost all people use desktops and waste their time and energy on icons, menus and mouse-clicks. Whole software industry is based and competing on who gives more desktop-eye-candy. Like high-school kids, users keep on eating those candies and spoil their teeth (brain in our case). Tiling WMs have a short learning curve and that takes some time (toook me a month to replace my desktop with StumpWM) and not everyone likes empty screens and black backgrounds. So, something was needed which could bring the usability of tiling WMs and pleasing-candy feelings of desktop under one roof and that is what GNOME 3 did. you can’t minimize a window in GNOME 3 ()it does not have those buttons) and it has no panel. Each Window is maximized, It does not have right-click menu on desktop. GNOME 3 does not have a menu and you can still find list of all of your applications and settings there, it does not have Home icon but it possesses a file manager for your tasks. GNOME 3 has been criticized by lot of people, even Linus Torvalds finds it a mess . I say GNOME 3 will change the way desktop will be looked at and used, GNOME 3 has redefined the word usability and it has put that word back into desktop. It has combines the effectivemess, speed and usability of tiling WMs and user-frindliness of desktops. There are many desktop UIs already developed for your desktop computers and many will be developed in future. The only difference is inbetween past and future desktop UIs lies GNOME 3. GNOME 3 will pave the way for future desktop UIs. I am using computers from last 10 years and WMs from last 5 years and in last 3 years I tried to use different desktops but could never use any for more than 2 minutes. Now I am using GNOME 3 from 2 weeks because GNOME 3 is not just a desktop, it is the reincarnation of desktop. I see that desktop is moving from traditional way (eye-candy) towards more usable way (tiling WMs) and GNOME 3 team has shown us the way. GNOME 3 team is decade ahead in innovation, is solving practical problems and I think it needs a well-done pat-on-the-back from me at least for their great work

Copyright © 2013 Arnuld Uttre, Village – Patti, P.O – Manakpur, Tehsil – Nangal, Distt. – Ropar, Punjab (INDIA). Image produced above is a modified work of art (originally taken from Wikipedia) and hence released under the license mentioned at http://en.wikipedia.org/wiki/Thumbs_signal

Verbatim copying and distribution of this entire article are permitted worldwide, without royalty, in any medium, provided this notice, and the copyright notice, are preserved.

#include <iostream>
#include <new>

int main()
{
  char * t = new char[1];

  if(!t) 
    {
      printf("Memory Exhausted\n");
      exit(EXIT_FAILURE);
    }

  t[0] = 'A';

  printf("t[0] = %c\n", t[0]);
  return 0;
}

Everything looks fine and g++ (on RHEL 5) even compiles/runs with flags (-ansi -pedantic -Wall -Wextra) and without any warning/error. Program just seems to be technically correct (which it is seems like but isn’t) and prints the value inside array as expected. Now let us take a more basic look at this. Why we are using printf() in a C++ program when C++ has its own standard library ? The program we have writen is actually C in C++. It is like using a powerful mechanism and throwing all the powerful tools/methods away because you don’t want to know about them. Many industrial programmers don’t want to know about it because life goes on fine without knowing about it and they are still earning much higer salaries without knowing it (and they will keep on increasing their monthly income by impressing HR guys with a bag of languages and big projects on their Resumes). Hence Why bother ? Wrong reasons. If you are really looking for laziness then find it elsewhere because laziness equals to the amount of bugs in programming. Rewrite it the C++ way:

#include <iostream>
#include <new>

int main()
{
  char * t = new char[1];

  if(!t) 
    {
      std::cerr << "Memory Exhausted" << std::endl;
      exit(EXIT_FAILURE);
    }

  t[0] = 'A';
  std::cerr << "t[0] = " << t[0] << std::endl;

  return 0;
}

It is still not C++. What we call it now is a mixture of C and C++ provided the programmer does not know about C++ much. He was basically a C programmer and was either forced to use C++ compiler or was too lazy to know C++. Again it compiles/runs fine as it looks technically correct. check out new operator in section 18.6.1 of current C++ standard (you can check out draft of the standard, just google for N3337.pdf). new does not return NULL, hence the check is wrong. new throws bad_alloc() if it can’t allocate memory. Hence the technically correct version looks like this:

#include <iostream>
#include <new>

int main()
{
  char * t;

  try { t = new char[1]; }
  catch(bad_alloc)
    {
      std::cerr << "Memory Exhausted" << std::endl;
      exit(EXIT_FAILURE);
    }
  
  return 0;
}

This will never compile. Why ? Because you did not mention where bad_alloc is coming from. It is in standard library, hence you need to use std::bad_alloc. If you think you simply dump the whole standard namespac by using using namespace std in there, then you really need to read C++ FAQs before writing C++ programs any further. You need to think why I am writing std::cout instead of usual cout used by typical Indian programmers. Let us try one more time:

#include <iostream>
#include <new>

int main()
{
  char * t;

  try { t = new char[1]; }
  catch(std::bad_alloc)
    {
      std::cerr << "Memory Exhausted" << std::endl;
      exit(EXIT_FAILURE);
    }

  t[0] = 'A';
  std::cout << "t[0] = " << t[0] << std::endl;

  return 0;
}

This seems like pure C++. Yes, it is. Sure ? We still have one general programmig problem remaining to be solved. If you call exit() then you are not being practical, e.g. you wrote a client which connects to a server. One of the users of your software is connected and suddenly he is out of memory, then you program will just disconnect without saying a bye. Server will not like it and may log it as an error or will wait for an automatic timeout.

That was a general exmaple, let us look at more technical example. When a game adjusts your resolution to 640×480 and resets it back to normal (say 1280×1024), it will call destructor on 640×480 in resetting but it will not do so because exit() will not call the destructor, you will get stuck in a low resolution screen. It happens when some games crash without throwing an exception and rolling back the stack. So what do you do ? Let us try one last time to write pure C++ code

#include <iostream>
#include <new>

int main()
{
  char * t;

  try { t = new char[1]; }
  catch(std::bad_alloc)
    {
      std::cerr << "Memory Exhausted" << std::endl;
      return EXIT_FAILURE;
    }

  t[0] = 'A';
  std::cout << "t[0] = " << t[0] << std::endl;

  return 0;
}

NOTE: There is still a way if you want to check for NULL (instead of catch()ing an exception). You can use the nothrow version of new operator which returns a NULL pointer instead of throwing an exception but you have to mention it explicitly.

Copyright © 2012 Arnuld Uttre, Village – Patti, P.O – Manakpur, Tehsil – Nangal, Distt. – Ropar, Punjab (INDIA)

Verbatim copying and distribution of this entire article are permitted worldwide, without royalty, in any medium, provided this notice, and the copyright notice, are preserved.

/* A queue implementation with the operations that I need:
 *  (1) Add an element to the front (head) of the queue
 *  (2) Remove an element from rear (tail) of the queue
 *  (2) remove an element with a unique ID (string constant)
 *  (3) compare 2 elements (string comparison) 
 *  (4) print queue
 *
 * VERSION 0.0
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

enum { SIZE_ID = 100, SIZE_ARR = 20, REPS = 3 };

struct myQ
{
  char id[SIZE_ID+1];
  struct myQ* next;
};

struct myList
{
  struct myQ* head;
  struct myQ* tail;
};



struct myList* allocmyList(void);
int enqueue(struct myList* s, const char* id);
struct myQ* dequeue(struct myList** s); 
void removeElement(struct myList* s, const char* id);
struct myQ* searchElement(struct myList* s, const char* is, struct myQ** pr);
void deleteElement(struct myList* s, struct myQ* q, struct myQ* prev);
void printQ(struct myList* s);


int main(void)
{
  struct myList* s = allocmyList();
  int i;
  for(i = 0; i < REPS; ++i)
    {
      int r;
      char arrc[SIZE_ARR+1];
      r = sprintf(arrc, "%d", i);
      if(0 > r) 
	{
	  printf("ERROR-SPRINF() = %d\n", r);
	}
      else
	{
	  enqueue(s, arrc);
	}
      printf("s->head = %p, s->tail = %p\n", (void*)s->head, (void*)s->tail);
    }
 
  printQ(s);
  dequeue(&s);
  printQ(s);
  free(s);

  return 0;
}


int enqueue(struct myList* s, const char* id)
{
  struct myQ *p;
  if(NULL == s || NULL == id) return -1;
  p = malloc(1 * (sizeof *p));
  if(NULL == p) return -1;
  strcpy(p->id, id);

  if(s->head)
    {
      p->next = s->head;
      s->head = p;
    }
  else
    {
      s->head = s->tail = p;
    }

  return 1;
}


struct myQ* dequeue(struct myList** s)
{
  struct myQ *temp, *prev;
  if(NULL == s || NULL == *s) return 0;
  if(NULL == (*s)->head) return 0;
  prev = (*s)->head;
  temp = (*s)->head;
  if(NULL == (*s)->head->next)
    {
      struct myQ* retp = (*s)->head;
      (*s)->head = (*s)->tail = NULL;
      return retp;
    }
  
  while(temp->next)
    {
      prev = temp;
      temp = temp->next;
    }

  (*s)->tail = prev;

  return temp;
}
       

void removeElement(struct myList* s, const char* id)
{
  struct myQ *p, *prev;
  if(NULL == s || NULL == id) return;
  p = searchElement(s, id, &prev);
  if(p)
    {
      deleteElement(s, p, prev);
    }
}


struct myQ* searchElement(struct myList* s, const char* id, struct myQ** pr)
{
  struct myQ *prev, *cur;
  prev = s->head;
  for(cur = s->head; cur; cur = cur->next)
    {
      if(0 == strcmp(cur->id, id)) { *pr = prev; return cur;}
      else prev = cur;
    }

  return NULL;
}


void deleteElement(struct myList* s, struct myQ* q, struct myQ* prev)
{
  if(0 == strcmp(s->head->id, q->id)) /* removing head */
    {
      s->head = q->next;
      free(q);
    }
  else 
    {
      prev->next = q->next;
      free(q);
    }
}

void printQ(struct myList* s)
{
  if(s)
    {
      struct myQ* t;
      for(t = s->head; t; t = t->next) printf("ID = %s\n", t->id);
    }
  else
    {
      printf("Nothing to print\n");
    }

  printf("--------------------------------\n");
}
	

struct myList* allocmyList(void)
{
  struct myList* p = malloc(1 * (sizeof *p));
  if(NULL == p) exit(EXIT_FAILURE);
  p->head = NULL;
  p->tail = NULL;
  return p;
}

There are 3 problems:

1. Dequeue operation is O(N). In Queue, addition and deletion are O(1). Can you see why deletion is O(N) here ?
2. Dequeue does not need to take the address of original pointer. It is not needed.
3. Memory Leak. None of the elements are free()ed.
4. Enqueue() allocated new element but does not set its “next pointer” to NULL. This error was completely ignored by gcc on CentOS 5 machine I am using.

Here is the correct code:

/* A queue implementation with the operations that I need:
 *  (1) Add an element to the front (head) of the queue
 *  (2) Remove an element from rear (tail) of the queue
 *  (2) remove an element with a unique ID (string constant)
 *  (3) compare 2 elements (string comparison) 
 *  (4) print queue
 *
 * VERSION 0.1
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

enum { SIZE_ID = 100, SIZE_ARR = 20, REPS = 3 };

struct myQ
{
  char id[SIZE_ID+1];
  struct myQ* next;
};

struct myList
{
  struct myQ* head;
  struct myQ* tail;
};



struct myList* allocmyList(void);
int enqueue(struct myList* s, const char* id);
struct myQ* dequeue(struct myList* s); 
void removeElement(struct myList* s, const char* id);
struct myQ* searchElement(struct myList* s, const char* is, struct myQ** pr);
void deleteElement(struct myList* s, struct myQ* q, struct myQ* prev);
void printQ(struct myList* s);


int main(void)
{
  struct myQ* temp = NULL;
  struct myList* s = allocmyList();
  int i;
  for(i = 0; i < REPS; ++i)
    {
      int r;
      char arrc[SIZE_ARR+1];
      r = sprintf(arrc, "%d", i);
      if(0 > r) 
	{
	  printf("ERROR-SPRINF() = %d\n", r);
	}
      else
	{
	  enqueue(s, arrc);
	}
      printf("s->head = %p, s->tail = %p\n", (void*)s->head, (void*)s->tail);
    }
 
  printQ(s);
  temp = dequeue(s);
  free(temp);
  printQ(s);
  temp = dequeue(s);
  free(temp);
  printQ(s);
  temp = dequeue(s);
  free(temp);
  printQ(s);
  temp = dequeue(s);
  free(temp);
  printQ(s);
  free(s);

  return 0;
}


int enqueue(struct myList* s, const char* id)
{
  struct myQ *p;
  if(NULL == s || NULL == id) return -1;
  p = malloc(1 * (sizeof *p));
  if(NULL == p) return -1;
  strcpy(p->id, id);
  p->next = NULL;

  if(NULL == s->head) s->head = p;
  else s->tail->next = p;
  s->tail = p;

  return 1;
}


struct myQ* dequeue(struct myList* s)
{
  struct myQ *retp;
  if(NULL == s || NULL == s->head) return NULL;
  
  retp = s->head;
  s->head = s->head->next;
  if(NULL == s->head) s->tail = s->head;
  return retp;
}
       

void removeElement(struct myList* s, const char* id)
{
  struct myQ *p, *prev;
  if(NULL == s || NULL == id) return;
  p = searchElement(s, id, &prev);
  if(p)
    {
      deleteElement(s, p, prev);
    }
}


struct myQ* searchElement(struct myList* s, const char* id, struct myQ** pr)
{
  struct myQ *prev, *cur;
  prev = s->head;
  for(cur = s->head; cur; cur = cur->next)
    {
      if(0 == strcmp(cur->id, id)) { *pr = prev; return cur;}
      else prev = cur;
    }

  return NULL;
}


void deleteElement(struct myList* s, struct myQ* q, struct myQ* prev)
{
  if(0 == strcmp(s->head->id, q->id)) /* removing head */
    {
      s->head = q->next;
      free(q);
    }
  else 
    {
      prev->next = q->next;
      free(q);
    }
}

void printQ(struct myList* s)
{
  if(s)
    {
      struct myQ* t = NULL;
      for(t = s->head; t; t = t->next) printf("ID = %s\n", t->id);
    }
  else
    {
      printf("Nothing to print\n");
    }

  printf("--------------------------------\n");
}
	

struct myList* allocmyList(void)
{
  struct myList* p = malloc(1 * (sizeof *p));
  if(NULL == p) exit(EXIT_FAILURE);
  p->head = NULL;
  p->tail = NULL;
  return p;
}

Deletion was O(N) because you get O(1) only if you add to tail and remove from head (in case of singly linked list) whereas I was adding to head and removing from tail and because of that I had to find previous pointer and set the tail of Queue to point to it and this operation was O(N).

Copyright © 2012 Arnuld Uttre, Village – Patti, P.O – Manakpur, Tehsil – Nangal, Distt. – Ropar, Punjab (INDIA)

Verbatim copying and distribution of this entire article are permitted worldwide, without royalty, in any medium, provided this notice, and the copyright notice, are preserved.

/* By considering the terms in the Fibonacci sequence whose values do not exceed four million, 
 * find the sum of the even-valued terms.
 */
#include <stdio.h>
 
unsigned long fib(unsigned long num);
 
 
int main(void)
{
  const unsigned long limit = 8;
  unsigned long sum = 0;
  unsigned long i = 0;
 
  for(i = 0; i <= limit; ++i)
    {
      unsigned long j = fib(i);
 
      if(0 == (j % 2))
        {
          sum += j;
        }
    }
 
  printf("Sum of all Fibonaci even numbers upto %lu = (%lu)\n", limit, sum);
 
  return 0;
}
 
 
unsigned long fib(unsigned long num)
{
  unsigned long temp = 0;
  
  if((0 == num) || (1 == num))
    {
      temp = 1;
    }
  else
    {
      temp = fib(num - 1) + fib(num - 2);
    }
 
  return temp;
}
 
 

What can you see from above code. I got the meaning of problem statement totally wrong. Problem says “I need to add all Fibonacci numbers with values upto 4 million” whereas I took it as “add all numbers upto 4 million as input to Fibonacci”. 2nd, What else is wrong ? Can you spot it ? Stop reading right now and run this in your compiler. If you have gcc then please use -ansi -pedantic -Wall -Wextra flags. Go ahead and try and come back again. This program keeps on running for 11 minutes when limit is 400. The recirsive call eats all CPU. Even after 11 minutes I killed it. My machine is quite average in terms of hardware. Imagine at 4 million as input, how many years it will take to complete ? So what do we do ? First we get our brains right that it requires us to add all Fibonacci values less than 4 millions. 2nd, we will not use recursion and instead we will make use of the fact that F(N) = F(N-1) + F(N-2) provided F(0) = F(1) = 1, where F is fibonacci for N. We can rememeber last two fibonacci numbers in some variables instead of using recursion to find out every time. Recursion uses a lot of stack and I don’t think you should assume that you will have stack for 4 millions. Here is the correct and new iterative version.

/* By considering the terms in the Fibonacci sequence whose values do not exceed four million, 
 * find the sum of the even-valued terms.
 */
#include <stdio.h>
 
int main(void)
{
  const unsigned long limit = 4000000;
  unsigned long sum = 0;
  unsigned long i = 0;
 
  unsigned long f = 1; /* Fibonacci(0); */
  unsigned long f2 = 1; /* Fibonacci(0); */ 
  unsigned long f1 = 1; /* Fibonacci(1); */
 
  for(i = 2; f <= limit ; ++i)
    {
      /* In first iteration, Fibonacci(2) = F(1) + F(0) */
      f = f1 + f2;
      if(0 == (f % 2))
        {
          sum += f;
        }
 
      f2 = f1;
      f1 = f;
    }
 
  printf("Sum of all Fibonaci even numbers upto %lu = (%lu)\n", limit, sum);
 
  return 0;
}
 

I still see something wrong with above code. Did you notice several issues ? Don’t just read ahead, read the code and see how it fits problem statement. Its using <= instead of < . Problem statement says “upto 4 millions” and that does not include 4 millionth term (##c on freenode correct me on this as I am not a native English speaker. I thought “upto” included 4 millions). Other problem is using iteger i. We are not iterating for a specific number of times but till a certain condition is reached without caring how many times we iterated. So we need to remove that counter.

/* By considering the terms in the Fibonacci sequence whose values do not exceed four million, 
 * find the sum of the even-valued terms.
 *
 * My Method: F(n) = F(n-1) + F(n - 2) (where F(0) = F(1) = 1)
 * find the sum of all values where F(n) is even, till 4 million
 *
 */
#include <stdio.h>

int main(void)
{
  const unsigned long limit = 4000000;
  unsigned long sum = 0;

  unsigned long f = 0; /* Fibonacci(0); */
  unsigned long f2 = 0; /* Fibonacci(0); */ 
  unsigned long f1 = 1; /* Fibonacci(1); */

  while((f1 < limit) && (f2 < limit))
    {
      /* In first iteration, F(2) = F(1) + F(0) */
      f = f1 + f2;
      if(f >= limit) break;

      if(0 == (f % 2))
	{
	  sum += f;
	}

      f2 = f1;
      f1 = f;
    }

  printf("Sum of all Fibonaci even numbers upto %lu = (%lu)\n", limit, sum);

  return 0;
}

How long it takes to execute. As per ideone.com , it take 0.02 seconds. And I was waiting for 11 minutes for the first piece of code. How much good programming practice is worth of ? a few thousands extra in salary of the programmer, a millions for the bugs caused or the entire bank account multi-billioon dollor corporation if it hires all bad programmers ? What do you think ?

Copyright © 2012 Arnuld Uttre, Village – Patti, P.O – Manakpur, Tehsil – Nangal, Distt. – Ropar, Punjab (INDIA)

Verbatim copying and distribution of this entire article are permitted worldwide, without royalty, in any medium, provided this notice, and the copyright notice, are preserved.

#include <stdio.h>
#include <time.h>
 
int main(void)
{
     char s[100];
     int rc;
     time_t temp;
     struct tm *timeptr;
 
     temp = time(NULL);
     timeptr = localtime(&temp);
 
     rc = strftime(s,sizeof(s),"Today is %A, %b %d.\nTime:  %r", timeptr);
     printf("%d characters written.\n%s\n",rc,s);
 
     return 0;
}
 
/*************************************************
     The output should be similar to:
     46 characters written
     Today is Wednesday, Oct 24.
     Time:  01:01:15 PM
************************************************************/

This C program is not correct. Do you see anything wrong with code ? What is it ? Do you see anything wrong with calls of localtime() and strftime() ? Return values from them are not checked:

• localtime():

Returns NULL when some error occures. You pass this NULL to strftime() and whoaaa.. you got undefined behavior.

• strftime():

Even if localtime() behaved correctly strftime() can return with an error condition. IBM’s code does save return value but again does no check of it. Program is simply printing array passed to strftime() without checking if return value was zero or not. Man page of strftime() says:

The strftime() function returns the number of characters placed in the array, not including the terminating null byte, provided the string, including the terminating null byte, fits. Otherwise, it returns 0, and the contents of the array is undefined. (Thus at least since libc 4.4.4; very old versions of libc, such as libc 4.4.1, would return max if the array was too small.)

Now if the contents of array are undefined then behavior of program is undefined too because you are trying to print an array with undefined contents. It can cause crash (if you are lucky), it can print garbage (you are still lucky) or it can just work fine printing the time because most of the time there will no error and that is utter badluck because definitely it will crash on first run when client is using it (trust me, its very ususal). So what we do ? Just two simple checks and client will be happy and that includes your happiness too. Here is the fixed code:

#include <stdio.h>
#include <time.h>
 
int main(void)
{
     time_t temp;
     struct tm *timeptr;
 
     temp = time(NULL);
     timeptr = localtime(&temp);

     if(NULL == timeptr)
       {
	 printf("Error localtime()\n");
       }
     else
       {
	 int rc;
	 char s[100] = {0}; 
	 rc = strftime(s,sizeof(s),"Today is %A, %b %d.\nTime:  %r", timeptr);
	 if(0 == rc)
	   {
	     printf("Error strftime()\n");
	   }
	 else
	   {
	     printf("%d characters written.\n%s\n",rc,s);
	   }
       }

     return 0;
}
 
/*************************************************
Compiled on Linux:

/home/arnuld/programs/C $ gcc -std=c99 -pedantic -Wall -Wextra ibm.c 
/home/arnuld/programs/C $ ./a.out 
43 characters written.
Today is Monday, Jun 04.
Time:  03:50:57 PM
/home/arnuld/programs/C $ 
************************************************************/

There is one more change. I have put varibales in closest possible block (check out int rc and char s, it is because I don’t see the point of decalring them earlier and using them later. Local variables must be decalred/defined in the closest block possible. Another difference is I am initializing the array with null characters (or filling it with zeroes) so that it does not contain any garbage. This is actually more of a matter of style, a personal thing rather than a rule to write correct programs in C. It does write correct program and its not required that you do same while the first change regarding keeping variables in tightest scope possible definitely comes under one of the methods of writing good C programs.

Copyright © 2012 Arnuld Uttre, Village – Patti, P.O – Manakpur, Tehsil – Nangal, Distt. – Ropar, Punjab (INDIA)

Verbatim copying and distribution of this entire article are permitted worldwide, without royalty, in any medium, provided this notice, and the copyright notice, are preserved.

/* (1) Write a program that prints the numbers from 1 to 100. But for multiples of three print "Fizz" instead of the 
number and for the multiples of five print "Buzz". For numbers which are multiples of both three and five print "FizzBuzz".

 (2) Write function to compute Nth fibonacci number

 (3) print all odd numbers between 1 and 99
 */

#include <stdio.h>

enum { LIMIT = 100 };

void fib(const int n);
void print_odds(const int limit);
void print_fizzbuzz(const int limit);

int main(void)
{
	print_fizzbuzz(LIMIT); 
	printf("\n\n");
	print_odds(LIMIT-1); 
	printf("\n\n");
	fib(20);
	return 0;
}

/* No int/unsigned-long overflow check */
void fib(const int n)
{
	unsigned long f0 = 0;
	unsigned long f1 = 1;
	unsigned long fnum = f1;
	int i;
	if((0 == n) || (1 == n))
	{
		printf("fib(%d) = %d\n", n, n);
		return;
	}
	for(i = 2; i <= n; ++i)
	{
		fnum = f1 + f0;
		f0 = f1;
		f1 = fnum;
	}
	
	printf("fib(%d) = %lu", n, fnum);
}

void print_odds(const int limit)
{
	int i;
	for(i = 1; i <= limit; i = i + 2)
	{
		printf("%d\t", i);
	}
	printf("\n");
}

void print_fizzbuzz(const int limit)
{
	int i;
	for(i = 0; i <= limit; ++i)
	{
		if((0 == i%3) && (0 == i%5))
		{
			printf("fizzbuzz\t");
		}
		else if(0 == i%3)
		{
			printf("fizz\t");
		}
		else if(0 == i%5)
		{
			printf("buzz\t");
		}
		else
		{
			printf("%d\t", i);
		}
	}
	printf("\n");
}

Copyright © 2012 Arnuld Uttre, Village – Patti, P.O – Manakpur, Tehsil – Nangal, Distt. – Ropar, Punjab (INDIA)

Verbatim copying and distribution of this entire article are permitted worldwide, without royalty, in any medium, provided this notice, and the copyright notice, are preserved.

/* Add all the natural numbers below one thousand that are multiples of 3 or 5. 
 * version 0.1
 */

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
  int i;
  unsigned long s = 0;
  
  for (i = 3; i < 1000; i += 3)
    s += i;

  for (i = 5; i < 1000; i += 5)
    {
      if(i % 3) s += i;
    }

  printf("%lu\n", s);

  return EXIT_SUCCESS;
}

After you solve a problem and give correct answer, it shows in your registered account as solved and a link to the forum thread is also provided where you can see different kinds of solutions posted in different languages. It also shows how many people so far have solved the problem. Thats a good measure of your intelligence (if very few has solved it). Iam using C language for now to solve problems as C is the only language I know currently. I think you must go ahead and give Project Euler a try.

Copyright © 2012 Arnuld Uttre, Village – Patti, P.O – Manakpur, Tehsil – Nangal, Distt. – Ropar, Punjab (INDIA)

Verbatim copying and distribution of this entire article are permitted worldwide, without royalty, in any medium, provided this notice, and the copyright notice, are preserved.

The complexity of C++ (even more complexity has been added in the new C++), and the resulting impact on productivity, is no longer justified. All the hoops that the C++ programmer had to jump through in order to use a C-compatible language make no sense anymore — they’re just a waste of time and effort. Now, Go makes much more sense for the class of problems that C++ was originally intended to solve.

Now thats a pretty solid and strong statement, I got shakes reading that and it reminded me of The Case for D by Andrei Alexandrescu. Go is designed by a team consiting of our good old friends Rob Pike and Ken Thompson. It has some very good positive reviews. I still have to read the criticizm of it. As per computer language shootout results, C (using GNU’s gcc) is far faster but the code-size of Go was much less (almost 1/3rd). Next on comparison was C++ (GNU’s g++) and results were almost same. Next on my list were Lisp and ATS. checkout the results yourself down here in graphs.

I discussed this performance issue on Go language IRC channel (#go-nuts, freenode) and they gave me very logical and accurate explanation that Go is not mature yet and performance comparison is with very mature C and C++ libraries which are around for a decade or more. So I cna conclude comparison is not exactly a fair comparison. I think Go will catch up with performance issues very fast as user base is growing at electric pace. Reminds me of the times and discussion when Python’s user base was growing and they were trying to resolve all the issues they could with full hard work.

Whenever a new language comes or whenever you want to learn an already established language, I think you must look into why that language was created in first place. Does that match your why of learning ? you must be using that language for some purpose, does the design goal suit your purpose ? In my case I think Go language suits, here is the excerpt from Does the world need another programming language ?

A couple of years ago, several of us at Google became a little frustrated with the software development process, and particularly using C++ to write large server software. We found that the binaries tended to be much too big. They took too long to compile. And the language itself, which is pretty much the main system software language in the world right now, is a very old language. A lot of the ideas and changes in hardware that have come about in the last couple of decades haven’t had a chance to influence C++. So we sat down with a clean sheet of paper and tried to design a language that would solve the problems that we have: we need to build software quickly, have it run well on modern multi-core hardware and in a network environment, and be a pleasure to use.

Go has the feel of a dynamic language like Python or Ruby or JavaScript, but it has the performance and safety of a language like Java or C or C++. So you get the lightweight feel of a modern scripting dynamic language but the robustness and performance of a more old-fashioned language.

Based solely on the above criteria I think I can start using Go right away and if I don’t have enough mature libraries or some specific functionality, then ATS is always there. When companies become big they become rigid, like a stubborn spoilt son of a businessman. They refuse to change to get edge over other software corporations because the change requires a lot of effort. I think the weight of word “Google” behind Go programming language will give it an edge over that rigidity. (same thinkg with Java and .NET).

Copyright © 2012 Arnuld Uttre, Village – Patti, P.O – Manakpur, Tehsil – Nangal, Distt. – Ropar, Punjab (INDIA)

Verbatim copying and distribution of this entire article are permitted worldwide, without royalty, in any medium, provided this notice, and the copyright notice, are preserved.