The right-left rule is a simple rule that allows you to interpret any declaration. It runs as follows:

Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole declaration has been parsed.

One small change to the right-left rule: When you start reading the declaration for the first time, you have to start from the identifier, and not the innermost parentheses.

Take the example given in the introduction:

int * (* (*fp1) (int) ) [10];

This can be interpreted as follows:

1. Start from the variable name ————————– fp1
2. Nothing to right but ) so go left to find * ————– is a pointer
3. Jump out of parentheses and encounter (int) ——— to a function that takes an int as argument
4. Go left, find * —————————————- and returns a pointer
5. Jump put of parentheses, go right and hit [10] ——– to an array of 10
6. Go left find * —————————————– pointers to
7. Go left again, find int ——————————– ints.

Here’s another example:

int *( *( *arr[5])())();

1. Start from the variable name ——————— arr
2. Go right, find array subscript ——————— is an array of 5
3. Go left, find * ———————————– pointers
4. Jump out of parentheses, go right to find () —— to functions
5. Go left, encounter * —————————– that return pointers
6. Jump out, go right, find () ———————– to functions
7. Go left, find * ———————————– that return pointers
8. Continue left, find * —————————– to ints.

Continued reading at: http://www.codeproject.com/KB/cpp/complex_declarations.aspx#right_left_rule
More: http://www.codeproject.com/KB/cpp/PointerArticle.aspx#11

The TCP/IP model is basically a shorter version of the OSI model. It consists of four instead of seven layers. Despite their architectural differences, both models have interchangeable transport and network layers and their operation is based upon packet-switched technology. The diagram below indicates the differences between the two models:

• Application Layer: The Application layer deals with representation, encoding and dialog control issues. All these issues are combined together and form a single layer in the TCP/IP model whereas three distinctive layers are defined in the OSI model. 
• Host-to-Host: Host-to-Host protocol in the TCP/IP model provides more or less the same services with its equivalent Transport protocol in the OSI model. Its responsibilities include application data segmentation, transmission reliability, flow and error control. 
• Internet: Again Internet layer in TCP/IP model provides the same services as the OSIs Network layer. Their purpose is to route packets to their destination independent of the path taken. 
• Network Access: The network access layer deals with all the physical issues concerning data termination on network media. It includes all the concepts of the data link and physical layers of the OSI model for both LAN and WAN media.

For OSI Model:

Application Layer

• Serves as a window for applications to access network services.
• Handles general network access, flow control and error recovery.

Presentation Layer

• Determines the format used to exchange data among the networked computers.
• Translates data from a format from the Application layer into an intermediate format.
• Responsible for protocol conversion, data translation, data encryption, data compression, character conversion, and graphics expansion.
• Redirector operates at this level.

Session Layer

• Allows two applications running on different computers to establish use and end a connection called a Session.
• Performs name recognition and security.
• Provides synchronization by placing checkpoints in the data stream.
• Implements dialog control between communicating processes.

Transport Layer

• Responsible for packet creation.
• Provides an additional connection level beneath the Session layer.
• Ensures that packets are delivered error free, in sequence with no losses or duplications.
• Unpacks, reassembles and sends receipt of messages at the receiving end.
• Provides flow control, error handling, and solves transmission problems.

Network Layer

• Responsible for addressing messages and translating logical addresses and names into physical addresses.
• Determines the route from the source to the destination computer.
• Manages traffic such as packet switching, routing and controlling the congestion of data.

Data Link Layer

• Sends data frames from the Network layer to the Physical layer.
• Packages raw bits into frames for the Network layer at the receiving end.
• Responsible for providing error free transmission of frames through the Physical layer.

Physical Layer

• Transmits the unstructured raw bit stream over a physical medium.
• Relates the electrical, optical mechanical and functional interfaces to the cable.
• Defines how the cable is attached to the network adapter card.
• Defines data encoding and bit synchronization.

Nagle’s algorithm, named after John Nagle, is a means of improving the efficiency of TCP/IP networks by reducing the number of packets that need to be sent over the network.

