*(I guess this question could apply to many typed languages, but I chose to use C++ as an example.)*

Why is there no way to just write:

    struct foo {
        little int x;   // little-endian
        big long int y; // big-endian
        short z;        // native endianness
    };

to specify the endianness for specific members, variables and parameters?

## Comparison to signedness

I understand that the type of a variable not only determines how many bytes are used to store a value but also how those bytes are interpreted when performing computations.

For example, these two declarations each allocate one byte, and for both bytes, every possible 8-bit sequence is a valid value:

    signed char s;
    unsigned char u;

but the same binary sequence might be interpreted differently, e.g. `11111111` would mean -1 when assigned to `s` but 255 when assigned to `u`. When signed and unsigned variables are involved in the same computation, the compiler (mostly) takes care of proper conversions.

In my understanding, endianness is just a variation of the same principle: a different interpretation of a binary pattern based on compile-time information about the memory in which it will be stored.

It seems obvious to have that feature in a typed language that allows low-level programming. However, this is not a part of C, C++ or any other language I know, and I did not find any discussion about this online.

# Update

I&#39;ll try to summarize some takeaways from the many comments that I got in the first hour after asking:

 

 1. signedness is strictly binary (either signed or unsigned) and will always be, in contrast to endianness, which also has two well-known variants (big and little), but also lesser-known variants such as mixed/middle endian. New variants might be invented in the future.
 2. endianness matters when accessing multiple-byte values byte-wise. There are many aspects beyond just endianness that affect the memory layout of multi-byte structures, so this kind of access is mostly discouraged.
 3. C++ aims to target an [abstract machine][1] and minimize the number of assumptions about the implementation. This abstract machine does not have _any_ endianness.

Also, now I realize that signedness and endianness are not a perfect analogy, because:

 * endianness only defines _how_ something is represented as a binary sequence, but now _what can be_ represented. Both `big int` and `little int` would have the exact same value range.
 * signedness defines _how_ bits and actual values map to each other, but also affects _what can be_ represented, e.g. -3 can&#39;t be represented by an `unsigned char` and (assuming that `char` has 8 bits) 130 can&#39;t be represented by a `signed char`.

So that changing the endianness of some variables would never change the behavior of the program (except for byte-wise access), whereas a change of signedness usually would.

  [1]: http://eel.is/c++draft/intro.abstract#1 

Why isn&#39;t there an endianness modifier in C++ like there is for signedness?

I&#39;ve been wondering what exactly are the principles of how the two properties work. I know the second one is universal and basically doesn&#39;t deal with time zones, but can someone explain in detail how they work and which one should be used in what scenario?

DateTime.Now vs. DateTime.UtcNow

I just came across an interesting situation in JavaScript.  I have a class with a method that defines several objects using object-literal notation.  Inside those objects, the `this` pointer is being used.  From the behavior of the program, I have deduced that the `this` pointer is referring to the class on which the method was invoked, and not the object being created by the literal.  

This seems arbitrary, though it is the way I would expect it to work.  Is this defined behavior?  Is it cross-browser safe?  Is there any reasoning underlying why it is the way it is beyond &quot;the spec says so&quot; (for instance, is it a consequence of some broader design decision/philosophy)?  Pared-down code example:

    // inside class definition, itself an object literal, we have this function:
    onRender: function() {

		this.menuItems = this.menuItems.concat([
			{
				text: &#39;Group by Module&#39;,
				rptletdiv: this
			},
			{
				text: &#39;Group by Status&#39;,
				rptletdiv: this
			}]);
		// etc
	}


How does &quot;this&quot; keyword work within a function?

This came up at the office today.  I have no plans of doing such a thing, but theoretically could you write a compiler in SQL?  At first glance it appears to me to be turing complete, though extremely cumbersome for many classes of problems.  

If it is not turing complete, what would it require to become so?

Note: I have no desire to do anything like write a compiler in SQL, I know it would be a silly thing to do, so if we can avoid that discussion I would appreciate it.

Is SQL or even TSQL Turing Complete?

I &#39;m trying to do :

    award_dict = {
        &quot;url&quot; : &quot;http://facebook.com&quot;,
        &quot;imageurl&quot; : &quot;http://farm4.static.flickr.com/3431/3939267074_feb9eb19b1_o.png&quot;,
        &quot;count&quot; : 1,
    }

    def award(name, count, points, desc_string, my_size, parent) :
        if my_size &gt; count :
            a = {
                &quot;name&quot; : name,
                &quot;description&quot; : desc_string % count,
                &quot;points&quot; : points,
                &quot;parent_award&quot; : parent,
            }
            a.update(award_dict)
            return self.add_award(a, siteAlias, alias).award

But if felt really cumbersome in the function, and I would have rather done :

            return self.add_award({
                &quot;name&quot; : name,
                &quot;description&quot; : desc_string % count,
                &quot;points&quot; : points,
                &quot;parent_award&quot; : parent,
            }.update(award_dict), siteAlias, alias).award

