White Elefant

The quantum model is simpler than the Newtonian model?

On 26 Oct 2011, at 01:10, stuart gordon <stuartgordon@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

You list a bunch of supposed problems with scala, without backing them up. Many of them are wrong.Instead of making assumptions, for each supposed problem consider you may be mistaken, and ask about each apparent issue as an independent question. If, after thorough discussion, it's clear that you were correct to begin with, it is then safe to discuss possible conclusions.


On Tue, Oct 25, 2011 at 8:10 PM, stuart gordon <stuartgordon@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

On 10/26/2011 10:10 AM, stuart gordon wrote:

BAY148-W1F0C74CBD77D50E63002B98ED0 [at] phx [dot] gbl" type="cite"> Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

Very, very amused.

-- 
Tony Morris
http://tmorris.net/

You guys got trolled.

On Tue, Oct 25, 2011 at 8:31 PM, Tony Morris wrote:
> On 10/26/2011 10:10 AM, stuart gordon wrote:
>
> Hi,
>
> I am a lot older that most of you out there and I have seen a lot of changes
> in computing in general. I was a Java programmer and trainer.
> I am now looking at Scala and functional programming but I am now really
> doubting much that has been said about this language and the use of
> functional language.
>
> Industry simplifies tools and process with time in all walks of life. It
> doesn't complicate them and doesn't lend to complicating the processes.
> Copernicus  displaced the earth centric ideas; Quantum displaces or enhances
> Newtonian, Euclidean models. Every model is simpler.
> Scala is the opposite. Now you are relying on very talented programmers who
> have to limit their semantics to make programs work.
> The very power that leverage's Scala is its weakness, because to test it, is
> almost impossible and very difficult.
> It relies on good programming practise  to write good programs. Even
> syntactically it is untidy.
> This has not been the trend in software. The trend is to make it more
> simple, robust and hopefully more error free.
> Scala with lazy evalution and psuedofuntional programming opens a minefield
> that will cost in production and in maintenance.
> Even the code will have to take into account the behaviour of tail end
> recursion and optimising strategies. This should be done by the compiler,
> and run time virtual machines and with hooks into the OS.
> Surely this should be transparent to any programming language.
>
> OO simplifies the real domain model to the machine image. Scala does not.
>
> I think most Scala will be unmaintainable and unpredictable.
>
> The future will see programming languages change but Scala isn't going to be
> one of them. Compilers, virtual machines and therefore ultimately the OS
> will do some of the work to make programming easier with multi threading and
> multi core.
> Think about parallel communication which is now replaced with a simple
> serial interface. Things get simpler not more elaborate.
>
> Why is it popular. Because academics want to have an interesting time but
> are not really interested in real world problems. Every one thinks its going
> to be the paradigm shift like OO was to procedural; it  never will be.
> Students think it cool or clever to do it. So is chess but for the most wont
> provide bread and butter on the table.  Its a dangerous fad that will
> produce horrible code like concrete did with architecture in the 1960´s.
>
> Very, very sceptical.
>
> Lunalobo
>
>
> Very, very amused.
>
> --
> Tony Morris
> http://tmorris.net/
>
>

Giving the benefit of the doubt here ("trolling" is stupidity
masquerading as an intellectual virtue), there really do exist people
who believe what is written below. One can only laugh innit?

On 10/26/2011 10:52 AM, David Landis wrote:
> You guys got trolled.
>
> On Tue, Oct 25, 2011 at 8:31 PM, Tony Morris wrote:
>> On 10/26/2011 10:10 AM, stuart gordon wrote:
>>
>> Hi,
>>
>> I am a lot older that most of you out there and I have seen a lot of changes
>> in computing in general. I was a Java programmer and trainer.
>> I am now looking at Scala and functional programming but I am now really
>> doubting much that has been said about this language and the use of
>> functional language.
>>
>> Industry simplifies tools and process with time in all walks of life. It
>> doesn't complicate them and doesn't lend to complicating the processes.
>> Copernicus displaced the earth centric ideas; Quantum displaces or enhances
>> Newtonian, Euclidean models. Every model is simpler.
>> Scala is the opposite. Now you are relying on very talented programmers who
>> have to limit their semantics to make programs work.
>> The very power that leverage's Scala is its weakness, because to test it, is
>> almost impossible and very difficult.
>> It relies on good programming practise to write good programs. Even
>> syntactically it is untidy.
>> This has not been the trend in software. The trend is to make it more
>> simple, robust and hopefully more error free.
>> Scala with lazy evalution and psuedofuntional programming opens a minefield
>> that will cost in production and in maintenance.
>> Even the code will have to take into account the behaviour of tail end
>> recursion and optimising strategies. This should be done by the compiler,
>> and run time virtual machines and with hooks into the OS.
>> Surely this should be transparent to any programming language.
>>
>> OO simplifies the real domain model to the machine image. Scala does not.
>>
>> I think most Scala will be unmaintainable and unpredictable.
>>
>> The future will see programming languages change but Scala isn't going to be
>> one of them. Compilers, virtual machines and therefore ultimately the OS
>> will do some of the work to make programming easier with multi threading and
>> multi core.
>> Think about parallel communication which is now replaced with a simple
>> serial interface. Things get simpler not more elaborate.
>>
>> Why is it popular. Because academics want to have an interesting time but
>> are not really interested in real world problems. Every one thinks its going
>> to be the paradigm shift like OO was to procedural; it never will be.
>> Students think it cool or clever to do it. So is chess but for the most wont
>> provide bread and butter on the table. Its a dangerous fad that will
>> produce horrible code like concrete did with architecture in the 1960´s.
>>
>> Very, very sceptical.
>>
>> Lunalobo
>>
>>
>> Very, very amused.
>>
>> --
>> Tony Morris
>> http://tmorris.net/
>>
>>

Can I contribute to this flame?

I'm 62, and have been a Java programmer since the early days of the Duke Applets. I've been programming full time in Scala for 2 years now, I think. But one look at my code and you can tell I'm still a Java programmer at heart. I'm using implicits but not option. I use Java collections almost exclusively. And I can't make heads nor tails of category theory.

There is no doubt that Scala has a very strong academic flavor. And there are some things which run slower than you would think reasonable. But guess what. I'm still sold on Scala. And speed always requires some deeper knowledge and lots of work regardless of the language.

Scala has a lot of features that I may not use much. But the point is, they are there when you need them. There is no question in my mind that Java is a dead language. And Scala is a viable alternative.

Bill La Forge

On Wed, Oct 26, 2011 at 6:24 AM, Tony Morris <tonymorris@gmail.com> wrote:

Giving the benefit of the doubt here ("trolling" is stupidity
masquerading as an intellectual virtue), there really do exist people
who believe what is written below. One can only laugh innit?


On 10/26/2011 10:52 AM, David Landis wrote:
> You guys got trolled.
>
> On Tue, Oct 25, 2011 at 8:31 PM, Tony Morris <tonymorris@gmail.com> wrote:
>> On 10/26/2011 10:10 AM, stuart gordon wrote:
>>
>> Hi,
>>
>> I am a lot older that most of you out there and I have seen a lot of changes
>> in computing in general. I was a Java programmer and trainer.
>> I am now looking at Scala and functional programming but I am now really
>> doubting much that has been said about this language and the use of
>> functional language.
>>
>> Industry simplifies tools and process with time in all walks of life. It
>> doesn't complicate them and doesn't lend to complicating the processes.
>> Copernicus  displaced the earth centric ideas; Quantum displaces or enhances
>> Newtonian, Euclidean models. Every model is simpler.
>> Scala is the opposite. Now you are relying on very talented programmers who
>> have to limit their semantics to make programs work.
>> The very power that leverage's Scala is its weakness, because to test it, is
>> almost impossible and very difficult.
>> It relies on good programming practise  to write good programs. Even
>> syntactically it is untidy.
>> This has not been the trend in software. The trend is to make it more
>> simple, robust and hopefully more error free.
>> Scala with lazy evalution and psuedofuntional programming opens a minefield
>> that will cost in production and in maintenance.
>> Even the code will have to take into account the behaviour of tail end
>> recursion and optimising strategies. This should be done by the compiler,
>> and run time virtual machines and with hooks into the OS.
>> Surely this should be transparent to any programming language.
>>
>> OO simplifies the real domain model to the machine image. Scala does not.
>>
>> I think most Scala will be unmaintainable and unpredictable.
>>
>> The future will see programming languages change but Scala isn't going to be
>> one of them. Compilers, virtual machines and therefore ultimately the OS
>> will do some of the work to make programming easier with multi threading and
>> multi core.
>> Think about parallel communication which is now replaced with a simple
>> serial interface. Things get simpler not more elaborate.
>>
>> Why is it popular. Because academics want to have an interesting time but
>> are not really interested in real world problems. Every one thinks its going
>> to be the paradigm shift like OO was to procedural; it  never will be.
>> Students think it cool or clever to do it. So is chess but for the most wont
>> provide bread and butter on the table.  Its a dangerous fad that will
>> produce horrible code like concrete did with architecture in the 1960´s.
>>
>> Very, very sceptical.
>>
>> Lunalobo
>>
>>
>> Very, very amused.
>>
>> --
>> Tony Morris
>> http://tmorris.net/
>>
>>


--
Tony Morris
http://tmorris.net/

What's doubly amusing are his broken analogies that actually end up contradicting his own arguments from the fields of physics and architecture
This just made my day a bit lighter! Thanks for the laugh.
On 26 October 2011 11:31, Tony Morris <tonymorris@gmail.com> wrote:

On 10/26/2011 10:10 AM, stuart gordon wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

Very, very amused.

-- 
Tony Morris
http://tmorris.net/

Oh my god , you must be a journo in your previous incarnation who writes about tech  with half baked knowledge.i was just roflmao.

On Oct 26, 2011 5:40 AM, "stuart gordon" <stuartgordon@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

Stuart, how do languages like Python fit into your train of thought?
My experience with Python has been that while it is syntactically simpler than Java it is overall morecomplex because it allows you to do so much more.
Does this then mean that Python and other similar dynamic languages are also doomed to fail?
Personally, I think you're dead wrong and I suspect that you knowledge of the history of computing, especially functional computing, is a bit blinded by personal experience.
For me, Scala represents a fusion between the best things from a number of languages that I'veworked with.
On 26 October 2011 04:24, Sreenivas Reddy T <thatiparthysreenivas@gmail.com> wrote:

Oh my god , you must be a journo in your previous incarnation who writes about tech  with half baked knowledge.i was just roflmao.

On Oct 26, 2011 5:40 AM, "stuart gordon" <stuartgordon@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

On the other end though, conceptually, the Quantum theory is much more difficult to grok than Newtonian physics, as the interactions it concerns itself with may seem somewhat unintuitive at first...

(btw - I am no physics expert, so my understanding of the fine detils is limited)

kolmapäev, 26. oktoober 2011 3:25.45 UTC+3 kirjutas Michael Thorpe:

The quantum model is simpler than the Newtonian model?

On 26 Oct 2011, at 01:10, stuart gordon <stuart...@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

Regarding simple vs easier: :)
http://www.infoq.com/presentations/Simple-Made-Easy (Rich Hickey at Strange Loop).

On Wed, Oct 26, 2011 at 8:49 AM, Roland Tepp <luolong@gmail.com> wrote:

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

