Here’s an excerpt:

The concert hall at the Sydney Opera House holds 2,700 people. This blog was viewed about 14,000 times in 2011. If it were a concert at Sydney Opera House, it would take about 5 sold-out performances for that many people to see it.

Click here to see the complete report.

#include <stdio.h>

int main(void)
{
  printf("%x\n", -1<<4);

  return 0;

}

=============== OUTPUT ====================
/home/arnuld/programs/C $ gcc -ansi -pedantic -Wall -Wextra interview-2.c
/home/arnuld/programs/C $ ./a.out
fffffff0
/home/arnuld/programs/C $

If you change %x to %d, you will get -16 as result, fffffff0 is just hexadecimal representation of it. You see that I am using strict ANSI mode and there are no warnings, program compiles fine and gives output as fine as input. Did you notice something wrong ?

Google for n1256.pdf, draft of the ANSI standard and it will be sufficient for your needs if your need is to become a C programmer following ANSI standard and this is what I do. n1256.pdf in Section 6.5.7 (4) states:

The result of E1 << E2 is E1 left shifted E2 bit positions; vacated bits are filled with zeroes. If E1 has unsigned type, the result is E1x2^E2, reduced modulo one more than the maximum value representable in the result type. If E1 has a signed type and nonnegative value, and E1x2^E2 is representable in the result type, then that is resulting value; otherwise , the behavior is undefined.

If you pick up a copy of C – A Reference manual by Harbison and Steele 5th editon, lovingly known as H&S5, you will see section 7.6.3 states:

1. Applying the shift operator >> is not portable when the left operand is negative, signed value and the right operand is nonzero.
2. The result value of shift operator is undefined if the value of right operand is negative. The result value is also undefined if the valu eof right operand is greater than or equal to the width (in bits) of the value of the converted left operand.
3. The right operand may be zero, in which case no shift occurs and result value is identical to the value of the left operand
4. Each operand must be an integral type. The usual unary conversions are performed on each operand and the result is the converted left operand. The result is not an lvalue.

Did you notice how many things you learned by oberving simple one line program ? Almost 5 basic distinctions before you start using bit-shifting in production environment. I have seen programmers in India (both CS engineering students and professionals doing C programming for almost a decade) always trying to srtive for writing bigger and complex programs and almost always avoiding all these small details of how any one of the C’s basic data structues or operators work. They almost hate going into basics. At the same time I observed masters and C experts writing small, terse, succinct and simpler programmes. I follow the masters. Who does not want to become a good C programmer ?

It is proved that this interview code has undefined behavior. (unfortunately it was a MCQ (Multiple Choice Question) and undefined behavior was not one of the options. You can Google for this question and see the answers for yourself ).

The above problem is just half of the story. Ben Bacarisse on comp.lang.c told me the other half of the story. The “%x” inside printf() expects an unisgned int argument but interview questions is passing it a signed value hence causing Undefined Behavior (UB in short). Hence above interview code is broken 2 times. Replacing that printf with printf(“%x\n”, (unsigned)-1<<4); would have fixed both problems. You can see the original discussion at Google groups and Rhinocerus forums and Velocity Reviews Forums using your web browser. Once again they all represent web-inerface to Usenet newsgroup comp.lang.c. I use PAN for reading comp.lang.c. Google for the list of news readeing softwares.

In fact, this another program is god for understanding how bit shifting works. Again I got it from comp.lang.c discussions:

#include <stdio.h>

enum { LIMIT = 16 };

int main(void)
{
  int i;

  for(i = 0; i <= LIMIT; ++i)
    {
      printf("%d is shifted left by %d bits, place %s = %d\n", 100, i, i==1?"":"s", 100<<i);
    }

  return 0;
}

