Eric Torreborre | 5 Nov 13:25 2009
Picon

[ANN] specs 1.6.1

Hi,

specs-1.6.1 (http://code.google.com/p/specs) is now available, essentially delivering bug fixes and small enhancements:

- the ability to define an "around" context to execute the body of an example inside a specific context, like a Lift Session for example. You can see it in action on the Lift wiki here:


- the possibility to display the "plan" of a specification without actually executing it, just to read the text: http://code.google.com/p/specs/wiki/RunningSpecs#Specification_plan

In addition to this, specs has been upgraded to use the latest of Scala (2.7.7), ScalaTest (1.0) and ScalaCheck (1.6).

Have fun specifying your software!

Eric.

PS: you may have to way a little bit for the Maven repository to be updated, if you need the jars right away, they are on the download section of the website)

Jakob Odersky | 8 Nov 18:48 2009
Picon

A Simple Physics Simulator written in Scala

Simple Mechanics Simulator (SiMS) is an open source physics simulation library I wrote in Scala. It's main features include:

    * 2D rigid body simulation
    * Simulation of joints
    * Collision detection and response

Important aspects of a developer's point of view are the extensibility and - as the name says - simplicity of the simulator. Unlike many other simulation libraries, SiMS is structured in a way that makes it easy to enhance or add new features to the library.
For example, a developer can implement a better collision detection system or create new types of shapes by simply inheriting from classes.
Moreover, SiMS is - thanks to Scala - programmed in a very concise manner, thus making the library very simple to understand.
The library was created under the terms of a one-year project at school. Having to comply with the evaluation criteria of a project in german language, I had no choice but to do part of the project in that language. Thus, all comments in the code and a tutorial on the simulator are written in german. However, the source code is in english; that is class, variable and method names are all in english. The comments may be translated in the future.
All source code is available at http://sourceforge.net/projects/simplemechanics
The site also provides a small GUI program, "graphyx",  for testing and visualizing SiMS.

If you want to give it a try, I'd be very interested in your opinions and suggestions,
Jakob Odersky

Antonio Cunei | 18 Nov 15:13 2009
Picon
Picon

The First Scala Workshop - Scala Days 2010

The First Scala Workshop
========================

Call for Papers
---------------

Scala is a general purpose programming language designed to express
common programming patterns in a concise, elegant, and type-safe
way. It smoothly integrates features of object-oriented and
functional languages.

This workshop is a forum for researchers and practitioners to share
new ideas and results of interest to the Scala community. The first
workshop will be held at EPFL in Lausanne, Switzerland, on Thursday
15 April 2010, co-located with Scala Days 2010 (15-16 April).

We seek papers on topics related to Scala, including (but not
limited to):

1. Language design and implementation -- language extensions,
optimization, and performance evaluation.

2. Library design and implementation patterns for extending Scala --
embedded domain-specific languages, combining language features,
generic and meta-programming.

3.Formal techniques for Scala-like programs -- formalizations of the
language, type system, and semantics, formalizing proposed language
extensions and variants, dependent object types, type and effect
systems.

4. Concurrent and distributed programming -- libraries, frameworks,
language extensions, programming paradigms: (Actors, STM, ...),
performance evaluation, experimental results.

5. Safety and reliability -- pluggable type systems, contracts,
static analysis and verification, runtime monitoring.

6. Tools -- development environments, debuggers, refactoring
tools, testing frameworks.

7. Case studies, experience reports, and pearls

Important Dates
---------------

Submission:             Friday, Jan 15, 2010 (24:00 in Apia, Samoa)
Notification:           Monday, Feb 15, 2010
Final revision:         Monday, Mar 15, 2010
Workshop:               Thursday, Apr 15, 2010

Submission Guidelines
---------------------

Submitted papers should describe new ideas, experimental results, or
projects related to Scala. In order to encourage lively discussion,
submitted papers may describe work in progress. All papers will be
judged on a combination of correctness, significance, novelty,
clarity, and interest to the community.

