suzanne.soy/racket
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

meta/new-web: release announcements as data

Browse Source 
... instead of only git meta-data attached to tags.
This commit is contained in:
Matthew Flatt 2014-04-29 14:10:02 -06:00
parent eb006a0e9e
commit a8fc2d5ec9
23 changed files with 1034 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
pkgs/plt-services/meta/announcements/README.txt Normal file
View File

@ -0,0 +1,3 @@
The format of each release-anouncement file is the release date in
seconds (like the result of `(current-seconds)`), any amount of
whitespace, and the the release announcement.

64
pkgs/plt-services/meta/announcements/v5.0.1.txt Normal file
View File

@ -0,0 +1,64 @@
1280887792
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).

58
pkgs/plt-services/meta/announcements/v5.0.2.txt Normal file
View File

@ -0,0 +1,58 @@
1289106828
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.

36
pkgs/plt-services/meta/announcements/v5.0.txt Normal file
View File

@ -0,0 +1,36 @@
1275916233
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.

64
pkgs/plt-services/meta/announcements/v5.1.1.txt Normal file
View File

@ -0,0 +1,64 @@
1304146952
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.

52
pkgs/plt-services/meta/announcements/v5.1.2.txt Normal file
View File

@ -0,0 +1,52 @@
1312399420
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.)

6
pkgs/plt-services/meta/announcements/v5.1.3.txt Normal file
View File

@ -0,0 +1,6 @@
1313480645
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.

79
pkgs/plt-services/meta/announcements/v5.1.txt Normal file
View File

@ -0,0 +1,79 @@
1297739878
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?)

48
pkgs/plt-services/meta/announcements/v5.2.1.txt Normal file
View File

@ -0,0 +1,48 @@
1332774630
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.

132
pkgs/plt-services/meta/announcements/v5.2.txt Normal file
View File

@ -0,0 +1,132 @@
1320893942
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.

73
pkgs/plt-services/meta/announcements/v5.3.1.txt Normal file
View File

@ -0,0 +1,73 @@
1352317841
Racket v5.3.1
Racket:
* The `case' form dispatches on characters, fixnums, symbols, and
keywords in logarithmic time. (Thanks to Jon Zeppieri.)
* The new `racket/format' library provides new and improved
string-formatting functions.
* Logging tools include improved filtering support based on the name
of a logger. A new `define-logger' form simplifies the use of
named loggers. Forms such as `log-debug' now support string
formatting.
* The `for' forms now support `#:break' and `#:final' clauses.
* The new PLTCOMPILEDROOTS environment variable configures the
search path for compiled bytecode.
DrRacket:
* Check Syntax now summarizes the documentation (i.e., the blue
boxes) for the identifier at the insertion point in the top-right
corner of the definitions window.
* Check Syntax now runs continuously for programs that declare their
language within the source. This mode has been available for
several of the past releases, but now enabled by default.
* DrRacket can spell-check string constants (enable this in the Edit
menu).
Typed Racket:
* Typed Racket interprets the Any type as a different contract.
This may signal dynamic errors in some existing mixed
typed/untyped programs. The normal fix is to replace a use of Any
with a more specific types.
* NaN is included in all of Typed Racket's floating-point types,
which makes precise floating-point types easier to use.
* Typed Racket supports a `cast' operation with support for
higher-order types.
* Typed Racket provides the `:query-type/args' and
`:query-type/result' utilities to explore types at the REPL.
Miscellaneous:
* The `compatibility' collection provides features from Racket
relatives, such as `defmacro' and mutable lists. These features
are provided to ease porting code to Racket. Avoid them in modern
Racket code.
* Screenshots of the widgets provided by the Racket GUI library are
included in the documentation. (Thanks to Diogo F. S. Ramos.)
* FrTime was ported to racket lang. (Thanks to Patrick Mahoney.)
Deprecation:
The following has been deprecated and will be removed in the January
2013 release:
* the `planet' command-line tool; use `raco planet' instead.
The following has been deprecated and will be removed in the August
2013 release:
* the `mzlib/class100' library; use `racket/class' instead.

88
pkgs/plt-services/meta/announcements/v5.3.2.txt Normal file
View File

