gmane.comp.lang.racket.announce

Fixed Racket v5.2.1 Installers

Eli Barzilay — 2012-03-26T20:44:10

Dear Racketeers,

We have just released a DrRacket version 5.2.1 that starts fine today.
The fixed version has replaced the 5.2.1 installers.  This version and
the original 5.2.1 differ only in this one fix.

Today's DrRacket problem

Matthias Felleisen — 2012-03-26T14:45:27

Dear Racket users, 

Many of you noticed that DrRacket v5.2.1 refused to launch today,
March 26.  We sincerely apologize for this inconvenience.

The problem is due to a so-called "Easter egg", which is a visual
surprise that one developer builds into the code for the others and
our users -- a tradition going back to the early days of our
project. The bug affects only DrRacket, no other Racket software.

As far as version 5.2.1 is concerned, the bug will disappear tomorrow,
but it will return later this year.  For the upcoming release -- due
out before the next "easter egg" date -- we will either install much
more reliable test methods for the Easter eggs or we will remove them
entirely.

We intend to make a fixed version of 5.2.1 available later today. In
the meantime, we offer the following workarounds for the DrRacket bug:

* Revert to version 5.2:

     http://download.racket-lang.org/racket-v5.2.html

* In your current installation of 5.2.1, navigate to the following
  folder:

     collects -> drracket -> private 

  remove the file

     drracket-normal.rkt

  and replace it with the corrected copy at

     http://www.cs.utah.edu/plt/fix/drracket-normal.rkt

* For those of you with commandline tool experience, download a Racket
  patch file from

     http://www.cs.utah.edu/plt/fix/patch-for-v5.2.1.plt

  navigate in your shell to the folder with the 5.2.1 executables, and
  install the patch with

    ./raco setup -A ....

  where .... specifies a path to the downloaded file.

As much as we prepare and test these Easter eggs, software obeys only
one law: what can go wrong will go wrong eventually. We definitely
should have been more careful.

Once again, we regret any problems we caused you today

Racket v5.2.1

Eli Barzilay — 2012-02-02T20:11:33

Racket version 5.2.1 is now available from

  http://racket-lang.org/

* Performance improvements include the use of epoll()/kqueue()
  instead of select() for the Racket thread scheduler, cross-module
  inlining of small functions, and the use of SSE instead of x87 for
  JIT-compiled floating-point operations on platforms where SSE is
  always available (including x86_64 platforms).  A related change
  is the interning of literal numbers, strings, byte strings,
  characters, and regexps that appear in code and syntax objects.

* DrRacket uses a set of composable ray-traced icons available from
  the new `images' library collection.

* Typed Racket's `typecheck-fail' form allows macro creators to
  customize the error messages that Typed Racket produces.  This is
  especially useful when creating pattern matching macros.

* The performance of Redex's matcher has been substantially
  improved; depending on the model you should see improvements
  between 2x and 50x in the time it takes to reduce terms.

* Plots look nicer and are more correct at very small and very large
  scales.  New features include customizable dual axis ticks and
  transforms (e.g., log axes, date and currency ticks, axis interval
  collapse and stretch), stacked histograms, and 3D vector fields.
  The legacy `fit' function and libfit have been removed.

* The `2htdp/universe' library's `big-bang' form supports an
  experimental game pad key handler.

* The `db' library now supports nested transactions and PostgreSQL
  arrays.  Bugs involving MySQL authentication and memory corruption
  in the SQLite bindings have been fixed.

* The Macro Stepper tool in DrRacket no longer executes a program
  after expanding it.

* In the DMdA teaching languages, infinite recursive signatures
  ("streams", for example) with no intervening `mixed' are now
  supported, and the signatures of record definitions without fields
  now have generators for use with `property'.

