Gambit-list Mai 2016

gambit-list@iro.umontreal.ca

6 participants
9 discussions

Gambit versus Python+GMP: Timing for Chudnovskys' algorithm for pi
by Bradley Lucier 07 Avr '22

07 Avr '22

Bakul Shah wrote a particularly elegant Scheme program for Chudnovskys' algorithm for pi based on the Common Lisp program here: https://bitbucket.org/tarballs_are_good/numericl/src/5fe8fe7089f48ab1c8a388… Nick Craig-Wood wrote a Python program using the GMP multiprecision library that appears to use exactly the same algorithm here: http://www.craig-wood.com/nick/articles/pi-chudnovsky/ I modified both programs a bit and include them here. They time the calculation of $10^n$ digits of pi for $n=1,2,3,4,5,6,7$. The results are heine:~/programs/gambiteer/gambit> !py python pi_chudnovsky_bs_gmpy.py 31415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679 ('chudnovsky_gmpy_mpz_bs: digits', 10, 'time', 1.0967254638671875e-05) ('chudnovsky_gmpy_mpz_bs: digits', 100, 'time', 3.0040740966796875e-05) Last 5 digits 70679 OK ('chudnovsky_gmpy_mpz_bs: digits', 1000, 'time', 0.00025582313537597656) Last 5 digits 01989 OK ('chudnovsky_gmpy_mpz_bs: digits', 10000, 'time', 0.00386810302734375) Last 5 digits 75678 OK ('chudnovsky_gmpy_mpz_bs: digits', 100000, 'time', 0.0834801197052002) Last 5 digits 24646 OK ('chudnovsky_gmpy_mpz_bs: digits', 1000000, 'time', 1.655979871749878) Last 5 digits 58151 OK ('chudnovsky_gmpy_mpz_bs: digits', 10000000, 'time', 30.67442488670349) Last 5 digits 55897 OK heine:~/programs/gambiteer/gambit> gsi chud1.scm Chudnovsky's algorithm using binary splitting in Gambit Scheme: digits 10, CPU time: 0.. Last 5 digits 26535. Chudnovsky's algorithm using binary splitting in Gambit Scheme: digits 100, CPU time: 0.. Last 5 digits 70679. Chudnovsky's algorithm using binary splitting in Gambit Scheme: digits 1000, CPU time: .004. Last 5 digits 1989. Chudnovsky's algorithm using binary splitting in Gambit Scheme: digits 10000, CPU time: .028. Last 5 digits 75678. Chudnovsky's algorithm using binary splitting in Gambit Scheme: digits 100000, CPU time: .472. Last 5 digits 24646. Chudnovsky's algorithm using binary splitting in Gambit Scheme: digits 1000000, CPU time: 6.448. Last 5 digits 58151. Chudnovsky's algorithm using binary splitting in Gambit Scheme: digits 10000000, CPU time: 98.612. Last 5 digits 55897. So it appears that for this algorithm applied to large integers, GMP's bignum routines are about 3-4 times as fast as Gambit's bignum routines. Not so bad. For smaller bignums, GMP has a bigger advantage. The C program gmp-chudnovsky.c includes certain optimizations to this basic algorithm: http://gmplib.org/pi-with-gmp.html ftp://ftp.gmplib.org/pub/misc/gmp-chudnovsky.c On my machine, compiled with gcc -O3 -march=native -o gmp-chudnovsky gmp-chudnovsky.c -lgmp -lm the CPU times for 1,000,000 and 10,000,000 digits are 1.064 and 18.200 seconds, respectively. This is with a somewhat older machine model name : Intel(R) Core(TM)2 Quad CPU Q8200 @ 2.33GHz running Ubuntu 13.04 with heine:~/programs/gambiteer/gambit> gcc -v Using built-in specs. COLLECT_GCC=gcc COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/4.7/lto-wrapper Target: x86_64-linux-gnu Configured with: ../src/configure -v --with-pkgversion='Ubuntu/Linaro 4.7.3-1ubuntu1' --with-bugurl=file:///usr/share/doc/gcc-4.7/README.Bugs --enable-languages=c,c++,go,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-4.7 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --with-gxx-include-dir=/usr/include/c++/4.7 --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --enable-gnu-unique-object --enable-plugin --with-system-zlib --enable-objc-gc --with-cloog --enable-cloog-backend=ppl --disable-cloog-version-check --disable-ppl-version-check --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --with-tune=generic --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu Thread model: posix gcc version 4.7.3 (Ubuntu/Linaro 4.7.3-1ubuntu1) heine:~/programs/gambiteer/gambit> gsi -v v4.6.9 20130607151908 x86_64-unknown-linux-gnu "./configure '--enable-single-host' '--enable-multiple-versions' '--enable-shared'" and the Ubuntu-provided GMP 5.0.5. (I'm sure the GMP folks have a better way to build GMP on my machine than the "generic" 64-bit version provided by Ubuntu.) Brad

