Read page 16 in the document.   Maybe that should clarify "Kojo supports a
very powerful language called Scala. Everything that you write within the
Script
window will be in the Scala language."

Therefore any documentation on Kojo is in fact documentation on using
Scala.   For an intro doc to cover defining functions, I think that's a
pretty big start into Scala.   Remember when you were first learning to
code.   I remember starting off with calling functions and using gotos in
BASIC.   I think that's about what this document teaches you in Scala.

Remember this is just the Intro, what you would expect to teach kids in a
few weeks.

However if you refuse to believe, fine.  I don't think this is a point worth
arguing anymore.


Like I said, I think the core points being thrown on the "Complicated" scale
are:

* Implicits
* Generics (being more "complex" than Java's... still debatable to me)
* Dropping Syntax ( ; inference, type inference,
expression-oriented-programming and operator notation)
* Pattern Matching (I've seen a few people attack this)

All of these are core to the "Scala is better" argument as well.   It
doesn't surprise me that this  is the front used to attack Scala as too
complicated.   Does anyone else find it ironic that (if you were to include
closures) these are the features that Scala has which are different than
Java (and grant it the power that everyone loves)?

Scala is too complicated because these features are not familiar to me from
Java.   Ok.   Haskell is too complicated because it's syntax is so
foreign.   Oh, but then I read Real World Haskell and found that actually
it's a pretty simple language.   The hard part is playing with the type
system.   Not having had to do that in Java much, I can see that being
"complicated" to begin with.

I just started learning Python as well (side effect of new employer).
However, I'm pretty familiar with most of its idioms from other languages.
I guess that means it's not complicated?   I still find all those "self"
keywords used in defining a class egotistical.   I pretty much ignore them
for now and just mimic other classes until I understand when they are needed
and when they are not.  I assume it's because python forces you to declare
the self-reference implicit in any method declared on an object.   If that's
so, it seems a needlessly complicated rule for a beginner.   But seeing
classes encoded into the C language, it's not unfamiliar and therefore
doesn't seem all that complicated.


- Josh





2010/8/29 Cédric Beust ♔ <ced...@beust.com>

>
>
> On Sun, Aug 29, 2010 at 12:21 PM, Josh Suereth 
> <joshua.suer...@gmail.com>wrote:
>
>> Perhaps we read different documents.
>>
>
> Please feel free to give me a few page numbers. All I can find in this
> documentation that has anything to do with Scala is the "def" keyword.
>
> In other words, the only thing that someone will be able to do in Scala
> after reading this document will be to define functions. Which is a great
> start, but certainly not a good argument to claim that Kojo is evidence that
> Scala is not complicated.
>
> --
> Cédric
>
>
>  --
> You received this message because you are subscribed to the Google Groups
> "The Java Posse" group.
> To post to this group, send email to javapo...@googlegroups.com.
> To unsubscribe from this group, send email to
> javaposse+unsubscr...@googlegroups.com<javaposse%2bunsubscr...@googlegroups.com>
> .
> For more options, visit this group at
> http://groups.google.com/group/javaposse?hl=en.
>

-- 
You received this message because you are subscribed to the Google Groups "The 
Java Posse" group.
To post to this group, send email to javapo...@googlegroups.com.
To unsubscribe from this group, send email to 
javaposse+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/javaposse?hl=en.

Reply via email to