[ANN] specs 1.6.1
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
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
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
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)
I created a project on github
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
RSS Feed6 | |
|---|---|
4 | |
3 | |
6 | |
11 | |
15 | |
9 | |
10 | |
12 | |
9 | |
8 | |
8 | |
9 | |
26 | |
10 | |
6 | |
8 | |
7 | |
11 | |
11 | |
5 | |
5 | |
10 | |
8 | |
10 | |
1 | |
7 | |
10 | |
5 | |
2 | |
2 | |
3 | |
5 | |
8 | |
9 | |
9 | |
1 | |
7 | |
2 | |
3 | |
7 | |
10 | |
1 | |
24 | |
4 | |
7 | |
10 | |
1 | |
4 | |
1 | |
1 | |
4 | |
7 | |
2 |