RIP

good thing it's minimalist

@ASCII-only needs more contrast and too busy

looks very out of tone and the greens are very sharp

@Downgoat too busy?

@Downgoat yeah haven't finished removing greens yet >_>

@ASCII-only I was just listening to the radio talking about "The Greens", an Australian political party, so "I haven't finished removing the greens yet" sounded a bit macabre.

@Οurous lol

@Downgoat halo?

sorry busy

@ASCII-only I don't like linking to the AST because it's too long

Or are the Charcoal answers generally too long to explain every command

@ASCII-only ok good news now even more complex things like default constructor compile :DDD

class Goat {
    let a = "foo"
}

public func main() {
    let name = Goat()
    print(name.a)
}

@Downgoat this is definitely black gaot magic 10/10

here you can see type deduction etc. too also

also pretty fast above only took 0.00032s to compile

@Downgoat actually?

@Downgoat What language is that>

@Zacharý VSL

it's been in development for like a year and a half how do you not know about it

vsl: github.com/vsl-lang/VSL see docs for info: github.com/vsl-lang/VSL/wiki/Introduction

I've heard about it ... just wasn't sure this was it

idk why llvm is so crap at optimize though: gist.github.com/vihanb/7c6d46ed3b81b1b276cec39e328671eb

Yeah shouldn't it just turn into a single statement to print the string?

yeah,

I'm not sure if the malloc is throwing it off

Greetings. I'm looking for a programming language that maximizes the number of valid (that doesn't produce any compilation or execution errors) programs for a given number of bytes -- so as many distinct outputs as possible as as many successful compilation/executes as possible. It's for experimenting with genetic/self-modifying programs. It seems golfing languages could be good candidates. Any ideas?

@ASCII-only what should metaclass-class be called

@Downgoat Class :P

-1 too Java-esque

@Real hmm. there are programs which minimise the number of errors that can occur, however, i'm not sure how distinct they are, since some of the commands simply won't do anything instead of erroring

@Real you could try making your own programming language

CMC: language-design: design a language that uses all 256 bytes and never throws errors (excluding things like memory limits or forcing sigints, etc). all commands must do something but no real specifications on that (thus why CMC and not real challenge)

feedback on this challenge please:

@Downgoat Type?

@Real I think if you're looking for genetics, most possible programs might not be what you want

@ASCII-only this is better

you might want programs with smaller character sets?

otherwise you get a crapshoot with whether or not you get any of the characters that might possibly be useful

@DestructibleLemon Good point most possible programs is not necessarily what I want. The problem is that if most changes to code produce no changes in result, this will slow down finding anything useful. On the other hand, if any tiny change completely modifies the program behavior, that could make it difficult to progress incrementally towards the goal.

@HyperNeutrino Actually?

@Real ... Interesting idea.

@Downgoat but snek use type too

@Real you definitely want to think about what you're trying to do

@ASCII-only yeah but lowercase

and also remember the problem of halting undecidability

@Downgoat ok then is good

@DestructibleLemon I don't see how the proof is valid though because the proof is just a paradox

@ASCII-only huh?

the paradox is a proof, because the contradiction shows the premise can't be true

@DestructibleLemon yes. but what prevents there from being a program that computes whether all other programs halt apart from itself

because how do you decide if two machines are equivalent?

surely you can write programs differently?

or have slightly different results

@DestructibleLemon yes?

yeah but how do you decide what is sufficiently different?

@DestructibleLemon you don't?

also it shows you can't decide all of them, even if you can decide some

@DestructibleLemon In any case minimizing the number of compilation errors (by design) and generally having small sets of symbols seems good, indeed. The halting problem isn't much relevant because I can just cut off candidates that are taking too long to execute.

@Real sure

what are you trying to acheive, though?

art?

@DestructibleLemon but you can e.g. build a halting machine for one specific language though

only if it isn't TC

also consider that any programs that don't halt are doing the same thing, not considering i/o

so you can only run this on things which you can trivially prove halt by just running them