@ -0,0 +1,88 @@
1359691127
Racket v5.3.2
Core Libraries:
* The new `math' library provides functions and data structures for
working with numbers and collections of numbers. Functions include
non-elementary (such as gamma, zeta, Lambert's W), number-theoretic
(factorization, modular arithmetic), linear algebra (arithmetic,
decompositions), and statistical (expected values, order statistics,
binning). Data structures include arbitrary-precision bigfloats,
probability distributions, and multidimensional arrays.
* The new `file/untar', `file/untgz', and `file/unzip' libraries support
unpacking widely used archive formats.
* The new `lazy-require' form allows programs to delay the loading and
instantiation of helper modules until they are needed.
* The new `data/bit-vector' library provides an implementation of bit
vectors (a mutable sequence of booleans) supporting popcount.
* The `racket/generic' library allows the specification of default
method implementations for core datatypes.
* The `openssl' library can verify hostnames and use the operating
system's certificate store to verify certificates.
Package System:
* A new package system is in beta release. This system will become
Planet's successor. It differs significantly from the latter. For
details, please read the documentation at
http://docs.racket-lang.org/planet2/ and list your packages on the new
index at https://pkg.racket-lang.org/.
* The `raco test' command supports testing by collection and package, in
addition to by directory and file, with the "-c" and "-p" options.
Teaching Libraries:
* batch-io: the read and write functions work on Unix-style standard
input and output.
DrRacket:
* DrRacket's GUI is more responsive.
* The automatic parenthesis insertion mode is improved.
Scribble:
* Scribble renders Markdown format files via the "--markdown"
command-line flag. Example use case: Generate documentation hosted on
GitHub or BitBucket.
* Documentation cross-reference information is stored in an SQLite3
database, which means that SQLite3 is required for building Racket
documentation on Unix/Linux machines (but SQLite3 is included in
Racket distributions for Windows and Mac OS X).
Using a database for cross-reference information significantly reduces
the initial footprint of DrRacket, since DrRacket no longer needs to
load all cross-reference information.
Typed Racket:
* Typed Racket programs can require `plot/typed' to draw plots. List-
and vector-accepting functions accept general sequences.
* Typed Racket supports Racket's delimited continuation and continuation
mark operators.
Redex:
* Added more support for `define-judgment-form', including random
generation for well-formed judgments and visualization of judgments.
Deprecation:
The following have been removed in this release:
* the `planet' command-line tool; use `raco planet' instead.
The following has been deprecated and will be removed in the August 2013
release:
* the `mzlib/class100' library; use `racket/class' instead.

6
pkgs/plt-services/meta/announcements/v5.3.3.txt Normal file
View File

@ -0,0 +1,6 @@
1360960689
Racket v5.3.3
This is a bug-fix release to address a flaw in DrRacket v5.3.2
concerning interactions between the contour window and the syntax
coloring.

22
pkgs/plt-services/meta/announcements/v5.3.4.txt Normal file
View File

@ -0,0 +1,22 @@
1368030118
Racket v5.3.4
* Extflonums (80-bit floating-point numbers) are supported on some
x86/x86_64 platforms -- including Windows, and including platforms
where Racket is compiled to use SSE instructions for flonum
arithmetic. Thanks to Michael Filonenko.
* OS X: DrRacket and all of the other apps are now signed with an
official key.
* Tally Maze: a new game based an enumeration of 2d mazes.
* The Optimization Coach, a DrRacket plugin, has been moved from the
Racket distribution to the Racket package repository. Install it
with: raco pkg install optimization-coach
* Redex: `define-union-language' now merges productions when
languages define the same nonterminals. Thanks to William Bowman.
* The `srfi/19' library is now compatible with the date structure
type exported by `racket/base'.

7
pkgs/plt-services/meta/announcements/v5.3.5.txt Normal file
View File

@ -0,0 +1,7 @@
1371553231
Racket v5.3.5
This is a special-purpose release to match the arrival of "Realm of
Racket" in bookstores. Racket v.5.3.5 adds a single `realm'
collection to the v5.3.4 release. The new collection contains the
source code that readers of Realm may wish to use for experiments.

5
pkgs/plt-services/meta/announcements/v5.3.6.txt Normal file
View File

@ -0,0 +1,5 @@
1376138835
Racket v5.3.6
Racket v5.3.6 is a bug-fix release. It eliminates errors from v5.3.5
that people have found over the summer.