===================== OUTPUT =====================
[arnuld@dune C]$ gcc -ansi -pedantic -Wall -Wextra bitshift.c
[arnuld@dune C]$ ./a.out
100 is shifted left by 0 bits, place s = 100
100 is shifted left by 1 bits, place = 200
100 is shifted left by 2 bits, place s = 400
100 is shifted left by 3 bits, place s = 800
100 is shifted left by 4 bits, place s = 1600
100 is shifted left by 5 bits, place s = 3200
100 is shifted left by 6 bits, place s = 6400
100 is shifted left by 7 bits, place s = 12800
100 is shifted left by 8 bits, place s = 25600
100 is shifted left by 9 bits, place s = 51200
100 is shifted left by 10 bits, place s = 102400
100 is shifted left by 11 bits, place s = 204800
100 is shifted left by 12 bits, place s = 409600
100 is shifted left by 13 bits, place s = 819200
100 is shifted left by 14 bits, place s = 1638400
100 is shifted left by 15 bits, place s = 3276800
100 is shifted left by 16 bits, place s = 6553600
[arnuld@dune C]$

You will see everytime you shift a bit left, result is as if input (100) multiplied by 2. Hence if you shift 2 bits, the output is 100 * 2^2 = 400 which gives you precise idea of what the output will be without even writing a program . Now ask yourself (without modifying the program) what right shifting will result in ?

Copyright © 2011 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.

This is Insertion Sort from Wikipedia which is similar to Cormen’s book:

for j = 1 to length(A)-1
     key = A[ j ]
      i = j - 1
     while i >= 0 and A [ i ] > key
         A[ i +1 ] = A[ i ]
         i = i -1
     A [i +1] = key

Felt too much confused with this, I tried to understand many times but never did. Did not find anyone explaining in the way I understand, hence I tried to use a C array of integers to understand and came up with this:

1. Take A = {3,5,2} as array to apply Insertion Sort pseudo code
2. first 3 lines: j = 1, key = 5, i = 0
3. while loop will not execute as A[0] = 3 and 3 > 5 is not true A = {3,5,2}
4. Last line: A = {3,5,2}
5. Outer loop 2nd turn, first three lines: j = 2, key = 2 , i = 1
6. After inner while loop, first round A = {3,2,5}, i = 0
7. After inner while loop, second round A = {3,3,5}, i = -1
8. Last line: {2,3,5}
9. Outer Loop finishes array is sorted

I am not a child prodigy hence it took me 3 hours to come up with an array with right elements in place. I did 3 pages of paper work with wrong values and wrong indices before I got them right. (please add 5 more days where I tried really haaaaaaaard to understand from the book). Hard part was not understanding the example of playing cards. Cormen’s book uses playing cards example to show insertion sort (special thanks to the authors as that picture of a hand sorting cards really helped). Real life sorting of playing card is very easy, I have done it a thousand times without thinking. Translating that practical approach into pseudo code was the hard part.

Copyright © 2011 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.

http://www.velocityreviews.com/forums/t752581-reading-a-file-into-std-string.html

http://www.rhinocerus.net/forum/language-c/682219-reading-file-into-std-string.html

I wrote the code as a C Programmer who did some google search and read a few pages of Stroustrup. Red Floyd posted a true C++ version. You see how much the difference in thinking, Red Floyd’s code is much superior than mine. You can easily conclude that C++ what you know or what your colleagues know is not really true C++. This program made me think harder about my learning and experience as a computer programmer. Solving problems in C++ is really vastly different from the way we do it in C. Don’t write C code and save the file with extension .cpp. If you want to write C code then please save the file as .c Lessons learned

#include <iostream>
#include <fstream>
#include <string>


int main()
{
  std::string my_contents, tmp_contents;
  std::ifstream my_file("reference.cpp");
  if(!my_file)
    {
      std::cerr << "Error Opening file" << std::endl;
      exit(EXIT_FAILURE);
    }

   while(my_file)
    {
     std::getline(my_file, tmp_contents);
     my_contents += tmp_contents;
     my_contents += "\n";
    }

  std::cout << "String contents are: "<< "\n"
	    << my_contents << std::endl;

  my_file.close();


  return 0;
}

#include <iostream>
#include <fstream>
#include <string>


