Theoretically, there is nothing stopping you from writing code which will never finish compiling if you have a Turing-complete typesystem.
106 karma · joined December 3, 2013
Theoretically, there is nothing stopping you from writing code which will never finish compiling if you have a Turing-complete typesystem.
It took only one sentence to show that you never used OCaml or Haskell, so I'm not sure how serious the rest of your claims should be taken.
When I said "some_integer_array.at(i)" I certainly didn't mean "rename both things".
Alternatively, having one additional magic kind/trait/... to denote "addressable" would be more manageable than shoe-horning things into the language's syntax which can – at this change – not be fixed anymore.
some_integer_array.at(i) other bad ideas just snowballed on top of it
It still baffles me how people can invent two separate ways to invoke something, () and [], and pretend that's a good idea.If they used [] for types, they wouldn't have needed to consider such a bad idea.
Now, Rust has to deal with all the random syntax quirks caused by misusing <> for Generics, and it does it pretty badly: As an example, the Foo::<Bar>:: syntax is even worse than Java's Fuz.<Baz>Meth() hack.
Rust's choice of <> ignored the lessons from all the language which made that choice before (Java, C#, C++) and from there, other bad ideas just snowballed on top of it.
Obviously they haven't.
Go devs made it clear that Go won't get Generics, and it's fine.
They also guarantee that if something compiles against a major version without deprecation warnings it will also compile against the next major version.
The only difference with Java is that Scala developers actually deal with deprecated things instead of letting them accumulate with every release and that binary artifacts are forward compatible.
> Now, each of those parties is a fully independent company, with its own CEO, own board, own employees and own counter-espionage division. [...]
Do you remember that US judges didn't even give a fuck about other _countries_ having different privacy laws? I can't imagine that they will respect that "this company which actually isn't one, but five"-move.
Plenty companies use Scala, including most financial institutions in London.
Given the adoption, it is unlikely that it will go away. It might not replace Java, but if you look at some metrics, Scala is the only language which is closing the gap between 2nd-tier languages and 1st-tier languages (Java, C, C++, PHP, C#, ...) and keeps moving up at a slow, but stable speed.
Scala seems to get quite some hate from both FP and OOP camps, due to unifying both paradigms fairly well: It's one of the most expressive FP languages as well as being one of the best OOP languages. It manages that without exposing a huge schism within the language.
This of course irks a lot of dogmatists on both sides.
Considering the improvement proposals: A ton of work is happening here, and I think most people agree on which parts need further improvements. But it's necessary to keep in mind that Scala stands for rock-solid releases (regressions are considered blocking bugs, any changes to binary compatibility fail the continuous integration builds, etc.).
Some changes need a lot of preparation to allow people a smooth migration while minimizing the churn; it's understandable that some people are unhappy with the speed and would like to move faster, increasing the burden on users of the language which want to upgrade.
I think the explanation why the forks are not seeing much activity is that the developers on the EPFL/Typesafe branch are just doing an awesome job. Nevertheless, they did a lot of work on the infrastructure so that forks can hook into many parts of the existing systems, making it easier for people to bootstrap their own Scala version. (Yes, they don't consider forking a bad thing, and especially the relationship between the Typelevel project and the Typesafe/EPFL developers is very good.)
TL;DR: Scala is rock-solid, has the best tooling and IDE support except maybe Java and C#, while constantly evaluating ways to further improve and simplify the language.
But it doesn't really matter. Some pieces might be slightly more verbose, but Scala is more concise in the long run, not because of saving some syntactic stuff here and there, but due to being able to express things which just aren't expressible in OCaml or F#.
If you want some shorter, more ML-like syntax, just pick a different parser https://github.com/lihaoyi/Scalite and have fun.
B: Unlike in OCaml/F#, OO is not "baggage". Scala took the good parts of OO and made them even better. OCaml/F# feel like the language creators tried to make a point about disliking OO by making OO support terrible on purpose. Scala demonstrates that having good FP support doesn't mean OO support need to be terrible.
Some of the stuff for Java support is a bit annoying, though, but doesn't matter in practice.
C: Performance is on par with Java. Scala can leverage the most powerful JIT-compilers and the world's best Garbage Collectors known to man. Does OCaml have working support for concurrency yet?
Everyone is happy.
Plus, sane typeclasses and higher-kinded types. :-)
You obviously don't read the Golang mailing list ... :-)
Go developers seem to be emphatically content with not using the best tool for the job. That makes sense, otherwise those developers wouldn't have ended up with Go in the first place.
For me it's not a question about "I can live without X?", but "why would I want to live without X?". I want the best tools to solve a job. Not some of the best tools. _All_ of them.
"I suppose"? This has been done for years already. There are even GUIs for that (so that people don't have to use the CLI) which tell you "between 1.2.3 and 1.2.4 you did the following: ... This will break compatibility in the following cases: ..."
So it's better to not even try?
Additionally, for many changes it is reasonable and possible to check whether behavior has changed. Not every function has an unlimited number of inputs and outputs.
That's one of the biggest reasons I avoid Go and PHP: It's not only that the developers ignore existing solutions if they haven't "invented" them themselves, but that they don't even care about improving things where no "perfect" solution is available.
Ignorance and arrogance is a combination which doesn't make me trust them, and products based on their software. (OwnCloud, Docker, ...)
Eh ... why? In some languages, it's standard to run source/binary compatibility checks against new versions and fail a build if the new version doesn't satisfy the requirements.
Then make Future generic so that you can use all the existing combinators out there, like `sequence` which turns `List[Future[Response]]` into a Future[List[Response]]`.
Yes, some people might prefer one over the another, but asking how they ended up with such a ridiculous issue would be a much better question.
Go has basically none of the mechanisms for sanely
creating composable complexity that Scala has. It makes
me really grossed out to think about something with the
complexity that Finagle exposes as a Go library. Go is
all about small, sturdy tools that work for most of the
cases most of the time and that compose well with each
other - IF - they are built into the standard library.
And if it's not, have fun spending your time writing
uni-typed interfaces for any kind of interop with
desired complexity. Go is great for writing dead simple
byte slingers, pipelines that will be rigid in the most
dynamic possibility, guns that shoot JS and interact
with services, etc. That's simply not Finagle.
A thousand times this.If you have time for making stuff up and downvoting, then you surely have time to run some benchmarks.