@DestructibleLemon I'm exploring alternative paradigms for machine learning. Say playing atari games, recognizing patterns in text and sound, etc. This approach interests me because Neural Networks (which are the main approach now) can have hundreds of millions of parameters, and be very large. Perhaps a small program could more efficiently accomplish the same.

i don't think so, to be honest

really, you'd want modifications to have as small impacts as possible, but as many possible changes that actually have effects

if the impacts are too significant, it ends up being nothing like the program it descended from

so you'd want commands to be sliding scales

for example, plus 100 versus plus 101

@Real you might be interested somewhat in neural turing machines

wrt learning a "program"

@Real that said, i think there are programming languages based around neural systems or some such, which might be best to use (note these are distinct from neural networks: neural networks aren't tc, they just transform inputs into outputs through a few layers)

Are static lazy fields any useful?

@DestructibleLemon Well, the DNA is more like a program than a Neural Network, so there's that :) Also, neural networks are awkward to deal with memory (see the mentioned Neural Turing machine and LSTMs), and are very large. While it may not beat NNs in say image recognition, there may be niches where small size or speed is particularly important.

because if I do that I will have to store the reference globally

@Real remember how long dna took to develop?

@DestructibleLemon a few hundreds of billions of generations perhaps? Not that much if our clock cycle is 1billion generations/second :) A bigger problem is that DNA is terabytes in size I believe

@Real 1 billion generations a second? seems a little bit generous

@Real well that's mostly for the soft attention varieties, which need to have the memory access tractable for gradient descent. pretty sure there are hard attention ones that read one cell directly from the tape but you train them unsupervised

anyways I think your main trouble is finding a dense representation for your "programs"

(haven't read the transcript yet so don't know what you've discusses)

@Real I definitely think you'd want to consider more than just possible programs, and erroring, because for example, bf (if it was modified such that looping would not break it when unmatching (I think i saw a derivative that did this)) would be wildly unsuitable, since moving one cell to the right would have such a major impact on the program, for example

lol imagine optimizing that with just one hot vectors for the instructions

yeah

@Downgoat they're just a function that you evaluate once

@quartata yeah, so is that useful

@DestructibleLemon @quartata Anyway I have quite a few ideas to address your concerns. For example, I wonder if I could evolve (or code myself) a small "programmer" program that avoids spurious changes to the code, to increase the efficiency.

I mean yeah but more importantly I don't see why it's an implementation issue at all

the crude version of QUARK is nearly turing. Just need to get loops working

@Real you need some big steps for global optimization

simulated annealing might be helpful? idk

github.com/HiroakiMikami/deep-coder

And this is extensible to "meta-learning" -- in which you, for example, get a good "programmer" as mentioned earlier, and this helps with future modifications of the programmer itself (you evaluate the programmer with how much it helps to evolve given tasks). Once you build a library of tasks, you can try optimizing the programmer for this library.

This optimization of course is done with the help of earlier "programmers" :)

But where does the first programmer come from

@user202729 ah goes to show you how up to date I am...

wonder if a deep Boltzmann machine would be good at learning the distribution

@moonheart The first programmer can be found through genetic algorithms -- it should be some simple heuristics saying "don't try that change because it likely yields errors" or "try that because it usually leads to better programs" at first (as measured by slightly improving the time to solve a task)

What would be a good starting task? Even simple things like a truth machine might be too complex

tm isn't exactly a well behaved problem for this

even/odd sounds maybe more its speed

@quartata hmm good idea

assuming the language doesn't just flat out have modulo of course

That'd work, i guess. Even/odd, for computers, is checking a single bit

But.. It wouldn't be very smart to use traditional languages with this concept, would it?

You'd need something more (or less, or somewhere in the fourth dimension) abstract

I were considering brainfuck since it has only 8 symbols, but i have never written a program in it myself

uh, actually, brainfuck, or boolfuck, might just work

@Real The first DNA was developed before "generations" existed though

@Real There's a language dzaima and I were working on in which basically every sequence of bytes would be valid

@Real shouldn't you be looking for language which do useful things >_>

@ASCII-only that's very cool, could be useful

@Real The actual parsing from/to bytes hasn't even been started though

