taradinoc

The MDL bumper sticker, "my other 1 is a REST", just doesn't have the same ring to it.

A C-based alternative for compiling ZIL? I don't believe there's one that works. The two options for compiling ZIL code are to run ZILF on a modern system or to run ZILCH on a PDP-10 emulator.

The good news is you don't need to install any C# development tools if you use the prepackaged binaries, since they're standalone executables.

Right - that's because ZIL was more or less a _superset_ of MDL.

ZILCH (Infocom's compiler) provided all the functions of MDL, _plus_ a bunch of new ones that manipulated data structures which were then used to generate assembly code for the Z-machine.

One of those new functions, ROUTINE, accepted code written in a domain-specific language resembling a stripped-down MDL, which was then translated into Z-machine instructions. But that domain-specific language isn't synonymous with ZIL: other functions that were inarguably part of ZIL, like OBJECT and SYNTAX, are not part of that domain-specific language.

IMO, the only reasonable definition of ZIL is "the language accepted by a ZIL compiler", which (depending on whether you look at ZILCH or ZILF) is either a superset of MDL or an overlapping set.

Author of ZILF here. I wouldn't say that ZIL "does not have support for custom macros", because ZIL never existed in a form independent of MDL. There's no such thing as "MDL macros that were not available in ZIL", because there was never a version of ZIL that didn't have macros.

>If allowing a particular person to visit means several others will refrain from visiting, is it then a good idea to permit that? That's a value judgement for the organizers to make.

That's part of it, but it's also a value judgment for everyone else to make.

In many cases, the rest of us in society care enough about how those decisions are made that we've passed laws prohibiting businesses from rejecting customers for certain reasons.

For example, if your market research shows that allowing Jews into your event results in lower overall attendance, because too many of the other potential attendees are anti-Semites who refuse to go to an event that allows Jews, you still don't get to ban them. We've established that making those opportunities equally available to all religions, ethnicities, genders, races, etc. is more important than maximizing profit. Even when that discrimination isn't illegal, it's often frowned upon by the culture.

And one reason for that is that we distinguish between the business deciding you can't visit them, and you deciding you can't visit them. We expect businesses to be inclusive, even if that means more people choose to exclude themselves -- because this way, the people who are excluded at least get a choice.

>And if you think they made the wrong decision, feel free to tell them so or even to boycott it yourself, giving them a reason to consider other potential solutions.

I've got no reason to attend a Kubernetes conference anyway, but I have the same interest as any other member of society in ensuring that people get treated fairly.

I'd worry that the doctor might recommend dangerous and ineffective treatments, that the police officers would arrest me on false pretenses, and that the cleaner would steal my belongings and poison my groceries. So, yeah, I'd fire the cleaner, switch doctors, etc.

But... would I let myself attend an industry conference that's also being attended by someone who voted for a politician whose opinions or policies are hostile to me?

Yes. Of course.

I'd also attend a conference that's being attended by someone who thinks I'm going to hell when I die. I'd even attend a conference where one of the speakers thinks that. Because I don't have to trust conference attendees or speakers with my life or health; I don't have to interact with them at all, and if I do, it'll be in a busy public place; and if they were the kind of person to go into a blind rage when they meet someone like me in public, they probably would've done it already and gotten caught.

Yes, goog-anon is doing candidates -- and the lawyers in Wilberg v. Google -- a huge favor by admitting on the record that there's explicit racial bias in their hiring process.

> Because college is where women are driven out of computer science, by behavior from professors and peers.

A lot of people take that for granted based on anecdotes, but actual data is elusive.

Some things we should expect to see if this theory is correct:

* CS student gender ratios close to 50:50 at admission

* A relatively large change in CS student gender ratios between admission and graduation, compared to other majors

* A relatively high rate of "misbehavior" (e.g. sexual harassment) in CS programs and/or the tech industry, compared to other fields

From what I can tell, though, we don't observe any of those.

> If you want to talk about fields where men are driven out (and they do exist: primary school teaching and nursing come to mind)

The same questions could be raised about those: why are we so sure they're being "driven out" at the college level?

Here's a paper investigating the causes of gender imbalance among primary school teachers: https://etd.ohiolink.edu/!etd.send_file?accession=ysu1515846...

The men interviewed for the paper disagreed that discrimination, social barriers, stereotypes, or other forms of injustice play a role. ("I don’t feel that there is any injustice… men who want to teach, are able to. It’s not like we’re being held down.")

It also points out that a greater number of men than women choose to go into primary education during college, which is the opposite of what we'd expect if they were being driven out by professors and peers.

> If you're self-taught you have to be willing to learn things you find completely uninteresting (or boring, hard, whatever) if you want to be as well-rounded as a CS graduate.

Not necessarily, you could also just find all that CS stuff interesting.

Interesting. I did find an implementation of backquoting in MDL, kind of:

https://github.com/PDP-10/muddle/blob/master/mim/development...

It doesn't run on any available MDL implementation, because it's actually for MIM, an even more obscure and undocumented extension of MDL. ZILF implements some parts of MIM, but doesn't implement READ-TABLEs at all, and the format of the table implied by that code is different from what's documented for MDL.

Do you like this?

>Quasiquotation pretty much doesn't need to exist because of the ! sequence "operator" for splicing lists into lists and forms.

Hmm... I guess I don't know everything quasiquoting is used for in Lisp, but in MDL and ZIL, segments don't really solve the problem that quasiquoting does when it comes to writing macros.

That is, I usually want to use macros to generate code according to a template:

  <PRSI? ,FOO>

should become

  <==? ,PRSI ,FOO>

The way to write that macro is to call FORM to build the form:

  <DEFMAC PRSI? (X)
    <FORM ==? ',PRSI .X>>

But if it's a complex block of code, and the blanks I want to fill in are deeply nested, the template quickly becomes unreadable, because every structure turns into a form, and every form turns into a call to FORM.

>When IF focuses on prose, and doesn't contain puzzles, it's harder to actually call it a game.

This debate has been going on for decades. (See Photopia.)

Yeah, if there's nothing after the final !- in an atom, it means the atom is in <ROOT>. (See section 15.5 in the manual.)

I'm not sure what the purpose of things like <RETURN!-> and <ORB!-> is. It could have something to do with the way they implemented Z-machine opcodes as MDL atoms, i.e. <RETURN!-> forces it to use the MDL SUBR instead of the opcode? Maybe they moved the MDL atoms that collided with Z-machine opcodes to a separate OBLIST, and this was needed to access them from MDL code in the same file?

I never figured that part out, so when ZILF is generating code, it uses the same OBLISTs it used while interpreting and just looks things up by their PNAMEs.

SETG20 and DEFINE20 are used in "MDL-ZIL" files, where routines are defined with DEFINE instead of ROUTINE, global variables are created with SETG instead of GLOBAL, etc. Presumably that was a way to run the games in MDL during development to avoid recompiling them. SETG20 and DEFINE20 are aliases for the MDL versions of SETG and DEFINE.

Angle brackets and parentheses are just two of the many flavors of brackets you'll find in MDL. First, you got your regular, "boring" brackets:

  <SETG X 0>           ;FORM
  (NORD BERT)          ;LIST
  [1 MONEY 2 SHOW]     ;VECTOR
  "Bracket-ish"        ;STRING
  { what goes here? }  ;TEMPLATE

Then you got your exciting brackets, where the first ! is mandatory but the second is optional:

  !<REST .FOO!>        ;SEGMENT
  ![2 4 8 16 32 64!]   ;UVECTOR

Then you got your hashtag brackets, which pop up in the corner of the TV screen reminding you that there's another way to CHTYPE:

  #FORM (+ 1 2)        ;"same as <+ 1 2>"

And your hashtag voucher brackets, which are really just defective angle brackets you can exchange for a free hashtag:

  <>                   ;"evaluates to #FALSE ()"

Finally, you got your bogus brackets, things that look like they could be a new kind of exciting brackets, but when you look closely they're just prefix operators that tend to appear before brackets:

  '(OSCAR WILDE)       ;"same as <QUOTE (OSCAR WILDE)>"
  %<+ 1 2>             ;"evaluate immediately"
  %%<CRLF>             ;"evaluate and discard result"

See also: https://github.com/taradinoc/mdl-docs/blob/master/docs/07-st...

Yes, it's a cruel twist of fate that all this news about Infocom's ZIL is happening shortly after the launch of a cryptocurrency called "ZIL", in the same month as a conference called "Infocom". Twitter search has been useless.

Function definitions normally go in the GVAL, so

  <DEFINE FOO () ...>

is equivalent to

  <SETG FOO <FUNCTION () ...>>

But EVAL will fall back to the LVAL if the atom doesn't have a GVAL. In other words:

  <A B C>

is equivalent to

  <APPLY <COND (<GASSIGNED? A> ,A)
               (<ASSIGNED? A> .A)
               (T <ERROR>)>
         B
         C>

https://github.com/taradinoc/mdl-docs/blob/master/docs/03-bu...

This is described in glorious high-definition ASCII art in Appendix 1 of The MDL Programming Language:

https://github.com/taradinoc/mdl-docs/blob/master/docs/appen...

Everything you said about I7 is true, but its real value comes from the abstractions it introduces.

That is, it isn't just an English-like syntax for writers who are used to writing in complete sentences... it's a programming model based on concepts from narrative, technical writing, and linguistics, for writers who are using it to write narratives, describe technical systems, and manipulate text.

I7 integrates high-level domain concepts of interactive fiction into the language: scenes and continuity, rules and their exceptions, relationships between objects, templates for parsing and printing text.

Hmm, which evaluation and splicing markers is it referring to?

MDL doesn't have quasiquoting, but it has "segments" that expanded while evaluating a structure (prefix a form with "!", and the result is spliced into the structure), and reader macros expanded while parsing source code (prefix a form with "%" and the result is inserted, or "%%" and it's discarded).

Yeah, MDL used the question mark suffix like Lisp used "p".

Here's a ZIL version of the game where "xyzzy" and "plugh" first appeared: https://bitbucket.org/jmcgrew/zilf/src/tip/Examples/advent/a...

It's defined in verbs.zil.

https://github.com/historicalsource/hitchhikersguide/blob/d7...

Who is that handsome mystery developer, where did he come from, and why can't we get enough of him?

Not functional? Warnings aren't errors. Maybe it's just better at catching potential bugs...

MDL and Lisp kinda co-evolved, and some MDL features (lambda lists, maybe others?) made it into the evolutionary branch that lived.

If you enjoy reading about the Zork Implementation Language, you might also enjoy my project, ZILF, which is a working implementation of ZIL: https://sourceforge.net/projects/zilf/

ZIL is basically a domain-specific language on top of MDL, the Lisp-like language that was used to write the original mainframe Zork. The developers went on to start Infocom and split Zork into three parts that were small enough to run on home computers, creating ZIL and the Z-machine in the process.

The source code for mainframe Zork is still available, but the subset of MDL implemented by ZILF isn't complete enough to play it. Matthew T. Russotto has written a MDL interpreter to do just that: http://www.ifarchive.org/indexes/if-archiveXprogrammingXmdlX...