Can we please (please!) move this to scala-debate (if we're going to have the discussion at all)?
On 26 Oct 2011, at 07:49, Roland Tepp wrote:

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

On the other end though, conceptually, the Quantum theory is much more difficult to grok than Newtonian physics, as the interactions it concerns itself with may seem somewhat unintuitive at first...

(btw - I am no physics expert, so my understanding of the fine detils is limited)

kolmapäev, 26. oktoober 2011 3:25.45 UTC+3 kirjutas Michael Thorpe:

The quantum model is simpler than the Newtonian model?

On 26 Oct 2011, at 01:10, stuart gordon <stuart...@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

--
paul.butcher->msgCount++

Snetterton, Castle Combe, Cadwell Park...
Who says I have a one track mind?

http://www.paulbutcher.com/
LinkedIn: http://www.linkedin.com/in/paulbutcher
MSN: paul@paulbutcher.com
AIM: paulrabutcher
Skype: paulrabutcher

Let's give a man a benefit of a doubt please,

It is clear, that this piece has been written up in a desperation over some concept or another in Scala that did not make sense, did not work the way the author had expected or over some feature that seemed kind of like handing a sharpened scalpels to a bunch of kids running in the yard, playing catch.

There is scant littel factual information in the rant below, so I will not quote, but let me just reply to some of the points just to try to give a balanced but opposite view of the matter.

First of all. You are learning a *new language*. That means that it is not a different flavour of Java (although it can by some accounts be used like this). And it is not C++ or Haskell or Python or C. It is Scala. This in turn means that you need to learn and adapt to the new concepts, if you ever hope to undertand and make any use of the language. If you don't want to use the language, fine. Don't use it. It is your choice.

As for bad code. You can not possibly imagine the amount the utterly and inescapably bad and unmaintainable code I have to work through each day at my current gig, all of it written in Java and none of it practicing anything even remotely resembling good engineering practices. You can write bad code in any language. Scala is no exception to this rule. Bad code is what happens, when you let a bunch of (not even unexperienced) programmers write code into a system they do not completely understand without any architectural oversight what so ever. Do this for enough years and the result is horrible unmaintainable and expensive hairball of code that still manages to do what it is supposed to do...

As for simplicity. Well, although I would agree that as physics models go, Quantum theory may well be the simpler model, but if you ever ask any of the non-physicist to explain a phenomena in terms of physics, I doubt anyone will rush in telling you how this is all would boil down to atoms bumping into eachother... The model may be simpler, but the application of the model just got much more ... let's just call it "flexible".

Same goes for Scala (in comparison with Java). The language itself got actually much simpler than Java - there are less special constructs involved than in Java, and they are much more composable. This flexibility gives much more power to wreak havoc, but it is also a tool to write beautiful, concise code that can concentrate on the "what" instead of "how" part of solving the problems at hand.

Ultimately, it's a choice of the market whether Scala will prevail in some form or another. Nothing we say or predict will make it happen. If the language and it's ecosystem of libraries and application frameworks make the work of ordinary programmer easier, then the market will choose Scala.

For truly good libraries, frameworks and components to crop up for the rest of us to use, we have always needed some brilliant minds - never mind the language.

kolmapäev, 26. oktoober 2011 3:10.09 UTC+3 kirjutas maestro:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

> Why, yes, in the essence.
> Quantum model is much simpler than Newtonian, as it manages to use one
> mathematical model to explain more phenomenons than the ones it replaced...
>
> On the other end though, conceptually, the Quantum theory is much more
> difficult to grok than Newtonian physics, as the interactions it concerns
> itself with may seem somewhat unintuitive at first...

I think I can safely say that nobody understands quantum mechanics -
Richard
Feynman, The Character of Physical Law.

Michael

This seems more full of holes than a sieve, I've addressed some of the more notable factual errors inline...

The first, unsurprisingly, is the the title.  You probably meant it to be called "white elephant". "elefant" is a mis-spelling that stands out very much like, well, an elephant in a room!
Programming languages and spoken languages are very much alike in this regard, their perceived complexity will increase as you move further from the comfort zone of your first language.  In both cases, a dictionary and spellchecker (a.k.a. scaladoc and IDE with highlighting) will prove to be very useful.  Without these tools, you can expect to make things a great deal harder for yourself when first learning a language.

On 26 October 2011 01:10, stuart gordon <stuartgordon@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.

This is a double-edged sword.  I have seen too many "trained", "certified" developers in my time than I'd like to.  They rarely do credit to the person who trained them, often demonstrating a lack of skills and some dangerously outdated ideas of how to get things done.
 

I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.

By every observable metric, Scala *is* simpler.  It has a smaller spec, a more consistent syntax, and far fewer corner cases.
For example, pattern matching is used in comprehensions, assignment, exception handling, match expressions, and the creation of partial functions.  If you understand pattern matching then you don't need to learn a new and specialised syntax for each of these tasks.
There's no special "operators" restricted to just primitives (there are no primitives), Operators are just methods and can exist on any object, so no need to use different semantic constructs for ints and BigIntegers.
Scala also doesn't need any special handling for strings in the language spec to support + as a concatenation/conversion operator.
== does what you would expect everywhere.  No need to use == for primitives and .equals for objects.
The list goes on, but that should be enough food for thought. 

The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.

Interesting, testing is a very specific aspect of a language.  My experience of testing in Scala is that the tools (ScalaTest, Specs, Scalacheck) are very powerful and intuitive, with good DSLs.  Functions are highly composable and easily tested in isolation, immutable objects and pure methods also avoid the need for setting up complicated test harnesses to duplicate state.  Even the ease of redirecting standard I/O streams makes life easier.
Java, by comparison, required a LOT of bloat to test accurately.  This is especially true when using a framework like Spring, in which a significant piece of logic is pulled into XML files and is rarely properly tested.  

It relies on good programming practise  to write good programs.

Always, for *any* language! For example, it takes good practices to write decent English (note the spelling of practices...) 

Even syntactically it is untidy.

If you were to post *any* sample Java code here, I'm sure that you'd find many people more than capable of rewriting it for you in Scala, using a far tidier syntax.  

This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.

Quite the opposite.  Pure functions and immutable objects make it far easier to reason about the design of a system, the reduced boilerplate also takes away a rich souche of accidental complexity.  From my experience of using Scala for 3 years now, in the real world, at a production level, I've seen time and time again that the language produces far more maintainable code than is possible with Java.  

Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler

tail CALL optimisation *is* done by the compiler.  The @tailrec annotation simply provides you with a warning if you've written a recursive method that can't be optimised in this way.  

, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

Agreed, the patch for adding tail-call optimisation support to the JAVA virtual machine is now quite long in the tooth.  If Oracle were to finally add this for Java 8 then it would be a Very Good Thing(tm)  

OO simplifies the real domain model to the machine image. Scala does not.

Very, very subjective.  Scala has some of the best support for domain specific languages (DSLs) that I have ever seen, allowing for a very strong association between the domain and its representation in source code.
You also seem to be labouring under the misconception that Scala is not an object-oriented language.  Whereas the removal of static methods and primitives have actually made it far MORE object-oriented than Java.  

I think most Scala will be unmaintainable and unpredictable.

I know, through real-world experience, that this is not the case. 

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

As regards external I/O, parallel printer ports are indeed a thing of the past, as technology allowed us to squeeze far more speek over a serial connection and to avoid the awkward clock synchronisation logic that was required.  As a paradigm, parallel ports could be equated to Java's multithreading via locks and synchronised methods.
Inside your computer, however, you'll discover the PCI bus.  This runs multiple serial channels, with their own synchronisation, in parallel.  The same synchronisation primitives are used behind the scenes, but a more powerful paradigm is built on top of them.  Very much like actors...  

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems.

I'm sure the guys at EDF trading, twitter, foursquare, Amazon, Novell, and LinkedIn are scratching their heads at this one.  Trying to figure out how they're academics and not in the real world.

Every one thinks its going to be the paradigm shift like OO was to procedural; it never will be.

Such certainty! Can I borrow your tea-leaves some day please?

Students think it cool or clever to do it.

The vast majority of students will do Java, because that's what they're taught!  If you every wanted to look for a language that could be flagged as being "for academics"...

So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

No, that would be COBOL 

Very, very sceptical.

s/sceptical/uninformed 

Lunalobo

Please take this discussion to scala-debate now.

On Wed, Oct 26, 2011 at 11:11, Kevin Wright <kev.lee.wright@gmail.com> wrote:

This seems more full of holes than a sieve, I've addressed some of the more notable factual errors inline...

The first, unsurprisingly, is the the title.  You probably meant it to be called "white elephant". "elefant" is a mis-spelling that stands out very much like, well, an elephant in a room!
Programming languages and spoken languages are very much alike in this regard, their perceived complexity will increase as you move further from the comfort zone of your first language.  In both cases, a dictionary and spellchecker (a.k.a. scaladoc and IDE with highlighting) will prove to be very useful.  Without these tools, you can expect to make things a great deal harder for yourself when first learning a language.

On 26 October 2011 01:10, stuart gordon <stuartgordon@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.

This is a double-edged sword.  I have seen too many "trained", "certified" developers in my time than I'd like to.  They rarely do credit to the person who trained them, often demonstrating a lack of skills and some dangerously outdated ideas of how to get things done.
 

I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.

By every observable metric, Scala *is* simpler.  It has a smaller spec, a more consistent syntax, and far fewer corner cases.
For example, pattern matching is used in comprehensions, assignment, exception handling, match expressions, and the creation of partial functions.  If you understand pattern matching then you don't need to learn a new and specialised syntax for each of these tasks.
There's no special "operators" restricted to just primitives (there are no primitives), Operators are just methods and can exist on any object, so no need to use different semantic constructs for ints and BigIntegers.
Scala also doesn't need any special handling for strings in the language spec to support + as a concatenation/conversion operator.
== does what you would expect everywhere.  No need to use == for primitives and .equals for objects.
The list goes on, but that should be enough food for thought. 

The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.

Interesting, testing is a very specific aspect of a language.  My experience of testing in Scala is that the tools (ScalaTest, Specs, Scalacheck) are very powerful and intuitive, with good DSLs.  Functions are highly composable and easily tested in isolation, immutable objects and pure methods also avoid the need for setting up complicated test harnesses to duplicate state.  Even the ease of redirecting standard I/O streams makes life easier.
Java, by comparison, required a LOT of bloat to test accurately.  This is especially true when using a framework like Spring, in which a significant piece of logic is pulled into XML files and is rarely properly tested.  

It relies on good programming practise  to write good programs.

Always, for *any* language! For example, it takes good practices to write decent English (note the spelling of practices...) 

Even syntactically it is untidy.

If you were to post *any* sample Java code here, I'm sure that you'd find many people more than capable of rewriting it for you in Scala, using a far tidier syntax.  

This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.

Quite the opposite.  Pure functions and immutable objects make it far easier to reason about the design of a system, the reduced boilerplate also takes away a rich souche of accidental complexity.  From my experience of using Scala for 3 years now, in the real world, at a production level, I've seen time and time again that the language produces far more maintainable code than is possible with Java.  

Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler

tail CALL optimisation *is* done by the compiler.  The @tailrec annotation simply provides you with a warning if you've written a recursive method that can't be optimised in this way.  

, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

Agreed, the patch for adding tail-call optimisation support to the JAVA virtual machine is now quite long in the tooth.  If Oracle were to finally add this for Java 8 then it would be a Very Good Thing(tm)  

OO simplifies the real domain model to the machine image. Scala does not.

Very, very subjective.  Scala has some of the best support for domain specific languages (DSLs) that I have ever seen, allowing for a very strong association between the domain and its representation in source code.
You also seem to be labouring under the misconception that Scala is not an object-oriented language.  Whereas the removal of static methods and primitives have actually made it far MORE object-oriented than Java.  

I think most Scala will be unmaintainable and unpredictable.

I know, through real-world experience, that this is not the case. 

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

As regards external I/O, parallel printer ports are indeed a thing of the past, as technology allowed us to squeeze far more speek over a serial connection and to avoid the awkward clock synchronisation logic that was required.  As a paradigm, parallel ports could be equated to Java's multithreading via locks and synchronised methods.
Inside your computer, however, you'll discover the PCI bus.  This runs multiple serial channels, with their own synchronisation, in parallel.  The same synchronisation primitives are used behind the scenes, but a more powerful paradigm is built on top of them.  Very much like actors...  

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems.

I'm sure the guys at EDF trading, twitter, foursquare, Amazon, Novell, and LinkedIn are scratching their heads at this one.  Trying to figure out how they're academics and not in the real world.

Every one thinks its going to be the paradigm shift like OO was to procedural; it never will be.

Such certainty! Can I borrow your tea-leaves some day please?

Students think it cool or clever to do it.

The vast majority of students will do Java, because that's what they're taught!  If you every wanted to look for a language that could be flagged as being "for academics"...

So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

No, that would be COBOL 

Very, very sceptical.

s/sceptical/uninformed 

Lunalobo

Please take this discussion to scala-debate now.

On Wed, Oct 26, 2011 at 11:11, Kevin Wright <kev.lee.wright@gmail.com> wrote:

This seems more full of holes than a sieve, I've addressed some of the more notable factual errors inline...

The first, unsurprisingly, is the the title.  You probably meant it to be called "white elephant". "elefant" is a mis-spelling that stands out very much like, well, an elephant in a room!
Programming languages and spoken languages are very much alike in this regard, their perceived complexity will increase as you move further from the comfort zone of your first language.  In both cases, a dictionary and spellchecker (a.k.a. scaladoc and IDE with highlighting) will prove to be very useful.  Without these tools, you can expect to make things a great deal harder for yourself when first learning a language.

On 26 October 2011 01:10, stuart gordon <stuartgordon@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.

This is a double-edged sword.  I have seen too many "trained", "certified" developers in my time than I'd like to.  They rarely do credit to the person who trained them, often demonstrating a lack of skills and some dangerously outdated ideas of how to get things done.
 

I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.

By every observable metric, Scala *is* simpler.  It has a smaller spec, a more consistent syntax, and far fewer corner cases.
For example, pattern matching is used in comprehensions, assignment, exception handling, match expressions, and the creation of partial functions.  If you understand pattern matching then you don't need to learn a new and specialised syntax for each of these tasks.
There's no special "operators" restricted to just primitives (there are no primitives), Operators are just methods and can exist on any object, so no need to use different semantic constructs for ints and BigIntegers.
Scala also doesn't need any special handling for strings in the language spec to support + as a concatenation/conversion operator.
== does what you would expect everywhere.  No need to use == for primitives and .equals for objects.
The list goes on, but that should be enough food for thought. 

The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.

Interesting, testing is a very specific aspect of a language.  My experience of testing in Scala is that the tools (ScalaTest, Specs, Scalacheck) are very powerful and intuitive, with good DSLs.  Functions are highly composable and easily tested in isolation, immutable objects and pure methods also avoid the need for setting up complicated test harnesses to duplicate state.  Even the ease of redirecting standard I/O streams makes life easier.
Java, by comparison, required a LOT of bloat to test accurately.  This is especially true when using a framework like Spring, in which a significant piece of logic is pulled into XML files and is rarely properly tested.  

It relies on good programming practise  to write good programs.

Always, for *any* language! For example, it takes good practices to write decent English (note the spelling of practices...) 

Even syntactically it is untidy.

If you were to post *any* sample Java code here, I'm sure that you'd find many people more than capable of rewriting it for you in Scala, using a far tidier syntax.  

This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.

Quite the opposite.  Pure functions and immutable objects make it far easier to reason about the design of a system, the reduced boilerplate also takes away a rich souche of accidental complexity.  From my experience of using Scala for 3 years now, in the real world, at a production level, I've seen time and time again that the language produces far more maintainable code than is possible with Java.  

Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler

tail CALL optimisation *is* done by the compiler.  The @tailrec annotation simply provides you with a warning if you've written a recursive method that can't be optimised in this way.  

, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

Agreed, the patch for adding tail-call optimisation support to the JAVA virtual machine is now quite long in the tooth.  If Oracle were to finally add this for Java 8 then it would be a Very Good Thing(tm)  

OO simplifies the real domain model to the machine image. Scala does not.

Very, very subjective.  Scala has some of the best support for domain specific languages (DSLs) that I have ever seen, allowing for a very strong association between the domain and its representation in source code.
You also seem to be labouring under the misconception that Scala is not an object-oriented language.  Whereas the removal of static methods and primitives have actually made it far MORE object-oriented than Java.  

I think most Scala will be unmaintainable and unpredictable.

I know, through real-world experience, that this is not the case. 

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

As regards external I/O, parallel printer ports are indeed a thing of the past, as technology allowed us to squeeze far more speek over a serial connection and to avoid the awkward clock synchronisation logic that was required.  As a paradigm, parallel ports could be equated to Java's multithreading via locks and synchronised methods.
Inside your computer, however, you'll discover the PCI bus.  This runs multiple serial channels, with their own synchronisation, in parallel.  The same synchronisation primitives are used behind the scenes, but a more powerful paradigm is built on top of them.  Very much like actors...  

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems.

I'm sure the guys at EDF trading, twitter, foursquare, Amazon, Novell, and LinkedIn are scratching their heads at this one.  Trying to figure out how they're academics and not in the real world.

Every one thinks its going to be the paradigm shift like OO was to procedural; it never will be.

Such certainty! Can I borrow your tea-leaves some day please?

Students think it cool or clever to do it.

The vast majority of students will do Java, because that's what they're taught!  If you every wanted to look for a language that could be flagged as being "for academics"...

So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

No, that would be COBOL 

Very, very sceptical.

s/sceptical/uninformed 

Lunalobo

Hi,

Sorry to have rattled the cage.

Thanks for all of the positive and interesting replies. Especially those not argumentum ad hominem.
Sorry for the Title. I was watching a Spanish program at the time. A bit of Spanglish.
Mr Wright - To confuse the verb with the noun in practice - Unpardonable.
Take it back, I am not the oldest.

Posted in the wrong place so I am done now.

Have a nice day :-)


