Why
Java Sucks & C# Rocks
      ZhaoJie @ SNDA
         April, 2010
About me

• Name:                   Jeffrey Zhao

• Blog: http://blog.zhaojie.me/
• Twitter: @jeffz_cn
• Email: jeffz@live...
Experiences

• Pascal,VB 5 & 6, Delphi before 2002
• Java programmer from 2002 to 2004
• C# programmer since 2004
I’m going to talk
    about ...
• Languages features
• Programming paradigms
• Usage patterns
• Why we should throw Java language away
I’m NOT going to make
       you ...
• Believe CLR is better than JVM
• Believe .NET is better than Java platform
• Get rid of Java language right away
• Use C...
Timeline

• 2002 - Java 1.4 & C# 1.0
• 2004 - Java 5.0 & C# 2.0
• 2006 - Java 6
• 2008 - C# 3.0
• 2010 - Java 7 & C# 4
So Java programmers,
 hold your breath ...
Let’s start from the
 very beginning ...
Is Java a pure object-
  oriented language?
No.
Primitive types are not
        objects.
In Java you can NOT ...

ArrayList	
  list	
  =	
  new	
  ArrayList();
list.add(5);	
  //	
  cannot	
  compile
int	
  i	
 ...
You have to ...

ArrayList	
  list	
  =	
  new	
  ArrayList();
Integer	
  five	
  =	
  Integer.valueOf(5);
list.add(five);...
In C# ...
• No primitive types
• All types are subtypes of Object.
• Just value types and reference types
• Programmers ca...
So you can always ...

ArrayList	
  list	
  =	
  new	
  ArrayList();
list.Add(5);
int	
  i	
  =	
  (int)list[0];

int	
  h...
Thank God!
Here comes Java 5.0!
Finally you can ...
ArrayList	
  list	
  =	
  new	
  ArrayList();
list.add(5);	
  //	
  auto	
  boxing

//	
  auto	
  unbo...
Java 5.0 also brings ...
• Annotation - allows language constructs to
  be tagged with additional data
• Enumerations - th...
But most of these
features were already
provided by C# 1.0 ...
... so who is the
     copy cat?
OK, let’s forget it and
 look deep inside ...
Annotations in Java are
     interfaces.

 Attributes in C# are
       classes.
Differences?
Let’s start coding!
Annotation’s shortages

• Strange convention
• Anemic object
• Hard to unit test
Well, Java 5.0 also
brings Generics, but ...
Type erasure: type
information will be lost
    after compiling!
What’s the output?

List<String>	
  a	
  =	
  new	
  ArrayList<String>();
List<Integer>	
  b	
  =	
  new	
  ArrayList<Inte...
