UNIX-domain sockets are generally more flexible than named pipes.  Some of their advantages are:

 - You can use them for more than two processes communicating (eg. a server process with potentially multiple client processes connecting);
 - They are bidirectional;
 - They support passing kernel-verified UID / GID credentials between processes;
 - They support passing file descriptors between processes;
 - They support packet and sequenced packet modes.

To use many of these features, you need to use the `send()` / `recv()` family of system calls rather than `write()` / `read()`.

One difference is that named pipes are one-way, so you&#39;ll need to use two of them in order to do two-way communication. Sockets of course are two way. It seems slightly more complicated to use two variables instead of one (that is, two pipes instead of one socket).

Also, the wikipedia article is pretty clear on [the following point][1]: &quot;Unix domain sockets may be created as byte streams or as datagram sequences, while pipes are byte streams only.&quot; 


----------

Named pipes are, in fact, bi-directional but [half-duplex][2]. This means that communication may go either from end A to end B, or B to A, but never both at the same time.

  [1]: http://en.wikipedia.org/wiki/Unix_domain_socket
  [2]: https://en.wikipedia.org/wiki/Duplex_(telecommunications)

I am creating a textview and adding to the layout dynamically. I am using `textView.setTextSize(18)` method to set the text size.I tested it on samsung tablet and found that the font size is too small for this screen then I changed the textsize to 25 but it is too big for an emulator(480*800). My problem is to set text size dynamically so that it fits for all the screens.

How to set text size of textview dynamically for different screens

Could not find this answer anywhere, but I did find several mailing lists where this was discussed, these are rather old however and I have no idea if this is implemented or not.

Is there anyway to force using strict mode in node.js?

Writing `&quot;use strict&quot;;` in all my .js files... well, i prefer it being forced to using strict mode, rather than adding extra boilerplate.

Any way to force strict mode in node?

After looking at a unix named socket and i thought they were named pipes. I looked at name pipes and didnt see much of a difference. I saw they were initialized differently but thats the only thing i notice. Both use the C write/read function and work alike AFAIK.

Whats the difference between unix domain sockets and named pipes? When would i pick one over the other? Which should i use by default (like how i use use vector by default in C++ than use deque, list or whatever else if i have needs)?


unix domain socket VS named pipes?

<p>After looking at a unix named socket and i thought they were named pipes. I looked at name pipes and didnt see much of a difference. I saw they were initialized differently but thats the only thing i notice. Both use the C write/read function and work alike AFAIK.</p>
<p>Whats the difference between unix domain sockets and named pipes? When would i pick one over the other? Which should i use by default (like how i use use vector by default in C++ than use deque, list or whatever else if i have needs)?</p>