From: lukas.rytz@epfl.ch
Date: Wed, 26 Oct 2011 11:19:05 +0200
Subject: Re: [scala-user] White Elefant
To: kev.lee.wright@gmail.com
CC: stuartgordon@hotmail.co.uk; scala-user@googlegroups.com; scala-debate@googlegroups.com

Please take this discussion to scala-debate now.

On Wed, Oct 26, 2011 at 11:11, Kevin Wright <kev.lee.wright@gmail.com> wrote:

This seems more full of holes than a sieve, I've addressed some of the more notable factual errors inline...

The first, unsurprisingly, is the the title.  You probably meant it to be called "white elephant". "elefant" is a mis-spelling that stands out very much like, well, an elephant in a room!
Programming languages and spoken languages are very much alike in this regard, their perceived complexity will increase as you move further from the comfort zone of your first language.  In both cases, a dictionary and spellchecker (a.k.a. scaladoc and IDE with highlighting) will prove to be very useful.  Without these tools, you can expect to make things a great deal harder for yourself when first learning a language.

On 26 October 2011 01:10, stuart gordon <stuartgordon@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.

This is a double-edged sword.  I have seen too many "trained", "certified" developers in my time than I'd like to.  They rarely do credit to the person who trained them, often demonstrating a lack of skills and some dangerously outdated ideas of how to get things done.
 

I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.

By every observable metric, Scala *is* simpler.  It has a smaller spec, a more consistent syntax, and far fewer corner cases.
For example, pattern matching is used in comprehensions, assignment, exception handling, match expressions, and the creation of partial functions.  If you understand pattern matching then you don't need to learn a new and specialised syntax for each of these tasks.
There's no special "operators" restricted to just primitives (there are no primitives), Operators are just methods and can exist on any object, so no need to use different semantic constructs for ints and BigIntegers.
Scala also doesn't need any special handling for strings in the language spec to support + as a concatenation/conversion operator.
== does what you would expect everywhere.  No need to use == for primitives and .equals for objects.
The list goes on, but that should be enough food for thought. 

The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.

Interesting, testing is a very specific aspect of a language.  My experience of testing in Scala is that the tools (ScalaTest, Specs, Scalacheck) are very powerful and intuitive, with good DSLs.  Functions are highly composable and easily tested in isolation, immutable objects and pure methods also avoid the need for setting up complicated test harnesses to duplicate state.  Even the ease of redirecting standard I/O streams makes life easier.
Java, by comparison, required a LOT of bloat to test accurately.  This is especially true when using a framework like Spring, in which a significant piece of logic is pulled into XML files and is rarely properly tested.  

It relies on good programming practise  to write good programs.

Always, for *any* language! For example, it takes good practices to write decent English (note the spelling of practices...) 

Even syntactically it is untidy.

If you were to post *any* sample Java code here, I'm sure that you'd find many people more than capable of rewriting it for you in Scala, using a far tidier syntax.  

This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.

Quite the opposite.  Pure functions and immutable objects make it far easier to reason about the design of a system, the reduced boilerplate also takes away a rich souche of accidental complexity.  From my experience of using Scala for 3 years now, in the real world, at a production level, I've seen time and time again that the language produces far more maintainable code than is possible with Java.  

Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler

tail CALL optimisation *is* done by the compiler.  The @tailrec annotation simply provides you with a warning if you've written a recursive method that can't be optimised in this way.  

, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

Agreed, the patch for adding tail-call optimisation support to the JAVA virtual machine is now quite long in the tooth.  If Oracle were to finally add this for Java 8 then it would be a Very Good Thing(tm)  

OO simplifies the real domain model to the machine image. Scala does not.

Very, very subjective.  Scala has some of the best support for domain specific languages (DSLs) that I have ever seen, allowing for a very strong association between the domain and its representation in source code.
You also seem to be labouring under the misconception that Scala is not an object-oriented language.  Whereas the removal of static methods and primitives have actually made it far MORE object-oriented than Java.  

I think most Scala will be unmaintainable and unpredictable.

I know, through real-world experience, that this is not the case. 

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

As regards external I/O, parallel printer ports are indeed a thing of the past, as technology allowed us to squeeze far more speek over a serial connection and to avoid the awkward clock synchronisation logic that was required.  As a paradigm, parallel ports could be equated to Java's multithreading via locks and synchronised methods.
Inside your computer, however, you'll discover the PCI bus.  This runs multiple serial channels, with their own synchronisation, in parallel.  The same synchronisation primitives are used behind the scenes, but a more powerful paradigm is built on top of them.  Very much like actors...  

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems.

I'm sure the guys at EDF trading, twitter, foursquare, Amazon, Novell, and LinkedIn are scratching their heads at this one.  Trying to figure out how they're academics and not in the real world.

Every one thinks its going to be the paradigm shift like OO was to procedural; it never will be.

Such certainty! Can I borrow your tea-leaves some day please?

Students think it cool or clever to do it.

The vast majority of students will do Java, because that's what they're taught!  If you every wanted to look for a language that could be flagged as being "for academics"...

So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

No, that would be COBOL 

Very, very sceptical.

s/sceptical/uninformed 

Lunalobo

On Wed, Oct 26, 2011 at 05:41, Roland Tepp wrote:
> Let's give a man a benefit of a doubt please,

I'm not so sure. There *was* a Stuart Gordon on an English meetup FP
group, whose profile claimed to have learned Scala at some SkillX.
Only the profile isn't there anymore. I think there's a good chance of
just being a troll, and if he isn't, there really isn't much to be
done except go on as usual.

On Wed, Oct 26, 2011 at 2:49 AM, Roland Tepp <luolong@gmail.com> wrote:

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

On the other end though, conceptually, the Quantum theory is much more difficult to grok than Newtonian physics, as the interactions it concerns itself with may seem somewhat unintuitive at first...

(btw - I am no physics expert, so my understanding of the fine detils is limited)

Huh, that sounds just like Scala.   It uses *one* model (say pattern matching) to express something and then you use that in many places, vs. lots of diverse strange rules (Java).   I think the comparison to Scala holds well, IMHO.   Lots of simple concepts (that may be hard to grok initially) working together.
- Josh 