well yes it should be efficient too, but efficiency must be balanced with reduced symbols and code size

And the way it is will be designed currently means that each version of the language will be completely backwards-incompatible with the last

@Real Then I doubt the machine would be possible to write any slightly non-complex program, as even we find it difficult to write one...

(fact: the situation has changed. On PPCG, BF is easy)

Definitely not brainfuck. Way too difficult to infer about due to the nature of its loops IMO

@Downgoat should ppcg design implement this

is there anything resembling c or python but with drastically reduced symbols and functions? (those are the languages I'm familiar with, unfortunately :P)

@Real what do you mean

@Real oh also IMO that would work best in conjunction with AI-scale neural networks (idk how to describe it) - basically the neural network would be the programmer, which would write programs to (somehow) replace parts of the network

could anyone here give feedback for a challenge in the sandbox i made?

@Real Also: I think the language you're looking for would have every token as one character, and a small set of keywords key-token-things to minimize useless changes to code?

How come the notification for your amd graphics drivers finishing installtion is opening a webpage subscriptions.amd.com/driverinstalled/index.html

Can it not just make a normal notification appear

@Pavel maybe their devs are underpaid

Actually it would be a lot easier to just make it generate a node tree

There are Pyth (golfing language based on Python), (disclaimer: I can't write Pyth)

@user202729 It doesn't have drastically reduced symbols nor functions

Charcoal is actually pretty similar to Python but it has barely any of Python's stdlib as builtins and uses a super slow parser

... "drastically reduced symbols"? Well, BF has only 8 symbols, and it certainly somewhat resembles C.

a tag system might be easy to infer

hmm

This one :P

trouble is you need order for the production

@ASCII-only ha, yeah that would do it

limited alphabet helps out

still the initial state is variable length

O_o there's a brainfuck interpreter for bitwise cyclic tag

and a /// interpreter too

/// would be easy

(assuming you mean BCT interpreter in /// which is the one I see)

(it's trivially compilable to C, too)

@quartata Do you think they might have meant the other way round?

sure looks like /// to me

There's also an interpreter in Thue O_o

But I guess that's a lot like ///

@DestructibleLemon So the (Quarterstaff) code is linear? Can there be other characters (space, tab, newline, comment) in the program?

oh yeah,i knew i was forgetting something

any character not mentioned as part of another command is considered a separator

@user202729 linear means only loops, not jumps?

@DestructibleLemon i think they mean 1D?

Means from-left-to-right, without indentation rules (Python) or source code layout (Hexagony).

Yes, 1D.

a newline is considered a valid character to be used

but it has no different effect from space

So, it's a separator.

newlines have no impact beyond being a separator, equivalent to a space, or a ^ or whatever

separators only affect variables and numbers

1234 vs 12,34 or ab vs a b

I guess i could constrain the input to ascii only as well?

@user202729 but yes that's right

@DestructibleLemon Why are there two ] but no }?

@DestructibleLemon to what? :P

@user202729 typo

reload the page

Also, "assume that the input is valid, no mismatched parentheses"?

@user202729 yeah i should mention that

is the spec clear for quarterstaff though?

that, and the bf spec, are my main concerns

also whether i should allow all characters to be inputted or just space among non-command characters

i think it's best to allow any

So [] are while-loop and {} are while-not-loop?

also i was considering changing to limited cell bf

@user202729 yup

Although not strictly necessary I think that's more intuitive.

@user202729 which?

Why are people so fast to VTC things...

@user202729 to specify, which thing is more intuitive?

@user202729 is the description for if else good?

The "while-loop" and "while-not-loop".

Yes.

@user202729 I'm sorry, what do you mean they're more intuitive

i haven't changed them, only corrected a typo

I wanted to say that you should add something like "Intuitively, [...] is a while loop, and {...} is a while-not loop."

ok, i guess i could do that

commonly known as an until loop

CMC: Design a language such that the language is decidable under the halting problem. Make it as generally usable as possible. (I might bounty an impressive answer!)

@ConorO'Brien ok this is very simple

if it would halt, just make it print something and then hang

@ATaco a-ta.co/generator is completely broken and unusable, for whatever reason when I copy-paste into the text box it pastes twice and then pressing keys just makes it spam the copied text everywhere

@DestructibleLemon then it wouldn't be valid for any ppcg challenges now would it? :)

ok so, idea for a brainfuck deriv that's not super trivial: limited size cells, and the cell size is the nth prime for the nth cell

muhahahahahha

that's actually kinda cool

@ConorO'Brien uhhhhhh C

doesn't it have limited size stuff

@DestructibleLemon design one, and that's boring :P

i'm just pointing out...

@HyperNeutrino I cannot repro

@DestructibleLemon Technically... every language has the halting problem decidable on practical implementation.

@ConorO'Brien you might want to specify unlimited memory as well perhaps, so that such a language does not win?

because having limited memory makes it instantly trivial

@DestructibleLemon I'm the one assigning the bounty, so I'm not worrying about trivial answers.

Then just limit the language to have "only" 1TB of memory. Decidable, usable, and boring.

ok, but saying you need to have unlimited memory seems like a good idea

having limited memory means that it's decideable by default

right

so I'm expecting people to be better than that if they want a chance at making something interesting

@ConorO'Brien VSL because most important things probably don't work yet

anyone here used LLVM before?

VSL generates this line:

 @llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @vsl.init, i8* null }]