Submissions must be in English and at most 12 pages total length in
the standard ACM SIGPLAN two-column conference format (10pt).
No formal proceedings will be published, but there will be a webpage
linking to all accepted papers. The workshop also welcomes short papers.

Submission instructions will be published at:
http://www.scala-lang.org/days2010

Program Committee
-----------------

Ian Clarke, Uprizer Labs
William Cook, UT Austin
Adriaan Moors, KU Leuven
Martin Odersky, EPFL (chair)
Kunle Olukotun, Stanford University
David Pollak, Liftweb
Lex Spoon, Google

David Bernard | 22 Nov 21:30 2009
Picon

[ANN] maven-scala-plugin 2.13

The maven-scala-plugin team is pleased to announce the maven-scala-plugin-2.13 release!

The maven-scala-plugin is used for compiling/testing/running/documenting scala code in maven.

Changes in this version include:

New features:
o compile, test-compile, cc log the root directories of compilation of the list of files that will be compiled (to allow editor/IDE to reset markers/annotation)
o prepare integration of scala-tool-server (sts) with the goal sts-init

Fixed Bugs:
o fix documentation of default value for goal's configuration (http://github.com/davidB/maven-scala-plugin/issues/unreads#issue/16)  Issue: 16. Thanks to awhitford.
o fix regression of 2.12 where scala:cc stop/exit at first error Thanks to Christophe Dehlinger.

Changes:
o compile, test-compile, cc compile all files by default (less wrong result with trait,... no more need to clean)
o output line from compiler are redirected to maven's logger in forked mode => prefixed by [ERROR]/[WARN]/[INFO] + ease integration with m2eclipse (FULL_BUILD)
o rename packages inside the plugin to use a "flat one level" : org.scala_tools.maven.xxx => org_scala_tools_maven_xxx (ease file / web browsing)


Have fun!
-maven-scala-plugin team
David Bernard | 25 Nov 09:40 2009
Picon

[ANN] YaScalaDT 0.1.0 (eclipse plugin)

Hi,

As some my coworkers, some of you could interested by the first version of my first eclipse plugin ;). There is no site/doc yet.
Current feature :
* very basic editor (comment, string, keyword highlight)
* error marker from console output
* hyperlink/jumper on error/warning from console output

The last 2 features are present in all my editor/configuration and is a must have for me.
Marker/Hyperlink support scala-maven-plugin output. So you could create an extranel tool who call scala:cc (or scala:compile) and have error updated in your project.
I've not test but marker/jumper should work with sbt, builr but you need to custom the command to emit (print to console) the line
 <path>: -1: compiling
then every marker for <path> (could be the root source dir => recursive) are removed/reset

There is no configuration panel.

The EPFL Scala plugin is not required, and both could work together (from my coworker).

https://sourceforge.net/projects/alchim/files/YaScalaDT/0.1.0/net_alchim31_eclipse_yascaladt_0.1.0.200911202226.jar/download

feedback welcome. (I already work of the second version, more info near)

/davidB

martin odersky | 25 Nov 10:09 2009
Picon
Picon

From incubator to greenhouse to trunk

Like any large scale open source project Scala faces the problem how
contributions can be best integrated into the code base. Integrating
them too fast risks instability, and lack of common vision.
Integrating them too hesitantly risks stagnation and turning valuable
contributors away.

To address this problem, we have decided to work with a staged
approach, involving a Scala ``incubator'' and a Scala ``greenhouse''
as two stages for extensions and possible future additions to the
standard Scala distribution (named ``trunk'' in the following).

The incubator was launched some weeks ago by Miles Sabin. It's purpose
is to be a highly visible hosting platform for Scala projects that
should have widespread appeal and that are possible candidates for
future inclusion in a Scala release. Projects in incubator go each at
their own pace. Typically each project has one or more owners,  but
there is no central instance that controls what goes into incubator
overall (except for making hosting arrangements). Two projects have
already started up: I/O, led by Jesse Eichar, and modularization,
led by Josh Suereth.

