Just posting a message here so that the room can be linked to

hmm, I guess this is a good place to talk about various languages that don't fit into a comment easily

Underload is normally fairly easy to fix; one thing that's worth particular mention is that (…)! is a comment in Underload (parentheses nest when determining where a comment ends)

also that (…) without a ! pushes code onto the stack but doesn't run or parse it immediately, so you can do things with it first (! just gets rid of the code again, but you can also do things like push other stack elements on top of it)

when I originally introduced Underload, I stabilised it by putting a few (::) on the stack, which has a tendency to copy itself when run

Yeah, I kinda messed up the underload. :P

incidentally, I've been working on some driver bugfixes

but haven't had a chance to post them as I haven't got an answer in

I've been working on asm-with-cpp, which seems really promising as a language to add

lol, yeah I was wondering why I haven't seen you answer in a while

(it's the language gcc implements if given a file with extension .S)

well, I've hardly PPCGed at all for a while, I've been busy

I'm pretty sure asm-with-cpp works but it might not work on x86

one thing I discovered, that seems helpful, is that you can get rid of the need to #include anything via using __builtin_puts rather than regular puts

oh interesting!

So I'm guessing INTERCAL's syntax errors all say "CORRECT SOURCE AND RESUBNIT". Is that right?

yes

actually all errors do that

whether runtime or compile time

I kind of assumed that all the languages that had messages in debug without an exit code > 0 were jsut warning messages. :/

those say RECONSIDER SOURCE AND RESUBNIT

but they're not turned on by default

btw, it's worth noting that syntax errors happen at runtime in INTERCAL, because it's fairly insane

lol

I loved getting into learning that one. So wacky!

right, it's actually the language that got me into esoprogramming, which got me into recreational programming, and I eventually ended up on PPCG

Cool.

finding new languages is hard, though; part of the problem is that most of my languages, I didn't write the interpreter myself, so I don't know how it'd handle a syntax error

(and most of the time I do write it myself, I error on errors rather than ignoring them)

however, this challenge has made me much more inclined to make any new languages I write produce warnings on unrecognised syntax rather than errors…

anyway, I was working on HPPA assembler, which I'm pretty sure can be made to work, but it's way too verbose (at least in the output of gcc with -Os, and also hard to test

PDP-11 asm might work but may be even harder to test (and I'm not sure gcc even runs on that platform, in which case there wouldn't be a pre-existing compiler that works the way we want)

the reason these two are promising is that they use semicolon as a comment marker

on x86 the comment marker is # or /* … */

which is so annoyingly similar to C's syntax that it seems very hard to make it work

Nice! that's sounds very promising.

it's not impossible, but you'd have to find some way to place a literal // or /* into the program via preprocessor abuse, and in a place where one language would parse it literally and the other as a comment

and asm and C have syntax so different that any polyglotting attempt breaks down very quickly

of course, given the whole "# as a comment marker" thing, I wonder if it's possible to do just plain asm, rather than asm-with-cpp

the problem is that then you need an asm/Python polyglot, which also seems nasty (polyglotting it with Perl and probably Ruby should be easy, but Python is a lot stricter syntax-wise)

btw, this page may be a good place to look for languages (it's a list of Esolang articles that claim to have links to implementations; not all do, but there's still a wide selection there)

ooh. that's a good resource

I am super committed to including asm.

huh, /// isn't in there yet, I think? that should actually be really easy

Something about adding non-esoteric languages just makes things feel so legitimate.

I looked at that one for a minute. Not sure why I passed on it.

/a/b/ is a comment if a doesn't appear anywhere in the code

the problem is that if a is a zero-length string, then it goes into an infinite loop

which is going to mean a lot of small changes all over the code

what's the // on the first line for? that breaks the code already

oh, I know what the problem is

/// outputs everything before the first slash literally

and the program starts with a #

that seems fairly insurmountable

line one // is for C line comment.

ya know... now that C's preprocessor directive contains (), /* might be safe on line 1. hmm

it wouldn't help /// due to the leading #

but starting the comment early is probably going to help golfing-wise

I think I'll explore that avenue this weekend. It'd be nice if Japt's string could start earlier.

the INTERCAL fix added 6 bytes.

gonna post it

is it still the greatest polyglot ever? :-)

yep

threshold achieved

I kind-of feel like we need to post this to the VIP challenge somehow but it doesn't seem to fit into the PPCG format

perhaps as a comment to the question?

That's not a bad idea.

But then we're probably going to beat it within a couple weeks.

oh, I meant posting this entire challenge as the answer

rather than any individual polyglot within it

That makes sense. You should do it.

OK, doing it now

cool. I gotta head out. Thanks for making the room

sure thing

you can ping me any time with "@ais523" and I'll be notified

like this

@ais523: I came up with a great new polyglot idea!

(although I might not be online, or around; I don't check PPCG all that often)