Re: [scala-language] The cake’s problem, dotty des ign and the approach to modularity.

Thanks nafg, Vlad, Rex, some-snytt, et al.

I will come back to this asap and with proper organization. I was in an 
extreme rush and just wanted to get my first thoughts recorded some where 
they might be seen. I especially wanted to get that summary post into the 
Scala Roadmap thread, because I am concerned that DOT and Dotty need some 
radical tweak yet before we go that direction. All the progress is great, 
but I think by not discarding subclassing and replacing it with my proposal 
for compiler assisted inversion-of-control (assuming it can't be otherwise 
unified from some other perspective such as category theory), then we will 
have lost a critical opportunity to be the next mainstream language that 
overtakes Java finally.

I recently watched the video of Martin's presentation from Scaladays 2015 
and I really love the TASTY direction to modularize orthogonal compilation 
layers. Kudos!

And I love the conceptual idea of simplification via unification (paradigm 
shift) in DOT. I just think we will miss a huge opportunity if we don't 
deprecate subclassing for Scala 3. If we love at the popular languages, it 
is Java #1 but on a steady decline (perhaps Android and Java 8 staved off a 
free fall for a short while) and all these FP languages as nipping at its 
heels, e.g. Scala, Clojure, Python, etc..

Scala needs to be cleaned up and even less verbose. Eliminating subclassing 
can enable the DOT calculus to become much simpler and also enable more 
opportunities to infer types to reduce verbosity.

IMO what has prevented an FP language from overtaking Java is the lack of 
mainstream need for any particular feature of FP, as well as it being 
presented a bit too obtusely. Scala made some leaps forward on being less 
obtuse because it looks more like a familiar OOP language, eager evaluation 
by default, non-total by default, etc.. But the most salient point IMHO, is 
there is no requirement to use typing in programming. People can make 
arguments either for and against static typing.

But I think I have shown (and I understand I need to organize my 
presentation and thoughts soon) that no one can get fine grained 
extensibility without refactoring and recompilation without my idea for 
inversion-of-control which requires the sophisticated and unified typing of 
DOT (sans the subclassing).

Even if Scala's community doesn't want to make my idea the main direction, 
I hope I can experiment and present as a side effort.

I'll try to get organized before the final commitment to current DOT has 
too much momentum. I am racing right now on other project first.

Apologies for cluttering the list with my stream of consciousness posts.

On Tuesday, July 28, 2015 at 3:01:26 AM UTC+8, Rex Kerr wrote:

-- 
You received this message because you are subscribed to the Google Groups "scala-language" group.
To unsubscribe from this group and stop receiving emails from it, send an email to [email protected].
For more options, visit https://groups.google.com/d/optout.