Scala 2.8.0 Final!

[Rafael_Afonso]

It is finally here!! After many, many months of hard work, the Scala team is truly happy to announce the new, much-awaited stable release of Scala! The all-new Scala 2.8.0 final distribution is ready to be downloaded from our Download Page. The Scala 2.8.0 codebase includes a huge number of bug fixes with respect to 2.7.7, and an impressive amount of new features. Please read below for further details!

[size=24]The Scala 2.8.0 distribution[/size]

[size=18]What is new?[/size]

The Scala 2.8 codebase includes the following new fixes and features:

* [b]Redesigned collection library[/b]
  The collection library has undergone a complete overhaul for Scala 2.8, offering a more coherent and efficient design, while maintaining virtually complete compatibility with existing sources. Detailed information at: http://www.scala-lang.org/sid/3

* [b]New array implementation, manifests for polymorphic arrays[/b]
  Handling of arrays has been simplified and optimized in Scala 2.8. The previous compiler magic has been replaced by a more systematic and predictable implementation in terms of implicit conversions. Full details at: http://www.scala-lang.org/sid/7

* [b]Type specialization[/b]
  Scala 2.8 adds specialized type parameters, which enable the compiler to generate transparently multiple versions of a given definition, and to use the most specific version whenever the static type information at a call site allows it. Details at: http://www.scala-lang.org/sid/9

* [b]Named and default arguments[/b]
  Named arguments improve the readability of method calls with many arguments. Default arguments reduce code duplication, and enable "copy" methods for case classes, useful to generate quickly modified copies of case classes. A complete description at: http://www.scala-lang.org/sid/1

* [b]Package objects[/b]
  Packages can now contain besides classes and objects also methods, fields or type aliases. These are added to a package by declaring a package object. More capabilities might be added to package objects in subsequent releases.

* [b]Beefed up Scala Swing libraries, better documentation[/b]
  Components publish key events, input events can be consumed, refactored window subhierarchy, additional demos, Swing listeners are installed lazily, more complete component caching, minor refactorings, bugfixes, more Scaladocs. Design document at: http://www.scala-lang.org/sid/8

* [b]Revamped REPL[/b]
  Many bugfixes. Tab-completion for all packages on the classpath, as well as object and instance methods and fields, including type aliases and package objects. Searchable history, integrated shell access, and a power mode which offers direct access to compiler internals.

* [b]Implicits changes[/b]
  We have refined the implicit resolution process so that resolution is now able to determine type variables.

* [b]Improved equality[/b]
  Equality across numeric types is to be consistent across all the primitives types, while also adhering to the equals/hashCode contract. Numeric comparisons will have the same results as they would between Java primitives. This is currently still being completed.

* [b]Packrat parser combinators[/b]
  With support for packrat parsing, parser combinators are now able to handle left-recursive grammars and will show improved performance for ambiguous productions.

* [b]Improved XML library[/b]
  Many bugfixes.

* [b]Type constructor inference[/b]
  Type inference has been extended to deal with type constructors, so that, in certain cases, you can omit type parameter lists that contain higher-kinded types (aka type constructors, e.g., List).

* [b]Improved Annotations[/b]
  Scala 2.8 adds support for nested java annotations. For annotations on fields, it is now possible to specify which synthetic members (getter / setter) will have the annotation. Documentation about Scala annotations can be found at: http://www.scala-lang.org/sid/5

* [b]Enhanced actors[/b]
  New Reactors provide more lightweight, purely event-based actors with optional, implicit sender identification. Support for actors with daemon-style semantics was added. Actors can be configured to use the efficient JSR166y fork/join pool, resulting in significant performance improvements on 1.6 JVMs. Schedulers are now pluggable and easier to customize.

* [b]Support for continuations[/b]
  Continuations are supported by a compiler plugin, which is now supported as part of the main distribution.

[size=18]Internal improvements[/size]

