Re: Program compression
- From: jaycx2.3.calrobert@xxxxxxxxxxxxxxxxxxxxxx (Robert Maas, http://tinyurl.com/uh3t)
- Date: Sun, 31 Aug 2008 03:27:39 -0700
Quick summary of the topic of this thread: "program compresssion"
means using tools (such as parse-tree rewrite rules or syntax
extension rules) to allow collapsing a verbose software pattern
into a very terse expression whereby all the boilerplate of the
software pattern is gone, leaving only the variable parts plus just
enough keyword and/or syntax to trigger expansion back to the full
software pattern.
From: Jon Harrop <j...@xxxxxxxxxxxxxxxxx>The solutions are shorter in modern FPLs.OK, let's say you have a text string which contains the notation
for a nested list starting from the beginning of the string.
"The" notation? You mean Lisp's notation?
Well I suppose "the" implies that. So let me change my wording to
say instead "any reasonable notation for a nested list". By
reasonable I mean that there's some mark to show the start of each
level of list and a matching mark to show the end of that same
level of list. For example, C uses curly braces instead of parens,
and commas instead of white-space, to denote initializer data for
arrays. If that same notation were in a string instead of the right
place in an array declaration in a C source file, could you write
code to parse it into a nested list, or can you usurp the code in
the C compiler to avoid having to write new code from scratch?
Or could you write code to parse SGML or XML instead?
That's fine but it is of no practical interest because real data
is rarely already in Lisp syntax. For a more useful comparison you
must consider other formats.
Are you saying the kind of notation used in C array initializers
and XML SOAP objects is not general enough? What kind of nested
list notation would you propose as an alternative where the data
might be naturally in that form without any human intervention, or
where manual methods for data keeping by humans have had that
notation existing prior to scanning that notation to be entered
into computers, or whatever else you meant? You say what your
favorite notation for nested lists is, and if it looks reasonable
to me then I'll agree it's a valid benchmark for comparing how easy
it is to implement a parser for it (creating a DOM structure as
output) in various programming languages.
On a related question, is there *any* nested-list notation that is
commonly convertible to/rom internal DOM structure by some
available C library? For Lisp the answer is YES, namely those
s-expresssions you seem to hate. So does C even have something
comparable, never mind the perverse syntax it uses??
How about something of practical relevance: custom grammars.
Does there exist an OCaml library which converts a BNF
specification into a corresponding parser function?
Consider parsing Mathematica expressions including lists, rules,
sums, products, powers and factorials with associativity and
precedence. In OCaml:
open Camlp4.PreCast;;
let mma = Gram.Entry.mk "mma";;
EXTEND Gram
mma:
[ "rule" LEFTA
[ e1 = mma; "->"; e2 = mma -> `Rule(e1, e2) ]
...
END;;
Does there exist an OCaml library which converts a BNF specification
into the above OCaml code, which can then be compiled and executed?
Two reasons:Macros are very rare in modern languages.Why?
. Macros are used primarily to work around deficiencies in the
language's design, ...
It is impossible for a language, as delivered, as standardized, to
already contain every syntax mechanism any user-programmer will
ever want to employ to make writing code easier. Consequently every
language ought to have Lisp-style macros (parse-tree
transformations) to allow ordinary programmers to extend the set of
allowed just-right parse-tree formulations beyond those which are
supplied by the standard/vendor. It is a gross deficiency that any
language is missing such parse-tree transformation capability.
These other (non-Lisp) languages already allow user-programmers to
define new functions to extend the functions given by the
vendor/standard. The OOP languages already allow user-programmers
to define new classes with associated methods to extend the class
hierarchy given by the vendor/standard. So why don't they also
allow user-programmers to define new transformations from
source-file syntax to what-actually-gets-compiled syntax?
Just one example: The new LOOP special-form is a wonderful addition
to Common Lisp, and was implementable by ordinary user-programmers
before it became part of the standard, merely by defining a LOOP
macro to transform the LOOP special form into ordinary supported
source code. Why don't other languages allow enough user-programmer
power to define an equivalent LOOP macro and thereby allow ordinary
user-programmers to implement a LOOP special form in those other
langauges?
Using macros forks the language and makes maintenance much harder.
True, but defining functions forks the language in almost exactly
the same way. A program that calls SQRT(5) isn't a valid program
unless the library containing the SQRT function is available.
Therefore applications which depend on the availability of
externally-defined functions, and applications which depend on the
availability of externally-defined macros, suffer almost exactly
the same extra hardness of maintenance. The only difference is that
with externally-defined macros you need to make sure the
appropriate macro library is loaded at compile time, whereas with
externally-defined functions you only need to make sure the
appropriate macro library is included in the load directives (in
languages such as C which require all external symbols to be
resolved at load time) or available at runtime (in languages such
as Java which support loading new classes at runtime). In languages
where the compiler itself is just another application written in
the same language (see the other thread about how to solve the
chicken-egg problem via bootstrapping early
versions of the compiler from some other
language before closing the loop on
self-supporting compiler)
making an external library available at compile time vs. load time
or run time is a trivial distinction. Accordingly the use of macros
does not make maintenance significantly more difficult than merely
using functions or methods.
New programmers must effectively learn a new language.
The way to do that is not to try to learn the whole thing at one
time. First just learn how to install and run a "Hello World"
program. Next learn how to include most of the essential
primitives, and practice coding simple algorithms using them and
getting these algorithms to work correctly. Finally, start learning
how to use additional functions/methods/macros and special
mechanisms such as multiple return values or keyword parameters
which are useful for whatever type of program that student wants to
tackle first. Note that at this stage every student should be able
to learn new stuff in a different sequence, appropriate for what
kinds of D/P tasks that particular student is trying to program.
The key during this never-ending stage is to have the means to
efficiently explore intentional data types and the libraries etc.
that implement those data types, including information as to
whether those libraries etc. are already part of the delivered
programming environment or need to be downloaded from some Web site
and linked into the programming environment, and if download is
needed than full installation instructions that are easy for
beginners to understand. For example, if you want to tackle the
definition of a custom grammar for some problem domain, you need to
be able to find what libraries deal with custom grammers and how to
pick the most appropriate one (if there are more than one "good"
libraries) and how to make the chosen library available for use.
Tools no longer work transparently with source code.
If the source code contains declarations to cause an additional
library to be available at compile time to support source-code
parse-tree transformations, but the tool fails to notice these
declarations and hence fails to work correctly when such "macros"
are used in source code, that is a deficiency in the tool. Use a
better tool, don't cramp the language because your stupid tool
doesn't work on the full range of the language syntax.
The parse tree is no longer relevant in modern languages.
If you are going to allow user-programmers to extend the set of
parse trees that can be compiled, by adding new parse-tree
transformations, then the parse tree is totally relevant!! Just
because your favorite language doesn't support parse-tree
transformations doesn't mean the technique is worthless. Lisp
doesn't support SQL with relational databases natively, it needs to
be added by a library, but I don't consider relational databases to
be worthless because of that. So why do you consider parse-tree
transformations to be worthless? Do you also consider
domain-specific laguages (DSLs) to be worthless??
In all modern languages, the parse tree (the internal
representation used by the compiler and macro system) is irrelevant
due to the use of quotations.
What do you mean by "quotations" in this context?
(It's not going to do any good to do a Google search, because it'll
turn up Shakespeare quotations, and Will Rogers quotations, and
George W. Bush gaffes, etc. etc. etc., so I'm asking you to cite
what you mean.)
Look at the following equivalent of UNWIND-PROTECT:
# EXTEND Gram
expr: LEVEL "top"
[ [ "try"; f=sequence; "finally"; g=expr ->
<:expr<
(function
| `Val v, g -> g(); v
| `Exn e, g -> (try g() with _ -> ()); raise e)
((try `Val $f$ with e -> `Exn e), (fun () -> $g$))
>> ] ];
END;;
I can't make heads or tails of what you wrote there. I see
half-meaningful pieces tangled together in a meaningless (to me)
mess, and I have no idea what that block of "code" is really
saying. Part of my problem seems to be that you're using a non-BNF
form of expression of grammar production rules, which I don't
understand. Perhaps whenever you are presenting such examples, you
should post the URL of a tutorial that explains that particular
grammar-production syntax, what it all means. Also you need to post
the URL of a playpen for testing my understanding of that syntax,
so that I can try my hand at writing my own grammer and checking if
I got it right by parsing what I believe to be sentences of my
grammar and see if the playpen parser agrees with me as to how the
sentence should parse.
By the way, either "whereis ocaml" nor "man ocaml" turns up
anything here. Is that the correct name that would be used for
OCaml on Unix, so I know it's not installed here? Or should I be
looking under some other name? I tried both commands with
capitalized "OCaml" but neither of those turned up anything here
either.
The input source code is represented by a sequence of tokens and
the associativity and precedence of the new grammar rule, so the
programmer is no longer forced to write without syntax as you do in
Lisp.
So with all this extra power, it should be **easy** for you to write
an extension to OCaml source-code syntax to support something like the
new LOOP special form in ANSI Common Lisp, right? Let's say you
wanted to make a toy demo of this capability by implementing only
something like (LOOP FOR el IN ls COLLECT (sqrt el)) where I've capitalized
the LOOP keywords and left the ordinary source code as lower case to make
the syntax clear. How would you design the corresponding OCaml syntax
extension? I'd guess something like:
LOOP FOR el IN ls COLLECT sqrt(el);
Is that the exact syntax you'd choose, or something different? In
either case, how would you implement that syntax extension in
OCaml, to achieve exactly equivalent semantics to what Common Lisp
provides? For example:
(LOOP FOR el IN '(1 2 3 4 5) COLLECT (sqrt el))
=> (1.0 1.4142135 1.7320508 2.0 2.236068)
(LOOP FOR sr IN * COLLECT (* sr sr))
=> (1.0 1.9999999 3.0 4.0 5.0) ;If I had my way, the default mode
; would be interval arithmetic
; instead of floating-point
; shot-in-dark, but that issue
; isn't relevant to this discussion.
Note your syntax extension must work for *any* local variable
instead of just 'el', *any* given object in place of 'ls', and
*any* valid form involving the local variable, not just (sqrt el)
or (* sr sr).
The action is represented by a quotation <:expr< ... >> that
contains ordinary OCaml code so, again, the programmer is no longer
forced to write without syntax as you do in Lisp.
That remark is a first step toward a tutorial and playpen for this
feature of OCaml, but until the full tutorial+playpen is available
for me to play with, I won't be able to really understand what
you're talking about and what your code fragment means.
Pattern matching is also instrumental here: you can quote code in
patterns and in expressions so you can rewrite OCaml code without
having to deal with the low-level parse tree at all.
I'm not granting your point just yet, but it sounds like this
feature *might* be a valid alternative to source-code parse-tree
transformation. At this point I really hope you do set up a CGI
application that lets me play with this feature, together with a
tutorial that explains what I should be trying, starting with the
simplest case and working toward more complicated cases.
This makes term rewriting much easier in OCaml than in Lisp ...
It doesn't at all look easier than how it's done in Lisp. Maybe
after you set up your tutorial+playpen and I spend some time
developing my understanding of how to use that facility, I'll
agree, or maybe I'll say it really works but is more complicated
than Lisp's "macro" facility.
We can now improve syntax far beyond the capabilities provided by Lisp.
That's blatantly untrue. *any* formally defined grammer can be
implemented as a parser using Lisp as the coding language,
whereupon any such grammer can be fed as syntax into such an
operational Lisp program. Witness how way back with MacLisp,
Vaughan Pratt developed CGOL, and about the same time with SL
(Standard Lisp) Tony Hearn developed REDUCE/RLISP, each an
Algol-like syntax for Lisp sourcecode.
You can implement UNWIND-PROTECT using only a higher-order function.(and thus avoid needing to use source-code parse-tree transformations)
Please explain what you mean by higher-order function in this
context, such that the syntax for an unwind-protect form can be
implemented without any need to enhance the Lisp kernel to provide
support for it. I don't believe it's possible to define
unwind-protect in terms of McCarthy's original Lisp primitives.
I'd like to see an example of a design pattern that cannot
already be factored out in modern FPLs without the use of macros.
Note that "macros", i.e. parse-tree post-read pre-compilation
transformations, are just one way to implement new syntax to
support what was formerly a design pattern in the underlying
language. I don't claim that "macros" are the only way. If and when
you provide a tutorial and playpen for OCaml's facility for
ordinary user-programers to introduce new syntax capabilities into
the OCaml compiler, I'll be able to better estimate whether it's
fully as capable as Lisp's "macros" or more capable or less
capable, as well as whether it's easier to use or harder to use or
about the same difficulty.
That is also why Lisp is so verbose in practice: the burden of
parsing is placed upon the programmer who must write out programs
in what should be an internal representation.
IMO this claim is totally bogus. Whenever a design pattern consists
of a lot of boiler plate and just a little bit of variability, a
Lisp "macro" can support a syntax that consists of a master keyword
to name the macro-expander together with just the barebones
variable parts and just enough parens to properly nest the variable
parts, which expands into the full boilerplate-plus-variability. If
the OCaml feature you have mentionned for introducing new syntax
rules works in the way you seem to imply, almost exactly the same
can be said for OCaml. There's no way that the syntax needed to
invoke an OCaml syntax extension would be significantly less
verbose than the syntax needed to invoke an equivalent Lisp "macro".
OCaml's macros act upon parse trees internally but they are notOCaml has a full macro system but it is rarely used.Is it a parse-tree macro system, like Lisp has, or is it a
string-syntax macro system, like C has?
imposed upon the programmer as they are in Lisp.
They are not imposed on LIsp programmers. They are merely available
for anyone who might wish to define one (and supplied macros are
available for use without even needing to know that they are
macros). In fact I hardly ever use "macros" in my work, because the
abstractions achieved by defining new functions are good enough for
my needs virtually all the time, and the need to load macros before
anyting that uses them would make my standard software development
methodology more trouble. Without sufficient extra value to offset
the increased trouble, I just don't bother. I don't use CLOS or
generic functions for exactly the same reason. Ordinary bottom-up
tool development using layers of defined functions are good enough
for 99.99% of my uses here. But still I appreciate that macros are
available for others to implement the LOOP special form and other
special forms that I use all the time such as WITH-OPEN-FILE and
WITH-OUTPUT-TO-STRING, and I sorely miss those macros in
implementations of Common Lisp that are incomplete. In the case of
the PUSH macro, I missed it so sorely in XLISP that I found the
source and copied it to my patch file which I then loaded whenever
I used XLISP. The fact that I could just load it into an
already-running XLISP environment and voila the PUSH special form
was available, is a big win IMO. Can your new-syntax-rule thingy in
OCaml be used like that??
In Lisp, macros are used primarily to Greenspun pattern matching.
Wrong. "macros" are used primarily to rearrange the variable parts
and supply the boilerplate parts. For example:
(push foo bar) => (setf foo (cons foo bar))
Note that SETF and CONS are boilerplate, and foo has been
rearranged to be in two places instead of just one, and bar has
descended to the second level of nested list. (Actually to handle
cases where foo is a complicated form, the actual expansion
invovles LET of gensyms for sub-forms so that each sub-form of foo
gets evaluated just once instead of twice. The LET and gensym etc.
are a *lot* of boilerplate that gets added, then in trivial cases
where foo is a simple variable the compiler optimizes away most of
that boilerplate. But the macro-expander doesn't have to worry
about special cases, it just generates a giant boilerplate
expression that will *always* work, making the macro very easy to
write.)
I'm curious: Does OCaml provide native support for the equivalent
of SETF and PUSH? Or is it easy using the syntax-extension
mechanism to add such syntax? When adding syntax for PUSH, is it
easy to make sure each sub-form of the place-expression ('foo' in
the above example) gets evaluated just once?
you have yet to come up with a single example of a useful macro.
SETF is a useful macro, whereby anybody can introduce a new data
type that has getter and setter methods, and then a corresponding
SETF rule can be defined, after which that new data type can be the
'place' parameter to setf, equivalent to the left side of an
assignment in infix-operator languages. Does that mechanism somehow
exist in OCaml?
After SETF or equivalent is available, next PUSH and POP and are
also very useful. They can be defined in Lisp, being careful to
evaluate sub-forms of the getter and setter expression just once.
Is an equivalent mechanism available in OCaml?
Finalizers are good when memory pressure is relevant, i.e. when
you are handling resources that consume system memory.
Using a reference-count GC system, where memory is freed
immediately when the last reference to it goes away, this would be
very useful, releasing the system resouce exactly at that point in
time. But with a mark-and-sweep GC system, where memory isn't
released until some random time later, this wouldn't be good at
all, IMO. Maybe somebody needs to implement a CL which uses both
kinds of GC, in two separate heaps. The application would then get
to choose which heap to use when allocating new structure. For most
applications, it wouldn't matter much which heap to use. For
applications that need to build circular structures, the
mark-and-sweep heap would be necessary. For applications that need
to establish system resources and close them the moment the last
reference goes away, the reference-count heap would be necessary to
make things work reliably. If choice of heap were a per-thread
global, I think this would be maximally useful. What do you think?
Do you know of any other languages where dual heap is employed? Or
is this a new great idea I came up with just tonight, which will
win me the Nobel prize eventually?
For example, finalizers are used to collect weakly referenced
parts of a cache. This allows the cache to be shrunk by the GC when
memory pressure is high.
I agree. In this case, either kind of GC would be appropriate,
since the purge would happen exactly when memory runs out with
either reference count or mark and sweep. I agree that weak
references are missing from ANSI Common Lisp and they would be a
good thing for some vendor to add.
[big context snip] Embedded devices used to be PICs but they now
include phones and larger devices that can have substantial
resources.
So indeed these are long-lived applications, with lots of
dynamically allocated memory, hence a need for automatic storage
reclamation (garbage collection). It seems to me that for *all*
these kinds of applications, circular list structure is totally
unnecessary, hence a reference-count system would be fully
adequate. Furthermore, any object has at most just a few
references. For example a WAV soundfile can be referenced from the
sound directory, from the voice-memo directory, from the ringtones
directory, from the currently-under-edit or currently-listened
sound facility, and that's about all. A GIF or JPEG image can be
referenced from the image directory, from the screensaver
directory, from the view-now/modify-image utility, and that's about
all. Hence a fixed-length integer would suffice for the reference
count, perhaps four bits for up to 15 references, or maybe overkill
with 8 bits for up to 255 references if that's more convenient to
program, or any other value at least 4 but less than 8 bits if some
bits of the octet are needed for other use. Do you agree?
What about cellphones that use Java as their OS? I'm pretty sure
they'd never need circular pointers, but might they occasionally
need more than 15 references to a single object?
... the "pre-customers" you are alluding to are either
unidentifiable or worthless. The vast majority of people who offer
you advice on the basis that they will buy your product end up not
buying anything and the people who do buy your product will be
people whom you have been completely unaware of and who have
completely different requirements and values.
So how do I find alpha brainstormers and beta testers for early
versions of my software so that I can get feedback to direct my
programming efforts towards something that has a good chance of
eventualy getting real paying customers?
Note that tools and applications are very different "animals".
With a software tool, I can probably figure out all by myself how
general to make the tool, to maximize its usefulness, and I don't
need either alpha brainstormers nor beta testers until I have it
all done and just need beta testers to check if I accidently let a
bug slip in.
But with an application, I really need alpha brainstormers from
nearly the very start to help me define what customer base my idea
could help and what features I want to implement first and best and
to help me design a good user interface etc. etc. Have you looked
at my mobile-InterNet-WAP-cellphone WebPage where I list several
new projects for which I'd like to find some alpha brainstormers?
<http://shell.rawbw.com/~rem/WAP/projectIdeas.html>
Do you have any suggestions how to get the help I need at designing
a good application, for *any* of those proposed new applications?
Let me give you some examples:
My book OCaml for Scientists was written by me as a physical
scientist and aimed at other physical scientists. I made the same
mistake that you are of seeking out pre-customers and taking their
advice. Atmospheric scientists told me to strip out the maths and
discuss interoperability with obscure tools but virtually none of
them actually paid for the book. Bioinformaticians are probably our
largest market of real paying customers. I never got any advice
from bioinformaticians whilst writing the book and the fact that
much of the content is well-suited to their work is a complete
fluke.
A book is not at all the same thing as an application. But your
experience may be of *some* limited value transferred from book
writing to software development. But I'd prefer your experience in
writing user-level application software, if you have any.
More recently, I have been completely ignoring advice from
"pre-customers" and have focussed on getting products to market
faster based upon my intuition of what people need. This is vastly
more lucrative.
I can't read people's minds, especially people I've never met or
even heard, my potential future user base. I don't have the
intuition to know what somebody might really want, among the
several things I am hot to develop but can spend my time developing
only one at a time, so I need to choose which *one* to apply heavy
effort toward. Recently I've been splitting my unpaid time among:
- ProxHash tool, and transferrable-skills application thereof.
- Custom products of pseudo-random large primes and public-key cryptography.
- Small utilities and applications for my own personal use, not for market.
- Practicing my skill at developing Web sites for tiny
(one-inch-square) screens of cellphones with mobile InterNet
(WAP) now that I've enabled such service about 5 weeks ago on my
cellphone that I bought in March. Currently my login form here:
<http://shell.rawbw.com/~rem/cgi-bin/LogForm.cgi?f=WAP>
doesn't work on my cellphone, but all my hello-CGI-plus stuff here:
<http://www.rawbw.com/~rem/WAP/HelloPlus/wHellos.html>
works just fine, so I need to spend some time someday soon to
diagnose why one works but the other doesn't, so that I can make
my login form and all the stuff after it work on cellphones too.
By the way, I know how to use the Paint program on MS-Windows to
crop and demagnify images to fit the cellphone screen, which
usually reduces their size to about 3-20k bytes. Here's a sample of
some of my cropping+demagnifying work:
<http://shell.rawbw.com/~rem/WAP/hotWantMeet.html>
The numbers in parens are the k size of the image, where the first
image in each group is the original image before cropping and later
images in the group are cropped. An 'x' means that particular image
doesn't work on my cellphone, shows as broken-image icon instead.
(So far *all* my images cropped and/or reduced to fit cellphone
screen actually do work on my cellphone, which is a great relief.)
But I'd really like to shrink the largest (10-30k) of the cropped
images to less than 10k each without shrinking their visual size,
by specifying lossy JPEG compression. Do you know how to do that on
MS Windows? I can't find that option in Paint.
Oh, if you notice images from #36 onward aren't cropped, that's
because I got only through #35 on Thursday before the computer lab
closed, and the lab was closed Friday because the admin has gone on
a four-day holiday, so I won't be finishing images #36-61 until
Tuesday at the earliest. Also I have two other HotOrNot accounts
and I haven't even begun setting up those images for cellphone.
... second highest risk approach to building a company ... ...
I found that selling commodities like OCaml for Scientists to
lots of ordinary programmers is not only more stable than
gambling but can also be just as lucrative.
Gambling isn't at all stable, so being more stable than gambling
isn't saying much at all.
In any case, you seem to be selling software-productivity tools
rather than end-user applications, right?
So can you find me a first brainstorm-use-cases customer to getThe only way to find out is to put it up for sale.
this whole process started? I've mentionned lots of new software
technology I've implemented to the pointer where I feel they might
possibly be useful for a variety of applications that might be of
value to others. But until I find a potential customer who is
actually interested in what I have done and how I can work it into
a salable product, I don't know if any of the wondrous things I've
programmed really could lead to a salable product.
I'm totally not comfortable offering for sale some software that I
am the **only** person who has ever seriously tried to use it. For
example, I have yet to find even one person in the local area who
has time to try my flashcard-drill algorithm and tell me what
he/she thinks of it. (It's been online since late 2002.) At present
it has flashcard decks for learning how to choose and spell the 900
most common words in context, where the context is mostly my own
particular choice of lyrics from some of my favorite romantic
ballads. I would want to customize it to include the customer's
personal choice of context before I sell it to anyone. Why would
anybody want **my** choice of song lyrics? When I used an earlier
version of this program (ran as desktop GUI application on
Macintosh Plus using Macintosh Allegro Common Lisp version 1.2.2,
whereas current version runs over CGI on CMUCL on FreeBSD Unix) to
teach my two children how to develop that skill when they were not
yet in first grade, my personal choice of song lyrics, songs I had
played for my children, was just fine. But I'm really not
comfortable trying to sell my application with *that* set of song
lyrics samples to the general public, especially since some of the
lyrics are still under copyright and I have no idea which those are
so I have no practical way to purge them without deleting my entire
corpus. Other flashcard decks with the current program including
pre-reading choosing single letters missing from Barney Dinosaur
lyrics, which worked very well for my 4-yr-old daughter to warm her
up enough for the rest of the program. Also I have several ESL
decks I developed more recently than 2002. I can't see why
*anybody* would want to buy the current program as-is with my
current hodge podge of useful and sample flashcard decks.
By the way, Tuesday of last week I gave a partial demo of some ofExcellent. Best of luck.
my computer-assisted instruction software, and the person seeing
the demo seemed to think it would be of interest to two of his
technical acquaintances, one very far away (about 1000 miles) and
one closer (about 40 miles), so he'll be contacting them to try to
get them interested.
Not excellent at all. He didn't have time to get a complete demo,
and since then a month has passed and he's been too busy for the
rest of the demo. So far he's seen the 2001.Jan SEGMAT demo by
itself (for guessing answers to riddles), and the
optmimum-flashcard-sequence algorithm by itself (for reading out
loud single letters and memorizing an accompanying usage), but
hasn't yet seen SEGMAT and optimum-sequence together, for all the
flashcard decks I talked about in the previous paragraph.
What part of the world are you in? Is there anybody in this part of
California who would like a full demo?
.
- References:
- Re: Program compression
- From: Jon Harrop
- Re: Program compression
- Prev by Date: Re: windows dev, cross-platform GUI?
- Previous by thread: Re: Program compression
- Next by thread: Re: Program compression
- Index(es):
Relevant Pages
|
