• Mar 26, 2012

    v5.2.1

    Racket v5.2.1
    * 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.
  • Nov 10, 2011

    v5.2

    Racket v5.2
    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.
  • Aug 16, 2011

    v5.1.3

    Racket v5.1.3
    This is a bugfix release, resolving the DrRacket issue with the contour
    view.  In addition, two tex files with problematic licensing were
    removed.
  • Aug 3, 2011

    v5.1.2

    Racket v5.1.2
    * 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.)
  • Apr 30, 2011

    v5.1.1

    Racket v5.1.1
    * 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.
  • Feb 15, 2011

    v5.1

    Racket v5.1
    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?)
  • Nov 7, 2010

    v5.0.2

    Racket v5.0.2
    * 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.
  • Aug 4, 2010

    v5.0.1

    Racket v5.0.1
    * Datalog is a lightweight deductive database system with Racket
      integration.  It is now available in the `datalog' collection and
      with `#lang datalog'.
    
    * Racklog provides Prolog-style logic programming in Racket, adapted
      from Dorai Sitaram's Schelog package.  It is available in the
      `racklog' collection and now as `#lang racklog'.
    
    * By default `make install' and `raco setup' compile collections in
      parallel on all available processors.  (Use `raco setup -j 1' to
      disable, if necessary.)
    
    * Changes (as part of 5.0) in the `racket' language compared to the
      `scheme' language: constructor-style printing, a `struct'
      alternative to `define-struct' that fits more naturally with
      `match' and constructor-style printing, bytecode-dependency
      management via SHA-1 hashes instead of just timestamps (where the
      `openssl/sha1' library provides the SHA-1 hash function), a
      reorganization of `scheme/foreign' into `ffi/unsafe' and
      associated libraries, and new printing functions `eprintf' and
      `displayln'.  Also, a generator from `racket/generator' is
      required to have the form `(generator () body ...)', which
      supports a planned extension to let a generator accept arguments.
    
    * Changes to the `racket' language (since 5.0): internal-definition
      positions allow mixing expressions with definitions, full
      continuations can escape past a continuation barrier, custodians
      can attempt to terminate subprocesses and subprocess groups (see
      `current-subprocess-custodian-mode', `subprocess-group-enabled'),
      the JIT supports additional unboxing flonum operations and unsafe
      variants, `ffi/unsafe' provides an asychronous-call mechanism to
      deal with foreign threads, a new "." modifier for format string
      directives (e.g., "~.s" and "~.a") limits the respective output to
      `(error-print-width)' characters.
    
    * The core type system of Typed Racket has been substantially
      revised.  In particular, Typed Racket can now follow significantly
      more sophisticated reasoning about the relationships between
      predicates.  Additionally, Typed Racket now allows variable arity
      types in more places, allowing programmers to specify
      variable-arity lists.
    
    * We are working on an optimizing version of Typed Racket that takes
      advantage of type information for certain classes of programs.
      This project is a work in progress.  For those interested, see the
      documentation for `#:optimized'.
    
    * The `web-server/formlets' library adds a `formlet*' form that
      allows dynamic formlet construction, as opposed to `formlet' which
      requires syntactic Xexprs and static formlets.  Several new
      library formlets are added.
    
    * The `syntax/parse' library has new support for matching literals
      at different phases using the `#:phase' argument for literals and
      literal sets.
    
    * RackUnit now includes a GUI test runner as `rackunit/gui'.
    
    * The `2htdp/image' library now includes `flip-vertical' and
      `flip-horizontal' operations that mirror images (vertically and
      horizontally).
  • Jun 7, 2010

    v5.0

    PLT is happy to announce the release of Racket, available from
      http://racket-lang.org/
    
    With Racket, you can script command shells and web servers; you can
    quickly prototype animations and complex GUIs; regexps and threads are
    here to serve you.  To organize your systems, you can mix and match
    classes, modules or components.  Best of all, you start without writing
    down types.  If you later wish to turn your script into a program, equip
    your Racket modules with explicit type declarations as you wish.  And
    Racket doesn't just come as a typed variant; you can also write your
    modules in a purely functional and lazy dialect.
    
    Racket comes in so many flavors because Racket is much more than a
    standard scripting language or a plain programming language.  Racket
    supports language extensibility to an unequaled degree.  A Racket
    programmer knows that making up a new language is as easy as writing a
    new library.
    
    To help you start quickly, Racket includes batteries in all shapes and
    sizes, most importantly, extensive documentation and all kinds of
    libraries.
    
    Racket occupies a unique position between research and practice.  It
    inherits many major ideas from language research, among them type safety
    (when the type system says that x is a number, then at runtime it always
    is a number) and memory safety (when some memory is reclaimed by the
    garbage collector it is impossible to still have a reference to it).  At
    the same time, user demand governs rigid adherence to purely theoretical
    principles.
    
    Racket, formerly PLT Scheme, is a product of over 15 years of
    development.  Although Racket starts with a mature software base and an
    established user community, its new name reflects our view that this is
    just the beginning of Racket's evolution.
  • Apr 3, 2010