Why doesn&#39;t update return the object so you can chain? 

JQuery does this to do chaining. Why isn&#39;t it acceptable in python?

Why doesn&#39;t a python dict.update() return the object?

Java has generics and C++ provides a very strong programming model with `template`s.
So then, what is the difference between C++ and Java generics?


What are the differences between &quot;generic&quot; types in C++ and Java?

So lets say I have this interface:

    public interface IBox
    {
       public void setSize(int size);
       public int getSize();
       public int getArea();
      //...and so on
    }

And I have a class that implements it:

    public class Rectangle implements IBox
    {
       private int size;
       //Methods here
    }

If I wanted to use the interface IBox, i can&#39;t actually create an instance of it, in the way:

    public static void main(String args[])
    {
        Ibox myBox=new Ibox();
    }


right? So I&#39;d actually have to do this:

    public static void main(String args[])
    {
        Rectangle myBox=new Rectangle();
    }

If that&#39;s true, then the only purpose of interfaces is to make sure that the class which implements an interface has got the correct methods in it as described by an interface? Or is there any other use of interfaces?


Is there more to an interface than having the correct methods

In C# (and many other languages) it&#39;s perfectly legitimate to access private fields of other instances of the same type. For example:

    public class Foo
    {
        private bool aBool;

        public void DoBar(Foo anotherFoo)
        {
            if (anotherFoo.aBool) ...
        }
    }