which seems to be correct according to: llvm.org/docs/…

however LLVM complains it does not have 'pointer type'

lli: <stdin>:7:1: error: global variable reference must have pointer type
@llvm.global_ctors = appending global [1 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @vsl.init, i8* null }]
^

which doesn't really make any sesne

@ConorO'Brien maybe a dual language that unites a severely memory-constrained turing-complete part with a decidable part, and limit communications between the two parts such that you can't just use the decidable part as a memory (you'd use it to calculate functions?). Now idea on the details.

No idea*

@Real How can memory-constrained be turing-complete...?

(also you can edit SE chat messages within 2 minutes)

@user202729 not actually Turing complete, you'd just take a turing complete language and modify it restricting its memory (pseudo-turing-complete?)

so that it is still practically as useful as any language

while the whole language would have unbounded memory? :)

@Real bounded storage machine?

ok idea: control flow is some sort of recursive thing but you can't access all of memory within the recursive thing

Yep, or LBA or something similar. Then you add an unbounded but decidable language to be used as an auxiliar

ok I'm not totally sure you can get anything which is interesting and not trivially limited

you have to figure out how to make a program have meaningful limits

@ASCII-only I am hosting rn

@Downgoat is it online

What is this?

@Downgoat I thought Mego was

Also I signed in with my SE account and got this:

{
  "error": true,
  "message": "Profile does not have name and email",
  "type": "bad_profile"
}

@Pavel "codegolf. vihan .org"

@user202729 I know Goat provides the domain

But it was definitely running on Mego's computer for the past couple months

@Pavel yeah megos server apparently went kaboom so now i am hostignn

@ASCII-only codegolf.vihan.org

@Pavel yeah im not sure why that is happening, u can blame SE in meanwhile but I'll work on it when I have time

I'm very busy this week

ok

well now login is broken entirely for me