* MysterX's ActiveX support is deprecated and will be removed in the
  next release.  MysterX's core COM functionality will become
  deprecated in the next release, but COM functionality will be
  supported for the foreseeable future as a compatibility layer over
  a forthcoming `ffi/com' library.

[Note that mirror sites can take a while to catch up with the new
downloads.]

Feedback Welcome,

Racket v5.2

Eli Barzilay — 2011-11-10T03:16:45

Racket version 5.2 is now available from

  http://racket-lang.org/

Release Highlights:

* DrRacket comes with an experimental, on-line check syntax tool,
  although this new tool is disabled default.  See below for more
  information.

* The new `db' library offers a high-level, functional interface to
  popular relational database systems, including PostgreSQL, MySQL,
  and SQLite, as well as other systems via ODBC.

* A new XREPL collection provides convenient commands for a plain
  racket REPL.  It is particularly convenient for people who prefer
  console-based work and alternative editors.  See also the new
  chapter on command-line tools and other editors at the end of the
  Racket Guide.

* The `plot' collection has been reimplemented in Racket.  It now
  offers PDF output, log axes, histograms, and more.  Some code that
  uses `plot' will still work, and some will need light porting.
  The `plot/compat' module offers expedient backward compatibility.

* DrRacket uses more conventional key bindings: `C-t' creates a new
  tab, `C-w' closes the current one, and `C-r' runs the definitions.
  On Mac OS X, the Command key is used.  See "Defining Custom
  Shortcuts" in the DrRacket manual for an example that uses the old
  key bindings.

* The new `raco link' command registers a directory as a collection,
  which allows the collection directory to reside outside the
  "collects" tree and without changing the PLTCOLLECTS environment
  variable.

* Typed Racket:
  - Typed Racket provides static performance debugging support to
    show which code gets optimized and point out code that does not.
    Use the "Performance Report" button in DrRacket.
  - More intuitive types in printouts in the REPL and in error
    messages.  Use `:query-result-type' to explore types, or
    `:print-type' for a full printout.
  - Typed Racket now supports defining function with optional
    arguments using the same syntax as Racket.

* Redex now supports specifying (and testing and automatically
  typesetting) judgment forms including type systems and SOS-style
  operational semantics.

* Fixed several GUI problems, including problems on Ubuntu 11.10
  (GTK+ 3) and 64-bit Mac OS X.

* Internal-definition expansion has changed to use `let*' semantics
  for sequences that contain no back references.  This change
  removes a performance penalty for using internal definitions
  instead of `let' in common cases, and it only changes the meaning
  of programs that capture continuations in internal definitions.
  Internal definitions are now considered preferable in style to
  `let'.

* Support for `begin-for-syntax' has been generalized; modules may
  now define and export both value bindings and syntax bindings
  (macros) at phase 1 and higher.

  Due to a bug, phase 1 syntax (or higher) is not available in
  DrRacket's `#lang'-based REPL.  A simple workaround is to disable
  debugging in DrRacket (see "no debugging" radio button in detailed
  language dialog).


Additional Items:

* The `racket/gui' library (and Slideshow) provides more support for
  multiple-screen displays.

* DrRacket remembers whether an opened file used LF or CRLF line
  endings, and will continue using the same.  When creating a new
  file, a preference determines how it is saved.

* `net/url' can now follow HTTP redirections.

* The LNCS and JFP class files are no longer distributed with
  Racket.  Instead, they are downloaded on demand.

* The Algol language implementation is now available as a plain
  language using `#lang algol60'.

* The Racket-to-C compiler (as accessed via `raco ctool' or `mzc')
  has been removed; Racket's JIT has long provided better
  performance, and the FFI provides better access to C libraries.

