Topic
- Scheme Workshop 2003
- 2003/11/07
- Notes by Jay McCarthy <jay@kenyamountain.com>
- They are a best effort.
- If you have a problem please email me.
- PLoT Scheme
- Alexander Friedman and Jamie Raymond
- Presentation by Alexander Friedman
- Scientific plotting in Scheme
- Features
- 2D Plotting
- 3D Plotting
- Curve Fitting
- Extensible in Scheme
- A Plot Item: Your data and how you want to see that data
- Examples
- 2D plots can display 3D-ish with colour intensity
- Can do parametric functions
- Extending PLTPlot
- Does not have 3D parametric renderer... maybe you want one?
- Conclusion
- Use PLPlot to do low level rending and math
- Doesn't do sampling though.
- But does have nice curve tracing.
- PLT Scheme
- MzScheme allows cross-platform FFI support
- DrScheme makes its easy to embed images in the environment
- Related Work
- GNUplot
- Reasonable functionality
- Homegrown language
- Difficult to extend
- Many limitation
- OCamlplot
- Future Work
- Different output formats
- More plot types
- DrScheme plot environment
- OpenGL
- Version 1.0
- Will be available on the PLT Scheme web site
- We would like user feedback
- Questions and Answers
- PLPlot isn't written in Scheme. PLTPlot is a wrapper.
- Look into Guppi for GNOME
- OpenGL isn't a plotting package, but does have polygons, consider SVG?
- PICBIT: A Scheme System for the PIC Microcontroller
- Marc Feeley and Danny Dube
- Presentation by Danny Dube
- Implement Scheme on a microcontroller
- Previous Work
- BIT, very very small scheme. Simple but full-featured.
- Ran on the LEGO Mindstorms block
- Ran on the Z8 Encore
- Objectives
- Target PIC microcontrollers
- Provide almost full Scheme... R4RS
- Fit in 2 KB of RAM
- Faster than BIT
- Conventional GC
- Tail recursion in constant space
- Safe-for-space closures and continuations
- Implementation
- Object representation
- Same size and allocated.
- "Complex" objects link things together
- Vectors and strings are trees
- The strings make a point of using every field... this complicates the GC
- Choosing the sizes was very particular
- 3 byte objects
- One 2 bit tag field
- Two 11 bit value fields
- and, difficult to experiment
- Garbage Collector
- Deutsch-Schorr-Waite marking algorithm
- Reverses the pointers of the object
- Needs 2 bits per object
- Virtual Machine
- Register based
- Continuations are 2 object structures linked together
- This is a reason why it is profitable to have objects with 3 fields rather than 2.
- The Compiler
- Converts into C which is compiled to executable
- Performs some optimizations
- Variable elimination
- Constant propagation
- Copy propagation
- Dead code elimination
- Keeps track of live variables (safe-for-space)
- generates the byte-code, the ROM heap, etc.
- Results
- Benchmark programs
- Space requirements
- The minimum space requirement is effected mainly by the runtime in C, not the program in Scheme.
- Larger byte-code than that of BIT
- Execution Speed
- PICBIT was not faster than BIT
- It is disadvantaged though, it has a smaller heap.
- When PICBIT uses inlining of functions it is much faster than both BIT
- GC Performance
- Size of sweep phase is proportional to the size of the heap
- Photovore on PICBIT
- Future Work
- Integrating control-flow, type, and escape analyses
- Inling
- Unboxing
- More aggressive elimination of variables
- Conversion of heap allocations into static or stack allocations
- Stripping of useless services in the C runtime
- CDR-coding of vectors and string
- Remove need for tree structure
- Demo by Marc Feeley
- "Applause at 38 line program, thank you very much."
- Questions and Answers
- How could you try this out?
- $10 PIC, $30-$100 Programmer, but $800 C compiler
- How do you get roboticists to use it?
- Dot-Scheme: A PLT Scheme FFI for the .NET Framework
- Pedro Pinto
- Presentation
- Use a .NET assembly from Scheme is simple
- import-assembly generates Scheme wrappers
- How does it work?
- PLT Scheme can use extensions written in C/C++
- Dot-Scheme uses Managed C++ to implement an extension
- Provides low-level access to .Net
- Marshalling
- Simple things are copied.
- GC prevents direct use of .NET references
- .NET references and their types are instead stored in an internal map.
- An integer key is packaged in an opaque Scheme type, registered with the Scheme GC, and returned.
- Not much is needed beyond dispatch
- import-assembly is a straight forward macro
- dispatch examines meta-data and generates Scheme wrappers
- Wrappers hide usage of dispatch. Types and methods are renamed to avoid name collisions
- Not rocket science
- 1200 lines of MC++
- 700 lines of Scheme
- Simple Minded Implementation
- .NET presents an opportunity
- It is fast becoming the binary standard on Windows
- A .NET FFI
- Easy to implement
- Comprehensive
- Naturally used in Scheme
- Implementors
- Stop worrying about COM or C FFIs
- Instead
- Port dot-scheme
- Roll your own FFI over the weekend
- Either way you will succeed
- Questions and Answers
- Is .NET tied to Windows OS?
- Features?
- Example was SOAP but everything is available
- No performance measures
- How do you handle typing ambiguities? Number to what?
- From Python to PLT Scheme
- Philippe Meunier and Daniel Silva
- Presentation by Daniel Silva
- Motivations and Goals
- Motivation
- DrScheme is good PDE
- Python is popular
- Python should map easily
- We want DrScheme (with tools) and Python (with libraries)
- Goals
- Support Python
- Support DrScheme
- Support CPython FFI
- Experimental
- Assumptions
- MzScheme
- First class, dynamic namespaces
- Hash tables
- Pythons
- First class, dynamic modules
- Dictionaries
- Spy Structure
- Standard compiler but it creates more than just S-exprs (properties about origin)
- Translations and Problems
- Functions
- Classes
- Problem
- Python OO system is completely dynamic
- Objects are hash tables
- Attribute access is syntactic sugar
- Classes are mutable as well
- MzScheme classes are immutable
- Mixins create new classes
- Multiple inheritance in Python vs. Single in MzScheme
- Solution
- Create a new Python object representation in Scheme
- Python objects/classes are not Scheme objects/classes
- Modules
- MzScheme modules are incompatible
- No cycles
- No assignment across modules
- Namespaces support assignment across namespaces
- So, Python modules are translated using MzScheme namespaces
- Status
- Language
- Runtime Library
- Too much boring work to be re-implemented
- addition, subtraction, etc
- Strategy: use CPython's standard modules
- C Extensions
- Experimental support
- CPython's stringobject.c loads (and works) correctly
- Still work to do on a simple tool
- Performance
- Horrible (3 orders of magnitude slower)
- Too many indirections
- Very inefficient runtime library
- No optimization yet
- DrScheme Tools
- Works
- Check (well-formed) syntax
- Test Coverage
- Do not work
- MrFlow
- No type-based flow information for primitives yet
- Stepper
- No decompiler yet
- Unlikely to do
- Debugger
- Spy can be instrumented to work the debugger
- Not yet done though
- Future Work
- Comprehensive Python language support
- Full C extension compatibility
- Simple Python <-> Scheme interoperability
- Conclusion
- Spy interprets most of Python
- Connects communities
- Questions and Answers
- Why are you implementing returns as escape continuations?
- Why are you implementing Python as opposed to interface with CPython
- That would be easier but the goal is to not modify DrScheme
- Do Python tail calls get optimized?
- Does the Python language have any pedagogical value?
- BREAK
- How to Add Threads to a Sequential Language Without Getting Tangled Up
- Martin Gasbichler, Eric Knauel, Michael Sperber, and Richard Kelsey
- Presentation
- How can you get tangled up?
- We shall use continuations to represent processes - Mitch Wand (1980)
- Myth: Threads = Continuations - Olin Shivers (1997)
- (spawn thunk)
- Spawn creates a new thread which calls thunk
- People have tried this and people do it different ways.
- Talking about interaction between having Threads and Sequential Scheme
- The term "thread" is very vague
- Parallelism
- Finish sooner, doesn't do anything
- Or maybe you want to interact with the threads
- This makes the issue complex
- Where do you run into trouble?
- state
- add semaphores
- not talked about
- I/O
- implementation issue
- not talked about
- dynamic context
- Dynamic Context
- R5RS doesn't really talk about dynamic context much.
- Part of a continuation is where the value goes.
- The OTHER part is anything else that's not about where the value goes.
- That part is the dynamic context.
- Jump into the current dynamic context and go run some code, then come back
- Two versions of spawn
- (spawn-child thunk)
- Uses the dynamic context when it was created and uses that in the new thread.
- (spawn-top)
- Uses the highest level dynamic context
- So what IS the dynamic context?
- current input and output ports
- dynamic-wind state
- random extensions
- What is dynamic-wind?
- (dynamic-wind before-thunk thunk after-thunk)
- Runs all the thunks.
- Interacts with call/cc so that every time you leave thunk you run after-thunk; and every time you run thunk you first run before-thunk
- What is this for?
- Make sure certain things are protected when you do throws.
- Contract
- All the before have been called and all the afters will be called
- Point 1
- (spawn-child thunk) needs to do some winding when it first runs.
- Run the before-thunks up until the point you're at
- Uses of dynamic-wind
- maintaining the fluid environment
- finally clauses
- preventing continuation re-use
- When we use threads - do we really want to run the winds?
- Orthogonality requires winding on thread switch (fluid enviornment)
- Orthogonality rules out winding on thread switch (finally)
- Point 2
- Switching threads must change the dynamic environment but not wind or unwind.
- The dynamic environment and the dynamic-wind point must be distinct
- Our threads cannot be build on top of call/cc
- Because that always does winding.
- The question is not, are threads continuations in the general sense - Are they in the Scheme sense?
- Digression
- What happens to unwinds of threads that aren't run?
- When you kill a thread, you want to run the unwinds - but who does it? The thread that you killed?
- This is primarily an issue when you want threads to be totally independent
- Threads are very awkward.
- What IS a thread anyways?
- A raw continuation
- A dynamic environment
- A dynamic-wind point
- Thread Local Storage
- (make-thread-call default) -> thread-cell
- (make-thread-ref thread-call) -> value
- (make-thread-set! thread-cell value)
- These thread cells don't follow continuations... so continuations can't use them.
- Thread is so vague. Do you get it?
- To inherit or not to inherit thread-cells?
- What is intent behind creating a thread?
- We know what is in the initial dynamic context
- Questions and Answers
- When you remove a thread?
- This causes something to happen.
- We want the ability to provide the initial value for something (current-dynamic-context)
- This is a good reason that dynamic-wind is strange
- A big problem with call/cc is that you only have one model of threading.
- Unwind-protect in portable Scheme
- Dorai Sitaram
- Presentation
- Visual representation of control flow in a running program
- Simplest is a point
- A great height, or waiting to be refine
- A sequence of subprograms: A tree of triangles
- Control tree
- Dynamic extent and dynamic context
- Control flow = depth first traversal of tree
- Tail-call optimization
- First order control
- Jumping to a node from anywhere within its dynamic extent
- Cannot jump to it from outside its dynamic extent. Exited dynamic extent can't be re-entered.
- The full control tree with triangles is too cluttered. Let's just stretch out the triangles into a line, and a start a fresh line following each control jump.
- Loss of information, but no big deal.
- Order doesn't necessarily say if something is within the dynamic extent
- un-wind protect
- First order control
- U: 1st node = protected code; 2nd node = postlude
- Postlude is used to perform cleanup actions reliably
- This puts the postlude in between first-order control jump points above the protected point
- What happens with higher order control?
- You can re-enter exited dynamic extent
- call/cc - provides user access to context as "continuation"
- Drawing this gets pretty messy.
- Constraining call/cc
- call/cc is powerful but messy if used straight
- Constraining call/cc's possible with the cob technique (Friedman & Haynes '85)
- let-fluid
- Works when there is no non-local control
- But a control jump should reinstate target's fluid-environment
- How do figure out what postludes have to be run when you're doing jumps?
- Friedman-Haynes Policy
- FH1 - Postludes from source to closest common ancestor of source & dest'n nodes.
- FH2 - Postludes that are ancestors of source node AND descendants of dest'n nodes.
- Problems with Friedman-Haynes Policy
- FH2 - A lateral jump could be the final jump out of the unwind-protect
- FH1 - An upward jump may not be the final jump. It could be a minor excursion.
- Pittman's Alternatives
- Problem with Pittman Policies
- P1: Full continuation may sometimes need to trigger postludes.
- P2: A continuation may need to trigger a postlude without forcing it to be the last use.
- Moral
- Many unwind-protects are possible, each of them reasonable
- We need to be able to provide all of them
- cobs help implement all them
- Moral 2
- call/cc and cobs are sufficient. Scheme doesn't need to consider different paterns
- Other policies
- dynamic-wind
- varieties of unwind-protect with dynamic-wind
- dynamic-wind itself definable with call/cc + cob
- cob technique is general, not just for unwind-protect.
- Questions and Answers
- "Do you have the same problems with cobs because they are not composable?"
- Didn't try this so no comment.
- LUNCH
- Enabling Complex UI In Web Applications With send/suspend/dispatch
- Peter Walton Hopkins
- Presentation
- Demo the addition server... the Hello World of continuation servers
- Working on new version of CONTINUE A full Web Application
- Elements
- Tabs
- k-url + ?tab=1 + ?tab=2 + ... + ?tab=n
- Column Headers
- Paper Titles
- Anchor URls: k-url + ?query-string
- Goal: Make these elements reusable.
- Combing elements is nontrivial
- Did they user click on the tab or the paper title?
- Just use (cond ...)
- For every page, additional URLs must be matched by additional dispatching
- send/suspend is a barrier to reusable UI
- Conceptually, we want three separate "virtual" continuations on top of the one continuation
- Virtual continuations split apart between trigger and execution
- The end point code must know what can come in.
- Limitations
- Unclear control flow
- maintenance and update problem
- Cannot "drop-in" UI elements
- Connect the triggers and execution...
- With send/suspend/dispatch!
- You get an "embed/url" procedure rather than k-url.
- You get to imbed a piece of code into a URL.
- One function can completely handle the tab UI elements.
- Can be dropped in to any exist page.
- No more dispatching!
- Contracts for Functions
- send/suspend: (URL -> page) -> request
- send/suspend/dispatch: (embed/url -> page) -> any
- embed/url: (request -> any) -> URL
- Questions and Answers
- This is about leakage containment.
- All done on server side?
- Have you played with encapsulating Javascript?
- How do you manage the storage of the lambdas?
- send/suspend takes care of it.
- Only one continuation?
- Just one and then look up the hash table.
- Or you could create one continuation for each configuration and pick the best one
- [Demo] Groupscheme
- Kenroy Granville
- What is it?
- Open source project.
- Tool to develop groupware tools.
- Not, groupware tools to develop in Scheme.
- Demo
- Questions and Answers?
- How portable?
- Does eval exist in Java?
- Was there anything in Scheme made it particularly suitable for this application
- Not really, use of JScheme was essential.
- What's the lesson to be learned? What didn't Scheme have during the process?
- Only speed is noticeable.
- [Demo] Orion - a window manager for X11
- Martin Gasbichler
- Presentation
- Implemented as a term project, written in Scheme.
- Implements 4 different policies.
- Implementation
- Runs on top of scsh
- Uses Xlib bindings (scx)
- Concurrent
- First thing to ever get more stable when adding concurrency.
- Uses CML port of scsh
- 4400 lines of code
- Demo
- Policies
- Switch Policy
- Like ion without divisions.
- Split Policy
- Move Policy
- Lets you move windows and resize them
- Workspace Policy
- Allows multiple workspaces each in Split or Move
- Every policy can contain another
- Allows you to emulate other window managers by combinations.
- Questions and Answers
- Well-Shaped Macros
- Ryan Culpepper and Matthias Felleisen
- Presentation by Ryan Culpepper
- Introduction to Macros
- Macros are rewriting rules on synax
- R5RS Scheme specifics a pattern based macro system: syntax-rules
- We do not handle programmed macros.
- Definition example
- Macros can go wrong
- Suppose you have the increment operator.
- (++ (vector-ref v 5)) does what?
- This is ill formed syntax.
- This violates the implicit contract
- How do you say that a macro had an error?
- Compare to Type Systems
- Type system reason before run time about classes of values
- We want a system that reasons before expansion time about macros.
- Would it be useful?
- Model Language
- A program is
- macro-definitions
- definition-or-expression
- Limit primitive syntax to define, lambda, quote
- We can immediate tell what is a define and what is a macro.
- Macro definitions
- Annotations on syntax-rules => "syntax-laws"
- for class of syntax produce
- for class of syntax expected by each pattern variable
- Basic classes of syntax
- Consider define and quote
- define consumes an identifier and an expression and produces a definition
- quote consumes any S-expression and produces an expression
- The basic classes of syntax...
- Shape Types
- The type language should also describe macro types
- identifier expression expression -> expression
- basic type t ::= identifier | expression | definition | any
- shape type s ::= () | (s . s) | (cases s1 s2) | (s1 ... s2)
- cases
- Union types
- Arise in three places
- macro clauses
- sequences
- explicit guards
- sequences
- Ellipses are modeled as sequences
- Checking Programs
- Structural type checking
- Type of term is simply computed from types of subterms
- Can we do this for macros?
- Dirtiness
- Cannot throw away shape information
- The context of a term indicates what shape it must have
- Shape Checking
- Build up canonical shape type of term
- Subtype relation on shapes takes place of deterministic simplification
- To check a top level form
- computer its shape type s, and
- check s <= (cases expression definition)
- To check a macro definition
- for each template, compute its shape type (based on the guards)
- compare each shape with the declared result type of the macro
- Subtype relation
- Relation is intuitive for cases, pairs, basic types
- Relation extended to sequences through
- (s1 ... . s2) = (case s2 (s1 . (s1 ... . s2)))
- Get infinite paths if you do it wrong
- Implementation
- Mostly turn the rules upside down and match
- Two interesting points
- pair-match contexts
- (a (cases b c)) <= (cases (a b) (a c))
- recursive sub-typing for sequences
- Related and Future Work
- Related
- Cardelli, Matthes, and Abadi consider macros as parse extensions, but only check whether extensions form well-defined grammar
- Ganz, Sabry, and Taha created MacroML, which requires explicit specification of binding relationships and other properties at macro application sites
- Through away the ambiguous ()'s
- Future
- Investigate soundness for shape checking
- Remove restrictions on the language of the model
- Question and Answers
- What about macros that expand into uses of themselves? How to define their shape?
- Seems like the Lisp and Scheme have an aversion to BNF. You're forcing me to annotate the implicit BNF. Same problem is awfully relevant in preserving the validity of XML transformations. Maybe Scheme can steal from XML?
- Aware of XML work, but not really useful to steal.
- How does type inference work? Do you do it?
- You don't do it, they are either expression or definition.
- This doesn't have anything to do with checking values, just shapes.
- Recursive use
- Define the type for the whole thing
- Can you do type reconstruction and mix unannotated and annotated macros?
- [Demo] FatherTime
- Greg Cooper
- Presentation
- Longer version tomorrow at LL3
- Goal
- Provide better linguistic support for applications that depend on time or need to interact with outside environment.
- Approach
- Take ideas from as far back as dataflow languages up to Haskell
- Functional reactive programming
- Problem
- (current-seconds) is very inconvenient
- Timers, out of date, etc.
- The time should just be a value
- Solution
- Language level in DrScheme programming environment
- seconds always has a value and it changes over time
- It's time varying nature effects anything that touches it!
- Very strange to work with!
- Time varying entities are called signals
- Animation is a good use
- By making signals values you can have interesting abstractions on them
- Ignore polling and waiting and such things.
- Signals in UI
- Defining what messages should be, etc.
- What about other time sensitive things that are discontinuous like button clicks?
- Build continuous things out of them by remember intermediate values
- No callbacks or state anywhere!
- Questions and Answers
- How does this differ from what's being done in Haskell? Why is Scheme better or worse?
- Scheme is not pure so we can use indiscretions where they are useful.
- Interaction is inherently impure.
- Completely event driven - no polling unlike in Haskell
- What happens when you mix those values with side effects?
- If you get an exception then it's taken care of it :P
- Not to try and program state! Model state and not think about it except for explicit points
- Just continuations and macros
- Actually no continuations!
- BREAK
- Porting Scheme Programs
- Dorai Sitaram
- Presentation
- Some ways to write portable Scheme code
- Write in your preferred dialect and expect it to take over the world.
- Or expect users to be interested enough to port to their dialect.
- Avoid dialect dependencies. Use standard Scheme!
- Embed dialect-conditionals in the code.
- Ideal situation
- Write preferred dialect with no limitations.
- Users should be able to run the code in whatever dialect she wants.
- The joy of s-expressions
- Above goals are not mutually exclusive.
- Make dealing with dialect dependencies a program of its own
- Some can be automatically resolved
- What scmxlate provides automatically?
- Definitions for non-standard things that everybody uses, e.g. file-exists? delete-file
- Known aliases
- The infinite variety of define-macro variants
- Common Lisp (at least for packages that don't use full continuations)
- All of the above plus,
- Use bound-variable analysis to figure out where to insert function and function
- (let loop ... ) into tail-recursive loops.
- Not all dependencies can be anticipated though, so you need to extend it
- Specifying a configuration for a package
- How a user installs a scmxlate configured program
- Probe for system, dialect, etc
- Creates a version of the program.
- What is a dialect configuration file?
- Add code to program file
- Just put them in the dialect configuration file
- They will go at the head of the output
- Or at the end if you use a scxmlate directive
- Substitute bits of code
- Conditionals
- Limitations
- Input file should be definitions and other top-level expressions
- This means it cannot be a module
- But the output can be a module
- Directory structure is very gross
- Output code can be seriously unnatural-looking, especially if the output language is Common Lisp
- Additions to R*RS and improved library support for the various Scheme dialects can obsolete scmxlate (e.g., SRFIs, SLIB.) But that's probably welcome. Until then...
- Questions and Answers
- Can it run in itself?
- It is always standard Scheme, so there's no reason.
- It also runs in both Common Lisp and Scheme
- Doesn't transform Common Lisp to Scheme
- What about macros?
- Just means you have to work harder.
- scxmlate is incredibly naive and lazy.
- You don't seem to care about hygiene?
- It's a generational thing.
- [Panel] Scheme standardization
- Panel Participants
- Alan Bawden
- Will Clinger
- Richard Kelsey
- Marc Feeley
- Mitch Wand
- Origins
- Back in 1984 the was a editoring process created
- A mailing was created: RnRS
- Some face to face meetings
- In face to face meetings things had to be unanimous
- This was good to deal with the incredibly vague idea
- If you were in the room, you knew the language wouldn't change in a bad way
- This led to incredible inertia and a long turn around... R5RS took a long time
- After the last Scheme Workshop, the editing process needed to be modified
- New model
- The Steering Committee is supposed to give legitimacy
- Put some graybeards on it
- The Editors are appointed by the Steering Committee
- Words about new charter
- The technical content is secondary to the new process around the work.
- The process is incredibly important and needs to be legitimate.
- That's the only thing that really matters.
- Perceived legitimacy though. And this is normally hereditary.
- Old model was very flawed
- The "Authors" were people who showed up
- The "consensus" idea at the first meeting wasn't meant to be unanimity.
- You couldn't move forward when there were two reasonable philosophies that were mutually exclusive.
- The IEEE standard process has stagnated and not really useful.
- Best suited for ratifying an existing standard, not design.
- The SRFI process is very great, but it can't do anything
- Too many people fighting over ideology
- Scheme Workshops had enough history and participation, so that they could usurp the wedge R*RS process.
- This is where we are today.
- The Charter doesn't do everything
- Goal
- Sometimes you need one idea of how to move forward, rather than twenty.
- Legitimacy of the Process
- Laid out in the Charter, but it needs to be given by the choice of the Committees and Editors
- The Strategy Committee should draw up a nomination process.
- Some people should be responsible for looking for responsible people wrt the IEEE.
- Problem is that IEEE has its own rules and not as free as R5RS.
- Suggestion: Hereditary Monarchy is not a good process, it should be technical merit.
- Why the random selection of dubious topics in the charter?
- Will the old editors be resistant?
- SK: Who cares! They haven't been around for the last 10 years.
- These committees are rather large and numerous. They take people out of circulation.
- 3 editors and 5 steerers? Or 5 editors and 3 steerers?
- Editors group shouldn't be smaller that the Steering board.
- Divide up the later better.
- Editors will do the most work.
- Steering board should be made up of older editors.
- Maybe there should an old editor on the editor board to give experience
- Maybe the old editors should pick the steering board and editors board.
- SK: Ignore the steering committee, they won't do anything.
- Maybe the editor-in-chief should sit on the steering committee?
- They'd communicate better and dissolve power struggles.
- Why are their no elections or feedback between community and committee?
- Need to close the door, stop talking and being bureaucratic and pick some people.
- Democracy the wrong model here.
- An election right here wouldn't even be very democratic.
- The legitimacy of the group will be defined by the technical merit of their results.
- The Strategy Committee will appoint the initial Steering Committee and Editorial Board.
- Are there any downsides?
- Too late to not trust them.
- RESOLVED!
- Number of each committee is up to the Strategy Committee.
- Criteria
- Volunteers, Nominations
- Technical Merit
- Enough time
- Motivated
- The committees will be announced in 2 weeks.
- Is the Authors List to be continued? Or will it be left behind.
- Continued to be used for it's current purpose (nothing.)
- Basically: No.
- Should there be a Standard Document and Standard Rationale Document?
- Topics
- Core Language vs. Libraries
- You have to be clear that something is a core language or a library.
- The Editors need to be clear about this, not the suggester.
- Objection to idea
- Premature to discuss concrete goals
- This is a rare opportunity to discuss things because the community is not often together in one room.
- How to promote and push progress
- People who impede the process can just be removed.
- The smaller number avoids the old issue.
- How to keep the community involved in the process
- Hard to define, but the SRFI process is explicitly mentioned.
- There is a 6 month period for the Scheme community to comment on a proposal.
- The community has ultimate veto power - they don't have to use it.
- Not to mention, they can create another coup like this one.
- Implementations need to be happy with the report, and by proxy their users.
- There is a decade of changes that will be difficult for users and implementors to face.
- Is comp.lang.scheme a good place to discuss?
- Is a mailing list better to keep out the trolls?
- The Editors can solicit advice from the community in any way.
- Shouldn't be inane though, they are editors for a reason.
- The community wants read only archive to discussions.
- Time Periods seem a bit artificial
- Maybe it should be linked to finished features and units of work.
- Document repository
- Legitimacy
- We need to get major users and implementors to go along with the result.
- Support the committee without regard to philosophical disputes.
- This sort of thing always just works out though.
- Implementors are answerable to their users.
- If the users want it then the implementors implement or die.
- Are people happy with the Strategy Document?
- Maybe minus the goals?
- This doesn't imply being bound to the document.
- Does the community believe in the group?
- What makes this system work where they other failed?
- Lots of people in the past felt like there was no point to work on things
- Because the old process had died. It felt like there would be no R6RS.
- But now with a rejuvenated process people should get more excited.
- Will this report be named R6RS?
- Technical Topics
- Why the listed goals were there
- Re-assure people that the current R5RS wasn't going to be destroyed.
- To suggest that it will be evolved.
- Not "Open Season"
- Don't take them too seriously.
- List Goals
- Portable Code
- Module System
- Is this a low level or high level issue?
- Something like PLT or Scheme-48 module system
- Standardize amongst the implementors?
- New Macro System
- Designate Library Modules
- Suggested Goals
- Abstract Data Types
- This question is what stopped records in the past.
- New Non-Forgeable datatypes.
- Arrays (Multi-dimensional)
- Arrays have evolved and everything else is expressed as them.
- Some variants do them "good" with uniform types
- Others go into the cave of vectors and lists.
- Seems like something that should be in the language.
- Better definition of constant values
- Editor's Note: This was raised earlier one but never discussed.
- SK: A recommendation: Every change should take into consideration the ability to have reasonable static type checking systems.
- MF: I would like to an operational semantics for Scheme. We are capable and should hold ourselves to a high standard.
- What are the 10 years of changes that need to be changed?
- What extent of backwards compatibility with there be?
- You have to allow incompatibility to bring the language forward.
- If we could get portability without changing implementations we would already have it.
- Specifying something more will not break when it is not specified at all.
- Backwards compatibility means two things
- Breaking portable code
- Breaking non-portable code
- SK: Don't want to become Common Lisp.
- There will be pain! But it's good for you.
- How does Common Lisp governing work?
- So we know what to avoid.
- Most design happened before committees were made.
- "If a little feature didn't make the language a whole lot worse, then it's not worth fighting to keep it out"
- Law of inconsequential degradation
- How does the Haskell process work?
- Truly different syntax that was some how resolved.
- Don't want to follow the model of shutting out implementations