The greenhouse is more centralized. It's role is to serve as a
concrete candidate for an alternate version of trunk which usually
includes the standard Scala distribution as a subset. Greenhouse code
is not yet cast in stone but is expected to build at all times and to
perform as well as trunk. There will be frequent merges of the latest
trunk with greenhouse code and there will be nightly builds.
Greenhouse jars will be made available from EPFL alongside
the standard distribution. There will also be regular assessments to
decide which parts of greenhouse are ready to be promoted to trunk.

The delta between greenhouse code and trunk code can be very flexible.
Some parts of greenhouse might introduce a whole package hierarchy,
where others could just add a couple of methods to existing trunk
classes.

Greenhouse has a ``gardener'', who acts as a central owner, deciding
what goes in, and who makes sure that everything works smoothly
together. Paul Phillips has agreed to serve in that role. He will
certainly need help, and I assume he will also delegate the
development of some parts to others, but he'll keep the final say of
what goes in.

In a sense, greenhouse is intended to recreate some of the feel of the
early days of Scala when development could be rapid because decisions
could be easily changed later on. With trunk that's now more difficult
because of the large and growing base of installed code. But if you
want to live a bit on the bleeding edge and value cool features over
100% stability of APIs you might well want to choose to build your
project on greenhouse instead of trunk.

By contrast, incubator casts a much wider net, combining projects that
will migrate to greenhouse/trunk alongside projects that will continue
to exist as separate entities.

So I believe both these efforts are ideally complementary, and I hope
that they will be enablers for lots of great contributions to the Scala
eco-system. Many thanks to Miles and Paul for running these efforts!

Cheers

 -- Martin

Bruno Oliveira | 26 Nov 04:46 2009
Picon

Re: GPCE'10 First Call for Papers (apologies for cross-postings)

Hi all,

Scala is a great language for developing generative programming tools
and developing highly expressible and reusable components. The GPCE
conference is interested to hear about  cutting-edge techniques of  
generative
and component-based software. You can show what Scala can do in this
area by submitting a research paper or a tool demonstration to GPCE!

------------------------------------------------------------------------
                       CALL FOR PAPERS

               Ninth International Conference on
        Generative Programming and Component Engineering
                      (GPCE 2010)

                   October 10-13, 2010
                 Eindhoven, The Netherlands
                 (co-located with SLE 2010)

                    http://www.gpce.org
------------------------------------------------------------------------

IMPORTANT DATES

* Submission of abstracts: May 17, 2010
* Submission of papers: May 24, 2010
* Author notification: Jul 5, 2010

SCOPE

Generative and component approaches are revolutionizing software
development similar to how automation and components revolutionized
manufacturing. Generative Programming (concerning programs that
synthesize other programs), Component Engineering (concerning
modularity in application design), and Domain-Specific Languages
(DSLs) (concerning compact domain-specific notations for expressing
programs) are key technologies for automating program development.

The International Conference on Generative Programming and Component
Engineering is a venue for researchers and practitioners interested in
techniques that, through deploying components and program generation,
increase programmer productivity, improve software quality, and
shorten the time-to-market of software products.  In addition to
exploring cutting-edge techniques of generative and component-based
software, our goal is to foster further cross-fertilization between
the software engineering and the programming languages research
communities.

SUBMISSIONS

Research papers:

10 pages in SIGPLAN proceedings style (sigplanconf.cls) reporting
original research results that contribute to scientific knowledge in
the areas listed below (the PC chair can advise on appropriateness).

Tool demonstrations:

Tool demonstrations should present tools that implement novel
generative and component-based software engineering techniques, and
are available for use. Any of the GPCE'10 topics of interest are
appropriate areas for research demonstrations.  Purely commercial tool
demonstrations will not be accepted. Submissions should contain a tool
description of 4 pages in SIGPLAN proceedings style (sigplanconf.cls)
and a demonstration outline of up to 2 pages text plus 2 pages screen
shots. The four page description will, if the demonstration is accepted,
be published in the proceedings. The 2+2 page demonstration outline
will only be used by the PC for evaluating the submission.

TOPICS

GPCE seeks contributions in software engineering and in programming
languages related (but not limited) to:

* Generative programming
   o Reuse, meta-programming, partial evaluation, multi-stage and
     multi-level languages, step-wise refinement, generic programming
   o Semantics, type systems, symbolic computation, linking and
     explicit substitution, in-lining and macros, templates,
     program transformation
   o Runtime code generation, compilation, active libraries,
     synthesis from specifications, development methods,
     generation of non-code artifacts, formal methods, reflection
* Generative techniques for
   o Product-line architectures
   o Distributed, real-time and embedded systems
   o Model-driven development and architecture
   o Resource bounded/safety critical systems.
* Component-based software engineering
   o Reuse, distributed platforms and middleware, distributed
     systems, evolution, patterns, development methods,
     deployment and configuration techniques, formal methods
* Integration of generative and component-based approaches
* Domain engineering and domain analysis
   o Domain-specific languages including visual and UML-based DSLs
* Separation of concerns
   o Aspect-oriented and feature-oriented programming,
   o Intentional programming and multi-dimensional separation of
     concerns
* Industrial applications of the above

Submissions must adhere to SIGPLAN's republication policy. Please
contact the program chair if you have any questions about how this
policy applies to your paper (chairs@...).

ORGANIZATION

General Chair:    Eelco Visser (Delft University of Technology, The  
Netherlands)
Program Chair:    Jaakko J‰rvi (Texas A&M University, USA)
Publicity Chair:  Giorgios Economopoulos (University of Southampton, UK)

Program Committee

* Sven Apel (University of Passau, Germany)
* Don Batory (University of Texas, USA)
* Martin Bravenboer (LogicBlox, USA)
* Krzysztof Czarnecki (University of Waterloo, Canada)
* Charles Consel (INRIA / LaBRI, France)
* Gabriel Dos Reis (Texas A&M University, USA)
* Ewen Denney (RIACS/NASA Ames, USA)
* Ronald Garcia (Carnegie Mellon University, USA)
* Magne Haveraaen (University of Bergen, Norway)
* Johan Lilius (≈bo Akademi University, Finland)
* Andres Lˆh (Utrecht University, The Netherlands)
* Mat Marcus (Canyonlands Software Design, USA)
* Marjan Mernik (University of Maribor, Slovenia)
* Klaus Ostermann (University of Marburg, Germany)
* Bruno C. d. S. Oliveira (Seoul National University, Korea)
* Hridesh Rajan (Iowa State University, USA)
* Sukyoung Ryu (Korea Advanced Institute of Science and Technology)
* Jo„o Saraiva (Minho University, Portugal)
* Sibylle Schupp (Hamburg University of Technology, Germany)
* Kwang Yi (Seoul National University, Korea)
* Mirko Viroli (University of Bologna, Italy)
* Alessandro Warth (Viewpoints Research Institute, USA)
* Edwin Westbrook (Rice University, USA)
* Jeremiah Willcock (Indiana University, USA)

David Bernard | 26 Nov 10:53 2009
Picon

Re: [ANN] YaScalaDT 0.1.0 (eclipse plugin)

I created a project on github


to store info, issue,...

On Wed, Nov 25, 2009 at 09:40, David Bernard <david.bernard.31-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> wrote:
Hi,

As some my coworkers, some of you could interested by the first version of my first eclipse plugin ;). There is no site/doc yet.
Current feature :
* very basic editor (comment, string, keyword highlight)
* error marker from console output
* hyperlink/jumper on error/warning from console output

The last 2 features are present in all my editor/configuration and is a must have for me.
Marker/Hyperlink support scala-maven-plugin output. So you could create an extranel tool who call scala:cc (or scala:compile) and have error updated in your project.
I've not test but marker/jumper should work with sbt, builr but you need to custom the command to emit (print to console) the line
 <path>: -1: compiling
then every marker for <path> (could be the root source dir => recursive) are removed/reset

There is no configuration panel.

The EPFL Scala plugin is not required, and both could work together (from my coworker).

https://sourceforge.net/projects/alchim/files/YaScalaDT/0.1.0/net_alchim31_eclipse_yascaladt_0.1.0.200911202226.jar/download

feedback welcome. (I already work of the second version, more info near)

/davidB


Gmane