kolmapäev, 26. oktoober 2011 3:25.45 UTC+3 kirjutas Michael Thorpe:

The quantum model is simpler than the Newtonian model?

On 26 Oct 2011, at 01:10, stuart gordon <stuart...@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

body p { margin-bottom: 0cm; margin-top: 0pt; }

Josh Suereth wrote:

CAFLqJkyaGNXFGSbO0Q26cfL7RqxbBWyPz8Bn4kA--CX8h5W0BQ [at] mail [dot] gmail [dot] com" type="cite">

On Wed, Oct 26, 2011 at 2:49 AM, Roland Tepp <luolong [at] gmail [dot] com" rel="nofollow">luolong@gmail.com> wrote:

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

On the other end though, conceptually, the Quantum theory is much more difficult to grok than Newtonian physics, as the interactions it concerns itself with may seem somewhat unintuitive at first...

(btw - I am no physics expert, so my understanding of the fine detils is limited)

Huh, that sounds just like Scala.   It uses *one* model (say pattern matching) to express something and then you use that in many places, vs. lots of diverse strange rules (Java).   I think the comparison to Scala holds well, IMHO.   Lots of simple concepts (that may be hard to grok initially) working together.

Let's face it. Scala is complex. If it weren't, we wouldn't have needed to debate so much about it.

About Java's diverse rules. It is true that Java has a lot of corner cases. The sort that makes the spec big and gives a lot of fodder for things like Java Puzzlers. But the thing is, they are rare corner cases. The sort you don't encounter every day, or ever. On the other hand, Scala's spec is very clean, and there are far less corner cases, but it is because the concepts are harder to digest (at least to those whose mind is already wired for C/C++/C#/Java). Sometimes it's like making everything a corner.

I love Scala, it's a great language. Once I got the concepts I am able to do things I'd never think about in Java. But we should not kid ourselves that there's no barrier.

Ittay

CAFLqJkyaGNXFGSbO0Q26cfL7RqxbBWyPz8Bn4kA--CX8h5W0BQ [at] mail [dot] gmail [dot] com" type="cite">
- Josh 

kolmapäev, 26. oktoober 2011 3:25.45 UTC+3 kirjutas Michael Thorpe:

The quantum model is simpler than the Newtonian model?

On 26 Oct 2011, at 01:10, stuart gordon <stuart...@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

On Wed, Oct 26, 2011 at 8:18 AM, Ittay Dror <ittay.dror@gmail.com> wrote:

Josh Suereth wrote:

On Wed, Oct 26, 2011 at 2:49 AM, Roland Tepp <luolong@gmail.com> wrote:

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

On the other end though, conceptually, the Quantum theory is much more difficult to grok than Newtonian physics, as the interactions it concerns itself with may seem somewhat unintuitive at first...

(btw - I am no physics expert, so my understanding of the fine detils is limited)

Huh, that sounds just like Scala.   It uses *one* model (say pattern matching) to express something and then you use that in many places, vs. lots of diverse strange rules (Java).   I think the comparison to Scala holds well, IMHO.   Lots of simple concepts (that may be hard to grok initially) working together.

Let's face it. Scala is complex. If it weren't, we wouldn't have needed to debate so much about it.

About Java's diverse rules. It is true that Java has a lot of corner cases. The sort that makes the spec big and gives a lot of fodder for things like Java Puzzlers. But the thing is, they are rare corner cases. The sort you don't encounter every day, or ever. On the other hand, Scala's spec is very clean, and there are far less corner cases, but it is because the concepts are harder to digest (at least to those whose mind is already wired for C/C++/C#/Java). Sometimes it's like making everything a corner.

I love Scala, it's a great language. Once I got the concepts I am able to do things I'd never think about in Java. But we should not kid ourselves that there's no barrier.

Ittay

That's not what I was implying at all.   I was comparing the barrier to entry to Scala vs. Java like quantum theory vs. newtonian physics.  Simpler model that covers more things, but barrier to entry is higher.

On 26 October 2011 13:18, Ittay Dror <ittay.dror@gmail.com> wrote:

Josh Suereth wrote:

On Wed, Oct 26, 2011 at 2:49 AM, Roland Tepp <luolong@gmail.com> wrote:

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

On the other end though, conceptually, the Quantum theory is much more difficult to grok than Newtonian physics, as the interactions it concerns itself with may seem somewhat unintuitive at first...

(btw - I am no physics expert, so my understanding of the fine detils is limited)

Huh, that sounds just like Scala.   It uses *one* model (say pattern matching) to express something and then you use that in many places, vs. lots of diverse strange rules (Java).   I think the comparison to Scala holds well, IMHO.   Lots of simple concepts (that may be hard to grok initially) working together.

Let's face it. Scala is complex. If it weren't, we wouldn't have needed to debate so much about it.

About Java's diverse rules. It is true that Java has a lot of corner cases. The sort that makes the spec big and gives a lot of fodder for things like Java Puzzlers. But the thing is, they are rare corner cases. The sort you don't encounter every day, or ever. On the other hand, Scala's spec is very clean, and there are far less corner cases, but it is because the concepts are harder to digest (at least to those whose mind is already wired for C/C++/C#/Java). Sometimes it's like making everything a corner.

I love Scala, it's a great language. Once I got the concepts I am able to do things I'd never think about in Java. But we should not kid ourselves that there's no barrier.

Ittay

But that's the rub...
Is this "barrier" something inherent to Scala, or something created by Java's vehement refusal to allow lambdas and functions as first-class entities, thereby denying millions of developers exposure to a whole class of solutions?
Scala's complex in the same way as Greek is complex. My first language was English and so I find that conjugation and gendered objects are really hard concepts to fit into my mental model.  These ideas aren't inherently difficult, billions of non-geniuses and non-academics can effortlessly speak conjugated languages every day.  The problems aren't a property of the language, they're only difficult concepts for people to whom they are foreign.
On the other hand... Greek is simple, because it has a strong relationship between how a word is spelled and how it's pronounced, invaluable to any learner.  This *is* an inherent property of Greek, and not the would-be learner.
Feel free to expand the metaphor (which is a Greek word) as you see fit :)

 

- Josh 

kolmapäev, 26. oktoober 2011 3:25.45 UTC+3 kirjutas Michael Thorpe:

The quantum model is simpler than the Newtonian model?

On 26 Oct 2011, at 01:10, stuart gordon <stuart...@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

Cheers

 -- Martin

On Wed, Oct 26, 2011 at 2:52 PM, Kevin Wright <kev.lee.wright@gmail.com> wrote:

On 26 October 2011 13:18, Ittay Dror <ittay.dror@gmail.com> wrote:

Josh Suereth wrote:

On Wed, Oct 26, 2011 at 2:49 AM, Roland Tepp <luolong@gmail.com> wrote:

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

On the other end though, conceptually, the Quantum theory is much more difficult to grok than Newtonian physics, as the interactions it concerns itself with may seem somewhat unintuitive at first...

(btw - I am no physics expert, so my understanding of the fine detils is limited)

Huh, that sounds just like Scala.   It uses *one* model (say pattern matching) to express something and then you use that in many places, vs. lots of diverse strange rules (Java).   I think the comparison to Scala holds well, IMHO.   Lots of simple concepts (that may be hard to grok initially) working together.

Let's face it. Scala is complex. If it weren't, we wouldn't have needed to debate so much about it.

About Java's diverse rules. It is true that Java has a lot of corner cases. The sort that makes the spec big and gives a lot of fodder for things like Java Puzzlers. But the thing is, they are rare corner cases. The sort you don't encounter every day, or ever. On the other hand, Scala's spec is very clean, and there are far less corner cases, but it is because the concepts are harder to digest (at least to those whose mind is already wired for C/C++/C#/Java). Sometimes it's like making everything a corner.

I love Scala, it's a great language. Once I got the concepts I am able to do things I'd never think about in Java. But we should not kid ourselves that there's no barrier.

Ittay

But that's the rub...
Is this "barrier" something inherent to Scala, or something created by Java's vehement refusal to allow lambdas and functions as first-class entities, thereby denying millions of developers exposure to a whole class of solutions?
Scala's complex in the same way as Greek is complex. My first language was English and so I find that conjugation and gendered objects are really hard concepts to fit into my mental model.  These ideas aren't inherently difficult, billions of non-geniuses and non-academics can effortlessly speak conjugated languages every day.  The problems aren't a property of the language, they're only difficult concepts for people to whom they are foreign.
On the other hand... Greek is simple, because it has a strong relationship between how a word is spelled and how it's pronounced, invaluable to any learner.  This *is* an inherent property of Greek, and not the would-be learner.
Feel free to expand the metaphor (which is a Greek word) as you see fit :)

 

- Josh 

kolmapäev, 26. oktoober 2011 3:25.45 UTC+3 kirjutas Michael Thorpe:

The quantum model is simpler than the Newtonian model?

On 26 Oct 2011, at 01:10, stuart gordon <stuart...@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

--
Martin Odersky
Prof., EPFL and Chairman, Typesafe
PSED, 1015 Lausanne, Switzerland
Tel. EPFL: +41 21 693 6863
Tel. Typesafe: +41 21 691 4967

body p { margin-bottom: 0cm; margin-top: 0pt; }

Kevin Wright wrote:

8_R2Hww [at] mail [dot] gmail [dot] com" type="cite">

On 26 October 2011 13:18, Ittay Dror <ittay [dot] dror [at] gmail [dot] com" rel="nofollow">ittay.dror@gmail.com> wrote:

Josh Suereth wrote:

On Wed, Oct 26, 2011 at 2:49 AM, Roland Tepp <luolong [at] gmail [dot] com" target="_blank" rel="nofollow">luolong@gmail.com> wrote:

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

On the other end though, conceptually, the Quantum theory is much more difficult to grok than Newtonian physics, as the interactions it concerns itself with may seem somewhat unintuitive at first...

(btw - I am no physics expert, so my understanding of the fine detils is limited)

Huh, that sounds just like Scala.   It uses *one* model (say pattern matching) to express something and then you use that in many places, vs. lots of diverse strange rules (Java).   I think the comparison to Scala holds well, IMHO.   Lots of simple concepts (that may be hard to grok initially) working together.

Let's face it. Scala is complex. If it weren't, we wouldn't have needed to debate so much about it.

About Java's diverse rules. It is true that Java has a lot of corner cases. The sort that makes the spec big and gives a lot of fodder for things like Java Puzzlers. But the thing is, they are rare corner cases. The sort you don't encounter every day, or ever. On the other hand, Scala's spec is very clean, and there are far less corner cases, but it is because the concepts are harder to digest (at least to those whose mind is already wired for C/C++/C#/Java). Sometimes it's like making everything a corner.

I love Scala, it's a great language. Once I got the concepts I am able to do things I'd never think about in Java. But we should not kid ourselves that there's no barrier.

Ittay

But that's the rub...
Is this "barrier" something inherent to Scala, or something created by Java's vehement refusal to allow lambdas and functions as first-class entities, thereby denying millions of developers exposure to a whole class of solutions?

The barrier is learning new concepts. I say it the benefits are worth overcoming it. But to convince newcomers, the benefits should be clearly demonstrated. People don't care about nice concepts in themselves. What they care about is code maintenance. We need to show that code written with these new concepts is easier to maintain and use. That is: it is easy to understand even after 6 months, modularity is better and usage is less prone to errors.

8_R2Hww [at] mail [dot] gmail [dot] com" type="cite">
Scala's complex in the same way as Greek is complex. My first language was English and so I find that conjugation and gendered objects are really hard concepts to fit into my mental model.  These ideas aren't inherently difficult, billions of non-geniuses and non-academics can effortlessly speak conjugated languages every day.  The problems aren't a property of the language, they're only difficult concepts for people to whom they are foreign.

Sure. So to keep the "barrier" theme: if you're a greek toddler, this barrier is worth overcoming, or else you wouldn't be able to communicate. If you're an english speaker, you might be satisfied communicating in English.

