From darren at darrenduncan.net Thu May 1 01:13:34 2008
From: darren at darrenduncan.net (Darren Duncan)
Date: Thu, 01 May 2008 01:13:34 -0700
Subject: [VPM] FYI: Muldis D code example, 2008 April 30 edition
Message-ID: <48197BAE.60803@darrenduncan.net>
All,
This message is a follow-up both to my April 28th post of subject "ANNOUNCE
- Muldis D v0.27.0 released", wherein I promised this message would soon
follow, and also follows up a few other posts over the past year where I
gave some pseudo-code examples.
At the end of this email is an example program written in Muldis D, which
you can peruse to get familiar with what the language is like than just
descriptions would do.
The example program will create a temporary depot/database, install a
stored procedure in it, and invoke that stored procedure. The stored
procedure will prompt the user to enter details for 3 people, specifically
their names and addresses, which it will store in a relvar/table. It will
then prompt the user to enter a person's name to search for, look for a
matching person's details in the relvar/table, and then inform the user of
that person's address. Note that for brevity this example program is naive
does not check that the search name actually matched 1 person, and simply
tries to use the result, meaning it will die if that expectation isn't met;
a real program would do more testing.
The program is written in the PTMD_Tiny dialect of Muldis D, which is
designed to exactly match the system catalog in structure. The majority of
it, the stored procedure definition, consists of a single tuple/record for
a catalog relvar/table, and some attributes/fields of that tuple/record
have collection-typed values, several levels deep. This Muldis D code
should resemble the AST you get after parsing a typical language's code and
so is fairly verbose. Though verbose, it should work well in a situation
where such code is mainly being generated or parsed or modified by a
program, though doing it by hand should be tolerable. The dialect is
designed to be parseable with a tiny grammar, which is where its name comes
from. Muldis D is homoiconic, meaning Muldis D code fundamentally is a low
level Muldis D data type, and you do all coding in it by manipulating data.
I assume that other Muldis D dialects will come about later where coding in
it is a lot less verbose, at the cost of the grammar being more
complicated, and code will translate between dialects. Or alternately the
Tiny dialect may just be used as an intermediate language for a programming
environment that, say, takes some specialized DWIM language as input, and
by way of the intermediate, generate SQL for any SQL DBMS to do the work.
So if there are any complaints about verbosity, I can probably do more to
get that down in these dialects, but after a point it would probably be
better to use some translation layer and write to that instead.
Now the PTMD_Tiny dialect happens to be well handled by syntax colorers for
the Perl language, but it isn't Perl. If you are a Perl programmer, you
would probably be more interested in the HDMD_Perl_Tiny dialect, which
looks very much like PTMD_Tiny, but consists of actual Perl arrays of
arrays. In fact, to translate from what you see below to the Perl version,
basically just do this:
- any "Foo:'bar':'baz'" gets changed to "[ 'Foo', 'bar', 'baz' ]"
- any "\q" gets changed to "\'", or use alternate string quoting
characters for string literals
- for payloads of Relation and Set, change the delimiters to "[]" from
"{}" since Perl 5 doesn't have set syntax so use array syntax instead
- the framing code, the 'boot_call' etc need to be replaced with API
calls to some Muldis D implementing Perl module such as Muldis Rosetta
- for a further guide, just compare the docs for the 2 dialects, ad all
the code examples directly correspond
Of course you don't have to use Perl, you could use some other host
language instead as is your preference, as the structures map to any decent
language easily enough. Both functional and imperative languages should
work with it.
Now the program example you see below is complete, with all framing code
needed to compile the plain text dialect, probably.
In the near future, I'll follow with another example email that just shows
snippits rather than a complete program, and the snippits can focus on
particular tasks such as doing joins or unions or defining database schemas
etc.
On another note, considering my OSCON talk is July 23, I've set myself up
with a hard deadline of July 1, and a soft deadline of June 1, to have an
actual working implementation of the language. The only main prerequisite
to making that is defining how to declare data types and schemas in the
language, but that should be done in a few days I expect.
-- Darren Duncan
--------------
Muldis_D:'http://muldis.com':'0.28.0':'PTMD_Tiny':{};
boot_call:'sys.std.Core.Cat.create_temp_empty_depot':{
'mount_name' => 'app',
};
boot_call:'sys.std.Core.Cat.create_depot_procedure':{
'depot' => 'app',
'parent' => Cat.DeclNameChain:'.',
'name' => 'main',
'comment' => Cat.Comment:'This is the program\qs main procedure.',
'head' => Tuple:{},
'body' => Tuple:{
'main_body' => Tuple:{
'vars' => Relation:[ 'name', 'type', ]:{
[ 'msg_gather_name', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'msg_gather_addr', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'msg_search_name', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'msg_result_addr', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'people', Cat.NameChain:'sys.std.Core.Type.Relation', ],
[ 'person_name', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'person_addr', Cat.NameChain:'sys.std.Core.Type.Text', ],
},
'stmts' => Seq:[
Tuple:{
'procedure' => Cat.NameChain:'inn.init_vars',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'msg_gather_name', Cat.NameChain:'lex.msg_gather_name', ],
[ 'msg_gather_addr', Cat.NameChain:'lex.msg_gather_addr', ],
[ 'msg_search_name', Cat.NameChain:'lex.msg_search_name', ],
[ 'msg_result_addr', Cat.NameChain:'lex.msg_result_addr', ],
[ 'people', Cat.NameChain:'lex.people', ],
},
},
Tuple:{
'procedure' => Cat.NameChain:'inn.gather_person',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'people', Cat.NameChain:'lex.people', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'msg_gather_name', Cat.NameChain:'lex.msg_gather_name', ],
[ 'msg_gather_addr', Cat.NameChain:'lex.msg_gather_addr', ],
},
},
Tuple:{
'procedure' => Cat.NameChain:'inn.gather_person',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'people', Cat.NameChain:'lex.people', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'msg_gather_name', Cat.NameChain:'lex.msg_gather_name', ],
[ 'msg_gather_addr', Cat.NameChain:'lex.msg_gather_addr', ],
},
},
Tuple:{
'procedure' => Cat.NameChain:'inn.gather_person',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'people', Cat.NameChain:'lex.people', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'msg_gather_name', Cat.NameChain:'lex.msg_gather_name', ],
[ 'msg_gather_addr', Cat.NameChain:'lex.msg_gather_addr', ],
},
},
Tuple:{
'procedure' => Cat.NameChain:'sys.std.Core.STDIO.prompt_Text_line',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'target', Cat.NameChain:'lex.person_name', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'prompt', Cat.NameChain:'lex.msg_search_name', ],
},
},
Tuple:{
'procedure' => Cat.NameChain:'inn.search_for_address',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'person_addr', Cat.NameChain:'lex.person_addr', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'people', Cat.NameChain:'lex.people', ],
[ 'person_name', Cat.NameChain:'lex.person_name', ],
},
},
Tuple:{
'procedure' => Cat.NameChain:'sys.std.Core.STDIO.write_Text',
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'v', Cat.NameChain:'lex.msg_result_addr', ],
},
},
Tuple:{
'procedure' => Cat.NameChain:'sys.std.Core.STDIO.write_Text_line',
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'v', Cat.NameChain:'lex.person_addr', ],
},
},
],
},
'inner_procs' => Relation:{
{
'name' => 'gather_person',
'comment' => Cat.Comment:'Gathers person info from user.',
'head' => Tuple:{
'upd_params' => Relation:[ 'name', 'type', ]:{
[ 'people', Cat.NameChain:'sys.std.Core.Type.Relation', ],
},
'ro_params' => Relation:[ 'name', 'type', ]:{
[ 'msg_gather_name', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'msg_gather_addr', Cat.NameChain:'sys.std.Core.Type.Text', ],
},
},
'body' => Tuple:{
'vars' => Relation:[ 'name', 'type', ]:{
[ 'person_name', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'person_addr', Cat.NameChain:'sys.std.Core.Type.Text', ],
},
'stmts' => Seq:[
Tuple:{
'procedure' =>
Cat.NameChain:'sys.std.Core.STDIO.prompt_Text_line',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'target', Cat.NameChain:'lex.person_name', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'prompt', Cat.NameChain:'lex.msg_gather_name', ],
},
},
Tuple:{
'procedure' =>
Cat.NameChain:'sys.std.Core.STDIO.prompt_Text_line',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'target', Cat.NameChain:'lex.person_addr', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'prompt', Cat.NameChain:'lex.msg_gather_addr', ],
},
},
Tuple:{
'procedure' => Cat.NameChain:'inn.add_person',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'people', Cat.NameChain:'lex.people', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'person_name', Cat.NameChain:'lex.person_name', ],
[ 'person_addr', Cat.NameChain:'lex.person_addr', ],
},
},
],
},
},
},
'inner_upds' => Relation:{
{
'name' => 'init_vars',
'comment' => Cat.Comment:'Initializes main routine\qs variables.',
'head' => Tuple:{
'upd_params' => Relation:[ 'name', 'type', ]:{
[ 'msg_gather_name', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'msg_gather_addr', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'msg_search_name', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'msg_result_addr', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'people', Cat.NameChain:'sys.std.Core.Type.Relation', ],
},
},
'body' => Tuple:{
'exprs' => Tuple:{
'sca_lit_exprs' => Relation:[ 'name', 'value', ]:{
[ 'emgn', Text:'Enter a person\qs name: ', ],
[ 'emga', Text:'Enter that person\qs address: ', ],
[ 'emsn', Text:'Enter a name to search for: ', ],
[ 'emrn', Text:'Found address for that person is: ', ],
},
'rel_lit_exprs' => Relation:{
{
'name' => 'ep',
'head' => Set:{ 'person_name', 'person_addr', },
'body' => Set:{},
},
},
},
'stmt' => Relation:{
{
'updater' => Cat.NameChain:'sys.std.Core.Universal.assign',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'target', Cat.NameChain:'lex.msg_gather_name', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'v', Cat.NameChain:'lex.emgn', ],
},
},
{
'updater' => Cat.NameChain:'sys.std.Core.Universal.assign',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'target', Cat.NameChain:'lex.msg_gather_addr', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'v', Cat.NameChain:'lex.emga', ],
},
},
{
'updater' => Cat.NameChain:'sys.std.Core.Universal.assign',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'target', Cat.NameChain:'lex.msg_search_name', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'v', Cat.NameChain:'lex.emsn', ],
},
},
{
'updater' => Cat.NameChain:'sys.std.Core.Universal.assign',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'target', Cat.NameChain:'lex.msg_result_addr', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'v', Cat.NameChain:'lex.emra', ],
},
},
{
'updater' => Cat.NameChain:'sys.std.Core.Universal.assign',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'target', Cat.NameChain:'lex.people', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'v', Cat.NameChain:'lex.ep', ],
},
},
},
},
},
{
'name' => 'add_person',
'comment' => Cat.Comment:'Adds a person to our db of people.',
'head' => Tuple:{
'upd_params' => Relation:[ 'name', 'type', ]:{
[ 'people', Cat.NameChain:'sys.std.Core.Type.Relation', ],
},
'ro_params' => Relation:[ 'name', 'type', ]:{
[ 'person_name', Cat.NameChain:'sys.std.Core.Type.Text', ],
[ 'person_addr', Cat.NameChain:'sys.std.Core.Type.Text', ],
},
},
'body' => Tuple:{
'exprs' => Tuple:{
'tup_lit_exprs' => Relation:{
{
'name' => 'person',
'attrs' => Relation:[ 'name', 'expr', ]:{
[ 'person_name', Cat.NameChain:'lex.person_name', ],
[ 'person_addr', Cat.NameChain:'lex.person_addr', ],
},
},
},
},
'stmt' => Relation:{
{
'updater' =>
Cat.NameChain:'sys.std.Core.Relation.assign_insertion',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'r', Cat.NameChain:'lex.people', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 't', Cat.NameChain:'lex.person', ],
},
},
},
},
},
{
'name' => 'search_for_address',
'comment' => Cat.Comment:'Look up person name, get their address.',
'head' => Tuple:{
'upd_params' => Relation:[ 'name', 'type', ]:{
[ 'person_addr', Cat.NameChain:'sys.std.Core.Type.Text', ],
},
'ro_params' => Relation:[ 'name', 'type', ]:{
[ 'people', Cat.NameChain:'sys.std.Core.Type.Relation', ],
[ 'person_name', Cat.NameChain:'sys.std.Core.Type.Text', ],
},
},
'body' => Tuple:{
'exprs' => Tuple:{
'rel_lit_exprs' => Relation:{
{
'name' => 'person_name_r',
'head' => Set:{ 'person_name', },
'body' => Set:{
Relation:[ 'name', 'expr', ]:{
[ 'person_name', Cat.NameChain:'lex.person_name', ],
},
},
},
},
'func_invo_exprs' => Relation:{
{
'name' => 'matched_people',
'function' => Cat.NameChain:'sys.std.Core.Relation.semijoin',
'args' => Relation:[ 'name', 'expr', ]:{
[ 'source', Cat.NameChain:'lex.people', ],
[ 'filter', Cat.NameChain:'lex.person_name_r', ],
},
},
{
'name' => 'matched_person',
'comment' => 'Note, we\qre assuming exactly one match.',
'function' =>
Cat.NameChain:'sys.std.Core.Relation.Tuple_from_Relation',
'args' => Relation:[ 'name', 'expr', ]:{
[ 'topic', Cat.NameChain:'lex.matched_person', ],
},
},
},
},
'stmt' => Relation:{
{
'updater' => Cat.NameChain:'sys.std.Core.Universal.assign',
'upd_args' => Relation:[ 'name', 'expr', ]:{
[ 'target', Cat.NameChain:'lex.person_addr', ],
},
'ro_args' => Relation:[ 'name', 'expr', ]:{
[ 'v', Cat.NameChain:'lex.matched_person.person_addr', ],
},
},
},
},
},
},
},
};
boot_call:'fed.lib.app.main':{};
From darren at darrenduncan.net Sat May 3 12:20:03 2008
From: darren at darrenduncan.net (Darren Duncan)
Date: Sat, 03 May 2008 12:20:03 -0700
Subject: [VPM] Tue, 2008 May 6th, 7pm - May RCSS meeting
Message-ID: <481CBAE3.3010702@darrenduncan.net>
This message is forwarded from the Recreational Computer Science
Society mailing list. -- Darren Duncan
-------- Original Message --------
Subject: [reccompsci] Announcement: May RCSS - Tue, May 6th 2008, 7:00pm
Date: Sat, 3 May 2008 05:08:34 -0700 (PDT)
From: Adam Parkin
To: Recreational Computer Science Society
Okay at long last, the announcement/reminder about the next monthly
RCSS meeting.
Since nobody volunteered to speak, and I didn't get a response back
from Allan about parametized chess, it's looking like it's going to be
a shorter/lighter meeting. So far the only confirmed speaker is
Peter, so unless someone else volunteers I'm going to talk a bit about
a paper I've been reading on classifying programming languages based
upon eductational merits and try and generate a bit of discussion.
To speak:
-- Mozilla stuff (Peter)
-- Brief summary and discussion on paper "Lowering the Barriers to
Programming: a survey of programming environments and languages for
novice programmers" (Me)
-- Anything you want to present..... :p
As per tradition, I'm going with the "lets just show up in a room and
hopefully it's not booked" routine. So meeting place is @ UVic in ECS
130 at 7PM on Tuesday May 6th, 2008. If for some reason that room
doesn't work (ie if it's already booked, etc) then our backup room
will be ECS 104 (which IIRC is the opposite end of the 1st floor of
ECS). So to recap:
Date: Tuesday, My 6th 2008
Time: 7PM
Place: UVic - ECS 130
See you all then!
As for looking past this month, I talked to my friend who's defending
a quantum computing related thesis soon, and it sounds like he'll
probably be able to present something to RCSS in June. And of course
I'm going to send out a few e-mails to see if I can maybe get someone
in the department to come out and talk as well. Other than that, I
NEED VOLUNTEERS FOR PRESENTATIONS..... :p If there's anything you'd
like to talk about, please, please, please, let me know.
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Recreational Computer Science Society" group.
To post to this group, send email to reccompsci at googlegroups.com
To unsubscribe from this group, send email to
reccompsci-unsubscribe at googlegroups.com
For more options, visit this group at
http://groups.google.com/group/reccompsci?hl=en
-~----------~----~----~----~------~----~------~--~---
From darren at darrenduncan.net Mon May 5 16:45:06 2008
From: darren at darrenduncan.net (Darren Duncan)
Date: Mon, 05 May 2008 16:45:06 -0700
Subject: [VPM] where would I find examples of software business contracts
(for services)?
Message-ID: <481F9C02.3050603@darrenduncan.net>
Hello,
I'm seeking help in finding some examples of software development contracts
so to help me write my own.
I have a new (6 months old) BC incorporated business which provides
database software development services, and its main unique selling
proposition regarding said services is leveraging its own superior FLOSS
toolkit for projects, which as creator I would know best.
I'm currently under the impression that I should have a written contract
for services (name?) with each of my customers that outlines essentially
that I do work for them which we mutually agree to and that they pay what I
invoice, which is by the hour, within 30 days of invoice, and that the work
is as-is and has no warranty, and that they own the result of just the work
that is billed them (except where overrided by a separate sponsoring
agreement), and nothing that I make in hours they aren't billed for. Part
of the reason for the contract is to help ensure I'm paid in a timely
manner, and also so that the government has more proof that I am
self-employed and not employed by my clients, even if I just have one major
client at a time, so my business qualifies for the small business tax
status. I expect the concept in question to be fairly simple and just talk
about our general relationship, and not be specific to any project, nor
mention any delivery timetables for work nor mention estimated total costs;
I may make or maintain several applications for the same client and just
get paid by the hour the same either way. I do not expect that the
contract would specify what the hourly rate is, as that is discussed
separately, though I suppose I could encode it there if necessary. There
are no explicit NDA elements, and no non-compete whatevers, no mention of
patents; stuff like NDAs would be separately negotiated where applicable.
The contract would be quasi-open-ended, and just operate for a year at a
time, eg applying to work performed in calendar 2008, and then be
renegotiated (possibly identically) for a subsequent year. The contract
would be generic so that it can be used with any client without being
customized, generally, save for the name of the other party and date.
I am under the impression that basic contracts like this are quite common,
and that a number of you have used such contracts already.
I am seeking some example/template contracts of this nature so that I can
see the actual wording and structure that is used in Canada/BC/Victoria for
such things so I can then use those to compose my own. As well as whether
there may be any gotchas I should be careful to avoid.
So far my efforts on Google haven't turned out anything very helpful, but I
may just not be searching with the right terms, as I expect this sort of
thing to be common.
I expressly want to keep this simple and I don't want to have to involve a
lawyer in the drafting of the contract, and I don't need any third party
witnesses. I also don't want to use a fill-in-the-blanks program to write
it for me. The whole contract should fit on a single 8x11 page at normal
fonts, if not within half a page.
Thank you in advance for any pointers.
-- Darren Duncan
From Peter at PSDT.com Mon May 5 17:59:50 2008
From: Peter at PSDT.com (Peter Scott)
Date: Mon, 05 May 2008 17:59:50 -0700
Subject: [VPM] where would I find examples of software business
contracts (for services)?
In-Reply-To: <481F9C02.3050603@darrenduncan.net>
References: <481F9C02.3050603@darrenduncan.net>
Message-ID: <6.2.3.4.2.20080505174933.030ea660@mail.webquarry.com>
At 04:45 PM 5/5/2008, Darren Duncan wrote:
>I expressly want to keep this simple and I don't want to have to involve a
>lawyer in the drafting of the contract, and I don't need any third party
>witnesses. I also don't want to use a fill-in-the-blanks program to write
>it for me. The whole contract should fit on a single 8x11 page at normal
>fonts, if not within half a page.
ECONFLICT.
I think there's a reason you didn't find anything in Google. There are
too many questions affecting the outcome. And a lawyer will laugh at
the idea at fitting such a contract within half a page. In which
jurisdiction should conflicts be arbitrated? Do you require conflicts
to go to binding arbitration? What is the license to be applied to
artifacts created under contract? If your client is located in the
United States what clauses are necessary? Those are a tiny sampling of
issues you should address if you want your clients to take your
contract seriously.
Also, invariably a corporate client will have their own contract and
want you to sign it, rather than the other way around. The two of you
negotiate and decide which contract you want to modify to suit both
your needs. The client will have things in their contract that you
will not have in yours, for example, E&O insurance limits. At that
point a lawyer may be invaluable.
If there were a generic contract that would suit your needs you would
have found it on Google. Bite the bullet and get a lawyer.
--
Peter Scott
Pacific Systems Design Technologies
http://www.perldebugged.com/
http://www.perlmedic.com/
From darren at darrenduncan.net Fri May 30 12:48:48 2008
From: darren at darrenduncan.net (Darren Duncan)
Date: Fri, 30 May 2008 12:48:48 -0700
Subject: [VPM] Tue, 2008 June 3rd, 7pm - June RCSS meeting
Message-ID: <48405A20.5080005@darrenduncan.net>
This message is forwarded from the Recreational Computer Science Society
mailing list, plus a slipstreamed correction and addition from Adam. --
Darren Duncan
-------- Original Message --------
Subject: [reccompsci] Announcement: June RCSS - Tue, June 3rd 2008, 7:00pm
Date: Fri, 30 May 2008 11:12:58 -0700 (PDT)
From: Adam Parkin
Reply-To: reccompsci at googlegroups.com
To: Recreational Computer Science Society
Hello all, it's that time of the month: the announcement/reminder
about the next monthly
RCSS meeting.
So for speakers this month we have two presentations, one by Chris
Ware (a graduate student here at UVic) on something related to quantum
computing, and one by myself on a paper by M. Anton Ertl on Stack
Caching.
As per tradition, I'm going with the "lets just show up in a room and
hopefully it's not booked" routine. So meeting place is @ UVic in ECS
130 at 7PM on Tuesday June 3rd, 2008. If for some reason that room
doesn't work (ie if it's already booked, etc) then our backup room
will be ECS 104 (which IIRC is the opposite end of the 1st floor of
ECS). So to recap:
Date: Tuesday, June 3rd 2008
Time: 7PM
Place: UVic - ECS 130
To talk:
-- Chris Ware - Something along the lines of Quantum Computing and
cryptography (he is to get back to me over the next day or two with a
more detailed topic)
-- Me (Adam Parkin) - Presentation based upon the paper "Stack Caching
for Interpreters" by M. Anton Ertl which was submitted to the
Programming Language Design and Implementation (PLDI) conference in
1995. Abstack: An interpreter for a virtual stack machine (such as
the Java virtual machine or .Net runtime) can spend a significant
amount of time fetching values to and from the stack. The paper
explores a few methods to reduce the overhead of memory accesses by
caching a few of the top items of the instruction stack in registers,
thereby improving execution times. In particular, I'll be talking
about how this relates to the Java programming language and the Java
virtual machine (JVM).
And of course, if there's anything else someone wants to present, I'm
always open to suggestions (either for this meeting or future ones).
Currently for our July meeting Darren is scheduled to give a talk
related to Muldis, but other than that there are no speakers currently
scheduled for July. Read an interesting paper? Seen a cool new
technology? Why not come give a talk for RCSS about it and share your
wisdom with like-minded computer geeks. :p
One more thing: if you'd like to see the paper that my talk is based
upon, you can find it at:
http://www.csc.uvic.ca/~csc485c/Papers/ertl94sc.pdf
Adam
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Recreational Computer Science Society" group.
To post to this group, send email to reccompsci at googlegroups.com
To unsubscribe from this group, send email to
reccompsci-unsubscribe at googlegroups.com
For more options, visit this group at
http://groups.google.com/group/reccompsci?hl=en
-~----------~----~----~----~------~----~------~--~---