[ANN] specs 1.6.1
2009-11-05 12:25:48 GMT
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,
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
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).
feedback welcome. (I already work of the second version, more info near)