82
pkgs/plt-services/meta/announcements/v5.3.txt Normal file
View File

@ -0,0 +1,82 @@
1344312796
Racket v5.3
* Submodules are nested module declarations that can be loaded and
run independently from the enclosing module. For an overview of
submodules, see
http://blog.racket-lang.org/2012/06/submodules.html
* The futures visualizer is a graphical profiling tool for parallel
programs using futures. The tool shows a detailed execution
timeline depicting the migration of futures between threads, and
gives detailed information about each runtime synchronization that
occurred during program execution. In addition, `would-be-future'
is a special type of future that always executes sequentially and
records all potential barricades a regular future would encounter.
* Optimization Coach (formerly Performance Report) reports
information about Racket's inlining optimizations. Optimization
Coach can be launched in any language through the View menu.
* The new `images/flomap' library defines floating-point bitmaps and
fast image processing operations on them. It is written in Typed
Racket, so Typed Racket code may use it without the cost of
contract checks.
* The new `json' library supports parsing and generating JSON.
(Originally based on Dave Herman's planet library.)
* `racket/string' is extended with a set of simplified string
manipulation functions that are more convenient than using
regexps. `regexp-match*' and friends can now be used with new
keyword arguments to return specific matched regexp group/s and
gaps between matches.
* The new `racket/generic' library allows generic function
definitions, which dispatch to methods added to a structure type
via the new `#:methods' keyword.
* The `class' form supports declaring a method abstract. An
abstract method prevents a class from being instantiated unless it
is overridden.
* The contract library comes with support for interfaces, generics,
prompts, continuation-marks, and structs.
* Most error messages use a new multi-line format that is more
consistent with contract errors and accommodates more information.
* Typed Racket supports function definitions with keyword arguments;
the startup time of Typed Racket programs has been sharply
reduced.
* The new `ffi/com' library replaces MysterX; a compatibility
`mysterx' library remains, but without ActiveX support. The new
`ffi/unsafe/com' library offers a more primitive and direct way to
use COM classes and methods.
* There is now a very complete completion code for zsh. It is not
included in the distribution though; get it at http://goo.gl/DU8JK
(This script and the bash completions will be included in the
standard installers in future versions.)
--- DEPRECATION ----------------------------------------------------
Effective this release:
- The `tex2page' and `combinator-parser' libraries have been moved
from the Racket distribution to PLaneT:
(require (planet plt/tex2page))
(require (planet plt/combinator-parser))
The following has been deprecated and will be removed in the
January 2013 release:
- the `planet' command-line tool; use `raco planet' instead.
The following has been deprecated and will be removed in the
August 2013 release:
- the `mzlib/class100' library; use `racket/class' instead.

83
pkgs/plt-services/meta/announcements/v5.92.txt Normal file
View File