7 18

Re: [gambit-list] JavaScript backend
by Marc Feeley 13 Fév '17

13 Fév '17

First of all, this change is for the universal backend. It is more of a temporary kludge to experiment with dynamically loading files generated by the universal backend. Here’s how it works… At the end of the link file, the Gambit linker generates a table of the Scheme modules required by the program. The table is passed as a parameter to the g_module_registry_init function of the Gambit runtime system. For example, the link command: gsc -link -l lib/_gambit.js a.js b.js will generate at the end of the link file “b_.js”: g_module_registry_init([new G_ModLinkInfo("_gambit",0), new G_ModLinkInfo("a",1), new G_ModLinkInfo("b",2)]); At then end of a file generated for the compilation of a module there is a call to a runtime system function that registers the module in the module registry. For example, when “a.scm” is compiled with the command “gsc -target js -c a.scm”, the file “a.js” generated ends with: g_module_register([g_make_interned_symbol("a"),g_bb1__20_a,1,null,false]); The parameter of g_module_register is a “module descriptor” giving information on the module: name, main function (g_bb1__20_a), preload flag (1), module meta information (null), and a dummy field (false) that is only interesting for the C backend. So when the files of generated code are loaded (incrementally) by the JS VM, g_module_register accumulates the modules in a table. When all the modules required by the program have beed loaded (in the example, _gambit, a and b) the function g_module_register will call the main function of the first module. This will run the Scheme code at the toplevel of the first module. The first module contains a loop, in Scheme, that iterates over the module registry and calls the main function of each of the remaining modules in the registry (this information is available in Scheme in the global variable ##program-descr). Specifically, the first module is the Gambit universal library (lib/_univlib.scm), which ends with a call to ##load-vm (a procedure defined in lib/_kernel.scm that runs each module other than the first). What my most recent change does is extend g_module_register so that any subsequent module that is loaded by the JS VM causes its immediate execution by calling the module's main function. In the C backend the mechanism is slightly different (and more flexible): the ##load-object-file procedure of the Gambit runtime library constructs a vector of module descriptors and this vector is passed to ##register-module-descrs-and-load! (defined in lib/_kernel.scm) which then runs the modules. It is more flexible because the loaded object file can contain more than one module, and also control goes through Scheme before the module is executed. Marc > On Jan 3, 2016, at 2:54 AM, Adam <adam.mlmb(a)gmail.com> wrote: > > Marc, > > Wait, what's the point? > > That is effectively C modules' default behavior isn't it? (even if it's the runtime or linker-generated code that actually does the actual run command.) > > So this way you create symmetrical behavior but the actual run command is in the module file itself rather than in runtime/linker - > > Is there any disadvantage.. could be, no, like, I need more modules loaded at the same time and with this model you introduced now, the global namespace in JS files is evaluated at load time so could cause a problem? > > > 2016-01-03 14:10 GMT+08:00 Marc Feeley <feeley(a)iro.umontreal.ca>: > I’ve just pushed a small change to the module registration method. Now, loading the generated .js file will run that file. > > Marc > > > On Jan 2, 2016, at 11:39 PM, Blake McBride <blake(a)mcbride.name> wrote: > > > > Yes, and I use jQuery get and html methods to load the html part. > > > > > > On Sat, Jan 2, 2016 at 8:43 PM, Marc Feeley <feeley(a)iro.umontreal.ca> wrote: > > That’s an interesting app! > > > > As I said, it shouldn’t be hard to do. In your app, how do you load new JS code? Are you using jQuery and the getScript method? > > > > Marc > > > > > On Jan 2, 2016, at 8:42 PM, Blake McBride <blake(a)mcbride.name> wrote: > > > > > > Hi Marc, > > > > > > Thanks for the reply. > > > > > > I started development of a Web based business application in 2006. The app is in production use. The front-end is about 450 screens written in Flash. The back-end is written in Java (over 9,000 classes) on top of an SQL database with 250 tables accessed through Hibernate. The front-end and back-end communicate through SOAP web services. > > > > > > Since Flash is now dead, I need to re-write at least parts of the front-end in JS to support tablets and phones at least. I have front-end JS code that communicates with the back-end SOAP Web services so I theoretically wouldn't need to touch the back-end. > > > > > > I have a preference to utilize scheme if I can, but the back-end is already written and works. It doesn't make sense to mess with it given the investment. > > > > > > The problems I had with Gambit (as well as many other systems) is as follows: > > > > > > Once a user logs in, my app has a consistent visual / UI framework. Beyond this framework, there are 450 different screens that appear within the framework (like in one of the div's). > > > > > > A. I cannot load all 450 screen at system startup. I must lazy load them as they are called up. > > > > > > B. The initial UI framework code should contain all of the Gambit machinery and libraries so that each of the 450 screens can be small, light-weight, compiled separately yet have full access to the entire Gambit facility. > > > > > > With respect, my investigation into Gambit as a possible solution in the past led me to the conclusions at that time it was not possible to produce separately compiled modules that leveraged off of a single main module for the Gambit machinery and libraries. > > > > > > I suppose some time has passed and I wanted to see if the situation has changed. I can only use Gambit if: > > > > > > 1. I can compile and load each screen separately > > > > > > 2. I only have to have one copy of the Gambit machinery and library so that the separate screens are small. > > > > > > Thank you. > > > > > > Blake > > > > > > > > > On Sat, Jan 2, 2016 at 7:06 PM, Marc Feeley <feeley(a)iro.umontreal.ca> wrote: > > > asmjs is cool and Gambit has already been compiled to it thanks to emscripten (see “Gambit in the browser”: http://feeley.github.io/gambit-in-the-browser/). The performance is not bad, perhaps 10x to 20x slower than when Gambit is compiled by gcc to native code. The main problem is the size of the JS that is generated when compiling Gambit-C with emscripten to JS. The gsi interpreter yields roughly 10 MB of asmjs code. > > > > > > As far as code size is concerned, a better solution is to use Gambit's JS backend with the Gambit library. The code generated is roughly half the size when minimized (and it could be even less if some thought went into how identifiers are encoded). > > > > > > Even more savings can be had by doing away with the default Gambit library and writing a custom library specialized for the application. Gambit’s library has lots of functionality that is not normally needed by typical applications. For example, the predefined map procedure can handle an arbitrary number of list parameters. If the application only uses the single list version, then this definition would be sufficient: > > > > > > (define (map f lst) > > > (if (pair? lst) > > > (cons (f (car lst)) (map f (cdr lst))) > > > ‘())) > > > > > > That 4 line version is 1/20th the size of the map defined in the Gambit library (which handles multiple lists, has type checking, precise error messages, same list length checking and is safe for multithreading). > > > > > > So perhaps what’s needed for Gambit to be more successful for web dev is the creation of such a “slim” library for Gambit to replace the default feature-full library. Gambit’s “tree shaker” would also help to eliminate the unused procedures of the slim library (unfortunately this only works for “whole program” compilation, so separate compilation would only be used for the development phase). > > > > > > Anyway, if this interests you please let me know. > > > > > > Marc > > > > > > > On Jan 1, 2016, at 11:44 AM, Blake McBride <blake(a)mcbride.name> wrote: > > > > > > > > Just some opinions. > > > > > > > > asmjs.org defines a portable subset that allows JS platforms to compile into very fast code. Targeting that subset, and within their spec, is probably a good idea. > > > > > > > > JS has, and is becoming increasingly, a very, very important platform. With ajax and rest services, code increasingly independent from the back-end is being developed. So, in a very important sense, JS has become its own platform, just like X86, and X86_64, along with Linux, Windows, Mac, etc. > > > > > > > > Many apps consist of two major parts: the back-end processing, and the front-end human interface. While one can write the back-end processing in any of dozens of languages targeting X86 or a VM, and the OS, there is really only one target for the other half - the human interface - and that is JS. > > > > > > > > While many languages are now targeting the JS platform (I am using the word "platform" to mean X86, X86_64, either, plus the OS) including, believe it or not, Smalltalk, there are few that can, IMO, be used in a real world application for several reasons. But, these issues will likely be resolved soon. > > > > > > > > With respect, Gambit, at least in the past, was in many ways another toy solution - one with a functioning "Hello world" application but missing important features that make it usable in a real-world situation. I would love to be a part of that solution, but alas, life doesn't offer me that level of freedom. I am only capable of using a system that is reportedly working, reporting bugs, making small adjustments, and providing feedback. Regardless of my attitude, preferences, and intentions, I cannot provide more. > > > > > > > > Look at node (JS for the back-end) and its vastly increasing popularity. Since developers are being forced to use JS on the front-end, it's bleeding over to the back-end. I think solutions that take JS seriously at this stage will prosper greatly. > > > > > > > > Now, having said all that, I would love to see Gambit target JS as a high-priority, first-class target. If that were the case, I would be happy to contribute what I stated above. > > > > > > > > Thanks! > > > > > > > > Blake McBride > > > > > > > > _______________________________________________ > > > > Gambit-list mailing list > > > > Gambit-list(a)iro.umontreal.ca > > > > https://webmail.iro.umontreal.ca/mailman/listinfo/gambit-list > > > > > > > > > > > > _______________________________________________ > Gambit-list mailing list > Gambit-list(a)iro.umontreal.ca > https://webmail.iro.umontreal.ca/mailman/listinfo/gambit-list >

2 1

Second CFP for Scheme and Functional Programming Workshop 2016
by Alex Shinn 28 Mai '16

28 Mai '16

SECOND NOTICE Call For Presentations 17th Annual Scheme and Functional Programming Workshop WEBSITE: http://scheme2016.snow-fort.org/ LOCATION: Nara, Japan (Co-located with ICFP 2016) DATE: 18 September 2016 ======================================================================== The 2016 Scheme and Functional Programming Workshop is calling for submissions. This year we are accepting general presentation proposals in addition to papers. Submissions related to Scheme, Racket, Clojure, and functional programming are welcome and encouraged. Topics of interest include but are not limited to: Program-development environments, debugging, testing Implementation (interpreters, compilers, tools, benchmarks, etc.) Syntax, macros, hygiene Distributed computing, concurrency, parallelism Probabilistic computing Interoperability with other languages, FFIs Continuations, modules, object systems, types Theory, formal semantics, correctness History, evolution and standardization of Scheme Applications, experience and industrial uses of Scheme Education Scheme pearls (elegant, instructive uses of Scheme) We also welcome submissions related to dynamic or multiparadigmatic languages and programming techniques. ======================================================================== Important Dates: 24 June 2016 - Submissions deadline 22 July 2016 - Author notification 15 August 2016 - Camera-ready deadline 18 September 2016 - Workshop All deadlines are 23:59 (UTC-12, "Anywhere on Earth"). Paper submissions must be in ACM proceedings format, no smaller than 9-point type (10-point type preferred). Microsoft Word and LaTeX templates for this format are available at: http://www.sigplan.org/Resources/Author/ Paper submissions should be in PDF and printable on US Letter, and generally in the range of 6 to 12 pages. Presentation submissions should include an outline of the material. Talks are 40 minutes, including questions and answers. More information available at: http://scheme2016.snow-fort.org/ ======================================================================== Organizers: Alex Shinn (general chair) Kathy Gray (program chair) (Apologies for duplications from cross-posting.)

1 0

gambit github repo moved
by Marc Feeley 27 Mai '16

27 Mai '16

I have just transferred the official repo from the “feeley” github account to the “gambit” organization. Don’t forget to edit .git/config to point to the new location, or you could start from scratch with a git clone https://github.com/gambit/gambit.git The transfer process has automatically moved all issues and also the users of the gitter chat room (which is now at https://gitter.im/gambit/gambit). The URL https://gitter.im/feeley/gambit redirects to https://gitter.im/gambit/gambit, but don’t rely on that for too long. The purpose of the “gambit” organization is to collect in a central location the repositories related to the Gambit system (tools, projects, extensions, modules). If you are interested in creating a repository in the “gambit” organization, please let me know. Marc

1 0

1st CfP: IFL 2016 (28th Symposium on Implementation and Application of Functional Languages)
by publicityifl＠gmail.com 24 Mai '16

24 Mai '16

Hello, Please, find below the first call for papers for IFL 2016. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Publicity Chair of IFL --- IFL 2016 - Call for papers 28th SYMPOSIUM ON IMPLEMENTATION AND APPLICATION OF FUNCTIONAL LANGUAGES - IFL 2016 KU Leuven, Belgium In cooperation with ACM SIGPLAN August 31 - September 2, 2016 https://dtai.cs.kuleuven.be/events/ifl2016/ Scope The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2016 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. Peer-review Following the IFL tradition, IFL 2016 will use a post-symposium review process to produce the formal proceedings. All participants of IFL 2016 are invited to submit either a draft paper or an extended abstract describing work to be presented at the symposium. At no time may work submitted to IFL be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy: http://www.sigplan.org/Resources/Policies/Republication The submissions will be screened by the program committee chair to make sure they are within the scope of IFL, and will appear in the draft proceedings distributed at the symposium. Submissions appearing in the draft proceedings are not peer-reviewed publications. Hence, publications that appear only in the draft proceedings are not subject to the ACM SIGPLAN republication policy. After the symposium, authors will be given the opportunity to incorporate the feedback from discussions at the symposium and will be invited to submit a revised full article for the formal review process. From the revised submissions, the program committee will select papers for the formal proceedings considering their correctness, novelty, originality, relevance, significance, and clarity. The formal proceedings will appear in the International Conference Proceedings Series of the ACM Digital Library. Important dates August 1: Submission deadline draft papers August 3: Notification of acceptance for presentation August 5: Early registration deadline August 12: Late registration deadline August 22: Submission deadline for pre-symposium proceedings August 31 - September 2: IFL Symposium December 1: Submission deadline for post-symposium proceedings January 31, 2017: Notification of acceptance for post-symposium proceedings March 15, 2017: Camera-ready version for post-symposium proceedings Submission details Prospective authors are encouraged to submit papers or extended abstracts to be published in the draft proceedings and to present them at the symposium. All contributions must be written in English. Papers must use the new ACM two columns conference format, which can be found at: http://www.acm.org/publications/proceedings-template For the pre-symposium proceedings we adopt a 'weak' page limit of 12 pages. For the post-symposium proceedings the page limit of 12 pages is firm. Authors submit through EasyChair: https://easychair.org/conferences/?conf=ifl2016 Topics IFL welcomes submissions describing practical and theoretical work as well as submissions describing applications and tools in the context of functional programming. If you are not sure whether your work is appropriate for IFL 2016, please contact the PC chair at tom.schrijvers(a)cs.kuleuven.be. Topics of interest include, but are not limited to: - language concepts - type systems, type checking, type inferencing - compilation techniques - staged compilation - run-time function specialization - run-time code generation - partial evaluation - (abstract) interpretation - metaprogramming - generic programming - automatic program generation - array processing - concurrent/parallel programming - concurrent/parallel program execution - embedded systems - web applications - (embedded) domain specific languages - security - novel memory management techniques - run-time profiling performance measurements - debugging and tracing - virtual/abstract machine architectures - validation, verification of functional programs - tools and programming techniques - (industrial) applications Peter Landin Prize The Peter Landin Prize is awarded to the best paper presented at the symposium every year. The honored article is selected by the program committee based on the submissions received for the formal review process. The prize carries a cash award equivalent to 150 Euros. Programme committee Chair: Tom Schrijvers, KU Leuven, Belgium - Sandrine Blazy, University of Rennes 1, France - Laura Castro, University of A Coru√±a, Spain - Jacques, Garrigue, Nagoya University, Japan - Clemens Grelck, University of Amsterdam, The Netherlands - Zoltan Horvath, Eotvos Lorand University, Hungary - Jan Martin Jansen, Netherlands Defence Academy, The Netherlands - Mauro Jaskelioff, CIFASIS/Universidad Nacional de Rosario, Argentina - Patricia Johann, Appalachian State University, USA - Wolfram Kahl, McMaster University, Canada - Pieter Koopman, Radboud University Nijmegen, The Netherlands - Shin-Cheng Mu, Academia Sinica, Taiwan - Henrik Nilsson, University of Nottingham, UK - Nikolaos Papaspyrou, National Technical University of Athens, Greece - Atze van der Ploeg, Chalmers University of Technology, Sweden - Matija Pretnar, University of Ljubljana, Slovenia - Tillmann Rendel, University of T√ºbingen, Germany - Christophe Scholliers, Universiteit Gent, Belgium - Sven-Bodo Scholz, Heriot-Watt University, UK - Melinda Toth, Eotvos Lorand University, Hungary - Meng Wang, University of Kent, UK - Jeremy Yallop, University of Cambridge, UK Venue The 28th IFL will be held in association with the Faculty of Computer Science, KU Leuven, Belgium. Leuven is centrally located in Belgium and can be easily reached from Brussels Airport by train (~15 minutes). The venue in the Arenberg Castle park can be reached by foot, bus or taxi from the city center. See the website for more information on the venue.

1 0

gambit github organization
by Marc Feeley 18 Mai '16

18 Mai '16

Hello. I have created the “gambit” organization on github and I plan to transfer the official “gambit” repo there so that it can be cloned from https://github.com/gambit/gambit.git . Does anyone see a problem with this beyond having to update some URLs in the documentation and Gambit wiki? Marc

1 0

{Spam?} Introducing Stanza: A New Optionally-Typed General Purpose Programming Language from U.C. Berkeley.
by Patrick Li 17 Mai '16

17 Mai '16

Hello Everyone! I'm happy to announce the official release of the Stanza programming language! Stanza is a new optionally-typed general purpose programming language from the University of California, Berkeley. It was designed to help programmers tackle the complexity of architecting large programs and significantly increase the productivity of application programmers across the entire software development life cycle. You can check out the website here: www.lbstanza.org. Gambit Scheme was instrumental in the design and development of Stanza. The first prototype for Stanza was hacked together in a month as a collection of Scheme macros. This enabled us to experiment with many of the organizational techniques of multi's and methods within Stanza's unique object system. Having a REPL at our fingertips meant that we could evaluate multiple designs per day. Just change the macro definition, and then try out the revised language in the REPL! The second prototype for Stanza was written entirely using Gambit and used Scheme as the target language. This enabled us to fine-tune all of the semantics of Stanza without having to deal with the details of code generation. Two features of Gambit/Scheme was critical. First, a dynamically typed target language is much much nicer as a target language than a statically typed one; *especially* if the language you're compiling already has its own type system. Second, Gambit's amazingly fast continuations implementation enabled us to design all of Stanza's coroutine system by first expressing it through continuations, and optimizing the implementation only after the semantics were figured out. If you're doing any sort of experiment with control flow, full continuations are a must! Finally the bootstrap compiler for Stanza was written in Gambit and generated x86 assembly code. And now, at version 0.9.0, Stanza is entirely self-hosted. Though Gambit is no longer a part of the implementation of Stanza, it had a great influence on its design. Stanza is essentially a (highly-decorated) Scheme at heart, with an optional type system layered on top, coupled with an object system built on multimethods. Stanza's interface to C took a lot of cues from Gambit's FFI system as well. So thanks Gambit! And also thanks Mark for being so encouraging when I ran into you at ICFP 2013 and for patiently explaining Gambit's continuation implementation to me. We've been using Stanza internally at Berkeley for about two years now, and we've designed a hardware language called FIRRTL, a teaching language called Feeny for teaching a graduate course on virtual machines, and a tool for automatically generating circuit boards for robotics. Now, Stanza is stable and mature enough for us to feel confident to share it with everyone. We hope you'll check it out! -Patrick

1 0

News
by Marc Feeley 10 Mai '16

10 Mai '16

Recently Gambit has seen a few noteworthy changes… As a necessary step on the path to a SMP Gambit, the garbage collector is being parallelized so that multiple OS threads can participate in the garbage collection. The GC is still stop the world (i.e. the main program stops while the GC is working), but because the work is done in parallel the pause time can be expected to be less. An experiment with a 7M heap on a 2.6 GHz i7, gives a GC time of 4 milliseconds when a single thread is used and 1 millisecond when 4 threads are used. The linear speedup in this experiment is encouraging… it remains to be tested in a wide variety of situations to see if speedups are this good in general. The parallel GC isn’t enabled by default and it requires a special setup to be run. I will inform the ML as soon as a generally usable version is available, probably in the next few weeks. Another noteworthy news is that the new GCC version 6.1.0 does a very good job compiling C code generated by gsc. The test4 (which tests the performance of the interpreter) runs about 20% faster than with GCC version 5. Compilation time is also improved… a “make -j8” takes 33 seconds with GCC 6.1.0 and 41 seconds with GCC 5. To install GCC 6.1.0 run the script misc/install-gnu-gcc . Finally, some of you may have noticed over the last week that Gambit wasn’t buildable from a “git clone” of the github repo. This is related to a bootstrapping problem. Since this is not the first time this has happened, I have changed the build procedure so that the latest release of Gambit (i.e. the commit with the most recent version tag, such as v4.8.5) is built first before doing the “make from-scratch”. The commands are now: git clone https://github.com/feeley/gambit.git cd gambit ./configure make -j4 latest-release ./configure --enable-single-host make -j4 from-scratch make check sudo make install So please update your habits accordingly. Marc

2 2

[TFP'16] call for participation
by Peter Achten 02 Mai '16

02 Mai '16

----------------------------- C A L L F O R P A R T I C I P A T I O N ----------------------------- ======== TFP 2016 =========== 17th Symposium on Trends in Functional Programming June 8-10, 2016 University of Maryland, College Park Near Washington, DC http://tfp2016.org/ The symposium on Trends in Functional Programming (TFP) is an international forum for researchers with interests in all aspects of functional programming, taking a broad view of current and future trends in the area. It aspires to be a lively environment for presenting the latest research results, and other contributions (see below). Authors of draft papers will be invited to submit revised papers based on the feedback receive at the symposium. A post-symposium refereeing process will then select a subset of these articles for formal publication. TFP 2016 will be the main event of a pair of functional programming events. TFP 2016 will be accompanied by the International Workshop on Trends in Functional Programming in Education (TFPIE), which will take place on June 7nd. == INVITED SPEAKERS == TFP 2016 is pleased to announce keynote talks by the following two invited speakers: * Ronald Garcia, University of British Columbia: "Static and Dynamic Type Checking: A Synopsis" * Steve Zdancewic, University of Pennsylvania: "Type- and Example-Driven Program Synthesis" == HISTORY == The TFP symposium is the heir of the successful series of Scottish Functional Programming Workshops. Previous TFP symposia were held in * Edinburgh (Scotland) in 2003; * Munich (Germany) in 2004; * Tallinn (Estonia) in 2005; * Nottingham (UK) in 2006; * New York (USA) in 2007; * Nijmegen (The Netherlands) in 2008; * Komarno (Slovakia) in 2009; * Oklahoma (USA) in 2010; * Madrid (Spain) in 2011; * St. Andrews (UK) in 2012; * Provo (Utah, USA) in 2013; * Soesterberg (The Netherlands) in 2014; * and Inria Sophia-Antipolis (France) in 2015. For further general information about TFP please see the TFP homepage. (http://www.tifp.org/). == SCOPE == The symposium recognizes that new trends may arise through various routes. As part of the Symposium's focus on trends we therefore identify the following five article categories. High-quality articles are solicited in any of these categories: Research Articles: leading-edge, previously unpublished research work Position Articles: on what new trends should or should not be Project Articles: descriptions of recently started new projects Evaluation Articles: what lessons can be drawn from a finished project Overview Articles: summarizing work with respect to a trendy subject Articles must be original and not simultaneously submitted for publication to any other forum. They may consider any aspect of functional programming: theoretical, implementation-oriented, or experience-oriented. Applications of functional programming techniques to other languages are also within the scope of the symposium. Topics suitable for the symposium include, but are not limited to: Functional programming and multicore/manycore computing Functional programming in the cloud High performance functional computing Extra-functional (behavioural) properties of functional programs Dependently typed functional programming Validation and verification of functional programs Debugging and profiling for functional languages Functional programming in different application areas: security, mobility, telecommunications applications, embedded systems, global computing, grids, etc. Interoperability with imperative programming languages Novel memory management techniques Program analysis and transformation techniques Empirical performance studies Abstract/virtual machines and compilers for functional languages (Embedded) domain specific languages New implementation strategies Any new emerging trend in the functional programming area If you are in doubt on whether your article is within the scope of TFP, please contact the TFP 2016 program chair, David Van Horn. == BEST PAPER AWARDS == To reward excellent contributions, TFP awards a prize for the best paper accepted for the formal proceedings. TFP traditionally pays special attention to research students, acknowledging that students are almost by definition part of new subject trends. A student paper is one for which the authors state that the paper is mainly the work of students, the students are listed as first authors, and a student would present the paper. A prize for the best student paper is awarded each year. In both cases, it is the PC of TFP that awards the prize. In case the best paper happens to be a student paper, that paper will then receive both prizes. == SPONSORS == TFP is financially supported by CyberPoint, Galois, Trail of Bits, and the University of Maryland Computer Science Department. == PAPER SUBMISSIONS == Acceptance of articles for presentation at the symposium is based on a lightweight peer review process of extended abstracts (4 to 10 pages in length) or full papers (20 pages). The submission must clearly indicate which category it belongs to: research, position, project, evaluation, or overview paper. It should also indicate which authors are research students, and whether the main author(s) are students. A draft paper for which ALL authors are students will receive additional feedback by one of the PC members shortly after the symposium has taken place. We use EasyChair for the refereeing process. Papers must be submitted at: https://easychair.org/conferences/?conf=tfp2016 Papers must be written in English, and written using the LNCS style. For more information about formatting please consult the Springer LNCS web site: http://www.springer.com/computer/lncs?SGWID=0-164-6-793341-0 == IMPORTANT DATES == Submission of draft papers: April 25, 2016 Notification: May 2, 2016 Registration: May 13, 2016 TFP Symposium: June 8-10, 2016 Student papers feedback: June 14, 2016 Submission for formal review: July 14, 2016 Notification of acceptance: September 14, 2016 Camera ready paper: October 14, 2016 == PROGRAM COMMITTEE == Amal Ahmed Northeastern University (US) Nada Amin École Polytechnique Fédérale de Lausanne (CH) Kenichi Asai Ochanomizu University (JP) Małgorzata Biernacka University of Wroclaw (PL) Laura Castro University of A Coruña (ES) Ravi Chugh University of Chicago (US) Silvia Ghilezan University of Novi Sad (SR) Clemens Grelck University of Amsterdam (NL) John Hughes Chalmers University of Technology (SE) Suresh Jagannathan Purdue University (US) Pieter Koopman Radboud University Nijmegen (NL) Geoffrey Mainland Drexel University (US) Chris Martens University of California, Santa Cruz (US) Jay McCarthy University of Massachusetts, Lowell (US) Heather Miller École Polytechnique Fédérale de Lausanne (CH) Manuel Serrano INRIA, Sophia-Antipolis (FR) Scott Smith Johns Hopkins University (US) Éric Tanter University of Chile (CL) David Van Horn (Chair) University of Maryland (US) Niki Vazou University of California, San Diego (US) Stephanie Weirich University of Pennsylvania (US)

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Gambit-list Mai 2016