As the [C# specification](http://msdn.microsoft.com/en-us/vcsharp/aa336809) (sections 3.5.1, 3.5.2) states access to private fields is on a type, not an instance. I&#39;ve been discussing this with a colleague and we&#39;re trying to come up with a reason why it works like this (rather than restricting access to the same instance).

The best argument we could come up with is for equality checks where the class may want to access private fields to determine equality with another instance. Are there any other reasons? Or some golden reason that absolutely means it must work like this or something would be completely impossible?

Why are private fields private to the type, not the instance?

I&#39;m always surprised that even after using C# for all this time now, I still manage to find things I didn&#39;t know about...

I&#39;ve tried searching the internet for this, but using the &quot;~&quot; in a search isn&#39;t working for me so well and I didn&#39;t find anything on MSDN either (not to say it isn&#39;t there)

I saw this snippet of code recently, what does the tilde(~) mean?

    /// &lt;summary&gt;
    /// Enumerates the ways a customer may purchase goods.
    /// &lt;/summary&gt;
    [Flags]
    public enum PurchaseMethod
    {	
        All = ~0,
        None =  0,
        Cash =  1,
        Check =  2,
        CreditCard =  4
    }

I was a little surprised to see it so I tried to compile it, and it worked... but I still don&#39;t know what it means/does. Any help??

What is the tilde (~) in the enum definition?

Is there a VB.NET equivalent to the C#:

    public string FirstName { get; set; }

I know you can do 

    Public Property name() As String
       Get
          Return _name.ToString
       End Get
       Set(ByVal value As String)
           _name = value
       End Set
    End Property

But I can&#39;t seem to google up an answer on a Visual Basic shorthand.


VB.NET equivalent of C# property shorthand?

C and many other languages have a [conditional (AKA ternary)][1] operator.  This allows you to make very terse choices between two values based on the truth of a condition, which makes expressions, including assignments, very concise.

I miss this because I find that my code has lots of conditional assignments that take four lines in Python:

    if condition:
        var = something
    else:
        var = something_else

Whereas in C it&#39;d be:

    var = condition ? something : something_else;

Once or twice in a file is fine, but if you have lots of conditional assignments, the number of lines explode, and worst of all the eye is drawn to them.

I like the terseness of the conditional operator, because it keeps things I deem un-strategic from distracting me when skimming the code.

So, in Python, is there a trick you can use to get the assignment onto a single line to approximate the advantages of the conditional operator as I outlined them?

  [1]: http://www.eskimo.com/~scs/cclass/int/sx4eb.html


Python ? (conditional/ternary) operator for assignments

In JavaScript, there are two values which basically say &#39;I don&#39;t exist&#39; - `undefined` and `null`.

A property to which a programmer has not assigned anything will be `undefined`, but in order for a property to become `null`, `null` must be explicitly assigned to it.

I once thought that there was a need for `null` because `undefined` is a primitive value and `null` an object. It&#39;s not, even if `typeof null` will yield `&#39;object&#39;`: Actually, both are primitive values - which means neither `undefined` nor `null` can be returned from a constructor function, as both will be converted to an empty object (one has to throw an error to proclaim failure in constructors).

They also both evaluate to `false` in boolean contexts. The only real difference I can think of is that one evaluates to `NaN`, the other to `0` in numeric contexts.

So why is there both `undefined` and `null` if this just confuses programmers who are incorrectly checking for `null` when trying to find out whether a property has been set or not?

What I&#39;d like to know is if anyone has a reasonable example where it&#39;s necessary to use `null` which couldn&#39;t be expressed using `undefined` instead.

So the general consensus seems to be that `undefined` means &#39;there is no such property&#39; while `null` means &#39;the property does exist, but holds no value&#39;.

I could live with that if JavaScript implementations would actually enforce this behavior - but `undefined` is a perfectly valid primitive value, so it can easily be assigned to existing properties to break this contract. Therefore, if you want to make sure if a property exists, you have to use the `in` operator or `hasOwnProperty()` anyway. So once again: what&#39;s the practical use for separate values for `undefined` and `null`?

I actually use `undefined` when I want to unset the values of properties no longer in use but which I don&#39;t want to `delete`. Should I use `null` instead?

Why is there a `null` value in JavaScript?

What are the guidelines as to when to use `begin` and `end` blocks in SQL Server?  

Also, what exactly does the `Go` keyword do?

Use of Begin / End Blocks and the Go keyword in SQL Server?

HTML being the most widely used language (at least as a markup language) has not gotten its due credit. &lt;br/&gt;
Considering that it has been around for so many years, things like the FORM / INPUT controls have still remained same with no new controls added.

So at least from the existing features, do you know any features that are **not well known** but very useful.

Of course, this question is along the lines of:

[Hidden Features of JavaScript][1]&lt;br /&gt;
[Hidden Features of CSS][2]&lt;br/&gt;
[Hidden Features of C#][3]&lt;br /&gt;
[Hidden Features of VB.NET][4]&lt;br /&gt;
[Hidden Features of Java][5]&lt;br /&gt;
[Hidden Features of classic ASP][6]&lt;br /&gt;
[Hidden Features of ASP.NET][7]&lt;br /&gt;
[Hidden Features of Python][8]&lt;br /&gt;
[Hidden Features of TextPad][9]&lt;br/&gt;
[Hidden Features of Eclipse][10]

Do not mention features of HTML 5.0, since it is in [working draft][11]&lt;br/&gt;

**Please specify one feature per answer**.&lt;br/&gt;


  [1]: https://stackoverflow.com/questions/61088
  [2]: https://stackoverflow.com/questions/628407
  [3]: https://stackoverflow.com/questions/9033
  [4]: https://stackoverflow.com/questions/102084
  [5]: https://stackoverflow.com/questions/15496
  [6]: https://stackoverflow.com/questions/2963484
  [7]: https://stackoverflow.com/questions/54929
  [8]: https://stackoverflow.com/questions/101268
  [9]: https://stackoverflow.com/questions/605439
  [10]: https://stackoverflow.com/questions/54886
  [11]: https://stackoverflow.com/questions/605439

Hidden features of HTML

Python&#39;s inner/nested classes confuse me. Is there something that can&#39;t be accomplished without them? If so, what is that thing?

What is the purpose of python&#39;s inner classes?

[This](http://www.cppreference.com/wiki/operator_precedence#Notes) is the only place I&#39;ve ever seen `and`, `or` and `not` listed as actual operators in C++. When I wrote up a test program in NetBeans, I got the red underlining as if there was a syntax error and figured the website was wrong, but it is NetBeans which is wrong because it compiled and ran as expected.

I can see `!` being favored over `not` but the readability of `and` &amp;&amp; `or` seems greater than their grammatical brothers. Why do these versions of the logical operators exist and why does seemingly no one use it? Is this truly valid C++ or some sort of compatibility with C that was included with the language?

The written versions of the logical operators

I just cleaned my Firefox addons and wondered: 

 - Which features does Firebug have that make it unique? 
   
 - Which features are available in both Firebug and the Firefox Developer Tools?  

What unique features does Firebug have that are not built-in to Firefox?

I came across the Python `with` statement for the first time today.  I&#39;ve been using Python lightly for several months and didn&#39;t even know of its existence!  Given its somewhat obscure status, I thought it would be worth asking:

 1. What is the Python `with` statement
    designed to be used for?   
 1. What do
    you use it for? 
 1. Are there any
    gotchas I need to be aware of, or
    common anti-patterns associated with
    its use?  Any cases where it is better use `try..finally` than `with`?
 1. Why isn&#39;t it used more widely?
 1. Which standard library classes are compatible with it?

What is the python &quot;with&quot; statement designed for?

I need some code samples (and I also really curious about them) of Scala and Java code which show that Scala code is more simple and concise then code written in Java (of course both samples should solve the same problem).

If there is only Scala sample with comment like &quot;this is abstract factory in Scala, in Java it will look much more cumbersome&quot; then this is also acceptable.

Thanks!

I like most of all accepted and [this][1] answers


  [1]: https://stackoverflow.com/questions/2952732/samples-of-scala-and-java-code-where-scala-code-looks-simpler-has-fewer-lines/2961620#2961620

Samples of Scala and Java code where Scala code looks simpler/has fewer lines?

Why was C# designed this way?

As I understand it, an interface only describes behaviour, and serves the purpose of describing a contractual obligation for classes implementing the interface that certain behaviour is implemented.

If classes wish to implement that behavour in a shared method, why shouldn&#39;t they?

Here is an example of what I have in mind:

    // These items will be displayed in a list on the screen.
    public interface IListItem {
      string ScreenName();
      ...
    }

    public class Animal: IListItem {
        // All animals will be called &quot;Animal&quot;.
        public static string ScreenName() {
            return &quot;Animal&quot;;
        }
    ....
    }

    public class Person: IListItem {

        private string name;

        // All persons will be called by their individual names.
        public string ScreenName() {
            return name;
        }
        
        ....

     }

Why Doesn&#39;t C# Allow Static Methods to Implement an Interface?

I&#39;m asking with regards to c#, but I assume its the same in most other languages.

Does anyone have a good definition of _expressions_ and _statements_ and what the differences are?

Expression Versus Statement

To be specific, I was trying this code:

    package hello;

    public class Hello {

        Clock clock = new Clock();

        public static void main(String args[]) {
            clock.sayTime();
        }
    }

But it gave the error 

&gt; Cannot access non-static field in static method main

So I changed the declaration of `clock` to this:

    static Clock clock = new Clock();

And it worked. What does it mean to put that keyword before the declaration? What exactly will it do and/or restrict in terms of what can be done to that object?

What does the &#39;static&#39; keyword do in a class?

I&#39;ve missed the memo somewhere, and I hope you&#39;ll explain this to me.

Why is the eigenclass of an object different from `self.class`?

    class Foo
      def initialize(symbol)
        eigenclass = class &lt;&lt; self
          self
        end
        eigenclass.class_eval do
          attr_accessor symbol
        end
      end
    end

My train of logic that equates the eigenclass with `class.self` is rather simple:

`class &lt;&lt; self` is a way of declaring class methods, rather than instance methods. It&#39;s a shortcut to `def Foo.bar`.

So within the reference to the class object, returning `self` should be identical to `self.class`. This is because `class &lt;&lt; self` would set `self` to `Foo.class` for definition of class methods/attributes.

Am I just confused? Or, is this a sneaky trick of Ruby meta-programming?

Why isn&#39;t the eigenclass equivalent to self.class, when it looks so similar?

I know, I know... Eric Lippert&#39;s answer to this kind of question is usually something like &quot;*because it wasn&#39;t worth the cost of designing, implementing, testing and documenting it*&quot;.

But still, I&#39;d like a better explanation... I was reading [this blog post about new C# 4 features][1], and in the section about COM Interop, the following part caught my attention :

&gt; By the way, this code uses one more new feature: indexed properties (take a closer look at those square brackets after Range.) **But this feature is available only for COM interop; you cannot create your own indexed properties in C# 4.0**.

OK, but why ? I already knew and regretted that it wasn&#39;t possible to create indexed properties in C#, but this sentence made me think again about it. I can see several good reasons to implement it :

- the CLR supports it (for instance, `PropertyInfo.GetValue` has an `index` parameter), so it&#39;s a pity we can&#39;t take advantage of it in C#
- it is supported for COM interop, as shown in the article (using dynamic dispatch)
- it is implemented in VB.NET
- it is already possible to create indexers, i.e. to apply an index to the object itself, so it would probably be no big deal to extend the idea to properties, keeping the same syntax and just replacing `this` with a property name

It would allow to write that kind of things :

    public class Foo
    {
        private string[] _values = new string[3];
        public string Values[int index]
        {
            get { return _values[index]; }
            set { _values[index] = value; }
        }
    }

Currently the only workaround that I know is to create an inner class (`ValuesCollection` for instance) that implements an indexer, and change the `Values` property so that it returns an instance of that inner class.

This is very easy to do, but annoying... So perhaps the compiler could do it for us ! An option would be to generate an inner class that implements the indexer, and expose it through a public generic interface :

    // interface defined in the namespace System
    public interface IIndexer&lt;TIndex, TValue&gt;
    {
        TValue this[TIndex index]  { get; set; }
    }

    public class Foo
    {
        private string[] _values = new string[3];
        
        private class &lt;&gt;c__DisplayClass1 : IIndexer&lt;int, string&gt;
        {
            private Foo _foo;
            public &lt;&gt;c__DisplayClass1(Foo foo)
            {
                _foo = foo;
            }
        
            public string this[int index]
            {
                get { return _foo._values[index]; }
                set { _foo._values[index] = value; }
            }
        }
        
        private IIndexer&lt;int, string&gt; &lt;&gt;f__valuesIndexer;
        public IIndexer&lt;int, string&gt; Values
        {
            get
            {
                if (&lt;&gt;f__valuesIndexer == null)
                    &lt;&gt;f__valuesIndexer = new &lt;&gt;c__DisplayClass1(this);
                return &lt;&gt;f__valuesIndexer;
            }
        }
    }

But of course, in that case the property would *actually* return a `IIndexer&lt;int, string&gt;`, and wouldn&#39;t really be an indexed property... It would be better to generate a real CLR indexed property.

What do you think ? Would you like to see this feature in C# ? If not, why ?

  [1]: http://blogs.msdn.com/csharpfaq/archive/2010/04/12/get-ready-for-c-4-0.aspx



Why C# doesn&#39;t implement indexed properties?

Here are some gems:

Literals:

    var obj = {}; // Object literal, equivalent to var obj = new Object();
    var arr = []; // Array literal, equivalent to var arr = new Array();
    var regex = /something/; // Regular expression literal, equivalent to var regex = new RegExp(&#39;something&#39;);

Defaults:

    arg = arg || &#39;default&#39;; // if arg evaluates to false, use &#39;default&#39;, which is the same as:
    arg = !!arg ? arg : &#39;default&#39;;

Of course we know anonymous functions, but being able to treat them as literals and execute them on the spot (as a closure) is great:

    (function() { ... })(); // Creates an anonymous function and executes it

**Question:** What other great syntactic sugar is available in javascript?

Best javascript syntactic sugar

I have written a little bit of C, and I can read it well enough to get a general idea of what it is doing, but every time I have encountered a macro it has thrown me completely. I end up having to remember what the macro is and substitute it in my head as I read. The ones that I have encountered that were intuitive and easy to understand were always like little mini functions, so I always wondered why they weren&#39;t just functions.

I can understand the need to define different build types for debug or cross platform builds in the preprocessor but the ability to define arbitrary substitutions seems to be useful only to make an already difficult language even more difficult to understand.

Why was such a complex preprocessor introduced for C? And does anyone have an example of using it that will make me understand why it still seems to be used for purposes other than simple if #debug style conditional compilations?

Edit:

Having read a number of answers I still just don&#39;t get it. The most common answer is to inline code. If the inline keyword doesn&#39;t do it then either it has a good reason to not do it, or the implementation needs fixing. I don&#39;t understand why a whole different mechanism is needed that means &quot;really inline this code&quot; (aside form the code being written before inline was around). I also don&#39;t understand the idea that was mentioned that &quot;if its too silly to be put in a function&quot;. Surely any piece of code that takes an input and produces an output is best put in a function. I think I may not be getting it because I am not used to the micro optimisations of writing C, but the preprocessor just feels like a complex solution to a few simple problems.

What are C macros useful for?

Consider the following example:

    class A:
        @property
        def x(self): return 5
So, of course calling the `a = A(); a.x` will return `5`

But imagine that you want to be able to modify the property x.  
This way, for example:

    class A:
        @property
        def x(self, neg = False): return 5 if not neg else -5

And call it with `a = A(); a.x(neg=True)`
  

That will raise a TypeError: `&#39;int&#39; object is not callable`, that is quite normal, since our `x` is evaluated as `5`.

So, I would like to know how one can pass more then one argument to the property getter, if it is possible at all.

Python: How to pass more than one argument to the property getter?

&gt; **This question already has an answer here:**  
&gt; https://stackoverflow.com/questions/105372/how-to-enumerate-an-enum  *26 answers*

&lt;!-- End of automatically inserted text --&gt;

    public enum Foos
    {
        A,
        B,
        C
    }

Is there a way to loop through the possible values of `Foos`?

Basically?

    foreach(Foo in Foos)


How to loop through all enum values in C#?

As made clear in update 3 on [this answer][1], this notation:

    var hash = {};
    hash[X]

does not actually hash the object `X`; it actually just converts `X` to a string (via `.toString()` if it&#39;s an object, or some other built-in conversions for various primitive types) and then looks that string up, without hashing it, in &quot;`hash`&quot;. Object equality is also not checked - if two different objects have the same string conversion, they will just overwrite each other.

Given this - are there any efficient implementations of hashmaps in JavaScript?

(For example, the second Google result of [`javascript hashmap`][2] yields an implementation which is O(n) for any operation. Various other results ignore the fact that different objects with equivalent string representations overwrite each other.

  [1]: https://stackoverflow.com/questions/367440/javascript-associative-array-without-tostring-etc#367454
  [2]: http://www.google.com/search?rlz=1C1GGLS_en-USUS299US303&amp;sourceid=chrome&amp;ie=UTF-8&amp;q=javascript%20hashmap


JavaScript hashmap equivalent

[Alan Storm&#39;s comments][1] in response to my answer regarding the [`with` statement][2] got me thinking. I&#39;ve seldom found a reason to use this particular language feature, and had never given much thought to how it might cause trouble. Now, I&#39;m curious as to how I might make effective use of `with`, while avoiding its pitfalls.

Where have you found the `with` statement useful?

  [1]: http://www.stackoverflow.com/questions/61088/hidden-features-of-javascript#61118
  [2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/with


Are there legitimate uses for JavaScript&#39;s &quot;with&quot; statement?

I haven&#39;t touched Java since using JBuilder in the late 90&#39;s while at University, so I&#39;m a little out of touch - at any rate I&#39;ve been working on a small Java project this week, and using Intellij IDEA as my IDE, for a change of pace from my regular .Net development.

I notice it has support for adding interfaces and @interfaces, what is an @interface, and how does it differ from a normal interface?

    public interface Test {
    }


vs.

    public @interface Test {
    }

I&#39;ve done a bit of searching, but couldn&#39;t find a great deal of useful info referring to @interface.


What&#39;s the difference between interface and @interface in java?

.Net 3.5 doesn&#39;t support tuples. Too bad, But not sure whether the future version of .net will support tuples or not? 

Will a future version of .NET support tuples in C#?

I [recently learned][1] that Unicode is permitted within Java source code not only as Unicode characters (eg. `double π = Math.PI;` ) but also as escaped sequences (eg. `double \u03C0 = Math.PI;` ).

The first variant makes sense to me - it allows programmers to name variables and methods in an international language of their choice. However, I don&#39;t see any practical application of the second approach.

Here are a few pieces of code to illustrate usage, tested with Java SE 6 and NetBeans 6.9.1:

This code will print out 3.141592653589793

    public static void main(String[] args) {
    	double π = Math.PI;
    	System.out.println(\u03C0);
    }

Explanation: π and \u03C0 are the same Unicode character

This code will not print out anything

    public static void main(String[] args) {
    	double π = Math.PI; /\u002A
    	System.out.println(π);

    	/* a comment */
    }

Explanation: The code above actually encodes:

    public static void main(String[] args) {
    	double π = Math.PI; /*
    	System.out.println(π);

    	/* a comment */
    }

Which comments out the print satement.

Just from my examples, I notice a number of potential problems with this language feature.

First, a bad programmer could use it to secretly comment out bits of code, or create multiple ways of identifying the same variable. Perhaps there are other horrible things that can be done that I haven&#39;t thought of.

Second, there seems to be a lack of support among IDEs. Neither NetBeans nor Eclipse provided the correct code highlighting for the examples. In fact, NetBeans even marked a syntax error (though compilation was not a problem).

Finally, this feature is poorly documented and not commonly accepted. Why would a programmer use something in his code that other programmers will not be able to recognize and understand? In fact, I couldn&#39;t even find something about this on the [Hidden Java Features question][2].

My question is this:

Why does Java allow escaped Unicode sequences to be used within syntax?
What are some &quot;pros&quot; of this feature that have allowed it to stay a part Java, despite its many &quot;cons&quot;?


  [1]: http://en.wikibooks.org/wiki/Java_Programming/Syntax/Unicode_Source
  [2]: https://stackoverflow.com/questions/15496/hidden-features-of-java

Why does Java permit escaped unicode characters in the source code?

I have heard/read the term but don&#39;t quite understand what it means.

When should I use this technique and how would I use it? Can anyone provide a good code sample?

Double dispatch in C#?

I would like to properly understand hashes in Perl. I&#39;ve had to use Perl intermittently for quite some time and mostly whenever I need to do it, it&#39;s mostly related to text processing.

And everytime, I have to deal with hashes, it gets messed up. I find the syntax very cryptic for hashes

A good explanation of hashes and hash references, their differences, when they are required etc. would be much appreciated.



What&#39;s the difference between a hash and hash reference in Perl?

Brief background: Many (most?) contemporary programming languages in widespread use have at least a handful of ADTs [abstract data types] in common, in particular,

 - **string** (a sequence comprised of characters)

 - **list** (an ordered collection of values), and

 - **map-based type** (an unordered array that maps keys to values)

In the R programming language, the first two are implemented as `character` and `vector`, respectively.

When I began learning R, two things were obvious almost from the start: `list` is the most important data type in R (because it is the parent class for the R `data.frame`), and second, I just couldn&#39;t understand how they worked, at least not well enough to use them correctly in my code.

For one thing, it seemed to me that R&#39;s `list` data type was a straightforward implementation of the map ADT (`dictionary` in Python, `NSMutableDictionary` in Objective C, `hash` in Perl and Ruby, `object literal` in Javascript, and so forth).

For instance, you create them just like you would a Python dictionary, by passing key-value pairs to a constructor (which in Python is `dict` not `list`):

    x = list(&quot;ev1&quot;=10, &quot;ev2&quot;=15, &quot;rv&quot;=&quot;Group 1&quot;)

And you access the items of an R List just like you would those of a Python dictionary, e.g., `x[&#39;ev1&#39;]`. Likewise, you can retrieve just the _&#39;keys&#39;_ or just the _&#39;values&#39;_ by: 

    names(x)    # fetch just the &#39;keys&#39; of an R list
    # [1] &quot;ev1&quot; &quot;ev2&quot; &quot;rv&quot;

    unlist(x)   # fetch just the &#39;values&#39; of an R list
    #   ev1       ev2        rv 
    #  &quot;10&quot;      &quot;15&quot; &quot;Group 1&quot; 

    x = list(&quot;a&quot;=6, &quot;b&quot;=9, &quot;c&quot;=3)  

    sum(unlist(x))
    # [1] 18

but R `list`s are also ***unlike*** other map-type ADTs (from among the languages I&#39;ve learned anyway). My guess is that this is a consequence of the initial spec for S, i.e., an intention to design a data/statistics DSL [domain-specific language] from the ground-up. 

*three* significant differences between R `list`s and mapping types in other languages in widespread use (e.g,. Python, Perl, JavaScript):

*first*, `list`s in R are an *ordered* collection, just like vectors, even though the values are keyed (ie, the keys can be any hashable value not just sequential integers). Nearly always, the mapping data type in other languages is *unordered*.

*second*, `list`s can be returned from functions even though you never passed in a `list` when you called the function, and *even though* the function that returned the `list` doesn&#39;t contain an (explicit) `list` constructor (Of course, you can deal with this in practice by wrapping the returned result in a call to `unlist`):

    x = strsplit(LETTERS[1:10], &quot;&quot;)     # passing in an object of type &#39;character&#39;

    class(x)                            # returns &#39;list&#39;, not a vector of length 2
    # [1] list

A *third* peculiar feature of R&#39;s `list`s: it doesn&#39;t seem that they can be members of another ADT, and if you try to do that then the primary container is coerced to a `list`. E.g.,

    x = c(0.5, 0.8, 0.23, list(0.5, 0.2, 0.9), recursive=TRUE)

    class(x)
    # [1] list

my intention here is not to criticize the language or how it is documented; likewise, I&#39;m not suggesting there is anything wrong with the `list` data structure or how it behaves. All I&#39;m after is to correct is my understanding of how they work so I can correctly use them in my code. 

Here are the sorts of things I&#39;d like to better understand:

 - What are the rules which determine when a function call will return a `list` (e.g., `strsplit` expression recited above)?

 - If I don&#39;t explicitly assign names to a `list` (e.g., `list(10,20,30,40)`) are the default names just sequential integers beginning with 1?  (I assume, but I am far from certain that the answer is yes, otherwise we wouldn&#39;t be able to coerce this type of `list` to a vector w/ a call to `unlist`.)

 - Why do these two different operators, `[]`, and `[[]]`, return the _same_ result?

    `x = list(1, 2, 3, 4)`
    
    both expressions return &quot;1&quot;:

    `x[1]`
    
    `x[[1]]`
  

 -  why do these two expressions **not** return the same result?

    `x = list(1, 2, 3, 4)`

    `x2 = list(1:4)`
    

Please don&#39;t point me to the R Documentation ([`?list`][1], [`R-intro`][2])--I have read it carefully and it does not help me answer the type of questions I recited just above.

(lastly, I recently learned of and began using an R Package (available on CRAN) called [`hash`][3] which implements *conventional* map-type behavior via an S4 class; I can certainly recommend this Package.)


  [1]: http://www.inside-r.org/r-doc/base/list
  [2]: http://cran.r-project.org/doc/manuals/r-devel/R-intro.html#Lists
  [3]: http://mran.revolutionanalytics.com/packages/info/?hash

How to Correctly Use Lists in R?

The **[C# language specification](http://www.microsoft.com/downloads/en/details.aspx?familyid=DFBF523C-F98C-4804-AFBD-459E846B268E&amp;displaylang=en)** describes type inference in Section &#167;7.5.2. There is a detail in it that I don’t understand. Consider the following case:

    // declaration
    void Method&lt;T&gt;(T obj, Func&lt;string, T&gt; func);

    // call
    Method(&quot;obj&quot;, s =&gt; (object) s);

Both the Microsoft and Mono C# compilers correctly infer `T` = `object`, but my understanding of the algorithm in the specification would yield `T` = `string` and then fail. Here is how I understand it:

**The first phase**

* If Ei is an anonymous function, an *explicit parameter type inference* (&#167;7.5.2.7) is made from Ei to Ti

    ⇒ has no effect, because the lambda expression has no explicit parameter types. Right?

* Otherwise, if Ei has a type U and xi is a value parameter then a *lower-bound inference* is made from U to Ti.

    ⇒ the first parameter is of static type `string`, so this adds `string` to the lower bounds for `T`, right?

**The second phase**

* All *unfixed* type variables Xi which do not *depend on* (&#167;7.5.2.5) any Xj are fixed (&#167;7.5.2.10).

    ⇒ `T` is unfixed; `T` doesn’t depend on anything... so `T` should be fixed, right?

**&#167;7.5.2.11 Fixing**

* The set of candidate types Uj starts out as the set of all types in the set of bounds for Xi.

    ⇒ { `string` (lower bound) }

* We then examine each bound for Xi in turn: [...] For each lower bound U of Xi all types Uj to which there is not an implicit conversion from U are removed from the candidate set. [...]

    ⇒ doesn’t remove anything from the candidate set, right?

* If among the remaining candidate types Uj there is a unique type V from which there is an implicit conversion to all the other candidate types, then Xi is fixed to V.

    ⇒ Since there is only one candidate type, this is vacuously true, so Xi is fixed to `string`. Right?

- - -

**So where am I going wrong?**

Problem understanding C# type inference as described in the language specification

I want to test whether an object is an instance of a class, and only this class (no subclasses). I could do it either with:

    obj.__class__ == Foo
    obj.__class__ is Foo
    type(obj) == Foo
    type(obj) is Foo

Are there reasons to choose one over another? (performance differences, pitfalls, etc)

In other words: a) is there any practical difference between using `__class__` and `type(x)`? b) are class objects always safe for comparison using `is`?

---

**Update:** Thanks all for the feedback. I&#39;m still puzzled by whether or not class objects are singletons, my common sense says they are, but it&#39;s been really hard to get a confirmation (try googling for &quot;python&quot;, &quot;class&quot; and &quot;unique&quot; or &quot;singleton&quot;).

I&#39;d also like to clarify that, for my particular needs, the &quot;cheaper&quot; solution that just works is the best, since I&#39;m trying to optimize the most out of a few, specialized classes (almost reaching the point where the sensible thing to do is to drop Python and develop that particular module in C). But the reason behind the question was to understand better the language, since some of its features are a bit too obscure for me to find that information easily. That&#39;s why I&#39;m letting the discussion extend a little instead of settling for `__class__ is`, so I can hear the opinion of more experienced people. So far it&#39;s been very fruitful!

I ran a small test to benchmark the performance of the 4 alternatives. The profiler results were:

                   Python  PyPy (4x)
    type()    is   2.138   2.594
    __class__ is   2.185   2.437
    type()    ==   2.213   2.625
    __class__ ==   2.271   2.453

Unsurprisingly, `is` performed better than `==` for all cases. `type()` performed better in Python (2% faster) and `__class__` performed better in PyPy (6% faster). Interesting to note that `__class__ ==` performed better in PyPy than `type() is`.

---

**Update 2:** many people don&#39;t seem to understand what I mean with &quot;a class is a singleton&quot;, so I&#39;ll ilustrate with an example:

    &gt;&gt;&gt; class Foo(object): pass
    ...
    &gt;&gt;&gt; X = Foo
    &gt;&gt;&gt; class Foo(object): pass
    ...
    &gt;&gt;&gt; X == Foo
    False
    &gt;&gt;&gt; isinstance(X(), Foo)
    False
    &gt;&gt;&gt; isinstance(Foo(), X)
    False

    &gt;&gt;&gt; x = type(&#39;Foo&#39;, (object,), dict())
    &gt;&gt;&gt; y = type(&#39;Foo&#39;, (object,), dict())
    &gt;&gt;&gt; x == y
    False
    &gt;&gt;&gt; isinstance(x(), y)
    False

    &gt;&gt;&gt; y = copy.copy(x)
    &gt;&gt;&gt; x == y
    True
    &gt;&gt;&gt; x is y
    True
    &gt;&gt;&gt; isinstance(x(), y)
    True
    &gt;&gt;&gt; y = copy.deepcopy(x)
    &gt;&gt;&gt; x == y
    True
    &gt;&gt;&gt; x is y
    True
    &gt;&gt;&gt; isinstance(x(), y)
    True

It doesn&#39;t matter if there are N objects of type `type`, given an object, only one will be its class, hence it&#39;s safe to compare for reference in this case. And since reference comparison will always be cheaper than value comparison, I wanted to know whether or not my assertion above holds. I&#39;m reaching the conclusion that it does, unless someone presents evidence in contrary.

Python type() or __class__, == or is

I am looking get to grips with functional programming concepts.

I&#39;ve used Javascript for many years for client side scripting in web applications and apart from using prototypes it was all simple DOM manipulation, input validation etc.  

Of late, I have [often read][1] that Javascript is one of the languages that supports functional programming.

With my familiarity and experience with Javascript, my preference is to use it to learn functional programming. I expect I would be able to concentrate more on the main functional concepts and not get bogged down or distracted by a completely new syntax.

So in summary, is Javascript a good choice to learn functional programming concepts?  What capabilities in Javascript are relevant/support functional programming?


  [1]: http://eloquentjavascript.net/chapter6.html

All Language Features Solutions on Gang of Coders

Total of 39 Language Features Solutions