int main()
{
  std::ifstream my_file("reference.cpp");
  if(!my_file)
    {
      std::cerr << "Error Opening file" << std::endl;
      exit(EXIT_FAILURE);
    }

  /* This was posted by "redfloyd" on comp.lang.c++ */
  std::string my_contents(std::istreambuf_iterator<char>(my_file.rdbuf()), (std::istreambuf_iterator<char>()));

  std::cout << "String contents are: "<< "\n"
	    << my_contents << std::endl;
  return 0;
}

Copyright © 2011 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.

NOTE: A Queue is used for adding elemnts at tail and removing them from head. Its not a good idea to remove elements from anywhere except head. Do not use use dequeu_anywhere() in production code as it is perfectly capable of causing efficiency issues in your software. Richard Heathfield once said, they are not for practical use but good for learning, as a mental exercise.

/* A Queue (FIFO)  implementation using doubly-linked list. All operations are based on page 70, section 2.4 "Data Structures and 
 *   Algorithms by Aho, Hopcraft and Ullman".
 *
 * VERSION 0.0
 *
 */

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

enum { VAL_SUCC = 0, VAL_ERR = 1};

struct dlqueue
{
  int num;
  struct dlqueue* next;
  struct dlqueue* prev;
};


struct dlqlist
{
  struct dlqueue* head;
  struct dlqueue* tail;
};



int enqueue(struct dlqlist*, int);
int dequeue(struct dlqlist*);
struct dlqueue* front(struct dlqlist*);
void makenull(struct dlqlist*);
int empty(struct dlqlist*);
void print_queue(struct dlqlist* );


int dequeue_anywhere(struct dlqlist*s , int numd);
void remove_element(struct dlqlist* s, struct dlqueue* d);


int main(void)
{
  struct dlqlist* s = malloc(1 * sizeof *s);
  if(NULL == s)
    {
      fprintf(stderr,"IN: %s @%d: Out of Memory\n", __FILE__, __LINE__);
      return EXIT_FAILURE;
    }
  else
    {
      s->head = s->tail = NULL;
    }

  enqueue(s, 10);
  enqueue(s, 11);
  enqueue(s, 12);
  enqueue(s, 13);
  print_queue(s);

  dequeue_anywhere(s,12);
  printf("\n\n----------------------------\n");
  print_queue(s);

  /*
  dequeue(s);
  printf("\n\n----------------------------\n");
  print_queue(s);

  dequeue(s);
  printf("\n\n----------------------------\n");
  print_queue(s);


  dequeue(s);
  printf("\n\n----------------------------\n");
  print_queue(s);
  */
  return EXIT_SUCCESS;
}



/* Adds an element to tail of Queue */
int enqueue(struct dlqlist* s, int i)
{
  int ret;
  if(NULL == s)
    {
      fprintf(stderr, "IN: %s @ %d: Invalid Args\n", __FILE__, __LINE__);
      ret = VAL_ERR;
    }
  else if(NULL == s->head && NULL == s->tail)
    {
      struct dlqueue* p = malloc(1 * sizeof *p);
      if(NULL == p)
	{
	  fprintf(stderr,"IN: %s @%d: Out of Memory\n", __FILE__, __LINE__);
	  ret = VAL_ERR;
	}
      else
	{
	  p->num = i;
	  p->prev = p->next = NULL;

	  s->head = s->tail = p;
	  ret = VAL_SUCC;
	}
    }
  else if(NULL == s->head || NULL == s->tail)
    {
      fprintf(stderr, "IN: %s @%d: Serious error.", __FILE__, __LINE__);
      fprintf(stderr,"List one of the list's head/tail is null while other is not\n");
      ret = VAL_ERR;
    }
  else
    {
      struct dlqueue* p = malloc(1 * sizeof *p);
      if(NULL == p)
	{
	  fprintf(stderr,"IN: %s @%d: Out of Memory\n", __FILE__, __LINE__);
	  ret = VAL_ERR;
	}
      else
	{
	  p->num = i;
	  p->prev = p->next = NULL;

	  s->tail->next = p;
	  p->prev = s->tail;
	  s->tail = p;
	  ret = VAL_SUCC;
	}
    }

  return ret;
}



