In your particular case this array is used as pathname for a `PF_LOCAL` socket; see [here][1]. And leading NUL is used to point that address is an abstract one. From [man 7 unix][2]:

&gt; an abstract socket address is distinguished by the fact that
&gt; sun_path[0] is a null byte (&#39;\0&#39;).

And this is the only reason why the first element is `\0`.

  [1]: https://kernel.googlesource.com/pub/scm/bluetooth/bluez/+/5.39/android/ipc.c#201
  [2]: http://man7.org/linux/man-pages/man7/unix.7.html

I am attempting to setup a new work space and transfer all of my projects from my old computer to the new one.  However, I am getting this error when I try to run IIS Express: 

&gt; Unable to start process C:\Program Files\dotnet\dotnet.exe. The web
&gt; server request failed with status code 500.

I am working in Visual Studio 2015, update 3 and I am using .NET Core RC2.  Does anyone have any idea how to fix this and get my old projects running on this new machine?

Unable to start process dotnet.exe

I followed the [instruction][1] to create new .NET Core project and ran this from cmd:

    dotnet new
    dotnet restore

The second statement creates `project.lock.json` that contains a lot of garbage (not really garbage but tons of dependencies, configurations etc.). I assume these dependencies is .NET framework that is broken down into separate NuGet packages. 

My questions:

 1. Is my assumption correct?
 2. Can I make my application lighter by removing not needed NuGet packages/dependencies?
 3. How?

  [1]: https://www.microsoft.com/net/core#windows

What is project.lock.json?

When I read [BlueZ][1] source code, I often see `char` arrays defined like this:

    // bluez/android/sco-msg.h
    static const char BLUEZ_SCO_SK_PATH[] = &quot;\0bluez_sco_socket&quot;;

What good is it to define the first element as `\0`?

  [1]: https://en.wikipedia.org/wiki/Bluetooth_stack#BlueZ


Why define \0 as the first element of a char array in C?

When I read <a href="https://en.wikipedia.org/wiki/Bluetooth_stack#BlueZ" target="_blank" rel="noopener noreferrer">BlueZ</a> source code, I often see <code>char</code> arrays defined like this:
<pre><code class="hljs language-arduino">// bluez/android/sco-msg.h
static const char BLUEZ_SCO_SK_PATH[] = "\0bluez_sco_socket";
</code></pre>
What good is it to define the first element as <code>\0</code>?

If you want to use [Qt][1], you have to embrace `quint8`, `quint16` and so forth.

If you want to use **[GLib][2]**, you have to welcome `guint8`, `guint16` and so forth.

On [Linux][3] there are `u32`, `s16` and so forth.

**uC/OS** defines `SINT32`, `UINT16` and so forth.

And if you have to use some combination of those things, you better be prepared for trouble. Because on your machine `u32` will be `typedef`d over `long` and `quint32` will be `typedef`d over `int` and the compiler *will complain*.

Why does everybody do this, if there is `&lt;stdint.h&gt;`? Is this some kind of tradition for libraries?

  [1]: https://en.wikipedia.org/wiki/Qt_%28software%29
  [2]: https://en.wikipedia.org/wiki/GLib
  [3]: http://en.wikipedia.org/wiki/Linux


Why does everybody typedef over standard C types?

Adding two 32-bit integers can result an integer overflow:

    uint64_t u64_z = u32_x + u32_y;

This overflow can be avoided if one of the 32-bit integers is first casted or added to a 64-bit integer.

    uint64_t u64_z = u32_x + u64_a + u32_y;

However, if the compiler decides to reorder the addition:

    uint64_t u64_z = u32_x + u32_y + u64_a;

the integer overflow might still happen.

Are compilers allowed to do such a reordering or can we trust them to notice the result inconsistency and keep the expression order as is?


(A + B + C) ≠ (A + C + B​) and compiler reordering

Doing this in C++

    char* cool = &quot;cool&quot;;

compiles fine, but gives me a warning: 
 &gt; **deprecated conversion from string constant to char*.**

I would never willfully use a C-style string over `std::string`, but just in case I&#39;m asked this question: 

is it bad practice to declare a C-style string without the `const` modifier? If so, why?

Is it bad to declare a C-style string without const? If so, why?

The statement

    printf(&quot;%f\n&quot;,0.0f);

prints 0.

However, the statement

    printf(&quot;%f\n&quot;,0);

prints random values.  

I realize I&#39;m exhibiting some kind of undefined behaviour, but I can&#39;t figure out why specifically.  

A floating point value in which all the bits are 0 is still a valid `float` with value of 0.  
`float` and `int` are the same size on my machine (if that is even relevant).  

Why does using an integer literal instead of a floating point literal in `printf` cause this behavior?

P.S. the same behaviour can be seen if I use

    int i = 0;
    printf(&quot;%f\n&quot;, i);

Why does printf(&quot;%f&quot;,0); give undefined behavior?

I&#39;ve seen programmers use the formula

    mid = start + (end - start) / 2

instead of using the simpler formula

    mid = (start + end) / 2

for finding the middle element in the array or list.

Why do they use the former one?

Why prefer start + (end - start) / 2 over (start + end) / 2 when calculating the middle of an array?

On the MSDN Documentation site it says the following about the `Array.Resize` method:

&gt; If newSize is greater than the Length of the old array, a new array is
&gt; allocated and all the elements are copied from the old array to the
&gt; new one.
&gt;
&gt; If newSize is less than the Length of the old array, a new array is
&gt; allocated and elements are copied from the old array to the new one
&gt; until the new one is filled; the rest of the elements in the old array
&gt; are ignored.

An array is a sequence of adjoined memory blocks. If we need a bigger array I understand that we cannot add memory to it since the memory next to it may already be claimed by some other data. So we have to claim a new sequence of adjoined memory blocks with the desired bigger size, copy our entries there and remove our claim of the old space.

But why create a new array with smaller size? Why can the array not just remove its claim of the last memory blocks? Then it would be an O(1) operation instead of O(n), as it is now.

Does it have something to do with how the data is organized on a computer architectural or physical level?



Why can arrays not be trimmed?

I have an array of `Person`&#39;s objects: 

    class Person {
       let name:String
       let position:Int
    }

and the array is: 

    let myArray = [p1,p1,p3]

I want to map `myArray` to be a Dictionary of `[position:name]` the classic solution is:

    var myDictionary =  [Int:String]()
            
    for person in myArray {
        myDictionary[person.position] = person.name
    }

is there any elegant way by Swift to do that with the functional approach `map`, `flatMap`... or other modern Swift style

Map array of objects to Dictionary in Swift

I had originally written an `ArrayList` and stored unique values (usernames, i.e. `Strings`) in it. I later needed to use the `ArrayList` to search if a user existed in it. That&#39;s `O(n)` for the search.

My tech lead wanted me to change that to a `HashMap` and store the usernames as keys in the array and values as empty `Strings`.

So, in Java - 

    hashmap.put(&quot;johndoe&quot;,&quot;&quot;);

I can see if this user exists later by running - 

    hashmap.containsKey(&quot;johndoe&quot;); 

This is `O(1)` right?

My lead said this was a more efficient way to do this and it made sense to me, but it just seemed a bit off to put null/empty  as values in the hashmap and store elements in it as keys.

My question is, is this a good approach? The efficiency beats `ArrayList#contains` or an array search in general. It works.
My worry is, I haven&#39;t seen anyone else do this after a search. I may be missing an obvious issue somewhere but I can&#39;t see it.

Is it a good idea to store data as keys in HashMap with empty/null values?

I have a simple object like the one below:

    var countries = {
        &quot;Argentina&quot;:1,
        &quot;Canada&quot;:2,
        &quot;Egypt&quot;:1,
    };

I need to create two arrays. The first array is an array of all the keys from the object. I created this array by: 

    var labels = Object.keys(countries);

This works well. I obtain an array of countries. Now when I try to create an array from the values...

    var labels = Object.values(countries);

I get this error: `Uncaught TypeError: Object.values is not a function JavaScript`

I don&#39;t know what I am doing wrong. I `console.log countries` before and after I declare `labels` and the object remains the same. How do I properly use `Object.values()`?

Uncaught TypeError: Object.values is not a function JavaScript

Let&#39;s say I have two arrays,

    var PlayerOne = [&#39;B&#39;, &#39;C&#39;, &#39;A&#39;, &#39;D&#39;];
    var PlayerTwo = [&#39;D&#39;, &#39;C&#39;];

What is the best way to check if arrayTwo is subset of arrayOne using javascript?

The reason: I was trying to sort out the basic logic for a game Tic tac toe, and got stuck in the middle. Here&#39;s my code anyway... Thanks heaps!

    var TicTacToe = {
    
    
      PlayerOne: [&#39;D&#39;,&#39;A&#39;, &#39;B&#39;, &#39;C&#39;],
      PlayerTwo: [],
    
      WinOptions: {
          WinOne: [&#39;A&#39;, &#39;B&#39;, &#39;C&#39;],
          WinTwo: [&#39;A&#39;, &#39;D&#39;, &#39;G&#39;],
          WinThree: [&#39;G&#39;, &#39;H&#39;, &#39;I&#39;],
          WinFour: [&#39;C&#39;, &#39;F&#39;, &#39;I&#39;],
          WinFive: [&#39;B&#39;, &#39;E&#39;, &#39;H&#39;],
          WinSix: [&#39;D&#39;, &#39;E&#39;, &#39;F&#39;],
          WinSeven: [&#39;A&#39;, &#39;E&#39;, &#39;I&#39;],
          WinEight: [&#39;C&#39;, &#39;E&#39;, &#39;G&#39;]
      },
    
      WinTicTacToe: function(){
    
        var WinOptions = this.WinOptions;
        var PlayerOne = this.PlayerOne;
        var PlayerTwo = this.PlayerTwo;
        var Win = [];
    
        for (var key in WinOptions) {
          var EachWinOptions = WinOptions[key];
    
            for (var i = 0; i &lt; EachWinOptions.length; i++) {
              if (PlayerOne.includes(EachWinOptions[i])) {
                (got stuck here...)
              }
    
            }
            // if (PlayerOne.length &lt; WinOptions[key]) {
            //   return false;
            // }
            // if (PlayerTwo.length &lt; WinOptions[key]) {
            //   return false;
            // }
            // 
            // if (PlayerOne === WinOptions[key].sort().join()) {
            //   console.log(&quot;PlayerOne has Won!&quot;);
            // }
            // if (PlayerTwo === WinOptions[key].sort().join()) {
            //   console.log(&quot;PlayerTwo has Won!&quot;);
            // } (tried this method but it turned out to be the wrong logic.)
        }
      },
    
    
    };
    TicTacToe.WinTicTacToe();



Content Type	Original Author	Original Content on Stackoverflow
Question	user1923105	View Question on Stackoverflow
Solution 1 - C	Sergio	View Answer on Stackoverflow

Why define \0 as the first element of a char array in C?

C Problem Overview

C Solutions

Solution 1 - C

What is project.lock.json?

Unable to start process dotnet.exe

Attributions