&gt; **Possible Duplicate:**  
&gt; [Why doesn&amp;#39;t GCC optimize structs?](https://stackoverflow.com/questions/118068/why-doesnt-gcc-optimize-structs)  
&gt; [Why doesn&amp;#39;t C++ make the structure tighter?](https://stackoverflow.com/questions/6730664/why-doesnt-c-make-the-structure-tighter)  

&lt;!-- End of automatically inserted text --&gt;

Consider the following example on a 32 bit x86 machine:

Due to alignment constraints, the following struct

    struct s1 {
        char a;
        int b;
        char c;
        char d;
        char e;
    }

could be represented more memory-efficiently (12 vs. 8 bytes) if the members were reordered as in

    struct s2 {
        int b;
        char a;
        char c;
        char d;
        char e;
    }

I know that C/C++ compilers are not allowed to do this. My question is why the language was designed this way. After all, we may end up wasting vast amounts of memory, and references such as `struct_ref-&gt;b` would not care about the difference.



**EDIT**: Thank you all for your extremely useful answers. You explain very well why rearranging doesn&#39;t work because of the way the language was designed. However, it makes me think: Would these arguments would still hold if rearrangement was part of the language? Let&#39;s say that there was some specified rearrangement rule, from which we required at least that

 1. we should only reorganize the struct if actually necessary (don&#39;t do anything if the struct is already &quot;tight&quot;)
 2. the rule only looks at the definition of the struct, not inside inner structs. This ensures that a struct type has the same layout whether or not it is internal in another structure
 3. the compiled memory layout of a given struct is predictable given its definition (that is, the rule is fixed)

Adressing your arguments one by one I reason:

*  _Low-level data mapping, &quot;element of least surprise&quot;_: Just write your structs in a tight style yourself (like in @Perry&#39;s answer) and nothing has changed (requirement 1). If, for some weird reason, you want internal padding to be there, you could insert it manually using dummy variables, and/or there could be keywords/directives.

*  _Compiler differences_: Requirement 3 eliminates this concern. Actually, from @David Heffernan&#39;s comments, it seems that we have this problem today because different compilers pad differently?

*  _Optimization_: The whole point of reordering is (memory) optimization. I see lots of potential here. We may not be able to remove padding all together, but I don&#39;t see how reordering could limit optimization in any way.

*  _Type casting_: It seems to me that this is the biggest problem. Still, there should be ways around this. Since the rules are fixed in the language, the compiler is able to figure out how the members were reordered, and react accordingly. As mentioned above, it will always be possible to prevent reordering in the cases where you want complete control. Also, requirement 2 ensures that type-safe code will never break.

The reason I think such a rule could make sense is because I find it more natural to group struct members by their contents than by their types. Also it is easier for the compiler to choose the best ordering than it is for me when I have a lot of inner structs. The optimal layout may even be one that I cannot express in a type-safe way. On the other hand, it would appear to make the language more complicated, which is of course a drawback.

Note that I am not talking about changing the language - only if it could(/should) have been designed differently.

I know my question is hypothetical, but I think the discussion provides deeper insight in the lower levels of the machine and language design.

I&#39;m quite new here, so I don&#39;t know if I should spawn a new question for this. Please tell me if this is the case.

Why can&#39;t C compilers rearrange struct members to eliminate alignment padding?

What I know is that global and static variables are stored in the `.data` segment, and uninitialized data are in the `.bss` segment. What I don&#39;t understand is why do we have dedicated segment for uninitialized variables?  If an uninitialised variable has a value assigned at run time, does the variable exist still in the `.bss` segment only?

In the following program,  `a` is in the `.data` segment, and `b` is in the `.bss` segment; is that correct? Kindly correct me if my understanding is wrong.


    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;

    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9};
    int b[20]; /* Uninitialized, so in the .bss and will not occupy space for 20 * sizeof (int) */

    int main ()
    {
       ;
    }  


Also, consider following program, 


    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;
    int var[10];  /* Uninitialized so in .bss */
    int main ()
    {
       var[0] = 20  /* **Initialized, where this &#39;var&#39; will be ?** */
    }

      
    


Why is the .bss segment required?

&gt; **Possible Duplicate:**  
&gt; [Error handling in C code](https://stackoverflow.com/questions/385975/error-handling-in-c-code)  
&gt; [What return value should you use for a failed function call in C?](https://stackoverflow.com/questions/8116480/what-return-value-should-you-use-for-a-failed-function-call-in-c)  

&lt;!-- End of automatically inserted text --&gt;

I always use 0, but its not really readable in `if`, `while`, etc. 

Should I return 1? Why main function `return 0` for success?

Should I return 0 or 1 for successful function?

So I figured when making function pointers, you do not need the `operator &amp;` to get the address of the initial function:

    #include &lt;stdio.h&gt;

    double foo (double x){
        return x*x;
    }

    int main () {

        double (*fun1)(double) = &amp;foo;
        double (*fun2)(double) =  foo;
        
        printf(&quot;%f\n&quot;,fun1(10));
        printf(&quot;%f\n&quot;,fun2(10));
        
        printf(&quot;fun1 = %p \t &amp;foo = %p\n&quot;,fun1, &amp;foo);
        printf(&quot;fun2 = %p \t  foo = %p\n&quot;,fun2,  foo);       
        
        int a[10];
        
        printf(&quot;  a = %p \n &amp;a = %p  \n&quot;,a,&amp;a);
        
        return 0;
    }

output:

    &gt;./a.out 
    100.000000
    100.000000
    fun1 = 0x4004f4 	 &amp;foo = 0x4004f4
    fun2 = 0x4004f4 	  foo = 0x4004f4
      a = 0x7fff26804470 
     &amp;a = 0x7fff26804470 

Then I realized this is also true for arrays, meaning that if you have `int a[10]` both `a` and `&amp;a` point to the same location. Why is that with arrays and functions? Is the address saved in a memory location that has the same address as the value(address) being saved in it?

Function pointers and address of a function

What I understand is that this shouldn&#39;t be done, but I believe I&#39;ve seen examples that do something like this (note code is not necessarily syntactically correct but the idea is there)

    typedef struct{
        int a,b;
    }mystruct;

And then here&#39;s a function

    mystruct func(int c, int d){
        mystruct retval;
        retval.a = c;
        retval.b = d;
        return retval;
    }

I understood that we should always return a pointer to a malloc&#39;ed struct if we want to do something like this, but I&#39;m positive I&#39;ve seen examples that do something like this. Is this correct? Personally I always either return a pointer to a malloc&#39;ed struct or just do a pass by reference to the function and modify the values there. (Because my understanding is that once the scope of the function is over, whatever stack was used to allocate the structure can be overwritten).

Let&#39;s add a second part to the question: Does this vary by compiler? If it does, then what is the behavior for the latest versions of compilers for desktops: gcc, g++ and Visual Studio?

Thoughts on the matter?


Is it safe to return a struct in C or C++?

I have installed gem on Ubuntu 10.10 32 bit with 

    apt-get install gem -y

But when I try to run

    gem install something.gem

I get the error of the command not being found.

    bash: gem: command not found

I installed gem, is there any reason it is saying it can&#39;t find the command?


These files were install by gem package

http://pastie.org/3483416

Gem Command not found

I would like to execute a single PHP statement like `if(function_exists(&quot;my_func&quot;)) echo &#39;function exists&#39;;` directly with the command line without having to use a separate PHP file.

How is it possible?


How can I execute PHP code from the command line?

    foo=&quot;/sdf/here/jfds&quot;
    bar=&quot;${foo##*/}&quot;

Can anyone explain how the &quot;`${foo##*/}`&quot; expression works? I understand it will return the string after the last forward slash (i.e. jfds). However, I have no idea how it does or what this type of expression is called?

Expression after last specific character

So far I&#39;ve been able to find out how to add a line at the beginning of a file but that&#39;s not exactly what I want. I&#39;ll show it with an example:

**File content**

    some text at the beginning

**Result**

    &lt;added text&gt; some text at the beginning

It&#39;s similar but I don&#39;t want to create any new line with it...

I would like to do this with `sed` if possible.


How to insert a text at the beginning of a file?

How do I write a simple--bare minimum needed for it to work--test application that illustrates how to use IPC/Named Pipes?

For example, how would one write a console application where Program 1 says &quot;Hello World&quot; to Program 2 and Program 2 receives message and replies &quot;Roger That&quot; to Program 1.


Example of Named Pipes

TCP has the tuple pairs (IP Addr/port/type) to tell one client from another.  UDP passes the client IP and port.  How does the unix domain keep track of different clients?

In other words the server creates a socket bound to some path say /tmp/socket.  2 or more clients connect to /tmp/socket.  What is going on underneath that keeps track of data from client1 and client2?  I imagine the network stack plays no part in domain sockets so is the kernel doing all the work here?

Is there a unix domain protocol format like there is an IP protocol format and TCP/UDP formats?  Is the format of domain socket datagram protocols published somewhere?  Is every unix different or does something like POSIX standardize it?

Thanks for any illumination.  I could not find any information that explained this.  Every source just glossed over how to use the domain sockets.

How do Unix Domain Sockets differentiate between multiple clients?

Working on an Android and iOS based application which require communication with a server running in the same device. Currently using TCP loopback connection for communicating with App and Server (App written in user layer, server written in C++ using Android NDK)

I was wondering if replacing inter communication with Unix Domain socket would improve the performance?

Or in-general is there any evidence/theory that proves that Unix Domain socket would give better performance then TCP loopback connection?

TCP loopback connection vs Unix Domain Socket performance

I am new to socket programming and I am  trying to understand the operation of `htons()`. I&#39;ve read a few tutorials on the Internet like [this][1] and [this][2] one for instance. But I couldn&#39;t understand what `htons()` does exactly. I tried the following code:

    #include &lt;stdio.h&gt;
    #include &lt;sys/types.h&gt; 
    #include &lt;sys/socket.h&gt;
    #include &lt;netinet/in.h&gt;
    
    int main( int argc, char *argv[] )
    {
        int sockfd, newsockfd, portno, clilen;
        char buffer[256];
        struct sockaddr_in serv_addr, cli_addr;
        int  n;
    
        /* First call to socket() function */
        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd &lt; 0) 
        {
            perror(&quot;ERROR opening socket&quot;);
            exit(1);
        }
        /* Initialize socket structure */
        bzero((char *) &amp;serv_addr, sizeof(serv_addr));
        portno = 5001;
        serv_addr.sin_family = AF_INET;
        serv_addr.sin_addr.s_addr = INADDR_ANY;
        serv_addr.sin_port = htons(portno);
     
        /* Now bind the host address using bind() call.*/
        if (bind(sockfd, (struct sockaddr *) &amp;serv_addr,
                              sizeof(serv_addr)) &lt; 0)
        {
             perror(&quot;ERROR on binding&quot;);
             exit(1);
        }
    
        /* Now start listening for the clients, here process will
        * go in sleep mode and will wait for the incoming connection
        */
        listen(sockfd,5);
        clilen = sizeof(cli_addr);
    
        /* Accept actual connection from the client */
        newsockfd = accept(sockfd, (struct sockaddr *)&amp;cli_addr, 
                                    &amp;clilen);
        if (newsockfd &lt; 0) 
        {
            perror(&quot;ERROR on accept&quot;);
            exit(1);
        }
        /* If connection is established then start communicating */
        bzero(buffer,256);
        n = read( newsockfd,buffer,255 );
        if (n &lt; 0)
        {
            perror(&quot;ERROR reading from socket&quot;);
            exit(1);
        }
        printf(&quot;Here is the message: %s\n&quot;,buffer);
    
        /* Write a response to the client */
        n = write(newsockfd,&quot;I got your message&quot;,18);
        if (n &lt; 0)
        {
            perror(&quot;ERROR writing to socket&quot;);
            exit(1);
        }
        return 0; 
    }

The value of `sin_port` was shown as `35091` while debugging and I don&#39;t understand how `portno` changed from `5001` to `35091`. Could someone explain the reason for that change in value please?


  [1]: http://www.beej.us/guide/bgnet/output/html/multipage/htonsman.html
  [2]: http://www.tutorialspoint.com/unix_sockets/network_byte_orders.htm

Content Type	Original Author	Original Content on Stackoverflow
Question	user34537	View Question on Stackoverflow
Solution 1 - C	caf	View Answer on Stackoverflow
Solution 2 - C	jtoberon	View Answer on Stackoverflow

unix domain socket VS named pipes?

C Problem Overview

C Solutions

Solution 1 - C

Solution 2 - C

Any way to force strict mode in node?

How to set text size of textview dynamically for different screens

Attributions