int dequeue(struct dlqlist* s)
{
  int ret;
  if(NULL == s)
    {
      fprintf(stderr, "IN: %s @ %d: Invalid Args\n", __FILE__, __LINE__);
      ret = VAL_ERR;
    }
  else if(NULL == s->head && NULL == s->tail)
    {
      printf("Nothing to Dequeue()\n");
      ret = VAL_SUCC;
    }
  else if(NULL == s->head || NULL == s->tail)
    {
      fprintf(stderr, "IN: %s @%d: Serious error.", __FILE__, __LINE__);
      fprintf(stderr,"List one of the list's head/tail is null while other is not\n");
      ret = VAL_ERR;
    }
  else
    {
      struct dlqueue* p = s->head;
      if(NULL == s->head->next && NULL == s->tail->next) /* if last element */
	{
	  s->head = s->tail = NULL;
	}
      else
	{
	  s->head = s->head->next;
	}

      free(p);
      ret = VAL_SUCC;
    }

  return ret;
}


int dequeue_anywhere(struct dlqlist*s , int numd)
{
  int ret;
  if(NULL == s)
    {
      fprintf(stderr, "IN: %s @ %d: Invalid Args\n", __FILE__, __LINE__);
      ret = VAL_ERR;
    }
  else if(NULL == s->head && NULL == s->tail)
    {
      printf("Nothing to Dequeue()\n");
      ret = VAL_SUCC;
    }
  else if(NULL == s->head || NULL == s->tail)
    {
      fprintf(stderr, "IN: %s @%d: Serious error.", __FILE__, __LINE__);
      fprintf(stderr,"List one of the list's head/tail is null while other is not\n");
      ret = VAL_ERR;
    }
  else
    {
      struct dlqueue* p = s->head;
      for(; p; p = p->next)
	{
	  if(numd == p->num)
	    {
	      remove_element(s,p);
	    }
	}
      ret = VAL_SUCC;
    }

  return ret;
}


void remove_element(struct dlqlist* s, struct dlqueue* d)
{
  if(NULL == d->next && (NULL == s->head->next && NULL == s->tail->next)) /* only one element in queue */
    {
      s->head = s->tail = NULL;
    }
  else if((NULL == d->next) && d->prev) /* removing tail */
    {
      s->tail = d->prev;
      d->prev->next = NULL;
    }
  else if(d->next && (NULL == d->prev)) /* removing head */
    {
      s->head = d->next;
      s->head->prev = NULL;
    }
  else /* removing from center or somewhere */
    {
      d->prev->next = d->next;
      d->next->prev = d->prev;
    }

  free(d);
}

void remove_element_2(struct dlqlist* s, struct dlqueue* d)
{
  if(NULL == d->next)
    {
      s->tail = d->prev;
    }
  else
    {
      d->next->prev = d->prev;
    }

  if(NULL == d->prev)
    {
      s->head = d->next;
    }
  else
    {
      d->prev->next = d->next;
    }

  free(d);


}


void print_queue(struct dlqlist* s)
{
  if(NULL == s)
    {
      fprintf(stderr, "IN: %s @ %d: Invalid Args\n", __FILE__, __LINE__);
     }
  else if(NULL == s->head && NULL == s->tail)
    {
      printf("Nothing to print\n");
    }
  else if(NULL == s->head || NULL == s->tail)
    {
      fprintf(stderr, "IN: %s @%d: Serious error.", __FILE__, __LINE__);
      fprintf(stderr,"List one of the list's head/tail is null while other is not\n");
    }
  else
    {
      struct dlqueue* p = s->head;
      while(p)
	{
	  printf("num = %d\n", p->num);
	  p = p->next;
	}
    }
}

Copyright © 2011 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.

• Solving Problems: Programming is all about solving problems. I knew that (and I am sure you knew that too), every programmer know this but how many programmers translate business problems into code? May be you are working on the problem which is just your interpretation of the problem? What is the real business problem you are trying to solve on your job as a programmer? You are actually a translator between a business man and computer.