(why doesn't the bold working without spaces)

ok so, idea i have: {...} is the control flow, and each character resides on a cell of infinite size, and you can't access any cells outside of the current scope

PPCG v2?

@Pavel run ErrorManager.dump() and send my way

@Zacharý How have you not heard of it we've been walking about it for months

Ah...

@Pavel I'm sorta oblivious...

"Error Dump for instance i7c5add5925dfda87615a83968d966746:

 1. Error
    Unexpected login error"

@Downgoat ^ doesn't seem very useful

weird, it should give me helpful dump with error message

do you see anything else in console

Yes

Like a shit ton of red stuff

Let me put it in the v2 room

I got the same message too.

@Pavel oh rip thats either a 400 or 500, neither is goodo

> Failed to load resource: the server responded with a status of 500 (INTERNAL SERVER ERROR)

> 500 (INTERNAL SERVER ERROR)

0/10 went onto quora and saw question from the math contest/exam that I wrote yesterday that specifically said "do not discuss online for 48 hours" (just over 24 hours passed)

@HyperNeutrino Flag?

(well, reported)

... they probably knew they had no chance of getting it in, so they just said "screw it". And you wrote it?!?! (The exam)

@Zacharý I think HyperNeutrino meant they took the exam (not sure what's the correct verb?)

wrote/took are both correct

@Zacharý yes I wrote it (because it is an american thing)

(and we're allowed to write it from canada lol, not sure if it's international or just usa+can)

Just Canada...

Or that Zacharý understood it as "you made the problems for the exam"

o

CANADA ^

Or at least I think it's just Canada, but I'm not sure since I live in the sticks.

it's invitational lol

idk

ಠ_ಠ french 0/10 (:P /s)

That wasn't golfier ... no clue why I did that >_<

don't you mean "jnsp pourquoi je le ferais"

I think it's "ferais"

oh god I've forgotten so much from not being in french class for so long :P thus why I never really learned french well, no opportunity to practice it

YOU LIVE IN CANADA.

yeah well not all provinces are officially bilingual and ontario claims to be but it's like 70% english here

the other 30% is a combination of chinese, arabic, and other languages

Where do you live in Ontario?

southwestern (waterloo region)

Ah... isn't French more commonly spoken up north?

Just randomly start speaking French when ordering food or something... :p /s

lol... idk if customer service here is required to be EN/FR bilingual. probably not required

but yeah, I think it is more common north of here

and definitely closer to Ottawa (national capital, kind of needs to know french for most cases) (and because that's close to the river)

I thought French was just Quebec

No, the lack of English is just Quebec

i.e., monolingual French = Quebec

Quebec is officially bilingual with a French majority and some provinces are officially bilingual with an English majority (Ontario, Maritimes, etc), and most Western provinces are officially monolingual English

@Zacharý pretty sure qc is also bilingual but idk

I've only ever been in BC

BC is a pretty cool place. I've been there before but only to Vancouver area

:43277869 well I mean they kind of hate anglophone culture for good reasons :P but idk about the official language status

Isn't there one providence where there's not really a majority?

In my experince, Vancouver is like a copy of Seattle. It's kinda interesting how similar they are.

wat?

@Zacharý Probably NB or something like that

@HyperNeutrino I think that was it.

@Downgoat :/ PPCG v2 is super unfinished

@Pavel They're basically right next to each other and yeah I definitely see a lot of similarities. I've only been to Seattle and Vancouver for like 2-3 days each so I don't really know much about either

definitely NB. the other maritimes are still anglo majority

anyway brb o/

@ASCII-only Well no shit

It only has two people working on it

It took you over a year to get VSL to print Hello World

So

@Pavel say what

@Pavel I haven't been working on VSL >_>

Wasn't that you and downgoat?

I'm pretty sure that there are many PPCG users who want to help with something and don't know what to do.

@Pavel It's mostly Downgoat and his IRL friend nowadays?

@Pavel VSL is muuucch more complex in terms of scoping, type system, module system, and compilation system

@ASCII-only other guy works on C++ version thuogh

so just me

@Pavel >_> why would Downgoat need to ping me if I knew it worked >_>

Also don't forget the fact that VSL compiles to x86, all LLVM targets, iOS, and WASM

@ASCII-only Well if he literally just made it happen and hadn't told you yet

Swift is backed by a $1T company and it took 2years for that to get dev'd to a similar point to where I'd say VSL will be in around 1 mo

@Pavel I guess that's true. But such a big step doesn't happen quickly

What is VSL in?

JS

But it's compiled and not interpreted so performance isn't actually shit

@Downgoat oh btw theoretically how long would it take to port VSL to different backend (other than LLVM)

@Pavel faster than C++

Is that just because you haven't implemented virtual calls yet

primary compiler is in JS, STL is in VSL, backend parts in C++

@Pavel Virtual calls you'll get similar performance to C++ but we also blow away C++ in terms of compilation time