Nagle’s document, Congestion Control in IP/TCP Internetworks (RFC896) describes what he called the ’small packet problem’, where an application repeatedly emits data in small chunks, frequently only 1 byte in size. Since TCP packets have a 40 byte header (20 bytes for TCP, 20 bytes for IPv4), this results in a 41 byte packet for 1 byte of useful information, a huge overhead. This situation often occurs in Telnet sessions, where most keypresses generate a single byte of data which is transmitted immediately. Worse, over slow links, many such packets can be in transit at the same time, potentially leading to congestion collapse.

Nagle’s algorithm works by coalescing a number of small outgoing messages, and sending them all at once. Specifically, as long as there is a sent packet for which the sender has received no acknowledgment, the sender should keep buffering its output until it has a full packet’s worth of output, so that output can be sent all at once.

Algorithm

if there is new data to send
  if the window size >= MSS and available data is >= MSS
    send complete MSS segment now
  else
    if there is unconfirmed data still in the pipe
      enqueue data in the buffer until an acknowledge is received
    else
      send data immediately
    end if
  end if
end if

where MSS = Maximum segment size.

This algorithm interacts badly with TCP delayed acknowledgments, a feature introduced into TCP at roughly the same time in the early 1980s, but by a different group. With both algorithms enabled, applications which do two successive writes to a TCP connection, followed by a read, experience a constant delay of up to 500 milliseconds, the “ACK delay”. For this reason, TCP implementations usually provide applications with an interface to disable the Nagle algorithm. This is typically called the TCP_NODELAY option. The first major application to run into this problem was the X Window System.

The tinygram problem and silly window syndrome are sometimes confused. The tinygram problem occurs when the window is almost empty. Silly window syndrome occurs when the window is almost full.

(From Wikipedia)

Big-Endian: MSB has the lowest address (Motoroal processors, SPARC)

Little-endian: LSB has the lowest address (x86, VAX, Z80, 6502)

+ Networks generally use big-endian order
+ English language uses big-endian order

Algorithms to determine the endianness of a machine:

//Return 0 if little-endian; 1 if big-endian
int Endianess1()
{
     int testNum = 1;
     char *ptr = (char*)&testNum;

return *ptr; //return the first byte
}

int Endianness2()
{
      union {
           int theInterger;
           char singleByte;
       } endianTest;

       endianTest.theInteger = 1;
       return endianTest.singleByte;
}

The following table summarizes a C++ program’s major distinct memory areas. Note that some of the names (for example, “heap”) do not appear as such in the standard; in particular, “heap” and “free store” are common and convenient shorthands for distinguishing between two kinds of dynamically allocated memory.

It’s important to distinguish between the “heap” and the “free store,” because the standard deliberately leaves unspecified the question of whether these two areas are related. For example, when memory is deallocated via ::operator delete(), the final note in section 18.4.1.1 of the C++ standard states:

“It is unspecified under what conditions part or all of such reclaimed storage is allocated by a subsequent call to operator new or any of calloc, malloc, or realloc, declared in <cstdlib>.”

Note that all bytes of multi-byte UTF-8 characters have the high-bit set to one, and only the first byte of a multi-byte character has both its highest bits set. This means there can never be confusion about where a character starts. So in UTF-8, the combined Greek and Latin sequence aβcδe is represented by the following seven bytes, and looking at the high bits you can pick out the extended characters without too much trouble:

01100001 11001110 10110010 01100011 11001110 10110100 01100101

Now the really clever bit about UTF-8 is that it is capable of passing unharmed through ASCII only systems [programs which don’t even recognize UTF-8], thanks to the fact that each character beyond U+007F looks like a valid sequence of extended ASCII when read as a byte-per-character. This is in stark contrast to other Unicode encodings such as UCS-2, which are full of zero bytes and therefore wreak havoc with ASCII processing systems. To an ASCII system, the UTF-8 representation of aβcδe parses as aβcδe . On the surface this may seem like a corruption, but the important thing to note is that no illegal ASCII characters appear in a UTF-8 bytestream, and so the same string can be read and written out again as raw ASCII and then decoded later as the original UTF-8. With the exception of 7-bit text systems [a legacy email standard, unfortunately, for which the hideous UTF-7 had to be invented] UTF-8 should be able to pass through ASCII systems unscathed.

Never allow an exception to escape from a destructor or from an overloaded operator delete() or operator delete[](); write every destructor and deallocation as though it had an exception specification of “throw()”