• Diagrams: Before you even think about coding you must draw a digram on how you are going to split this business problem into some or lots of small ones and what will be the general idea behind solving this problem. That you can accomplish very effectively by drawing a diagram on paper using a pen (or pencil). Also known as DFDs (Data Flow Diagrams). You will see how much of your life has become easier with DFDs. DFDs follow some rules and you can make your own diagrams and your own rules but make sure you stick to some standard (whether your own or someone else). DFDs are designed to make your life easier, it will make you happy because once you start coding you will see how important they are.

• Tools: What tools you are using to translate problems into code ? Whether you are solving business problems or you do it for joy of solving problems (in the world of Hackers), Algorithms and Data Structures are the first of the tools you need, programming language is 2nd tool. Majority of programmers do not focus on first tool. Why you need qsort() over other sorting techniques. Why AVL tree will be better than Red-Black tree or Binary-Search tree. Why you will use a circular linked list instead of a doubly-linked list implemented as a Stack ? Why there exist so many different kind of trees and linked lists. Even I, myself, know only few of them. Its hard work but surely simple and very rewarding. I think half of the bugs exist in software because programmers lack this tool or the intended use of it

• Tools-2: Like I said, programming language you are using is 2nd tool. Don’t go to high level talk here or dig yourself into advanced programming before you understand the basics. I use C language, so before I go into advanced C book, I will make sure I have spent two years on comprehending C FAQs and comp.lang.c archives

• Breaking a big problem into small problems: I am using C, which is a procedural programming language. Hence I break down a business problem into small procedures (also known as functions). I will make sure that when one procedure calls other then both of them are doing some specific work and that in a proper and structured way. Writing too many procedures or the ones which do not have a proper siginificance can (and will) cause semantic bugs which in turn cause headaches over time.

Copyright © 2011 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:     public static int binarySearch(int[] a, int key) {
2:         int low = 0;
3:         int high = a.length - 1;
4:
5:         while (low <= high) {
6:             int mid = (low + high) / 2;
7:             int midVal = a[mid];
8:
9:             if (midVal < key)
10:                 low = mid + 1
11:             else if (midVal > key)
12:                 high = mid - 1;
13:             else
14:                 return mid; // key found
15:         }
16:         return -(low + 1);  // key not found.
17:     }

Author says line 6: int mid =(low + high) / 2; is broken because if sum of low and high is greater than INT_MAX then it will overflow. From author himself; This bug can manifest itself for arrays whose length (in elements) is 2^30 or greater (roughly a billion elements). This was inconceivable back in the ’80s, when Programming Pearls was written, but it is common these days at Google and other places. He is right and I am not posting this to say what has already been said. I am interested in line 3: int high = a.length – 1;

Like I said I don’t know much about Java and if we write same line of code in C, it will overflow if a.length is long, unsigned long or anything larger than what size_t type can handle. It will give strange results (UB or Undefined Behavior). If having more than size_t elements is common for places like Google then I think line number 3 needs to be the cause of concern too, not just line number 6. You can know size of array in C with these methods:

const char* arrc = “123″;
int arri[] = {3,2,1};

first is an array of characters while 2nd is an array of integers. You can use sizeof(arri) / sizeof(arri[0]) to know number of elements in arri. To know number of elements in arrc you can use either strlen(arrc) or sizeof(arrc) / sizeof(*arrc) – 1. Both sizeof and strlen() return size_t type which is unsigned int and hence does not fit in int type. I have commented this on that blog, lets see what author says.

Copyright © 2010 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.

Copyright does not belong to Java code. Please ask for permission from the author of the following blog before using mentioned Java code: http://googleresearch.blogspot.com/2006/06/extra-extra-read-all-about-it-nearly.html