@ -0,0 +1,83 @@
1390668968
Racket v5.92
Racket 5.92 has a new package system, including a catalog of
hundreds of already-available packages. Please visit
http://pkgs.racket-lang.org/
for an overview of the packages.
Recent releases included the "beta" versions of the package system.
Racket version 5.92 incorporates many improvements suggested by these
preliminary experiences:
* A package is treated as a single collection by default, so it is
even easier to use a Github repository as a package. Get started
quickly:
http://docs.racket-lang.org/pkg/getting-started.html
* DrRacket includes a new package manager GUI, available via the
File|Package Manager ... menu item. The GUI is also available
as a stand-alone program via the "gui-pkg-manager" package.
* The main Racket distribution has been separated into about 200
packages. The Racket installer combines the core system with
bundled versions of these packages.
Alternatively, you may now install a Minimal Racket distribution
--- which is about 1/10 the size of the main distribution --- and
add only those packages that you need.
* Package installation supports pre-built packages that include
compiled byte code and rendered documentation, meaning packages can
be installed quickly when built versions are available. All
packages in the main distribution are available in pre-built form.
Further improvements are in the works, notably including package
documentation on the package-catalog web site.
COMPATIBILITY NOTE: PLaneT, the previous Racket package system, will
remain in place for the foreseeable future, but we expect all package
work to shift to the new system.
Beyond the package system, this release brings a number of other
changes:
* Racket's HTML documentation has a new and improved look, thanks to
Matthew Butterick.
* The documentation includes a style guide, "How to Program Racket"
http://docs.racket-lang.org/style/
* Racket's JIT compiler supports the ARM architecture.
* Racket supports the Mac's Retina display mode.
* The performance of the Typed Racket compiler improved by 50% on
some typed programs; e.g., see http://bit.ly/1d0Ye4z
* The profiler provides a new mode that uses the errortrace library
to produce fine-grained profiles.
* A new contract profiler reports how much time programs spend
checking contracts, and which contracts are most expensive.
* The math/flonum library exports fast 105-bit precision operations.
* Check Syntax handles generated identifiers, especially those
introduced by struct (e.g. field selectors) and Redex (e.g., e_1,
e_2)
* 2htdp/batch-io includes functions for dealing with html/xml in
files and web sites as X-expressions plus conveniences for
web-based graph traversals.
* The `gen:set' generic interface extends set operations to work on
user-defined types that implement set methods, as well as on other
set-like built-in types, such as lists.
* Picts support conversion to SVG format.
* Under unix, Racket provides desktop entries (.desktop files) for
its graphical executables.

19
pkgs/plt-services/meta/announcements/v5.93.txt Normal file
View File

@ -0,0 +1,19 @@
1391210625
Racket v5.93
Version 5.93 repairs a few problems with the recent v5.92 release (in
preparation for a v6.0 release):
* fixed a low-level concurrency problem with the GUI library for Mac
OS X, which especially affected 32-bit builds;
* fixed GRacket-based launchers (such as `drracket`) in a Unix-style
installation;
* expanded the list of recognized OpenSSL library versions;
* fixed small CSS problems and inconsistencies (relative to v5.3.6) in
the new Scribble style as used by the Racket documentation; and
* added the version number back to the "racket" directory within the
source distribution bundle.

87
pkgs/plt-services/meta/announcements/v6.0.txt Normal file
View File

@ -0,0 +1,87 @@
1393453108
Racket v6.0
Racket 6.0 has a new package system, including a catalog of
hundreds of already-available packages. Please visit
http://pkgs.racket-lang.org/
for an overview of the packages.
Racket versions 5.3.4 through 5.3.6 included "beta" versions of the
package system. Racket version 6.0 incorporates many improvements
suggested by preliminary experiences in those versions:
* A package is treated as a single collection by default, so it is
even easier to use a GitHub repository as a package. Get started
quickly:
http://docs.racket-lang.org/pkg/getting-started.html
* DrRacket includes a new package manager GUI, available via the
File|Package Manager ... menu item. The GUI is also available
as a stand-alone program via the "gui-pkg-manager" package.
* The main Racket distribution has been separated into about 200
packages. The Racket installer combines the core system with
bundled versions of these packages.
Alternatively, you may now install a Minimal Racket distribution
--- which is about 1/10 the size of the main distribution --- and
add only those packages that you need.
* Package installation supports pre-built packages that include
compiled byte code and rendered documentation, meaning packages can
be installed quickly when built versions are available. All
packages in the main distribution are available in pre-built form.
The recent 5.92 and 5.93 releases served as release candidates for 6.0,
and 6.0 includes a few additional repairs related to the package
system.
Further improvements to the package system are in the works, notably
including package documentation on the package-catalog web site.
COMPATIBILITY NOTE: PLaneT, the previous Racket package system, will
remain in place for the foreseeable future, but we expect all package
work to shift to the new system.
Beyond the package system, this release brings a number of other
changes:
* Racket's HTML documentation has a new and improved look, thanks to
Matthew Butterick.
* The documentation includes a style guide, "How to Program Racket"
http://docs.racket-lang.org/style/
* Racket's JIT compiler supports the ARM architecture.
* Racket supports the Mac's Retina display mode.
* The performance of the Typed Racket compiler improved by 50% on
some typed programs; e.g., see http://bit.ly/1d0Ye4z
* The profiler provides a new mode that uses the errortrace library
to produce fine-grained profiles.
* A new contract profiler reports how much time programs spend
checking contracts, and which contracts are most expensive.
* The math/flonum library exports fast 105-bit precision operations.
* Check Syntax handles generated identifiers, especially those
introduced by struct (e.g. field selectors) and Redex (e.g., e_1,
e_2)
* 2htdp/batch-io includes functions for dealing with html/xml in
files and web sites as X-expressions plus conveniences for
web-based graph traversals.
* The `gen:set' generic interface extends set operations to work on
user-defined types that implement set methods, as well as on other
set-like built-in types, such as lists.
* Picts support conversion to SVG format.
* Under unix, Racket provides desktop entries (.desktop files) for
its graphical executables.