8_R2Hww [at] mail [dot] gmail [dot] com" type="cite">
On the other hand... Greek is simple, because it has a strong relationship between how a word is spelled and how it's pronounced, invaluable to any learner.  This *is* an inherent property of Greek, and not the would-be learner.
Feel free to expand the metaphor (which is a Greek word) as you see fit :)

 

- Josh 

kolmapäev, 26. oktoober 2011 3:25.45 UTC+3 kirjutas Michael Thorpe:

The quantum model is simpler than the Newtonian model?

On 26 Oct 2011, at 01:10, stuart gordon <stuart...@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

body p { margin-bottom: 0cm; margin-top: 0pt; }

martin odersky wrote:

CAENVNkb5qkhCCirRS+VDy-NXrvpyjqgnFy_zCdoojc7q6a_rhQ [at] mail [dot] gmail [dot] com" type="cite">For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

(since we're on the debate list...)

You only show that there is a child that can understand Scala. For this to be a counter-argument, you need to show that there are more children that can understand Scala than those that get Java.

CAENVNkb5qkhCCirRS+VDy-NXrvpyjqgnFy_zCdoojc7q6a_rhQ [at] mail [dot] gmail [dot] com" type="cite">
Cheers

 -- Martin

On Wed, Oct 26, 2011 at 2:52 PM, Kevin Wright <kev [dot] lee [dot] wright [at] gmail [dot] com" rel="nofollow">kev.lee.wright@gmail.com> wrote:

On 26 October 2011 13:18, Ittay Dror <ittay [dot] dror [at] gmail [dot] com" target="_blank" rel="nofollow">ittay.dror@gmail.com> wrote:

Josh Suereth wrote:

On Wed, Oct 26, 2011 at 2:49 AM, Roland Tepp <luolong [at] gmail [dot] com" target="_blank" rel="nofollow">luolong@gmail.com> wrote:

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

On the other end though, conceptually, the Quantum theory is much more difficult to grok than Newtonian physics, as the interactions it concerns itself with may seem somewhat unintuitive at first...

(btw - I am no physics expert, so my understanding of the fine detils is limited)

Huh, that sounds just like Scala.   It uses *one* model (say pattern matching) to express something and then you use that in many places, vs. lots of diverse strange rules (Java).   I think the comparison to Scala holds well, IMHO.   Lots of simple concepts (that may be hard to grok initially) working together.

Let's face it. Scala is complex. If it weren't, we wouldn't have needed to debate so much about it.

About Java's diverse rules. It is true that Java has a lot of corner cases. The sort that makes the spec big and gives a lot of fodder for things like Java Puzzlers. But the thing is, they are rare corner cases. The sort you don't encounter every day, or ever. On the other hand, Scala's spec is very clean, and there are far less corner cases, but it is because the concepts are harder to digest (at least to those whose mind is already wired for C/C++/C#/Java). Sometimes it's like making everything a corner.

I love Scala, it's a great language. Once I got the concepts I am able to do things I'd never think about in Java. But we should not kid ourselves that there's no barrier.

Ittay

But that's the rub...
Is this "barrier" something inherent to Scala, or something created by Java's vehement refusal to allow lambdas and functions as first-class entities, thereby denying millions of developers exposure to a whole class of solutions?
Scala's complex in the same way as Greek is complex. My first language was English and so I find that conjugation and gendered objects are really hard concepts to fit into my mental model.  These ideas aren't inherently difficult, billions of non-geniuses and non-academics can effortlessly speak conjugated languages every day.  The problems aren't a property of the language, they're only difficult concepts for people to whom they are foreign.
On the other hand... Greek is simple, because it has a strong relationship between how a word is spelled and how it's pronounced, invaluable to any learner.  This *is* an inherent property of Greek, and not the would-be learner.
Feel free to expand the metaphor (which is a Greek word) as you see fit :)

 

- Josh 

kolmapäev, 26. oktoober 2011 3:25.45 UTC+3 kirjutas Michael Thorpe:

The quantum model is simpler than the Newtonian model?

On 26 Oct 2011, at 01:10, stuart gordon <stuart...@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

--
Martin Odersky
Prof., EPFL and Chairman, Typesafe
PSED, 1015 Lausanne, Switzerland
Tel. EPFL: +41 21 693 6863
Tel. Typesafe: +41 21 691 4967

body p { margin-bottom: 0cm; margin-top: 0pt; }

Btw, just to put in some context as to what I think will make Scala more approachable:

1. Show concepts not for themselves, but for the benefits they bring. For example, the use of functions makes ARM easy to do. So developers do it, so code becomes more robust. This should be the main theme in scala tour. I want to emphasize again, I think telling people Scala has first-class function values and then not showing how this transforms code to something better maintained does not create value, on the contrary. 

2. Have "real world" code examples. Preferably starting from Java, to trivial conversion to Scala to incremental refactoring until a final result which is still easy to understand and very obviously easy to extend. Mentioning monads somewhere there is probably very wrong. I like this: http://www.coconut-palm-software.com/the_new_visual_editor/doku.php?id=blog:simplifying_swt_with_scala

3. Better organization of the collection API. Somehow don't overwhelm a newbie with ton of methods (maybe a 'basic' vs 'advanced' view toggle?)

4. A lengthy list of "idiomatic scala" reciepts. Small snippets of code are easier to understand for newcomers and give the feeling that there is a simple answer for every use case (which should be, of course, better than Java)

All of this should be in the scala-lang.org site. People that start learning scala should find these at the top of their google search, not tmorris/apocalisp/debasishg (which are, of course, great for me and others that are already hooked on scala)

Ittay

martin odersky wrote:

CAENVNkb5qkhCCirRS+VDy-NXrvpyjqgnFy_zCdoojc7q6a_rhQ [at] mail [dot] gmail [dot] com" type="cite">For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

Cheers

 -- Martin

On Wed, Oct 26, 2011 at 2:52 PM, Kevin Wright <kev [dot] lee [dot] wright [at] gmail [dot] com" rel="nofollow">kev.lee.wright@gmail.com> wrote:

On 26 October 2011 13:18, Ittay Dror <ittay [dot] dror [at] gmail [dot] com" target="_blank" rel="nofollow">ittay.dror@gmail.com> wrote:

Josh Suereth wrote:

On Wed, Oct 26, 2011 at 2:49 AM, Roland Tepp <luolong [at] gmail [dot] com" target="_blank" rel="nofollow">luolong@gmail.com> wrote:

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

On the other end though, conceptually, the Quantum theory is much more difficult to grok than Newtonian physics, as the interactions it concerns itself with may seem somewhat unintuitive at first...

(btw - I am no physics expert, so my understanding of the fine detils is limited)

Huh, that sounds just like Scala.   It uses *one* model (say pattern matching) to express something and then you use that in many places, vs. lots of diverse strange rules (Java).   I think the comparison to Scala holds well, IMHO.   Lots of simple concepts (that may be hard to grok initially) working together.

Let's face it. Scala is complex. If it weren't, we wouldn't have needed to debate so much about it.

About Java's diverse rules. It is true that Java has a lot of corner cases. The sort that makes the spec big and gives a lot of fodder for things like Java Puzzlers. But the thing is, they are rare corner cases. The sort you don't encounter every day, or ever. On the other hand, Scala's spec is very clean, and there are far less corner cases, but it is because the concepts are harder to digest (at least to those whose mind is already wired for C/C++/C#/Java). Sometimes it's like making everything a corner.

I love Scala, it's a great language. Once I got the concepts I am able to do things I'd never think about in Java. But we should not kid ourselves that there's no barrier.

Ittay

But that's the rub...
Is this "barrier" something inherent to Scala, or something created by Java's vehement refusal to allow lambdas and functions as first-class entities, thereby denying millions of developers exposure to a whole class of solutions?
Scala's complex in the same way as Greek is complex. My first language was English and so I find that conjugation and gendered objects are really hard concepts to fit into my mental model.  These ideas aren't inherently difficult, billions of non-geniuses and non-academics can effortlessly speak conjugated languages every day.  The problems aren't a property of the language, they're only difficult concepts for people to whom they are foreign.
On the other hand... Greek is simple, because it has a strong relationship between how a word is spelled and how it's pronounced, invaluable to any learner.  This *is* an inherent property of Greek, and not the would-be learner.
Feel free to expand the metaphor (which is a Greek word) as you see fit :)

 

- Josh 

kolmapäev, 26. oktoober 2011 3:25.45 UTC+3 kirjutas Michael Thorpe:

The quantum model is simpler than the Newtonian model?

On 26 Oct 2011, at 01:10, stuart gordon <stuart...@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

--
Martin Odersky
Prof., EPFL and Chairman, Typesafe
PSED, 1015 Lausanne, Switzerland
Tel. EPFL: +41 21 693 6863
Tel. Typesafe: +41 21 691 4967

On Wed, Oct 26, 2011 at 3:57 PM, Ittay Dror <ittay.dror@gmail.com> wrote:

martin odersky wrote:

For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