I know you will say that everyone just can’t love programming. Yes, you are right. Trouble is, Indian education system does its best to not to let creative students love computers. The whole academic syllabus will be designed and selection of books will be done in such a way they will make any creative man to hate computers. You have to find your own way, you are on your own, thats bad news. Good news is once you determined to find your way then lot of people will help you, many of them you will never meet in real life. The community of these programmers, hanging out there reading code for hours can become your favorite pass time. Real programmers are very helpful friends, instructors and teachers. You will never be spoonfed, you will never be disrespected but only analyzed and encouraged to write good programs, programs that have quality. And one thing I have learned is that qulity comes from writing small programs, not big ones. I had a misocnception when I was a graduate student (most Indian students do have same) that writing big and complex programs will make you a better programmer, It will not (actually It will but its not true for beginners, you must already be good at basics to start writing big and complex software) Unfortunately most programmers have a weak basic and fundamental grouding in what they do. Here is the answer:

• Write short programs. They will make you better. e.g. think what *p++ and *++p will do for a pointer p and what can be the result of *p++ = *++p.
• Don’t just think, write code. Reading books will not take you anywhere. Knowledge alone is essential and it won’t make you a better programmer. Write code and write more code and write a lot more code.
• Write code and read archives of comp.lang.c if you get problems. Most of the time solution will already be there. Don’t just ask for help. Search, read archives and if you can’t sit for hours reading archives and trying code, find some other profession
• Hang onto you favorite language newsgroup. For C we have comp.lang.c, same for others e.g. comp.lang.lisp, comp,land.c++ etc. you can’t be a better programmer without hanging out there for a few years.
• Be technical rather than personal on usenet. If someone says something that you don’t like because it goes against what you have learned from your school/college then please get over it. You are not in school anymore, its real world and hence things are done differently here, things are practical here
• Rather than learning three or four new languages, give priority to learn basic algorithms and data structures. They are tough, yes, and they are very rewarding when it comes to solving real world problems (which is what you will do in a software job/business). This approach will save you not only from lot of suffering caused by Segmentation Faults but also happiness will come when you see how succinct, meaningful and readable your programs have become. Thats called maturity.
• If you want to learn new language then learn something opposite to what you already know e.g. if you know C or C++ already then rather than learning Java, go learn Common Lisp, If you already know Python, then start learning learn Haskell, if you already know Perl, then learn Ruby to see how it solves the same problems. If you think you know already know a lot of programming then read Structure and Interpretation of Computer Programs and tell me how you feel

What I have written is based on my years of experience in programming. I have summarized my experience in a very small and short blog. Don’t just ignore it. I have done many mistakes as beginner and I don’t want you to waste your young years in walking a path and later realize that it was wrong. Youth won’t come again, save it, invest it to proper use. Programming is a kind of love difficult to leave once you got hooked onto living with it. Its a joy but a hard kind of joy

Copyright © 2010 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.

There are programmers I have met (very few though, you know what minority means) who are interested in sharpening their craft, who are interested in learning programming but the organization does not support such kind of environment. Most MNCs in India do not provide an environment where a programmer can learn basics of programming, they never ever talk to their programmers on why Niklaus Wirth said Algorithms + Data Structures = Programs. All of them are made busy to meet deadlines, and they have to do it else they will loose their jobs. No one wants to loose his job. There will be hundreds of programmers working on one project and almost 80% of them never know what other one is doing. There will be less than or equal to hundred source code files and those 120 or 100 or 200 programmers will be working on them and on the top of that project manager will not be knowing which data structure (in conjunction with what algorithm) was used for solving the problem and then companies wonder why their proprietary software is called crap quality by programmers who have Open Source mindset. Programming is about solving problems, solving them in a smart way, solving them with an attitude of diligence and contemplating over small, very small and very tiny parts of code. Big parts, big things do not matter when it comes to problem solving in programming (coding). If you think you should have big programs, big files and need big teams to make a fine piece of software, you are wrong. Companies already have hired hundreds of programmers, dividing them in teams and then managers are managing them like a herd of cows and they are making software this way since the inception of word software. No wonder they still have problems they were getting 20 years back, testing pahse of the code written by those hundreds is 5 to 10 times more than the coding phase. What a shame. How much it costs ? The more you do it, the more the price of end product is going to rise. You have two solutions for this problem

• MBA solution:

Filter all the empoyees based on some stupid tests taken from some books that teach wrong ways of programming. Fancy name is cost cutting, real name is jackassing in action.

• Technical solution:

Provide an environment for programmers to learn, to sharpen their programming skills. Fire the current manager (especially if he has MBA degree) and hire technical one, he will do the job better. Ask programmers why Niklaus Wirth said Algorithms + Data Structures = Programs. Fire all those programmers who are not willing to learn. If you are a opening a new division of the company, then rather than hiring 100 programmers, add the salaries of all 100 programmers, divide it by 4 and hire 3 programmers, like Richard Heathfield, Pascal Bourguignon , Victor Bazarov, Edi Weitz, H. S. Lahman or Neil Walfield. Pay them that 3 units of ‘100 divided by 4′ salary and get a piece of software which your 1000 programmers team can not create in a thousand years and I bet on that. Don’t forget Arnuld Uttre for 4th position =:o)

Many managers and programmers may (and will) think that I am talking of crap solutions. Well, You can think anything you want and I speak from experience. I talk real, I write facts. Companies who pay salaries/bonuses on who wrote more lines of code are simply wasting their resources, pay more to them who write less code. Real programs are succinct and short: for(;;) *p++ = *q++ . In India, there are too many talented programmers who are living their lives on tiny financial amount they get. There are programmers who write crap and get 10 times more salary than the real one. There are very talented programmers who are doing odd jobs because they can’t get a programming job. Whether you agree or not, a quality piece of software will always be created by a programmer who has a solid grasp of algorithms and data structures and if you don’t have such kind of programmers then, either you or your management have sheep mentality, just like everyone else.

Copyright © 2010 Arnuld Uttre, #331/type-2/sector-1, Naya Nangal, Distt. – Ropar, Punjab (INDIA) – 140126

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.

Wrote this small piece of code to get data form any web-site and save it in the program for later use. This is what I wrote in 1 hour hack, a program that compiles fine with -ansi -pedantic -Wall -Wextra flags to gcc and sill buggy:

/* WARNING: Buggy Program. Not using libcurl in a proper way. Not recommended to be even saved on HDD 
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curl/curl.h>

size_t save_data(void* buffer, size_t size, size_t nmemb, void* incoming_data);

enum {
  SIZE_ERROR_ARR = CURL_ERROR_SIZE * 4
};


int main(void)
{
  CURL* curl;
  CURLcode res;
  char error_arr[SIZE_ERROR_ARR+1] = {0};

  curl = curl_easy_init();
  if(curl)
    {
      /* Use one VERSION by commenting the other */

      /* VERSION 1 : Outputs to stdout*/ 
      curl_easy_setopt(curl, CURLOPT_URL, "http://google.com");
      res = curl_easy_perform(curl); 

      /* VERSION 2 : Saves to array 
      curl_easy_setopt(curl, CURLOPT_URL, "http://google.com");
      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, save_data);
      curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, error_arr);
      res = curl_easy_perform(curl); 
      */
      if(res)
	{
	  printf("IN: %s @%d: Some error occured while curl_easy_perform(), ERRORBUFFER said: \n", __FILE__, __LINE__);
	  printf("%s\n", error_arr);
	}

      /* always cleanup */
      curl_easy_cleanup(curl);
    }

  return 0;
}