5
pkgs/plt-services/meta/new-web/download/data.rkt
View File

@ -153,9 +153,8 @@
(λ ()
(define info (get-version-tag-info v))
(if info
(let* ([tagger (car info)]
[date (cadr info)]
[announcement (caddr info)]
(let* ([date (car info)]
[announcement (cadr info)]
[year (date-year date)]
[month (vector-ref months (sub1 (date-month date)))])
(release v date (format "~a ~a" month year) announcement))

2
pkgs/plt-services/meta/new-web/download/download-pages.rkt
View File

@ -81,7 +81,7 @@
@page[#:site download-site
#:file (format "v~a.html" ver) #:title title #:part-of 'download]{
@table[align: 'center]{
@tr{@td{@h2{Release Announcements for Version @ver}}}
@tr{@td{@h2{Release Announcement for Version @ver}}}
@tr{@td{@pre{@release-announcement[rel]}}}}
})
(define release-page

74
pkgs/plt-services/meta/new-web/download/release-info.rkt
View File

@ -1,60 +1,20 @@
#lang racket/base
(require racket/system racket/port racket/match racket/runtime-path
racket/promise)
(define-runtime-path THIS-GIT "../../../../../.git")
(define (warn fmt . xs)
(eprintf "Warning: ~a\a\n" (apply format fmt xs))
(flush-output (current-error-port))
(sleep 1)
#f)
(define git*
(lazy
(define exe (or (find-executable-path "git")
(warn "no `git' executable => no release info")))
(define (try dir) (and dir (directory-exists? dir) dir))
(define dir (and exe (or (ormap try (list (getenv "GIT_DIR") THIS-GIT))
(warn "no git dir found => no release info\n (~a)"
"set $GIT_DIR to a racket repo .git dir"))))
(define nowhere (open-output-nowhere))
(and dir (λ args (define o (open-output-string))
(parameterize ([current-directory dir]
[current-output-port o]
[current-error-port nowhere])
(and (apply system* exe "--no-pager" args)
(get-output-string o)))))))
(require racket/port)
(provide get-version-tag-info)
(define (get-version-tag-info version)
(define git (force git*))
(let/ec return
(unless git (return #f))
(define (bad . args) (apply warn args) (return #f))
(define (try fmt)
(let* ([tag (format fmt version)]
[text (and (git "cat-file" "-e" tag)
(git "cat-file" "tag" tag))])
(and text (cons tag text))))
(let* ([text (or (try "v~a") (try "old-v~a")
(bad "no git info for ~s (missing tag)" version))]
[tag (car text)]
[text (cdr text)]
[check (λ (x) (or x (bad "malformed git info for ~s" tag)))]
[sep (check (regexp-match-positions #rx"\n\n" text))]
[meta (map (λ (h)
(let ([m (check (regexp-match-positions #rx" " h))])
(list (string->symbol (substring h 0 (caar m)))
(substring h (cdar m)))))
(regexp-split #rx"\n" (substring text 0 (caar sep))))]
[text (substring text (cdar sep))])
(match meta
[`((object ,_) (type "commit") (tag ,_)
(tagger ,(regexp #rx"^(.* <.*>) ([0-9]+) ([-+]?[0-9][0-9])00$"
(list _ tagger date ofs))))
;; ignore the time offset (it probably depends on where the tag
;; was made)
(list tagger (seconds->date (string->number date)) text)]
[_ (check #f)]))))
(define (get-version-tag-info vers)
(with-handlers ([exn:fail? (lambda (exn)
(log-error "error getting v~a announcement: ~a"
vers
(exn-message exn))
#f)])
(define p (collection-file-path (format "v~a.txt" vers)
"meta/announcements"))
(call-with-input-file p
(lambda (i)
(define s (read i))
(unless (number? s) (error "release info does not start with a number of seconds"))
(regexp-match #px"^[\\s]*" i) ; discard whitespace
(list (seconds->date s)
(port->string i))))))