* Contracts can be applied to exports with the new `contract-out'
  form within `provide', instead of a separate `provide/contract'
  form.  (The new `contract-out' form is implemented as a new kind
  of "provide pre-transformer".)

* The `date*' structure type is an extension of `date' with
  `nanosecond' and `time-zone-name' fields.

* New looping constructs: `for/sum' and `for/product'.

* Direct calls to keyword-accepting functions are now optimized to
  eliminate the overhead of keywords.  In addition, the compiler
  detects and logs warnings for keyword-argument mismatches.

* The libfit interface is available from `plot/deprecated/fit', and
  will be removed in the near future.

* The Unix installer has been re-done, and it is now more robust.

* The built-in reader and printer support for Honu is removed.
  (This functionality is re-implemented in Racket.)


On-line Check Syntax:

DrRacket now provides an on-line version of the syntax check tool,
which means that syntax checking runs automatically while you
continue to edit a program.  With this tool enabled, its annotations
(e.g., binding arrows) and actions (e.g., the renaming refactoring
and direct documentation links) are almost always available.

We have noticed that on-line syntax checking renders DrRacket
unstable on occasion, perhaps because it relies on relatively new
support for parallelism.  Occurrences of the problem are rare, but
they are not rare enough, which is why we have disabled the tool by
default.  At the same time, current users of the tool find it so
valuable that we felt it should be included in the release.  We
expect to track down the remaining problems and enable the tool by
default in near-future release.

To enable on-line syntax checking (for `#lang'-based programs only),
click on the red dot in the bottom right of DrRacket's window.  To
turn it off, click there again.


Feedback Welcome,

Racket v5.1.3

Eli Barzilay — 2011-08-16T08:05:40

Racket version 5.1.3 is now available from

  http://racket-lang.org/

This is a bugfix release, resolving the DrRacket issue with the
contour view.  In addition, two tex files with problematic licensing
were removed.

Feedback Welcome,

Racket v5.1.2

Eli Barzilay — 2011-08-03T19:36:11

Racket version 5.1.2 is now available from

  http://racket-lang.org/

* The download page includes 64-bit installers for Mac OS X,
  Windows, and two Debian flavors.  Racket now supports OS X Lion.

* Racket now includes a new `racket/place' library to support
  parallelism, complementing `racket/future'.  Racket's parallel
  build process is now based on places instead of multiple OS
  processes.

  Places support share-nothing parallelism and message-passing
  communication.  Compared to futures, places are heavyweight, but
  they have a simpler performance model.

* The syntax-certificate system has been replaced by a syntax-taint
  system.  Both certificates and taints were designed to protect
  otherwise inaccessible bindings from abuse when they appear in
  macro expansions.  Taints are simpler and lighter, and the switch
  closes known holes in the certificate system.  Macros that are not
  implemented with `syntax-rules' or `define-syntax-rule', however,
  must explicitly use `syntax-protect' to protect their expansions
  from abuse.

* The `net/url' library supports HTTPS connections, but beware that
  by default all sites are accepted (equivalent to ignoring a
  browser's warnings about untrusted certificates).

* Error messages in the student languages use a simplified
  vocabulary and consistent phrasings.  If you maintain curriculum
  material or teachpacks then please consider updating.  See the
  "Error Message Composition Guidelines" section in the
  documentation for details.

* Typed Racket: almost all core Racket data structures and
  operations are now accessible in Typed Racket (most of this work
  is due to prolific contributor Eric Dobson).  The performance of
  the typechecker has been significantly improved.

* The `scriblib/bibtex' library supports BibTeX-formatted citation
  databases in Scribble documents.  BibTeX can be tricky to parse,
  so please report failed entries as bug reports.

* The `for' forms now support an `#:unless' clause, and a
  nonnegative integer can be used as a sequence.  The new `compose1'
  function creates single-valued composition functions.  The
  `racket/function' library now provides `identity', `thunk', and
  `thunk*'.

* The license has been clarified: we now use LGPLv2.1 uniformly.
  (The license file used to specify LGPLv2, contrary to the download
  pages.)

[Note that mirror sites can take a while to catch up with the new
downloads.]

Feedback Welcome,

Racket v5.1.1

Eli Barzilay — 2011-04-30T07:07:58

Racket version 5.1.1 is now available from

  http://racket-lang.org/

* The new `racket/stream' library provides `stream-first',
  `stream-rest', a lazy `stream-cons', and so on.  Streams are a
  subtype of sequences, so they work in `for' forms.  Some sequence
  generators, such as `in-range', now produce streams.  A
  `racket/sequence' library replaces the old `racket/stream'
  library.

* The new `racket/syntax' library contains facilities useful for
  writing macros.  The new `syntax/srcloc' and `syntax/location'
  libraries provide support for manipulating source locations.

* The `racket/gui' library now supports multi-column list boxes and
  scrolling panels.

* The new `ffi/file' library is useful for writing foreign library
  bindings that cooperate with Racket's security guard mechanism.

* Generators from the `racket/generator' library can now have formal
  arguments that are used when the generator is fired up.

* Single-precision floating-point support is now enabled by default.
  Single-precision floats print differently from their default
  double-precision counterparts, new primitives convert between the
  two precisions, and new reader syntax supports single-precision
  literals.

* JIT improvements include a small change to aid x86 branch
  prediction on function-call returns, which can speed up some
  programs significantly.

* Typed Racket:
  - The numeric tower has been entirely overhauled.  TR programs can
    now use more precise types than before, and check more numeric
    properties, such as sign or range properties.
  - Fixnum optimizations have been improved and should apply more
    broadly.
  - The performance of the typechecker has been improved.  In
    particular, dispatch on large union types should typecheck much
    faster than before.

* The Stepper can now step through Lazy Racket programs.

* The `racket/future' library includes `fsemaphore' values, the
  `future' primitive no longer freezes futures (so a future can
  spawn new futures), and `future' log messages are more
  informative.

* PLaneT development links are now version-specific.

* The `2htdp/image' library now includes `overlay/align',
  `underlay/align', `overlay/align/offset' and
  `underlay/align/offset'.

* The network protocol for universes in `2htdp/universe' has
  changed, so that v5.1.1 is incompatible with earlier versions.

* The "DrScheme" application (which simply ran DrRacket in the last
  few releases) has been removed.  The "MrEd" GUI executables for
  Windows and Mac OS X have also been removed, although the "mred"
  console executable remains for Unix and Mac OS X to support old
  scripts.

[Note that mirror sites can take a while to catch up with the new
downloads.]

Feedback Welcome,

Announcing the first Racket Days

Sam Tobin-Hochstadt — 2011-03-11T17:59:31

       Calling All Racketeers!

PLT is pleased to announce the date of the first Racket Days:

        23 & 34 July 2011

The meeting will take place at Northeastern University in Boston, MA.
It will be an opportunity for developers, researchers, and educators
using Racket, DrRacket, Program By Design, and related technologies to
come together to share plans, ideas, and enthusiasm.  To make it
accessible, we will not charge any registration fees; we'll also serve
you breakfast and lunch.

Racket Days will feature presentations by key members of the
development team, including Matthew Flatt on the future of Racket and
Matthias Felleisen on the Program By Design curriculum.

Most importantly, though, we also want it to feature you.  We are
interested in presentations of any length on using Racket in
industrial software development, academic research, or education -- as
well as anything that we haven't thought of.  All sorts of
presentations are welcome, from extended tutorials to short demos to
experience reports.  Be creative!

To obtain a slot on the program, please send a title and a brief
abstract on what you would like to present to:

   Sam Tobin-Hochstadt <racket-days-GvBox1K3Ixw1Q5oZIJT9Xw< at >public.gmane.org>

Specify how much time you would like for your presentation (anything as
short as 5 minutes and as long as 30 minutes works).  We will try to
accommodate as many presentations as possible.

Further information on Racket Days will appear soon on this list.

Racket v5.1

Eli Barzilay — 2011-02-15T03:34:07

Racket version 5.1 is now available from

  http://racket-lang.org/

The most significant change in version 5.1 is a rewrite of the GUI
library:

  http://blog.racket-lang.org/2010/12/racket-version-5.html

Unix/X users will see the biggest difference with this change,
because DrRacket and all Racket GUI programs now take on the desktop
theme for menus, buttons, and other GUI widgets.

In the long run, Racket GUI programs on all platforms will improve
as a result of the library rewrite.  In the short run, beware that
this first release of a new library will inevitably include a new
set of bugs.

Version 5.1 changes in more detail:

* The `racket/draw' library -- which implements the drawing half the
  GUI toolkit -- can be used independent of the `racket/gui/base'
  library and without a graphics display (e.g., without an X11
  connection).

  The new library has one small incompatibility with the old GUI
  toolbox: 'xor drawing is no longer supported.  The new library has
  many additional features: rotation and general affine
  transformations, PDF and SVG drawing contexts, gradients, and
  alpha-channel bitmaps.

* The GRacket executable is no longer strictly necessary for running
  GUI programs, because the `racket/gui/base' library can be used
  from Racket.  To the degree that a platform distinguishes GUI and
  console applications, however, the GRacket executable still offers
  some additional GUI-specific functionality (e.g., single-instance
  support).

  The new `racket/gui/base' library includes small incompatibilities
  with the old GUI toolbox: the `send-event',
  `current-ps-afm-file-paths', and `current-ps-cmap-file-paths'
  functions have been removed.  The `racket/gui/base' library
  re-exports `racket/draw', so it includes the same drawing
  functionality as before (except for 'xor drawing).

* The new `racket/snip' library can be used independently of
  `racket/gui/base' to work with graphical editor content (e.g.,
  images in student programs).  Like `racket/draw', the
  `racket/snip' library is re-exported by `racket/gui/base'.

* The Web Server includes a backwards incompatible change that
  prevents X-expressions and lists of bytes from being directly
  returned from servlets.  This change will increase performance for
  those types of responses and allow easier experimentation with
  response types.  Please see "collects/web-server/compat/0/README"
  in the installation to learn about porting your servlets forward.
  Don't worry.  It's easy.

* The new `raco demodularize' tool collapses a module's dependencies
  into a single module comprising the whole program.  This
  transformation currently provides no performance improvement, but
  is the basis for cross-module optimization and dead-code
  elimination tools to come.  The transformation is currently useful
  for static analysis of whole Racket programs.

* The picturing-programs teachpack, formerly installed via PLaneT,
  is now bundled with the standard distribution.  Use the teachpack
  with `(require picturing-programs)' instead of `(require
  installed-teachpacks/picturing-programs)'.  The old PLaneT-based
  installation procedure still works, but it now merely installs a
  stub that invokes the bundled version.

* Slideshow picts, `racket/draw' bitmaps, and images created with
  `2htdp/image' can now be used directly in Scribble documents.
  More generally, the new `file/convertible' protocol enables any
  value that is convertible to a PNG and/or PDF stream to be used as
  an image in a Scribble document.

* The Same game sports a new look and an improved scoring system.
  (The current known high score is 12,429; can you beat that?)

[Note that mirror sites can take a while to catch up with the new
downloads.]

Feedback Welcome,

[Racket announcement] Racket v5.0.2

Eli Barzilay — 2010-11-07T05:22:31

Racket version 5.0.2 is now available from

  http://racket-lang.org/

* Typed Racket's optimizer is now turned on by default; error
  messages have been simplified and clarified.

* Contracts: contracts on mutable containers allow functions or
  other higher order values, and contracts are checked when updating
  or dereferencing the containers.  The new contracts are slower
  than the old ones, so the old check-once functionality is still
  available.

  A new dependent function contract combinator, `->i', properly
  assigns blame for contracts that violate themselves and the
  generated wrappers are more efficient than `->d'.  (Although it
  does more checking so your contracts may be faster or slower).

  See the docs for `box/c', `hash/c', `vector/c', `vectorof' and
  `->i' for more details.

* The `when', `unless', `cond', `case', and `match' forms (in
  `racket/base' and derived languages) now allow immediate internal
  definitions.

* Web server: the formlets library provides more HTML form elements;
  `make-xexpr-response' supports a preamble for DTD declarations;
  `serve/servlet' supports stateless servlets.

* New WebSocket implementation, see `net/websocket' for details.

* The new `data' collection contains implementations of several data
  structures, including growable vectors and order-based
  dictionaries.

* `racket/match' is now significantly faster

* The Racket documentations are built in parallel by default.

* The stepper is now compatible with programs using the Universe
  teachpack.

* `2htdp/image': pinholes are now supported in the library (if you
  don't use pinhole primitives you will not see them); a number of
  new triangle functions added; supports conversion of images to
  color lists and back.  Also, cropping has been improved for
  scenes; see the documentation section on the nitty-gritty of
  pixels for details.

* Signatures have been moved to ASL, BSL, BSL+, ISL, and ISL+ (HtDP
  teaching languages) no longer support checked signatures.

* Student languages: one-armed `check-error' in all levels; ASL is
  extended with hash operations, and `define-datatype'.

* DMdA languages: Checking for parametric signatures is now eager.
  This catches errors earlier, but retains the asymptotic complexity
  properties; signatures for record types now have generators;
  `list-of' and `any' signatures are now provided.

[Note that mirror sites can take a while to catch up with the new
downloads.]

Feedback Welcome,

[Racket announcement] STOP'11 Call for Papers

Tobias Wrigstad — 2010-09-17T15:38:43

Call for Papers
Script to Program Evolution (STOP)
at POPL 2011
Jan 29th, 2011, Austin, TX

Recent years have seen increased use of scripting languages in
large applications. Scripting languages optimize development time,
especially early in the software life cycle, over safety and
robustness.

As the understanding of the system reaches a critical point and
requirements stabilize, scripting languages become less appealing.
Compromises made to optimize development time make it harder to
reason about program correctness, harder to do semantic-preserving
refactorings, and harder to optimize execution speed. Lack of type
information makes code harder to navigate and to use correctly. In
the worst cases, this situation leads to a costly and potentially
error-prone rewrite of a program in a compiled language, losing
the flexibility of scripting languages for future extension.

Recently, pluggable type systems and annotation systems have been
proposed. Such systems add compile-time checkable annotations
without changing a program's run-time semantics which facilitates
early error checking and program analysis. It is believed that
untyped scripts can be retrofitted to work with such systems.
Furthermore, integration of typed and untyped code, for example,
through use of gradual typing, allows scripts to evolve into safer
programs more suitable for program analysis and compile-time
optimizations. With few exceptions, practical reports are yet to
be found.

The STOP workshop focuses on the evolution of scripts, largely
untyped code, into safer programs, with more rigid structure and
more constrained behavior through the use of
gradual/hybrid/pluggable typing, optional contract checking,
extensible languages, refactoring tools, and the like. The goal is
to further the understanding and use of such systems in practice,
and connect practice and theory.

To this end, we encourage not only submissions presenting original
research results, but also papers that attempt to establish links
between different approaches and/or papers that include survey
material, experience reports and tool demonstrations. Original
research results should be clearly described, and their usefulness
to practitioners outlined. Paper selection will be based on the
quality of the submitted material, including surveys.

Important Dates
---------------
Submission: Nov 1st, 2010
Notification: Dec 15th, 2010
Final Version: Jan 15, 2011
Workshop: Jan 29, 2011

Programme Committee
-------------------
Amal Ahmed, Indiana
Robby Findler, Northwestern (chair)
Fritz Henglein, DIKU
Gavin Bierman, Microsoft
Gilad Bracha, Cloud Programming Model
Jeff Foster, Maryland
Peter Thiemann, Freiburg
Sam Tobin-Hochstadt, Northeastern

Organizers
----------
Jan Vitek, Purdue
Tobias Wrigstad, Uppsala

Steering Committee
------------------
Matthias Felleisen, Northeastern
Cormac Flanagan, UC Santa Cruz
Nate Nystrom, UTA
Jan Vitek, Purdue
Philip Wadler, Edinburg
Tobias Wrigstad, Uppsala

Selection Process
-----------------
Both full papers (up to 12 pages LNCS) and position papers (1-2
pages LNCS) are welcome. All submissions will be reviewed by the
program committee. The accepted papers, after rework by the
authors, will be published in the Workshop Proceedings, which will
be distributed at the workshop. All accepted submissions shall
remain available from the workshop web page.

Papers should be submitted through the STOP'11 website by November 1,
2010. (http://wrigstad.com/stop11)

Questions may be directed to Tobias Wrigstad (tobias.wrigstad< at >
it.uu.se) and Robby Findler (robby-5YcgHWA4rVnfxgxxWyf0drK6bRJNSFrb< at >public.gmane.org).

______________________________________________________
Racket Announcements list
announce-GvBox1K3Ixw1Q5oZIJT9Xw< at >public.gmane.org
http://lists.racket-lang.org/listinfo/announce