(since we're on the debate list...)

You only show that there is a child that can understand Scala. For this to be a counter-argument, you need to show that there are more children that can understand Scala than those that get Java.

 Oh, I know lots more children (see recent Kojo story, and also people I know privately). But they don't have youtube videos :-).

I firmly believe that Scala is easier to learn than Java. For a starter: public static void main( String[] args) what?

The main problem that I see is that the Scala community as a whole sometimes overcomplicates things.

Cheers

 -- Martin

On Wed, Oct 26, 2011 at 4:24 PM, Ittay Dror <ittay.dror@gmail.com> wrote:

Btw, just to put in some context as to what I think will make Scala more approachable:

1. Show concepts not for themselves, but for the benefits they bring. For example, the use of functions makes ARM easy to do. So developers do it, so code becomes more robust. This should be the main theme in scala tour. I want to emphasize again, I think telling people Scala has first-class function values and then not showing how this transforms code to something better maintained does not create value, on the contrary.   

2. Have "real world" code examples. Preferably starting from Java, to trivial conversion to Scala to incremental refactoring until a final result which is still easy to understand and very obviously easy to extend. Mentioning monads somewhere there is probably very wrong. I like this: http://www.coconut-palm-software.com/the_new_visual_editor/doku.php?id=blog:simplifying_swt_with_scala

3. Better organization of the collection API. Somehow don't overwhelm a newbie with ton of methods (maybe a 'basic' vs 'advanced' view toggle?)

4. A lengthy list of "idiomatic scala" reciepts. Small snippets of code are easier to understand for newcomers and give the feeling that there is a simple answer for every use case (which should be, of course, better than Java)

All of this should be in the scala-lang.org site. People that start learning scala should find these at the top of their google search, not tmorris/apocalisp/debasishg (which are, of course, great for me and others that are already hooked on scala)

Full agreement on all of these. There will be some significant news on Scala documentation soon.

Cheers

 -- Martin

On Wed, Oct 26, 2011 at 04:24:45PM +0200, Ittay Dror wrote:
> 2. Have "real world" code examples. Preferably starting from
> Java, to trivial conversion to Scala to incremental refactoring
> until a final result which is still easy to understand and very
> obviously easy to extend.

I'm not sure how many will agree with me, but we spend too much time
trying to win over "java developers" and not enough time trying to win
over "developers". Sure there are a lot of Java developers, but I don't
think they are a privileged group which deserves special treatment.

I agree with Ittay that it's great to have examples, but I don't think
these examples should be framed in the context of Java (save this for a
"coming to Scala from Java" section). Concepts should stand on their
own, and not assume tons of facility with Java.

I haven't seen core documentation for Clojure, Python, Ruby, etc. which
does this and I don't think Scala should either.

body p { margin-bottom: 0cm; margin-top: 0pt; }

martin odersky wrote:

i_odpww [at] mail [dot] gmail [dot] com" type="cite">

On Wed, Oct 26, 2011 at 3:57 PM, Ittay Dror <ittay [dot] dror [at] gmail [dot] com" rel="nofollow">ittay.dror@gmail.com> wrote:

martin odersky wrote:

For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

(since we're on the debate list...)

You only show that there is a child that can understand Scala. For this to be a counter-argument, you need to show that there are more children that can understand Scala than those that get Java.

  Oh, I know lots more children (see recent Kojo story, and also people I know privately). But they don't have youtube videos :-).

I firmly believe that Scala is easier to learn than Java. For a starter: public static void main( String[] args) what?

I think you view this from the "spec" point of view. Has this definition of 'main' ever cause tricky bugs? Made code harder to write or change?

i_odpww [at] mail [dot] gmail [dot] com" type="cite">
The main problem that I see is that the Scala community as a whole sometimes overcomplicates things.

Hence my suggestion for 'idiomatic' approach a-la python.

See this for example: http://stackoverflow.com/questions/7852471/idiomatic-construction-to-check-whether-a-collection-is-ordered
Runar answered with a post containing semigroups and traverse, pointing to a haskell paper
I answered with a solution using iteratees, which is no better
The best solution IMHO was: (l, l.tail).zipped.forall(_ <= _) (by missingfaktor)

A newbie should have a rich resource of such snippets instead of finding answers about traverse/iteratee which are harder to learn, read and more code to write.


i_odpww [at] mail [dot] gmail [dot] com" type="cite">
Cheers

 -- Martin

On Wed, Oct 26, 2011 at 4:48 PM, Ittay Dror <ittay.dror@gmail.com> wrote:

martin odersky wrote:

On Wed, Oct 26, 2011 at 3:57 PM, Ittay Dror <ittay.dror@gmail.com> wrote:

martin odersky wrote:

For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

(since we're on the debate list...)

You only show that there is a child that can understand Scala. For this to be a counter-argument, you need to show that there are more children that can understand Scala than those that get Java.

  Oh, I know lots more children (see recent Kojo story, and also people I know privately). But they don't have youtube videos :-).

I firmly believe that Scala is easier to learn than Java. For a starter: public static void main( String[] args) what?

I think you view this from the "spec" point of view. Has this definition of 'main' ever cause tricky bugs? Made code harder to write or change?

No, I mean if I have to teach hello world, compare

  object Hello extends App {
    println("hello world!")
  }

to its Java equivalent. How much do you have to explain? Or can you get away with saying: these are incantations that you just need to write, not understand? What feeling does that give to a newbie?
 
And that even leaves aside the Scala REPL, which is a fantastic tool for learning.

The main problem that I see is that the Scala community as a whole sometimes overcomplicates things.

Hence my suggestion for 'idiomatic' approach a-la python.

See this for example: http://stackoverflow.com/questions/7852471/idiomatic-construction-to-check-whether-a-collection-is-ordered
Runar answered with a post containing semigroups and traverse, pointing to a haskell paper
I answered with a solution using iteratees, which is no better
The best solution IMHO was: (l, l.tail).zipped.forall(_ <= _) (by missingfaktor)


yes, that one's nice.
 


A newbie should have a rich resource of such snippets instead of finding answers about traverse/iteratee which are harder to learn, read and more code to write.


 
Could not agree more.

Cheers

 -- Martin

I think this can be arranged.  Maybe we'll have a Kojo convention :)
Honestly, Java was *tough* to learn when I was starting programming.  Fortran, Basic and C where the programming languages I was used to.  I think people forget how tough Java is to learn since they haven't done it in a long time.   I used to read and re-read my Java books until I finally mastered the language.  I think Scala took me about the same amount of time, but with *way* more concepts to learn.   There's still a lot of odd Java corner-cases I'm not aware of.
In any case, I think a lot of us a sick of the "Scala is Complex" debate.  Lots of arguments have been made. If you want to duplicate them, that's fine but I think both sides have made their most persuasive arguments.
And again, let's prove through practice.   I love Scala and use it everywhere. I teach it to others.  The thing that blows peoples minds is the Functional way of thinking, not the language Scala.
- Josh

On Wed, Oct 26, 2011 at 9:57 AM, Ittay Dror <ittay.dror@gmail.com> wrote:

martin odersky wrote:

For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

(since we're on the debate list...)

You only show that there is a child that can understand Scala. For this to be a counter-argument, you need to show that there are more children that can understand Scala than those that get Java.

Cheers

 -- Martin

On Wed, Oct 26, 2011 at 2:52 PM, Kevin Wright <kev.lee.wright@gmail.com> wrote:

On 26 October 2011 13:18, Ittay Dror <ittay.dror@gmail.com> wrote:

Josh Suereth wrote:

On Wed, Oct 26, 2011 at 2:49 AM, Roland Tepp <luolong@gmail.com> wrote:

Why, yes, in the essence.
Quantum model is much simpler than Newtonian, as it manages to use one mathematical model to explain more phenomenons than the ones it replaced...

On the other end though, conceptually, the Quantum theory is much more difficult to grok than Newtonian physics, as the interactions it concerns itself with may seem somewhat unintuitive at first...

(btw - I am no physics expert, so my understanding of the fine detils is limited)

Huh, that sounds just like Scala.   It uses *one* model (say pattern matching) to express something and then you use that in many places, vs. lots of diverse strange rules (Java).   I think the comparison to Scala holds well, IMHO.   Lots of simple concepts (that may be hard to grok initially) working together.

Let's face it. Scala is complex. If it weren't, we wouldn't have needed to debate so much about it.

About Java's diverse rules. It is true that Java has a lot of corner cases. The sort that makes the spec big and gives a lot of fodder for things like Java Puzzlers. But the thing is, they are rare corner cases. The sort you don't encounter every day, or ever. On the other hand, Scala's spec is very clean, and there are far less corner cases, but it is because the concepts are harder to digest (at least to those whose mind is already wired for C/C++/C#/Java). Sometimes it's like making everything a corner.

I love Scala, it's a great language. Once I got the concepts I am able to do things I'd never think about in Java. But we should not kid ourselves that there's no barrier.

Ittay

But that's the rub...
Is this "barrier" something inherent to Scala, or something created by Java's vehement refusal to allow lambdas and functions as first-class entities, thereby denying millions of developers exposure to a whole class of solutions?
Scala's complex in the same way as Greek is complex. My first language was English and so I find that conjugation and gendered objects are really hard concepts to fit into my mental model.  These ideas aren't inherently difficult, billions of non-geniuses and non-academics can effortlessly speak conjugated languages every day.  The problems aren't a property of the language, they're only difficult concepts for people to whom they are foreign.
On the other hand... Greek is simple, because it has a strong relationship between how a word is spelled and how it's pronounced, invaluable to any learner.  This *is* an inherent property of Greek, and not the would-be learner.
Feel free to expand the metaphor (which is a Greek word) as you see fit :)

 

- Josh 

kolmapäev, 26. oktoober 2011 3:25.45 UTC+3 kirjutas Michael Thorpe:

The quantum model is simpler than the Newtonian model?

On 26 Oct 2011, at 01:10, stuart gordon <stuart...@hotmail.co.uk> wrote:

Hi,

I am a lot older that most of you out there and I have seen a lot of changes in computing in general. I was a Java programmer and trainer.
I am now looking at Scala and functional programming but I am now really doubting much that has been said about this language and the use of functional language.

Industry simplifies tools and process with time in all walks of life. It doesn't complicate them and doesn't lend to complicating the processes.
Copernicus  displaced the earth centric ideas; Quantum displaces or enhances Newtonian, Euclidean models. Every model is simpler.
Scala is the opposite. Now you are relying on very talented programmers who have to limit their semantics to make programs work.
The very power that leverage's Scala is its weakness, because to test it, is almost impossible and very difficult.
It relies on good programming practise  to write good programs. Even syntactically it is untidy.
This has not been the trend in software. The trend is to make it more simple, robust and hopefully more error free.
Scala with lazy evalution and psuedofuntional programming opens a minefield that will cost in production and in maintenance.
Even the code will have to take into account the behaviour of tail end recursion and optimising strategies. This should be done by the compiler, and run time virtual machines and with hooks into the OS.
Surely this should be transparent to any programming language.

OO simplifies the real domain model to the machine image. Scala does not.

I think most Scala will be unmaintainable and unpredictable.

The future will see programming languages change but Scala isn't going to be one of them. Compilers, virtual machines and therefore ultimately the OS will do some of the work to make programming easier with multi threading and multi core.
Think about parallel communication which is now replaced with a simple serial interface. Things get simpler not more elaborate.

Why is it popular. Because academics want to have an interesting time but are not really interested in real world problems. Every one thinks its going to be the paradigm shift like OO was to procedural; it  never will be.
Students think it cool or clever to do it. So is chess but for the most wont provide bread and butter on the table.  Its a dangerous fad that will produce horrible code like concrete did with architecture in the 1960´s.

Very, very sceptical.

Lunalobo

--
Martin Odersky
Prof., EPFL and Chairman, Typesafe
PSED, 1015 Lausanne, Switzerland
Tel. EPFL: +41 21 693 6863
Tel. Typesafe: +41 21 691 4967

2011/10/26 Ittay Dror <ittay.dror@gmail.com>

martin odersky wrote:

On Wed, Oct 26, 2011 at 3:57 PM, Ittay Dror <ittay.dror@gmail.com> wrote:

martin odersky wrote:

For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

(since we're on the debate list...)

You only show that there is a child that can understand Scala. For this to be a counter-argument, you need to show that there are more children that can understand Scala than those that get Java.

  Oh, I know lots more children (see recent Kojo story, and also people I know privately). But they don't have youtube videos :-).

I firmly believe that Scala is easier to learn than Java. For a starter: public static void main( String[] args) what?

I think you view this from the "spec" point of view. Has this definition of 'main' ever cause tricky bugs? Made code harder to write or change?

I gave Java another try a few weeks ago on a pet project, just to see how it feels like after a few years spent with Scala. I must confess that I was still barely able to make sense about how generics work. That and the verbose syntax with limited type inference really makes Java too complex for type safe usage. I lost patience after one day and switched back to Scala.

Do you know many developers that use fluently Java generics in production code? Personally, I don't know any. Most Java developers do type casting. These may cause nasty runtime bugs and certainly make the code harder to maintain. My conclusion is that, beyond the basic examples, that is when you want to build robust, scalable and maintainable production code, Scala is much simpler and safer to use than Java.
 

The main problem that I see is that the Scala community as a whole sometimes overcomplicates things.

Hence my suggestion for 'idiomatic' approach a-la python.

See this for example: http://stackoverflow.com/questions/7852471/idiomatic-construction-to-check-whether-a-collection-is-ordered
Runar answered with a post containing semigroups and traverse, pointing to a haskell paper
I answered with a solution using iteratees, which is no better
The best solution IMHO was: (l, l.tail).zipped.forall(_ <= _) (by missingfaktor)

A newbie should have a rich resource of such snippets instead of finding answers about traverse/iteratee which are harder to learn, read and more code to write.


Let these people chose their own poison. Thanks to Runar, anyone looking for the same question on stackoverflow will have a wider panel of solutions to choose from. Maybe some of them, who have never heard aboutsemigroups or applicative functors before, will be curious to learn what this is all about and have a great time with that.

Cheers

 -- Martin

--
Sébastien

body p { margin-bottom: 0cm; margin-top: 0pt; }

martin odersky wrote:

hrYcJDBVLYZaoGPCor-crecLg++g [at] mail [dot] gmail [dot] com" type="cite">

On Wed, Oct 26, 2011 at 4:48 PM, Ittay Dror <ittay [dot] dror [at] gmail [dot] com" rel="nofollow">ittay.dror@gmail.com> wrote:

martin odersky wrote:

On Wed, Oct 26, 2011 at 3:57 PM, Ittay Dror <ittay [dot] dror [at] gmail [dot] com" target="_blank" rel="nofollow">ittay.dror@gmail.com> wrote:

martin odersky wrote:

For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

(since we're on the debate list...)

You only show that there is a child that can understand Scala. For this to be a counter-argument, you need to show that there are more children that can understand Scala than those that get Java.

  Oh, I know lots more children (see recent Kojo story, and also people I know privately). But they don't have youtube videos :-).

I firmly believe that Scala is easier to learn than Java. For a starter: public static void main( String[] args) what?

I think you view this from the "spec" point of view. Has this definition of 'main' ever cause tricky bugs? Made code harder to write or change?

No, I mean if I have to teach hello world, compare

  object Hello extends App {
    println("hello world!")
  }

to its Java equivalent. How much do you have to explain? Or can you get away with saying: these are incantations that you just need to write, not understand? What feeling does that give to a newbie?

Even if this initial snippet is easier, after a little while you need to explain how for comprehension works...

It is I think a fact that most people find Scala complex compared with other languages they know. A product manager should gather all this input and make a list that is taken as-is to be the reasons why Scala *is* more complex. Then work on documentation or features to make it simpler. On the other hand, it should be noted why this complexity is worth it (gaining more maintainable code, performance etc.)

hrYcJDBVLYZaoGPCor-crecLg++g [at] mail [dot] gmail [dot] com" type="cite">  
And that even leaves aside the Scala REPL, which is a fantastic tool for learning.

+1. This is an amazing huge plus for Scala. These are the things that should be emphasized. An introduction should start by telling the user how to quickly get a repl running ('wget <some url> | sh' is nice...)

hrYcJDBVLYZaoGPCor-crecLg++g [at] mail [dot] gmail [dot] com" type="cite">

The main problem that I see is that the Scala community as a whole sometimes overcomplicates things.

Hence my suggestion for 'idiomatic' approach a-la python.

See this for example: http://stackoverflow.com/questions/7852471/idiomatic-construction-to-check-whether-a-collection-is-ordered
Runar answered with a post containing semigroups and traverse, pointing to a haskell paper
I answered with a solution using iteratees, which is no better
The best solution IMHO was: (l, l.tail).zipped.forall(_ <= _) (by missingfaktor)


yes, that one's nice.
 


A newbie should have a rich resource of such snippets instead of finding answers about traverse/iteratee which are harder to learn, read and more code to write.


 
Could not agree more.

Cheers

 -- Martin

How did Microsoft manage to produce Vista?

On 26 October 2011 02:10, stuart gordon <stuartgordon@hotmail.co.uk> wrote:

Industry simplifies tools and process with time in all walks of life.

On Wed, Oct 26, 2011 at 5:14 PM, Ittay Dror <ittay.dror@gmail.com> wrote:

martin odersky wrote:

On Wed, Oct 26, 2011 at 4:48 PM, Ittay Dror <ittay.dror@gmail.com> wrote:

martin odersky wrote:

On Wed, Oct 26, 2011 at 3:57 PM, Ittay Dror <ittay.dror@gmail.com> wrote:

martin odersky wrote:

For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

(since we're on the debate list...)

You only show that there is a child that can understand Scala. For this to be a counter-argument, you need to show that there are more children that can understand Scala than those that get Java.

  Oh, I know lots more children (see recent Kojo story, and also people I know privately). But they don't have youtube videos :-).

I firmly believe that Scala is easier to learn than Java. For a starter: public static void main( String[] args) what?

I think you view this from the "spec" point of view. Has this definition of 'main' ever cause tricky bugs? Made code harder to write or change?

No, I mean if I have to teach hello world, compare

  object Hello extends App {
    println("hello world!")
  }

to its Java equivalent. How much do you have to explain? Or can you get away with saying: these are incantations that you just need to write, not understand? What feeling does that give to a newbie?

Even if this initial snippet is easier, after a little while you need to explain how for comprehension works...

Note that the 11 year old kid had no problem with them in his talk! I think for comprehensions are far easier to use than the alternatives.

Don't get me wrong: Of course Scala has difficult parts, as has almost every programming language. But I can get a beginning user a long way without ever introducing these parts. In Java, accidental complexity bites you much sooner, that's why I think Scala is easier to teach for a total newcomer.

Cheers

 -- Martin

i think the problem is that (this is my personal impression which only applies to this list) people sometimes tend to throw overly generic/academic solutions at simple problems as examples of how it is done "properly" while not paying attention to the fact that sometimes "properly" heavily depends on who asked and what (s)he wanted to now.

i am more impressed by simple/easy to use solutions than by signature rampages. most people are library users, not library designers.

most times i ask a question, i am not interested in an answer that covers the problem by 100%. a 90% coverage & 70% complexity drop is easier to understand, and i can go to 100% from there.

once upon a time when i tried to understand quicksort, the wikipedia entry confused me. what i did understand at once was:
1) pick x randomly
2) divide your list into 2 parts, one < x, one > x
3) repeat with sublists
4) put the result together

i know this explanation is wrong as you need more memory, several optimizations could be made, it's incomplete (what happens with x?) and whatever - but from here on, i could easily follow wikipedias explanation.

another example: what's a monad?

it's a wrapper around something. you can throw a transformation function at it and that returns a new wrapper around the result.

-------- Original-Nachricht --------
> Datum: Wed, 26 Oct 2011 16:25:18 +0200
> Von: martin odersky
> An: Ittay Dror
> CC: Kevin Wright , Josh Suereth , scala-debate
> Betreff: Re: [scala-debate] Re: [scala-user] White Elefant

> On Wed, Oct 26, 2011 at 3:57 PM, Ittay Dror wrote:
>
> >
> >
> > martin odersky wrote:
> >
> > For a great counter-argument to the original post, see:
> >
> > http://www.youtube.com/watch?v=6RwrT6N43lY
> >
> >
> > (since we're on the debate list...)
> >
> > You only show that there is a child that can understand Scala. For this
> to
> > be a counter-argument, you need to show that there are more children
> that
> > can understand Scala than those that get Java.
> >
> >
> Oh, I know lots more children (see recent Kojo story, and also people I
> know
> privately). But they don't have youtube videos :-).
>
> I firmly believe that Scala is easier to learn than Java. For a starter:
> public static void main( String[] args) what?
>
> The main problem that I see is that the Scala community as a whole
> sometimes
> overcomplicates things.
>
> Cheers
>

On 26/10/2011 17:31, martin odersky wrote:

CAENVNkZHc07un7hNkjjKhwjkiYV2xNC6e8A9aiwkWpGQvVeSGA [at] mail [dot] gmail [dot] com" type="cite">

On Wed, Oct 26, 2011 at 5:14 PM, Ittay Dror <ittay [dot] dror [at] gmail [dot] com" rel="nofollow">ittay.dror@gmail.com> wrote:

[..] Even if this initial snippet is easier, after a little while you need to explain how for comprehension works...

Note that the 11 year old kid had no problem with them in his talk! I think for comprehensions are far easier to use than the alternatives.

Don't get me wrong: Of course Scala has difficult parts, as has almost every programming language. But I can get a beginning user a long way without ever introducing these parts. In Java, accidental complexity bites you much sooner, that's why I think Scala is easier to teach for a total newcomer.

Supporting that: we just took in our company a total newbie in development. He has a little exposure to C++ (and suffer) and to Java (and well, there was a lot of strange things that he didn't understand and must be done "because don't ask"). I mean, he is really a newbie: he read some tutorial, started to try hello world, etc.

Then, we took him, and has we are a full Scala shop, we ask him to try Scala. In no time (counting in minutes, not even hours), he was able to solve Euler project games in the REPL - what he wasn't able to do after much more time in C++ or Java.

It's just the beginning, and so we will see how he can understand all the complicated part of Scala we use, but for now, I can say that for a total newbie, Scala is easier than Java or C++ (well, ok, C++ was not a real contender).

Cheers,

-- 
Francois ARMAND
http://fanf42.blogspot.com
http://www.normation.com

Quote: The main problem that I see is that the Scala community as a whole sometimes overcomplicates things.

 

That’s a very good point. It’s been my experience that many people in general overcomplicate things.

 

When the purpose of any piece of code if to be maintained by others in the company or contributed on from others in the community, things must be as strait-forward as possible.

 

I for one generally refuse to use and even learn things that I deem not efficient complexity/usability wise… can’t think of an example right now J but I asure you there’s lots.

 

To the OP – you’re largely wrong. I don’t see much laziness in scala, on a daily basis at least. The FP features that are there are very easy to use and simplify things a lot, if you don’t abuse them.

 

Going beyond simple trolls, there’s a lot of poorly informed people out there, many spreading dis-information and many with an agenda. A guy on linkedin gave this example as to why scala is too complex (and challenged anyone to be able to explain it, too):

 

trait *->*->** { implicit def *->*->** [A, F[_,_], B](a: F[A,b]): *->*->*[A, F, B] = new *->*->*[A, F, B] { val value = a } }

 

this is obvisouly an abuse of scala on many levels and Kevin found this counter-example of Java (from the default library nevertheless)

 

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) { 
T[] copy = ((Object)newType == (Object)Object[].class) 
? (T[]) new Object[newLength] 
: (T[]) Array.newInstance(newType.getComponentType(), newLength); 
... 
} 

 

this is the discussion – towards the end: http://www.linkedin.com/groups/Yet-another-Is-Scala-too-746917%2ES%2E67512085?qid=c1313331-3137-43ab-b803-a8a426cf118b&trk=group_most_popular-0-b-ttl&goback=%2Egmp_746917

 

BTW, he claims he was given that example at a JavaOne presentation of JVM languages.

 

 

From: scala-debate@googlegroups.com [mailto:scala-debate@googlegroups.com] On Behalf Of martin odersky
Sent: October-26-11 10:25 AM
To: Ittay Dror
Cc: Kevin Wright; Josh Suereth; scala-debate
Subject: Re: [scala-debate] Re: [scala-user] White Elefant

 

 

On Wed, Oct 26, 2011 at 3:57 PM, Ittay Dror <ittay.dror@gmail.com> wrote:

 

martin odersky wrote:

For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

 

(since we're on the debate list...)

You only show that there is a child that can understand Scala. For this to be a counter-argument, you need to show that there are more children that can understand Scala than those that get Java.

 

 

Oh, I know lots more children (see recent Kojo story, and also people I know privately). But they don't have youtube videos :-).

I firmly believe that Scala is easier to learn than Java. For a starter: public static void main( String[] args) what?

The main problem that I see is that the Scala community as a whole sometimes overcomplicates things.

Cheers

 -- Martin

 

On Wed, Oct 26, 2011 at 7:25 AM, martin odersky <martin.odersky@epfl.ch> wrote:

Oh, I know lots more children (see recent Kojo story, and also people I know privately).

Sure, but that would probably be sample bias. You are probably much more interested in seeking out examples of children who program in Scala than in Java. It would probably be trivial to find entire classrooms of children who write Java code on a regular basis. This doesn't prove anything.  

I firmly believe that Scala is easier to learn than Java.

Of course you do, as do most people on this mailing-list. Again, this doesn't change the points brought up by Stuart about what other people think of Scala. 

The main problem that I see is that the Scala community as a whole sometimes overcomplicates things. 

Definitely true. Now, does this come from the community, the language, the platform, all of the above?  

 For a starter: public static void main( String[] args) what?

Yes, it's verbose, but I don't think this has ever come remotely close to the top of Java annoyances. Bringing up this example looks great on slides but does little to convince because nobody will relate to it.
Also, as you are aware, Scala has its own closet filled with skeletons when it comes to the handling of main(), Application, App, etc...
-- Cédric

On Wed, Oct 26, 2011 at 8:00 AM, martin odersky <martin.odersky@epfl.ch> wrote:

No, I mean if I have to teach hello world, compare

  object Hello extends App {
    println("hello world!")
  }

to its Java equivalent. How much do you have to explain? Or can you get away with saying: these are incantations that you just need to write, not understand? What feeling does that give to a newbie?

Not to belabor this particular point, but yes, there is just as much to explain to a beginner about the example above ("object", "extends" and "App", and what's in App, and how come the example doesn't work if you forget to extend, etc...) as with Java's main.
And of course, the right way of doing it in both cases is: we'll explain these in turn, let's just focus on println() for now.
It's the same thing when you learn to drive: you sit down behind the wheel and there are many things that you can ignore at first. It's a perfectly normal learning process.
-- Cédric

What my ten year old loved was being able to just write working code in either of:

-          Kojo

-          Interpreter

-          Simplyscala.com

 

You know, just type 1+2 and get back 4…

 

Do that in Java – we’re talking beginners and kids here, right?

 

From: scala-debate@googlegroups.com [mailto:scala-debate@googlegroups.com] On Behalf Of Cédric Beust ?
Sent: October-26-11 2:13 PM
To: martin odersky
Cc: Ittay Dror; scala-debate
Subject: Re: [scala-debate] Re: [scala-user] White Elefant

 

On Wed, Oct 26, 2011 at 8:00 AM, martin odersky <martin.odersky@epfl.ch> wrote:

No, I mean if I have to teach hello world, compare

  object Hello extends App {
    println("hello world!")
  }

to its Java equivalent. How much do you have to explain? Or can you get away with saying: these are incantations that you just need to write, not understand? What feeling does that give to a newbie?

 

Not to belabor this particular point, but yes, there is just as much to explain to a beginner about the example above ("object", "extends" and "App", and what's in App, and how come the example doesn't work if you forget to extend, etc...) as with Java's main.

 

And of course, the right way of doing it in both cases is: we'll explain these in turn, let's just focus on println() for now.

 

It's the same thing when you learn to drive: you sit down behind the wheel and there are many things that you can ignore at first. It's a perfectly normal learning process.

 

-- 

Cédric

 

 

 

imho simpler: sliding(2).forall(e => e.head <= e.last)

in the zipped example, you need to think a bit about what happens to the leftover element

Am 26.10.2011 16:48, schrieb Ittay Dror:

4EA81DDA [dot] 1030707 [at] gmail [dot] com" type="cite"> body p { margin-bottom: 0cm; margin-top: 0pt; }

martin odersky wrote:

i_odpww [at] mail [dot] gmail [dot] com" type="cite">

On Wed, Oct 26, 2011 at 3:57 PM, Ittay Dror <ittay [dot] dror [at] gmail [dot] com" rel="nofollow">ittay.dror@gmail.com> wrote:

martin odersky wrote:

For a great counter-argument to the original post, see:

  http://www.youtube.com/watch?v=6RwrT6N43lY

(since we're on the debate list...)

You only show that there is a child that can understand Scala. For this to be a counter-argument, you need to show that there are more children that can understand Scala than those that get Java.

  Oh, I know lots more children (see recent Kojo story, and also people I know privately). But they don't have youtube videos :-).

I firmly believe that Scala is easier to learn than Java. For a starter: public static void main( String[] args) what?

I think you view this from the "spec" point of view. Has this definition of 'main' ever cause tricky bugs? Made code harder to write or change?

i_odpww [at] mail [dot] gmail [dot] com" type="cite">
The main problem that I see is that the Scala community as a whole sometimes overcomplicates things.

Hence my suggestion for 'idiomatic' approach a-la python.

See this for example: http://stackoverflow.com/questions/7852471/idiomatic-construction-to-check-whether-a-collection-is-ordered
Runar answered with a post containing semigroups and traverse, pointing to a haskell paper
I answered with a solution using iteratees, which is no better
The best solution IMHO was: (l, l.tail).zipped.forall(_ <= _) (by missingfaktor)

A newbie should have a rich resource of such snippets instead of finding answers about traverse/iteratee which are harder to learn, read and more code to write.


i_odpww [at] mail [dot] gmail [dot] com" type="cite">
Cheers

 -- Martin

On 26 October 2011 19:16, Razvan Cojocaru <pub@razie.com> wrote:

You know, just type 1+2 and get back 4…

Scala's got bigger problems than I thought!

Paul
/ 1 + 2 == 3, even for large values of 2

On Wed, Oct 26, 2011 at 7:38 PM, Razvan Cojocaru <pub@razie.com> wrote:

Quote: The main problem that I see is that the Scala community as a whole sometimes overcomplicates things.

 

That’s a very good point. It’s been my experience that many people in general overcomplicate things.

 

When the purpose of any piece of code if to be maintained by others in the company or contributed on from others in the community, things must be as strait-forward as possible.

 

I for one generally refuse to use and even learn things that I deem not efficient complexity/usability wise… can’t think of an example right now J but I asure you there’s lots.

 

To the OP – you’re largely wrong. I don’t see much laziness in scala, on a daily basis at least. The FP features that are there are very easy to use and simplify things a lot, if you don’t abuse them.

 

Going beyond simple trolls, there’s a lot of poorly informed people out there, many spreading dis-information and many with an agenda. A guy on linkedin gave this example as to why scala is too complex (and challenged anyone to be able to explain it, too):

 

trait *->*->** { implicit def *->*->** [A, F[_,_], B](a: F[A,b]): *->*->*[A, F, B] = new *->*->*[A, F, B] { val value = a } }

 

this is obvisouly an abuse of scala on many levels and Kevin found this counter-example of Java (from the default library nevertheless)

 

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) { 
T[] copy = ((Object)newType == (Object)Object[].class) 
? (T[]) new Object[newLength] 
: (T[]) Array.newInstance(newType.getComponentType(), newLength); 
... 
} 

 

this is the discussion – towards the end: http://www.linkedin.com/groups/Yet-another-Is-Scala-too-746917%2ES%2E67512085?qid=c1313331-3137-43ab-b803-a8a426cf118b&trk=group_most_popular-0-b-ttl&goback=%2Egmp_746917

 

BTW, he claims he was given that example at a JavaOne presentation of JVM languages.

 

Just shows there's a lot of FUD being spread. It's good to counter that, politely but firmly.
 -- Martin 

2011/10/26 Cédric Beust ♔ <cedric@beust.com>

On Wed, Oct 26, 2011 at 8:00 AM, martin odersky <martin.odersky@epfl.ch> wrote:

No, I mean if I have to teach hello world, compare

  object Hello extends App {
    println("hello world!")
  }

to its Java equivalent. How much do you have to explain? Or can you get away with saying: these are incantations that you just need to write, not understand? What feeling does that give to a newbie?

Not to belabor this particular point, but yes, there is just as much to explain to a beginner about the example above ("object", "extends" and "App", and what's in App, and how come the example doesn't work if you forget to extend, etc...) as with Java's main.

I definitely disagree with that. 
class    -- need to explain what a class is, and why Hello is not really one (because no instances are ever created)public   -- need to explain privacy levels  static    -- what the heck is that?void      -- void???main     OK, I might get thatString[] -- need to explain irregular array syntaxargs     -- need to explain command line arguments
Compare that to:
object Hello   -- need to explain what objects are, it's definitely simpler than classes!extends App -- need to explain that Hello an instance of an `App', i.e. something that can be run.
That's all. It's no contest really. The only way you could claim that java is as simple is if you take everything in Java for granted. I guess I have started working with Java earlier than you have, and I can tell you that for teaching the Hello world problem was a big deal. It eventually went away once everyone took Java for granted. But that does not mean that the problem does not exist, only that we do not see it anymore.
Cheers
 -- Martin 

2011/10/26 martin odersky <martin.odersky@epfl.ch>

I definitely disagree with that. 
class    -- need to explain what a class is, and why Hello is not really one (because no instances are ever created) public   -- need to explain privacy levels  static    -- what the heck is that?void      -- void???main     OK, I might get thatString[] -- need to explain irregular array syntaxargs     -- need to explain command line arguments

Maybe for someone who's never programmed in their life, but I bet that most people who started programming in Java had some prior exposure to C and/or C++, so I still think the description above is vastly overblown.
Either way, my original point stands: it's really no big deal to tell beginners to not pay attention to some details in the early stages.
-- Cédric

2011/10/26 martin odersky <martin.odersky@epfl.ch>

2011/10/26 Cédric Beust ♔ <cedric@beust.com>

On Wed, Oct 26, 2011 at 8:00 AM, martin odersky <martin.odersky@epfl.ch> wrote:

No, I mean if I have to teach hello world, compare

  object Hello extends App {
    println("hello world!")
  }

to its Java equivalent. How much do you have to explain? Or can you get away with saying: these are incantations that you just need to write, not understand? What feeling does that give to a newbie?

Not to belabor this particular point, but yes, there is just as much to explain to a beginner about the example above ("object", "extends" and "App", and what's in App, and how come the example doesn't work if you forget to extend, etc...) as with Java's main.

I definitely disagree with that. 
class    -- need to explain what a class is, and why Hello is not really one (because no instances are ever created)public   -- need to explain privacy levels  static    -- what the heck is that?void      -- void???main     OK, I might get thatString[] -- need to explain irregular array syntaxargs     -- need to explain command line arguments
Compare that to:
object Hello   -- need to explain what objects are, it's definitely simpler than classes!extends App -- need to explain that Hello an instance of an `App', i.e. something that can be run.
That's all. It's no contest really. The only way you could claim that java is as simple is if you take everything in Java for granted. I guess I have started working with Java earlier than you have, and I can tell you that for teaching the Hello world problem was a big deal. It eventually went away once everyone took Java for granted. But that does not mean that the problem does not exist, only that we do not see it anymore.
Cheers
 -- Martin 

Isn't it funny how that works. After seeing the same thing for a while, out minds automatically filter it out. Like that box in the corner of the room, that I had intended to put away eventually. Now I don't even notice it. But visitors definitely do.

Someone could invent a programming language that requires the statement "Do not think about a pink elephant" on every other line, but after a while experienced users would not even notice it. Then some newbie would suggest removing it, and he would be scolded for trying to reinvent the language.

--Russ P.

--
http://RussP.us

I think Scala aims at being simple.  Not being simple for java developers.   Long term vision here.
Scala isn't trying to replace Java, Scala is trying to *be a general purpose programming language on the JVM*.   The fact that a lot of folk are moving from Java to Scala is a sign of pain in Java that's causing the to move to Scala.   But let's get this straight:
Scala needs to attract the young generation more than the older generation for long term success.   If we can attract children, they'll be comfortable with Scala, hopefully some FP and it's a big win for education everywhere.   
Java was a *beast* to learn initially.  Lots of odd rules and strange behavior.  I was able to pick up Scala and even write a book on it.  With Java I had to read all the books first, to really 'get it'.  With Scala, things are *much* more consistent in the language so you can focus on the *hard things* like API design, how much abstraction to use and solving real world problems.
In Java, the language always got in the way.   A great example:  I just read through all of JGit's source.  While a well done Java project, the command line library really confused me for a bit until I saw all the magical reflection things happening with annotations.   In Scala I can just pattern match arguments, no need for get opt and friends.
Scala's in it for the long haul.   We need to think past Java.   In fact, in Pittsburgh at least, the competition is trying to get people to move to Scala from C#.  They've already left the JVM....
- Josh


2011/10/26 Cédric Beust ♔ <cedric@beust.com>

2011/10/26 martin odersky <martin.odersky@epfl.ch>

I definitely disagree with that. 
class    -- need to explain what a class is, and why Hello is not really one (because no instances are ever created) public   -- need to explain privacy levels  static    -- what the heck is that?void      -- void???main     OK, I might get thatString[] -- need to explain irregular array syntaxargs     -- need to explain command line arguments

Maybe for someone who's never programmed in their life, but I bet that most people who started programming in Java had some prior exposure to C and/or C++, so I still think the description above is vastly overblown.
Either way, my original point stands: it's really no big deal to tell beginners to not pay attention to some details in the early stages.
--  Cédric