size_t save_data(void* buffer, size_t size, size_t nmemb, void* incoming_data)
{
  size_t idx;
  const size_t END_INDEX = size * nmemb;
  char* src = (char*) buffer;

  char* dest = malloc(END_INDEX * sizeof*dest);
  memset(dest, '\0', END_INDEX);

  if(NULL == dest)
    {
      printf("IN: %s @%d: Out of Memory\n", __FILE__, __LINE__);
      exit(EXIT_FAILURE);
    }

  /*  Using Static Array by taking extremely large size wasting 100 times the memoery required.
      char dest[100001] = {0};
      How to know the size of array in advance. 
      char dest[END_INDEX + 1] = {0}; will not work as variable-size arrays are not allowed in ANSI standard. But using variable-size 
      is good solution to the problem ???
      malloc() will be expensive for 10 million http sends/receive  waitings to happen. 
      So what to do ???
  */

  for(idx = 0; idx < END_INDEX - 1; ++idx)
    {
      dest[idx] = *src++;
    }
  dest[idx] = '\0';
  printf("--------------------------------------\n");
  /* I wonder what 4th argument is used for when it contains garbage :-o */
  printf("incoming_data = %s\n", (char*)incoming_data); 
  printf("dest = %s\n", dest);

  if(0 == strcmp(dest, ""))
    {
      printf("EMPTY string received\n");
    }

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

Unfortunately, this is exactly what you can expect from a guy with no gifted ability to program, who learns from hard-work and experience only. I learn by dwelling deep into refernce manuals, man pages, FAQs and mailing-list archives and thats tough and the only one way to learn to use a program in proper way, the way the API was supposed to be used. I discussed this on mailing list and I get this reply from the creator of cURL: “See http://curl.haxx.se/libcurl/c/getinmemory.html“, one line reply which matches exactly with what I needed. Any programmer who does his home work before asking questions deserves such kind of meaningful reply .

Here is the whole conversation: http://curl.haxx.se/mail/lib-2010-11/0123.html and here is the code I needed to understand before aksing anymore questions:

/*****************************************************************************
 *                                  _   _ ____  _
 *  Project                     ___| | | |  _ \| |
 *                             / __| | | | |_) | |
 *                            | (__| |_| |  _ <| |___
 *                             \___|\___/|_| \_\_____|
 *
 *
 * Example source code to show how the callback function can be used to
 * download data into a chunk of memory instead of storing it in a file.
 */

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

#include <curl/curl.h>

struct MemoryStruct {
  char *memory;
  size_t size;
};


static size_t
WriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
{
  size_t realsize = size * nmemb;
  struct MemoryStruct *mem = (struct MemoryStruct *)data;

  mem->memory = realloc(mem->memory, mem->size + realsize + 1);
  if (mem->memory == NULL) {
    /* out of memory! */
    printf("not enough memory (realloc returned NULL)\n");
    exit(EXIT_FAILURE);
  }

  memcpy(&(mem->memory[mem->size]), ptr, realsize);
  mem->size += realsize;
  mem->memory[mem->size] = 0;

  return realsize;
}


int main(int argc, char **argv)
{
  CURL *curl_handle;

  struct MemoryStruct chunk;

  chunk.memory = malloc(1);  /* will be grown as needed by the realloc above */
  chunk.size = 0;    /* no data at this point */

  curl_global_init(CURL_GLOBAL_ALL);

  /* init the curl session */
  curl_handle = curl_easy_init();

  /* specify URL to get */
  curl_easy_setopt(curl_handle, CURLOPT_URL, "http://www.example.com/");

  /* send all data to this function  */
  curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);

  /* we pass our 'chunk' struct to the callback function */
  curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk);

  /* some servers don't like requests that are made without a user-agent
     field, so we provide one */
  curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");

  /* get it! */
  curl_easy_perform(curl_handle);

  /* cleanup curl stuff */
  curl_easy_cleanup(curl_handle);

  /*
   * Now, our chunk.memory points to a memory block that is chunk.size
   * bytes big and contains the remote file.
   *
   * Do something nice with it!
   *
   * You should be aware of the fact that at this point we might have an
   * allocated data block, and nothing has yet deallocated that data. So when
   * you're done with it, you should free() it as a nice application.
   */

  printf("%lu bytes retrieved\n", chunk.size);

  if(chunk.memory)
    free(chunk.memory);

  /* we're done with libcurl, so clean it up */
  curl_global_cleanup();

  return 0;
}

So I came to know that CURLOPT_WRITEFUNCTION sets the function that libcurl will call. CURLOPT_WRITEDATA is used to set the pointer that the function gets in its fourth argument. They were both needed to use libcurl properly, the way it was supposed to be used. Daniel was very faaaast in replying and to the point. Thanks to him, he saved a lot of time and energy of mine.

Copyright © 2010 Arnuld Uttre, #331/type-2/sector-1, Naya Nangal, Distt. – Ropar, Punjab (INDIA) – 140126

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.