Yahoo Excludes BlackBerry From Employee Smartphone List

Nerval's Lobster writes "Freshly minted Yahoo CEO Marissa Mayer is promising the company's U.S. employees a new smartphone of their choice. There's just one catch: it can't be a BlackBerry. According to Business Insider, which posted significant portions of Mayer's memo, employees will have a choice of the Samsung Galaxy S3, HTC One X, HTC EVO 4G LTE, Nokia Lumia 920, or the upcoming iPhone 5. 'We'd like our employees to have devices similar to our users, so we can think and work as the majority of our users do,' she wrote, adding that Yahoo will shift away from BlackBerry as its corporate device of choice. Somewhere up in Waterloo, at least one Research In Motion executive could be screaming in frustration over this development. Not because Yahoo is a bellwether for corporate smartphone use; its U.S. employees shifting to an iOS, Windows Phone or Android device won't automatically drive other major companies will follow suit. But as a symbol of RIM's current issues, it's difficult to find a better one than a high-profile technology company dumping its collective BlackBerry stock in favor of pretty much any other platform."

Comments

Re:Nokia Lumia 920

[mystikkman]

With a comparison like that, I guess there would no differences between C, C++, JavaScript, Objective C.

  A few differences copied from a Stackoverflow post:

Generics are completely different between the two; Java generics are just a compile-time "trick" (but a useful one at that). In C# and .NET generics are maintained at execution time too, and work for value types as well as reference types, keeping the appropriate efficiency (e.g. a List as a byte[] backing it, rather than an array of boxed bytes.)
C# doesn't have checked exceptions
Java doesn't allow the creation of user-defined value types
Java doesn't have operator and conversion overloading
Java doesn't have iterator blocks for simple implemetation of iterators
Java doesn't have anything like LINQ
Partly due to not having delegates, Java doesn't have anything quite like anonymous methods and lambda expressions. Anonymous inner classes usually fill these roles, but clunkily.
Java doesn't have expression trees
C# doesn't have anonymous inner classes
C# doesn't have Java's inner classes at all, in fact - all nested classes in C# are like Java's static nested classes
Java doesn't have static classes (which don't have any instance constructors, and can't be used for variables, parameters etc)
Java doesn't have any equivalent to the C# 3.0 anonymous types
Java doesn't have implicitly typed local variables
Java doesn't have extension methods
Java doesn't have object and collection initializer expressions
The access modifiers are somewhat different - in Java there's (currently) no direct equivalent of an assembly, so no idea of "internal" visibility; in C# there's no equivalent to the "default" visibility in Java which takes account of namespace (and inheritance)
The order of initialization in Java and C# is subtly different (C# executes variable initializers before the chained call to the base type's constructor)
Java doesn't have an equivalent of the using statement for simplified try/finally handling of resources
Java doesn't have properties as part of the language; they're a convention of get/set/is methods
Java doesn't have the equivalent of "unsafe" code
Interop is easier in C# (and .NET in general) than Java's JNI
Java and C# have somewhat different ideas of enums. Java's are much more object-oriented.
Java has no preprocessor directives (#define, #if etc in C#).
Java has no equivalent of C#'s ref and out for passing parameters by reference
Java has no equivalent of partial types
C# interfaces cannot declare fields
Java has no unsigned integer types
Java has no language support for a decimal type. (java.math.BigDecimal provides something like System.Decimal - with differences - but there's no language support)
Java has no equivalent of nullable value types
Boxing in Java uses predefined (but "normal") reference types with particular operations on them. Boxing in C# and .NET is a more transparent affair, with a reference type being created for boxing by the CLR for any value type.

This is not exhaustive, but it covers everything I can think of off-hand.

Re:Nokia Lumia 920

[cbhacking]

Oh, let's see.

Proper anonymous functions, including lambdas.
Proper function pointers (called delegates) without needing to write entire classes for them.
Support for stack-allocated complex types (structs).
Support for bi-directional and output parameters, even of types normally passed by value.
Unsigned integer types.
Object parameters (technically functions, but cleaner than a bunch of Get*and Set* function definitions and usages).
Proper generics (try declaring an array of generic type in Java, for example).
Easy interop with native code (P/Invoke, good marshaling capabilities, support for ordered structs and unsigned types, etc.).
Support for direct memory access (if you want/need it; use the unsafe keyword and byte* or similar types).
LINQ.
Tuples.
No one-public-class-per-source-file restriction, or the associated restriction on file name.
No restriction on project directory structure.
Partial classes (allows separating parts of the same class, such as autogenerated code from developer code, into different files).
The using keyword (in both of its uses).
Conditional compilation (similar to C preprocessor) to do things like exclude debug code without any overhead at all.

These are the ones that came to mind in just a few minutes of thinking about it, based on personal experiences, I'm sure there's a ton more. C# is a vastly more advanced language than Java. I don't deny that MS learned heavily from Java, but half of that learning was "let's not repeat their mistakes" and the other half was "what is it really lame that this language lacks? Let's do better."