And you can’t do this
public	
  class	
  MyClass<E>	
  {
	
  	
  	
  	
  public	
  static	
  void	
  myMethod(Object	
  it...
And “use-site variance”
 is strange and stupid.
Well, maybe I’m biased.
   I can give you a
separate talk about it.
Let keep moving.
The same time Java
  released 5.0 ...
C# 2.0 comes with

• Better generics (comparing to Java 5.0)
• Anonymous methods (hello, closure!)
• “yield” keyword - ite...
Why closure matters?
And “yield” is only
 about iterator?
Let’s see some samples.
So closure and yield are ...
 • Increasing productivity dramatically
 • Coming with new programming patterns
 • Important ...
Two years after C# 2.0,
 Java 6 released with ...
Nothing!
Nothing!!
Nothing!!!
Give me a break and
 leave me alone ...
OK, I admit it ...
Java 6 is cool because of ...

  • pluggable annotations (JSR 269): customized
    compile-time processing (Project Lombok...
But we’re talking about
    language, so ...
Let’s move on to
     C# 3.0,
which brings us ...
LINQ
(Language Integrated
      Query)
Only LINQ?
Yes! The great LINQ!
LINQ is made up of ...
• Extension method - safely add methods to
  types without breaking anything
• Lambda expression - ...
Now tell me, which one
   do you prefer?
BBCode to HTML

//	
  Java
Util.stripWhites(
	
  	
  	
  	
  Util.stripXss(
	
  	
  	
  	
  	
  	
  	
  	
  Util.bbToHtml(...
Sorting an array
//	
  C#
users.Sort((u1,	
  u2)	
  =>	
  u1.Age	
  -­‐	
  u2.Age);

//	
  Java
Arrays.sort(
	
  	
  	
  	...
JSON Output (C#)
List<User>	
  userList	
  =	
  ...;
var	
  json	
  =	
  new	
  {
	
  	
  	
  	
  errorCode	
  =	
  0,
	
 ...
JSON Output (Java)
JSONObject	
  obj	
  =	
  new	
  JSONObject();
obj.put("errorCode",	
  0);
obj.put("message",	
  "OK");...
Is C# just full of
Syntactic Sugar?
I don’t think so.
It really changed my mind

 • Real-world Functional Programming
 • Write declarative code (anti-for)
 • Make code / API mo...
Please write a program
   to index a list of
keywords (like books).
Explanation

• Input: List<String>
• Output: Map<Character, List<String>>
• The key of map is ‘a’ to ‘z’
• Each list in th...
Let’s see the Java code
         first ...
List<String>	
  keywords	
  =	
  ...;
Map<Character,	
  List<String>>	
  result	
  =	
  new	
  HashMap<>();

for	
  (Strin...
List<String>	
  keywords	
  =	
  ...;
Map<Character,	
  List<String>>	
  result	
  =	
  new	
  HashMap<>();

for	
  (Strin...
Quite easy, ah?
Guess how does C#
  code look like?
List<string>	
  keywords	
  =	
  ...;
var	
  result	
  =	
  keywords
	
  	
  	
  	
  .GroupBy(k	
  =>	
  k[0])
	
  	
  	
 ...
List<string>	
  keywords	
  =	
  ...;
var	
  result	
  =	
  keywords
	
  	
  	
  	
  .GroupBy(k	
  =>	
  k[0])
	
  	
  	
 ...
Amazing, isn’t it?
What about the Java
  community?
Well, the Functional
Java project is out!
       But ...
... do you really want to
   write code like this?
keywords
	
  	
  .groupBy(
	
  	
  	
  	
  new	
  F<String,	
  Character>	
  {
	
  	
  	
  	
  	
  	
  public	
  Character...
It’s really a pain without
   lambda expressions.
Fortunately, Java 7 will
  provide a sort of
   lambda syntax.
keywords
	
  	
  	
  	
  .groupBy({	
  String	
  k	
  =>	
  k.charAt(0)	
  })
	
  	
  	
  	
  .toMap(
	
  	
  	
  	
  	
  ...
Much better,
but still noisy because
     of lacking ...
Type Inference
C# is an FPL because of

• First class functions (as .NET delegates)
• Elegant lambda expression syntax
• Enough type infe...
Fixed-point combinator
static	
  Func<T,	
  TResult>	
  Fix<T,	
  TResult>(
	
  	
  	
  	
  Func<Func<T,	
  TResult>,
	
  ...
Is it really useful in real
  world programming?
Yes, of course.
 I can’t live without the
functional features now.
Let me prove it to you.
Expression Trees
Code as Expressions

• Serializable code
• Consistent coding style
• Strong typing
• Compile-time verification
• Generate d...
Many projects use
    Expressions.
Let me show you sth.
Java 7 is coming
• Automatic Resource Management
• Collection Literals
• Improved Type Inference for Generics
  Instance C...
Most of them are
provided by C# now
What’s new in C# 4

• Default parameters
• Naming parameters
• Language build-in dynamic support
• Convariance / Contravar...
Taste a bit
Ruby-like Markup Builder
dynamic	
  b	
  =	
  new	
  XmlMarkupBuilder();
var	
  persons	
  =	
  new	
  []	
  {
	
  	
  	
 ...
Ruby-like Markup Builder
dynamic	
  b	
  =	
  new	
  XmlMarkupBuilder();
var	
  persons	
  =	
  new	
  []	
  {
	
  	
  	
 ...
Convariance &
       Contravariance

• Improving the generics type system
• More powerful and safer than Java’s use-site
 ...
Summary


• (maybe I should put a table here...)
C# always make me
happy when coding ...
... and it brings us lots
of useful code patterns
But Java keeps me away
  from the great JVM
Java is popular since it’s ...

 • Fast - designed for the JVM, as C is
   designed for the machine
 • Stable - it’s alway...
But what’s wrong with
        Java?
Java is too noisy

• The only way to work is not simple
• Write more and do less
• Little room for smart people.
Java is weird ...
int	
  a	
  =	
  1000,	
  b	
  =	
  1000;
System.out.println(a	
  ==	
  b);	
  //	
  true

Integer	
  c	...
... and becoming even more
//	
  C#
dynamic	
  o	
  =	
  ...;
int	
  i	
  =	
  o.SomeMethod(true,	
  “hello”);

//	
  Java...
If JVM is machine ...


• Java byte code is the machine code
• Java language is the ASM.
Would you like to
program with ASM?
What should we do?
Let’s use C# instead!
Just kidding
We can’t use C# since ...

 • JVM is powerful
 • Java libraries are great
 • Platform migration is a nightmare
So choose another
     language!
Languages on JVM

• JRuby
• Jython
• Groovy
• Clojure
• Scala
All these languages are

• More powerful
• Run on JVM
• Interop with Java seamlessly
• Mature enough
• Successful in real ...
Scala makes me write
 Java program again.
Why Scala?
• a statically-compiled language
• a pure object-oriented languages
• clean & powerful generic support (includi...
What do you think?
Contact me via

• Email: jeffz@live.com
• Twitter: @jeffz_cn
• Blog: http://blog.zhaojie.me/
Show me your idea ...
... and prove it to me
Future Talks

• Why F# matters
• Why Scala matters (TBD.)
• Generics in Java, Scala, C# & F#
• The beauty of Parallel Libr...
Thanks
Upcoming SlideShare
Loading in...5
×

Why Java Sucks and C# Rocks (Final)

137,706

Published on

46 Comments
170 Likes
Statistics
Notes
  • @Johnny If you look 2 or 3 slides down, he goes over how Java 5.0 added boxing and un-boxing, and provides similar code. Regardless, naturally this slideshow is outdated, it's from 2010...
    At the same time, the gap between Java features and C# features has only grown since then (Just look at C# 6).
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
  • Notice the date of the slideshow is early 2010 - over 4 years ago. In the very first slide, due to autoboxing/unboxing the Java code would now be written as:

    ArrayList list = new ArrayList();
    list.add(5);
    int i = list.get(0);
    int hash = ((Integer)3).hashCode();

    I can only imagine the other slides as being equally outdated.
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
  • @orelero can you please name an example of such libraries? I'm so tired of hearing that argument over and over thrown into the air, but no one has ever been able to come up with a FACTUAL list of the supposed libraries that are available for java and not for C# / .Net.
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
  • @SerendipitySeraph Well said. Distinct answer that one usually think of.
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
  • @JasonNelson5 I knew C# could go cross-platform but not to that extent.
    Still, I am so happy I came back from C# to Java as the derived languages like Xtend and Scala and also the eclipse frameworks are way beyond what C# can offer.

    *I just checked Xamarin and it reminded I had to say that Java frameworks are, most of the time, Open Source.
       Reply 
    Are you sure you want to  Yes  No
    Your message goes here
No Downloads
Views
Total Views
137,706
On Slideshare
0
From Embeds
0
Number of Embeds
33
Actions
Shares
0
Downloads
2,786
Comments
46
Likes
170
Embeds 0
No embeds

No notes for slide

Why Java Sucks and C# Rocks (Final)

  1. 1. Why Java Sucks & C# Rocks ZhaoJie @ SNDA April, 2010
  2. 2. About me • Name: Jeffrey Zhao • Blog: http://blog.zhaojie.me/ • Twitter: @jeffz_cn • Email: jeffz@live.com
  3. 3. Experiences • Pascal,VB 5 & 6, Delphi before 2002 • Java programmer from 2002 to 2004 • C# programmer since 2004
  4. 4. I’m going to talk about ...
  5. 5. • Languages features • Programming paradigms • Usage patterns • Why we should throw Java language away
  6. 6. I’m NOT going to make you ...
  7. 7. • Believe CLR is better than JVM • Believe .NET is better than Java platform • Get rid of Java language right away • Use C# instead of Java language • Use .NET instead of Java platform
  8. 8. Timeline • 2002 - Java 1.4 & C# 1.0 • 2004 - Java 5.0 & C# 2.0 • 2006 - Java 6 • 2008 - C# 3.0 • 2010 - Java 7 & C# 4
  9. 9. So Java programmers, hold your breath ...
  10. 10. Let’s start from the very beginning ...
  11. 11. Is Java a pure object- oriented language?
  12. 12. No. Primitive types are not objects.
  13. 13. In Java you can NOT ... ArrayList  list  =  new  ArrayList(); list.add(5);  //  cannot  compile int  i  =  (int)list.get(0);  //  cannot  compile int  hash  =  3.hashCode();  //  cannot  compile
  14. 14. You have to ... ArrayList  list  =  new  ArrayList(); Integer  five  =  Integer.valueOf(5); list.add(five); int  i  =  ((Integer)list.get(0)).intValue(); Integer  three  =  Integer.valueOf(3); int  hash  =  three.hashCode();
  15. 15. In C# ... • No primitive types • All types are subtypes of Object. • Just value types and reference types • Programmers can build custom value types • Value types can be assigned to Object variables without explicit casting.
  16. 16. So you can always ... ArrayList  list  =  new  ArrayList(); list.Add(5); int  i  =  (int)list[0]; int  hash  =  3.GetHashCode();
  17. 17. Thank God! Here comes Java 5.0!
  18. 18. Finally you can ... ArrayList  list  =  new  ArrayList(); list.add(5);  //  auto  boxing //  auto  unboxing int  i  =  (Integer)list.get(0); //  you  still  can’t  do  this! int  hash  =  3.hashCode();
  19. 19. Java 5.0 also brings ... • Annotation - allows language constructs to be tagged with additional data • Enumerations - the “enum” keyword creates a typesafe, ordered list of values • Varargs - make passing an array as parameter easier then before • Enhanced “for” loop - simplified iteration
  20. 20. But most of these features were already provided by C# 1.0 ...
  21. 21. ... so who is the copy cat?
  22. 22. OK, let’s forget it and look deep inside ...
  23. 23. Annotations in Java are interfaces. Attributes in C# are classes.
  24. 24. Differences? Let’s start coding!
  25. 25. Annotation’s shortages • Strange convention • Anemic object • Hard to unit test
  26. 26. Well, Java 5.0 also brings Generics, but ...
  27. 27. Type erasure: type information will be lost after compiling!
  28. 28. What’s the output? List<String>  a  =  new  ArrayList<String>(); List<Integer>  b  =  new  ArrayList<Integer>(); bool  sameType  =  a.getClass()  ==  b.getClass(); System.out.println(sameType);
  29. 29. And you can’t do this public  class  MyClass<E>  {        public  static  void  myMethod(Object  item)  {                if  (item  instanceof  E)  {  //  Compiler  error                        ...                }                E  item2  =  new  E();  //  Compiler  error                E[]  iArray  =  new  E[10];  //  Compiler  error        } }
  30. 30. And “use-site variance” is strange and stupid.
  31. 31. Well, maybe I’m biased. I can give you a separate talk about it.
  32. 32. Let keep moving.
  33. 33. The same time Java released 5.0 ...
  34. 34. C# 2.0 comes with • Better generics (comparing to Java 5.0) • Anonymous methods (hello, closure!) • “yield” keyword - iterator creation can’t be more easier
  35. 35. Why closure matters?
  36. 36. And “yield” is only about iterator?
  37. 37. Let’s see some samples.
  38. 38. So closure and yield are ... • Increasing productivity dramatically • Coming with new programming patterns • Important features for async / parallel / reactive programming • The primitives for Fibers - lightweight computation units
  39. 39. Two years after C# 2.0, Java 6 released with ...
  40. 40. Nothing!
  41. 41. Nothing!!
  42. 42. Nothing!!!
  43. 43. Give me a break and leave me alone ...
  44. 44. OK, I admit it ...
  45. 45. Java 6 is cool because of ... • pluggable annotations (JSR 269): customized compile-time processing (Project Lombok) • dramatic JVM improvements: compiler performnace, start-up time, GC, JIT... • scripting language support (JSR 223): Rhino JavaScript for Java included
  46. 46. But we’re talking about language, so ...
  47. 47. Let’s move on to C# 3.0, which brings us ...
  48. 48. LINQ (Language Integrated Query)
  49. 49. Only LINQ?
  50. 50. Yes! The great LINQ!
  51. 51. LINQ is made up of ... • Extension method - safely add methods to types without breaking anything • Lambda expression - make C# a better functional language • Anonymous type - compile time auto generated types • Expression tree - language-level code in the form of data
  52. 52. Now tell me, which one do you prefer?
  53. 53. BBCode to HTML //  Java Util.stripWhites(        Util.stripXss(                Util.bbToHtml(bbCode))) //  C# bbCode.BBToHtml().StripXss().StripWhites()
  54. 54. Sorting an array //  C# users.Sort((u1,  u2)  =>  u1.Age  -­‐  u2.Age); //  Java Arrays.sort(        users,        new  Comparator<User>()  {                public  int  compare(User  u1,  User  u2)  {                        return  u1.Age  -­‐  u2.Age;                }        });
  55. 55. JSON Output (C#) List<User>  userList  =  ...; var  json  =  new  {        errorCode  =  0,        message  =  "OK",        users  =  userList.Select(u  =>  new  {                name  =  u.FirstName  +  "  "  +  u.LastName,                age  =  (DateTime.Now  -­‐  u.BirthData).Year        }), };
  56. 56. JSON Output (Java) JSONObject  obj  =  new  JSONObject(); obj.put("errorCode",  0); obj.put("message",  "OK"); JSONArray  userArray  =  new  JSONArray(); for  (User  u:  userList)  {        JSONObject  objUser  =  new  JSONObject();        objUser.put("name",  /*  get  full  name  */);        objUser.put("age",  /*  calculate  age  */);        userArray.add(objUser); } obj.put("users",  userArray);
  57. 57. Is C# just full of Syntactic Sugar?
  58. 58. I don’t think so.
  59. 59. It really changed my mind • Real-world Functional Programming • Write declarative code (anti-for) • Make code / API more and more elegant
  60. 60. Please write a program to index a list of keywords (like books).
  61. 61. Explanation • Input: List<String> • Output: Map<Character, List<String>> • The key of map is ‘a’ to ‘z’ • Each list in the map are sorted
  62. 62. Let’s see the Java code first ...
  63. 63. List<String>  keywords  =  ...; Map<Character,  List<String>>  result  =  new  HashMap<>(); for  (String  k:  keywords)  {   char  firstChar  =  k.charAt(0);     if  (!result.containsKey(firstChar))  {     result.put(firstChar,  new  ArrayList<String>());   }     result.get(firstChar).add(k); } for  (List<String>  list:  result.values())  {   Collections.sort(list); }
  64. 64. List<String>  keywords  =  ...; Map<Character,  List<String>>  result  =  new  HashMap<>(); for  (String  k:  keywords)  {   char  firstChar  =  k.charAt(0);     if  (!result.containsKey(firstChar))  {     result.put(firstChar,  new  ArrayList<String>());   }     result.get(firstChar).add(k); } for  (List<String>  list:  result.values())  {   Collections.sort(list); } Imperative code “How” to do
  65. 65. Quite easy, ah? Guess how does C# code look like?
  66. 66. List<string>  keywords  =  ...; var  result  =  keywords        .GroupBy(k  =>  k[0])        .ToDictionary(                g  =>  g.Key,                g  =>  g.OrderBy(k  =>  k).ToList());
  67. 67. List<string>  keywords  =  ...; var  result  =  keywords        .GroupBy(k  =>  k[0])        .ToDictionary(                g  =>  g.Key,                g  =>  g.OrderBy(k  =>  k).ToList()); Declarative code “What” to do
  68. 68. Amazing, isn’t it?
  69. 69. What about the Java community?
  70. 70. Well, the Functional Java project is out! But ...
  71. 71. ... do you really want to write code like this?
  72. 72. keywords    .groupBy(        new  F<String,  Character>  {            public  Character  f(String  s)  {  return  s.charAt(0);  }        })    .toMap(        new  F<Grouping<Character,  String>,  Character>  {            public  Character  f(Grouping<Char,  String>  g)  {                  return  g.getKey();            }        },        new  F<Grouping<Character,  String>,  List<String>>  {            public  List<String>  f(Grouping<Character,  String>  g)  {                return  g                    .orderBy(                        new  F<String,  String>  {                            public  String  f(String  s)  {  return  s;  }                        })                    .toList();            }        });
  73. 73. It’s really a pain without lambda expressions.
  74. 74. Fortunately, Java 7 will provide a sort of lambda syntax.
  75. 75. keywords        .groupBy({  String  k  =>  k.charAt(0)  })        .toMap(                {  Grouping<Character,  String>  g  =>  g.getKey()  },                {  Grouping<Character,  String>  g  =>                          g.orderBy({  String  c  =>  c  }).toList()  });
  76. 76. Much better, but still noisy because of lacking ...
  77. 77. Type Inference
  78. 78. C# is an FPL because of • First class functions (as .NET delegates) • Elegant lambda expression syntax • Enough type inference for most cases • Full set of functional primitives in BCL • Great extensibility (by extension method)
  79. 79. Fixed-point combinator static  Func<T,  TResult>  Fix<T,  TResult>(        Func<Func<T,  TResult>,        Func<T,  TResult>>  f) {        return  x  =>  f(Fix(f))(x); } var  fib  =  Fix<int,  int>(f  =>  x  =>        x  <=  1  ?  1  :  f(x  -­‐  1)  +  f(x  -­‐  2));
  80. 80. Is it really useful in real world programming?
  81. 81. Yes, of course. I can’t live without the functional features now.
  82. 82. Let me prove it to you.
  83. 83. Expression Trees
  84. 84. Code as Expressions • Serializable code • Consistent coding style • Strong typing • Compile-time verification • Generate dynamic method easily
  85. 85. Many projects use Expressions. Let me show you sth.
  86. 86. Java 7 is coming • Automatic Resource Management • Collection Literals • Improved Type Inference for Generics Instance Creation • Language support for JSR 292 • Simplified Varargs Method Invocation • Support for Strings in Switch Statements
  87. 87. Most of them are provided by C# now
  88. 88. What’s new in C# 4 • Default parameters • Naming parameters • Language build-in dynamic support • Convariance / Contravariance
  89. 89. Taste a bit
  90. 90. Ruby-like Markup Builder dynamic  b  =  new  XmlMarkupBuilder(); var  persons  =  new  []  {        new  Person("Tom",  10),        new  Person("Jerry",  8) }; XElement  xml  =          b.persons(                from  p  in  persons                select  b.person(p.Name,  age:  p.Age));
  91. 91. Ruby-like Markup Builder dynamic  b  =  new  XmlMarkupBuilder(); var  persons  =  new  []  {        new  Person("Tom",  10),        new  Person("Jerry",  8) }; <persons> XElement  xml  =      <person  age=”10”>Tom</person>    <person  age=”8”>Jerry</person>        b.persons( </persons>                from  p  in  persons                select  b.person(p.Name,  age:  p.Age));
  92. 92. Convariance & Contravariance • Improving the generics type system • More powerful and safer than Java’s use-site variance • Really a brain fucker
  93. 93. Summary • (maybe I should put a table here...)
  94. 94. C# always make me happy when coding ...
  95. 95. ... and it brings us lots of useful code patterns
  96. 96. But Java keeps me away from the great JVM
  97. 97. Java is popular since it’s ... • Fast - designed for the JVM, as C is designed for the machine • Stable - it’s always one and only one way to do things • Easy - most of the features are quite easy to learn
  98. 98. But what’s wrong with Java?
  99. 99. Java is too noisy • The only way to work is not simple • Write more and do less • Little room for smart people.
  100. 100. Java is weird ... int  a  =  1000,  b  =  1000; System.out.println(a  ==  b);  //  true Integer  c  =  1000,  d  =  1000; System.out.println(c  ==  d);  //  false Integer  e  =  100,  f  =  100; System.out.println(e  ==  f);  //  true
  101. 101. ... and becoming even more //  C# dynamic  o  =  ...; int  i  =  o.SomeMethod(true,  “hello”); //  Java Object  o  =  ...; Object[]  args  =  new  Object[]  {  true,  “hello”  }; InvokeDynamic.<int>SomeMethod(o,  args);
  102. 102. If JVM is machine ... • Java byte code is the machine code • Java language is the ASM.
  103. 103. Would you like to program with ASM?
  104. 104. What should we do?
  105. 105. Let’s use C# instead!
  106. 106. Just kidding
  107. 107. We can’t use C# since ... • JVM is powerful • Java libraries are great • Platform migration is a nightmare
  108. 108. So choose another language!
  109. 109. Languages on JVM • JRuby • Jython • Groovy • Clojure • Scala
  110. 110. All these languages are • More powerful • Run on JVM • Interop with Java seamlessly • Mature enough • Successful in real world
  111. 111. Scala makes me write Java program again.
  112. 112. Why Scala? • a statically-compiled language • a pure object-oriented languages • clean & powerful generic support (including convariance & contravariance) • enough functional features • actor-based programming model • really scalable
  113. 113. What do you think?
  114. 114. Contact me via • Email: jeffz@live.com • Twitter: @jeffz_cn • Blog: http://blog.zhaojie.me/
  115. 115. Show me your idea ...
  116. 116. ... and prove it to me
  117. 117. Future Talks • Why F# matters • Why Scala matters (TBD.) • Generics in Java, Scala, C# & F# • The beauty of Parallel Library • Real-world reactive programming
  118. 118. Thanks
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×