language-features

What is main purpose of using Clone() in C#? What is the benefit of using it? Jon The idea is that using Clone you can create a new object of the same type as the one you invoke it on, without knowing the exact type of the object you are invoking it on . For example: void Test(ICloneable original) { var cloned = original.Clone(); } Here cloned is of the same runtime type as original , and you did not need to know what that type was to perform the cloning. However the usefulness of ICloneable is pretty much none, because it does not define the semantics of the clone operation: is it a shallow

I'm not quite understanding why there are finalizers in languages such as java and c#. AFAIK, they: are not guaranteed to run (in java) if they do run, they may run an arbitrary amount of time after the object in question becomes a candidate for finalization and (at least in java), they incur an amazingly huge performance hit to even stick on a class. So why were they added at all? I asked a friend, and he mumbled something about "you want to have every possible chance to clean up things like DB connections", but this strikes me as a bad practice. Why should you rely on something with the

dict methods dict.keys(), dict.items() and dict.values() return “views” instead of lists. http://docs.python.org/dev/3.0/whatsnew//3.0.html First of all how is a view different from an iterator? Secondly, what is the benefit of this change? Is it just for performance reasons? It doesn't seem intuitive to me, i.e., I'm asking for a list of thing (give me all your keys) and I'm getting something else back. Will this confuse people? You are effectively getting a list. It's just not a copy of the internal list, but something that acts as if it where a list but only represents the internal state.

I've been examining the Java Language Specification here (instead I should be out having a beer) and I am curious about what a method can contain. The specification states a method body can contain a block MethodBody: Block Where a 'Block' contains 'BlockStatements'. The 'BlockStatement' rule looks like this: BlockStatement : LocalVariableDeclarationStatement ClassOrInterfaceDeclaration [Identifier :] Statement I can understand the 'LocalVariableDeclarationStatement' which could be [final] int x, y, z; However, I don't get why the 'ClassOrInterfaceDeclaration' rule is there. This rule looks

I know this has been discussed many times, but I am not sure I really understand why Java and C# designers chose to omit this feature from these languages. I am not interested in how I can make workarounds (using interfaces, cloning, or any other alternative), but rather in the rationale behind the decision. From a language design perspective, why has this feature been declined? P.S: I'm using words such as "omitted", which some people may find inadequate, as C# was designed in an additive (rather than subtractive) approach. However, I am using such words because the feature existed in C++

I used IntelliJ's ability to convert Java code to Scala code which generally works quite well. It seems that IntelliJ replaced all casts with calls to asInstanceOf . Is there any valid usage of asInstanceOf[Int] , asInstanceOf[Long] etc. for value types which can't be replaced by toInt , toLong , ...? I do not know of any such cases. You can check yourself that the emitted bytecode is the same by compiling a class like class Conv { def b(i: Int) = i.toByte def B(i: Int) = i.asInstanceOf[Byte] def s(i: Int) = i.toShort def S(i: Int) = i.asInstanceOf[Short] def f(i: Int) = i.toFloat def F(i: Int