* [b]New presentation compiler[/b]
  This new infrastructure, within the Scala compiler, enables IDEs to hook into the compiler to find efficiently information about the structure of the program under editing. This new code offers a better platform for the development of IDE plugins.

* [b]New build manager[/b]
  The new feature used by for example Eclipse to detect intelligently changes in the files and compile only necessary Scala sources, instead of performing clean build on whole projects. This technique enables to significantly reduce the compilation time on bigger projects.

* [b]Speed improvements[/b]
  The compiler now runs as optimised code. In addition, a number of improvements and fine-tunings have further improved the compiler speed up to 50%.

Mais em http://www.scala-lang.org/node/7009 (via Leitor RSS)

[fredferrao]

Excelente, e vamo que vamo.

[Alexandre_Gazola]

Aproveitando o ensejo, o que vcs acham do post “Scala is unfit for serious development” ( http://codemonkeyism.com/scala-unfit-development/ )?

[fabiocsilva]

[quote=Alexandre Gazola]Aproveitando o ensejo, o que vcs acham do post “Scala is unfit for serious development” ( http://codemonkeyism.com/scala-unfit-development/ )?
[/quote]

Artigo controverso. Primeiramente, é bom salientar que o Brasil não é nem de perto o cenário imaginado pelo autor, afinal programador Scala profissional aqui você conta nos dedos. De uma mão.

Quanto aos tópicos levantados, eu acho engraçado. Reclamam do Java porque ele deixa de evoluir para manter a compatibilidade, aí vem o autor(que provavelmente começou a olhar o Scala por conta desse problema) e fala que a quebra de compatibilidade binária e de API é um problema. As linguagens que mais evoluiram nos últimos tempos foram obrigadas a quebrar a compatibilidade, vide PHP e a plataforma .NET. Mais cedo ou mais tarde até o Java vai passar por isso. Depois ele reclama de nomenclatura e mais algumas baboseiras. Mesmo que os argumentos sejam reais, eles não se aplicam a idéia de que o Scala não é adaquedo para desenvolvimento “sério”.

[bobmoe]

[quote=Alexandre Gazola]Aproveitando o ensejo, o que vcs acham do post “Scala is unfit for serious development” ( http://codemonkeyism.com/scala-unfit-development/ )?
[/quote]
o chato é que se aprendermos uma linguagem por ano, neste caso aí teria perdido um ano.
mas por outro lado ganhou várias horas com uma linguagem mais fácil.

[Bruno_Laturner]

[quote=bobmoe][quote=Alexandre Gazola]Aproveitando o ensejo, o que vcs acham do post “Scala is unfit for serious development” ( http://codemonkeyism.com/scala-unfit-development/ )?
[/quote]
o chato é que se aprendermos uma linguagem por ano, neste caso aí teria perdido um ano.
mas por outro lado ganhou várias horas com uma linguagem mais fácil.[/quote]

O objetivo do “aprender uma linguagem por ano” é você mudar o modo de pensar, atacando o problema por outros lados, com novas idéias., idéias que também podem ser aplicadas usando outras linguagens. Aprender a linguagem em si é benefício secundário. Fora que conhecimento não se perde, em uma semana reaprende-se a linguagem.

[bobmoe]

[quote=Bruno Laturner][quote=bobmoe][quote=Alexandre Gazola]Aproveitando o ensejo, o que vcs acham do post “Scala is unfit for serious development” ( http://codemonkeyism.com/scala-unfit-development/ )?
[/quote]
o chato é que se aprendermos uma linguagem por ano, neste caso aí teria perdido um ano.
mas por outro lado ganhou várias horas com uma linguagem mais fácil.[/quote]

O objetivo do “aprender uma linguagem por ano” é você mudar o modo de pensar, atacando o problema por outros lados, com novas idéias., idéias que também podem ser aplicadas usando outras linguagens. Aprender a linguagem em si é benefício secundário. Fora que conhecimento não se perde, em uma semana reaprende-se a linguagem.[/quote]
oi bruno, é verdade. mas nada como aprender uma linguagem que está no mainstream, ter tempo para usa-la na pratica é o melhor aprendizado.

[fredferrao]

[quote=Alexandre Gazola]Aproveitando o ensejo, o que vcs acham do post “Scala is unfit for serious development” ( http://codemonkeyism.com/scala-unfit-development/ )?
[/quote]

Code Monkeyism’s Post Is Unfit For Serious Reading

…Reclamam do Java porque ele deixa de evoluir para manter a compatibilidade, aí vem o autor(que provavelmente começou a olhar o Scala por conta desse problema) e fala que a quebra de compatibilidade binária e de API é um problema. As linguagens que mais evoluiram nos últimos tempos foram obrigadas a quebrar a compatibilidade, vide PHP e a plataforma .NET. Mais cedo ou mais tarde até o Java vai passar por isso. Depois ele reclama de nomenclatura e mais algumas baboseiras. Mesmo que os argumentos sejam reais, eles não se aplicam a idéia de que o Scala não é adaquedo para desenvolvimento “sério”.

Acho que nem chega a ser isto, o cara ta usando uma versão beta pra desenvolver, os caras estão diariamente mudando as coisas arrumando os bugs, enfim, o cara quer compatibilidade??

Fui olhar o post agora, e ja esta todo diferente, não esta como eu vi pela primeira vez, pelo jeito deu o que falar :lol:

[Adelar]

Parece interessante… vou dar uma olhada.

Valeu

[rdgms]

Opa… ja vou baixar…

eu cheguei a fazer alguns projetos triviais usando Scala Ide Eclipse… e o negocio ainda não estava muito estavel…
que ide vocês utilizam para desenvolver em scala!?

[fredferrao]

[quote=rdgms]Opa… ja vou baixar…

eu cheguei a fazer alguns projetos triviais usando Scala Ide Eclipse… e o negocio ainda não estava muito estavel…
que ide vocês utilizam para desenvolver em scala!?[/quote]

Bom eu estou estudando ainda, e to usando o JEdit puro, com plugin do scala-tool-support.

[Javart]

O que percebo é o cenário que Scala traz com facilidade de se extender a tecnologias diversas rodando em JVM ele traz soluções de padrões de projetos que já estão desenhadas e prontas para reutilizar estratégicamente em sua linguagem,na certa e fazer o real reuso de muitos e muitos frameworks, não tem dependencia de plataforma, trabalha diretamente no dominio e resolve fácil responsabilidades entre especificações.

Não é a questão somente da linguagem pensar assim é um erro mas sim de toda um nova concepção de fazer software com as tendências e modelos e metodologia, a ciência não é o código mas sim o que é pensado e suportado na sua implementação isso envolve conceitos avançados de engenharia de arquiteturas entre software e hardware também, e nesse design nasce a linguagem a tecnologia.

Recomendo o Video:

http://days2010.scala-lang.org/node/138/157

A Domain Specific Language Approach to Heterogeneous Parallel Programming Using Scala.

The increasing diversity of parallel architectures with heterogeneous programming models motivate the need for Domain Specific Languages (DSLs) that make programming these architectures accessible to average software developers. To simplify the process of developing new DSLs, the Pervasive Parallelism Lab (PPL) at Stanford and the Programming Research Group at EPFL are collaborating to develop a Scala based DSL infrastructure. In this talk, I will describe the elements of this infrastructure which provide support for DSL embedding, DSL staging and execution on heterogeneous parallel hardware. Polymorphic embedding is used to encode simple type-safe DSLs in Scala. Staging support makes it easy to analyze, optimize and transform a domain-specific abstract syntax tree into code for heterogeneous architectures. Execution support includes parallel/concurrent data structures and parallel runtimes for heterogeneous systems.