In each function, take all the code that might emit an exception and do all the work safely off to the side. Only then, when you know that the real work has succeeded, should you modifiy the program state (and clean up) using only non-throwing operations.

    Animals may have moments of pleasure but only man has got a lot to do with it. It is through our sense of organs that we enjoy pleasure. The sense of smell, sight, hearing, touch and taste each brings pleasure. Even the baby as soon as it is born feels the pleasure of suckling and the comfort of being cuddled in the wads of cloth in the mother’s lap. But for the pleasing smell we will not be able to enjoy our food. We are thrilled by the sight of ice capped mountains or the roaring water falls of the Niagara. So they are the sense that help us to get the pleasure. 

    There is no end to the sources of pleasure. But reading for pleasure belongs to a higher order and stands as a category by itself. While external things bring pleasure to the sense organs, reading brings pleasure to the mind. Greater the mind is cultured, greater will be the pleasure derived from reading for reading makes full man.

    Reading is the end product of writing. Unless there is something written one cannot read. So good writing is a concomitant of reading. Man alone can write, in other words put his ideas in black and white. In fact even before printing came into being man was writing and it is as old as modern civilization. Man can preserve his thoughts and ideas through writing. Thus the whole world of literature is there for one to read.

   Now reading material is available for all tastes. A scholar may go through serious writing for the sake of enriching his knowledge. Another may read a magazine or a picture book for whiling away the time. One chooses the reading material according to his moods, his literary background, the time at his disposal and ther purpose if any. A teenager may like stories of romance and an old man may prefer books on philosophy and religion. Some gifted with imagination and the faculty to reflect may read poetry.

   One who takes pleasure in reading always tries to build his library. Very often a good library may serve the purpose.

   The greatest advantage in reading is when one comes across great minds. Whether you agree with what is there to  read or do not agree there will not be any quarrel. You may pronounce your judgement on the writer. There will be no harm if your judgment is silent and not published.

   Given the proper atmosphere like a good silent place, soft light and comfortable seat, one can read and read and enjoy it.

   There are greate master of writing in all great languages of the world. English language abounds in such great authors. Again it may be poetry, novel, fiction, drama, travelogue, letters and so on. Biographies and autobiographies form a sizable part. In these days of rush good magazines supply the material for reading. For example , one may cite the Reader’s Digest.

   In order to enjoy reading, one must cultivate that habit. It can be ennobling. There is dignity in the reading habit.

RAII: Resource Aquisition Is Initialization - The technique combines acquisition and release of resources with initialization and uninitialization of objects.

auto_ptr: is a pointer-like object (a smart pointer), whose destructor automatically calls delete on what it points to. It’s important that there never be more than one aut_ptr pointing to an object because an auto_ptr automatically delete what it points to when the auto_ptr is destroyed.
      std::auto_ptr<Student>p1(new Student);    //p1 points to an Student object
      std::auto_ptr<Student>p2(p1);                  //p2 now points to the obj, p1 is now null
      p1 = p2                                                       //p1 now points to the obj, p2 is null

shared_ptr: is a reference-counting smart pointer that keeps tracks of how many objects point to a particular resource and automatically deletes the resource when nobody is pointing to it any longer. (Like a garbage collection except that such pointers can’t break cycles of references, e.i two otherwise unused objects that point to one another)
     std::tr1::shared_ptr<Student>p1(new Student);  //p1 points to a Student object
     std::tr1::shared_ptr<Student>p2(p1);                //both p1 and p2 point to the object
     p1 = p2;                                                            //same

Both auto_ptr and tr1::shared_ptr use delete in their destructors, not delete[]. Therefore, they should not be used with dynamically allocated arrays:
    std::auto_ptr<std::string> aps(new std::string[10]);  //bad
    std::tr1::shared_ptr<int>spi(new int[1024]);             //bad  

Operator new allocates memory from the heap, on which an object is constructed. Standard C++ also supports placement new operator, which constructs an object on a pre-allocated buffer. This is useful when building a memory pool, a garbage collector or simply when performance and exception safety are paramount (there’s no danger of allocation failure since the memory has already been allocated, and constructing an object on a pre-allocated buffer takes less time):

char *buf = new char[1000]; //pre-allocated buffer
string *p = new (buf) string(”hi”); //placement new
string *q = new string(”hi”); //ordinary heap allocation