... I think I found my error from before ... I feel stupid now

References ,.. ugh I hate them so much...

@ngn ... Is there a lot of users here who use APL? ... /// Will you award it immediately or until the deadline had passed?

@user202729 As a golf-ish-language, or as a language? (I feel the former has more than the latter)

CMP: Should int and float be one type? Should char and string? (For Jagony)

@user202729 By the way, note that that challenge requires a "named function". The author (xnor) said f←something is ok as a named function. I've assumed a complete program is not allowed.

@Zacharý how can int and float be one type?

JavaScript

@Pavel javascript has only double-precision float, no int

Good point

In that case, Perl

@Pavel ok with perl you caught me unprepared :) i don't know how it works there

Where 1, 1.0, and "1" are not only equal to each other but are literally the same exact value.

@Pavel WHAT?

it does internally represent 1 and 1.0 as different types, and you can see that using Data#Dumper which serializes objects, but if say I have $i = 1 and then run $i eq "foo" it'll actually convert the value $i is represented by internaly to a string even though all we did was check for equality with a string.

"1" is the same VALUE as 1?

Yep

... more reason to eternally hate perl

You can't tell them apart except to use essentially a debugging tool

... burn it with fire

@Zacharý Guess what the internal representation of !0 is? You'd think it would be 1, but it's actually a union type containing 1, 1.0, and "1".

BURN IT

@Zacharý perl 6 has an entire grammar built in

@moonheart08 A crappy grammar that I remember being bugged out to saying 2+3=2

That Perl 6 is built on itself, allowing you to modify it on the fly.

@Zacharý Pretty sure they fixed that

Perl 6 is recursive then?

lul

I should learn it, just to mess with my friend's heads

Perl also lets you define custom types that are entirely indistinguishable from ints and strings.

So you can make the mess that is the type system even worse

The only GOOD decision Perl has are its grammars and operator overloading ... past that, BURN IT WITH FIREEEEE!

Float v. int, that actually makes some sense

@ngn Bitwise operations do in fact behave differently for ints and floats. I believe most perlers consider this to be a mistake.

@Pavel but I've used the same expression 1<<53 in both cases, it should evaluate to an int, no?

@ngn Addition on ints and floats being minutely different? It makes more sense then some of the other things

@Zacharý yeah, it could be that

@ngn Right. In fact, 1.0<<53 would get you the same results.

Bitwise operations in Perl are just really weird.

/Bit wise operations in Perl are/Perl is/s

it starts getting weird at 1<<50, it looks different from 2**50

Bitwise and works differently for 1 and "1": perl -E'say( (1 & "") eq ("1" & "") ? "eq" : "!eq")'

This is worse than [] + [] in JS...

to answer the cmp: my opinion is that fp and ints should be kept as separate as possible

I don't have a strong preference for char vs string, that depends on what would fit best with the rest of your language

@ngn who needs 'char' when you have integers? :P

@moonheart08 and ints are just bit arrays :)

who needs bits when you have unary

@moonheart08 who needs numbers... we could be like those tribes who have words only for "one", "two" and "many" :) (I'm not sure about the "two")

"one" and "many": Pirahã language (tribe != language)

@Zacharý yeah, that one :) aren't they a tribe in the amazon or something... ?

They're horrible fish ... :p

But yeah, I think so

Greeting again codegolfers. I'm about to start a little project (not unlike others that come before) to use genetic algorithms to generate short programs that do little tasks (some day perhaps play a simple game?). Brainfuck has a history with this kind of experiment due to having only 8 program symbols. Are you aware of any similar esolang that contains very few symbols but is perhaps a little more efficient, more straightforward, etc?

@Zacharý You can read the answers to stackoverflow.com/questions/48750100/… for a better explanation of Perl's type system

@Real not exactly an esolang, but I've been fascinated with this game: robozzle.com You control a robot with a small set of instructions, including conditional execution. There's a stack, so recursion is possible. The goal is to collect the stars from a maze. I suspect some of the best scores were achieved with the help of genetic algorithms.

@ngn That's pretty cool. I will eventually need to write the genetic algorithm in brainfuck itself. Due to BF's infamy as hard to program that scares me, which is why I'm looking for a more friendly or faster alternative if it exists.

@Real oh, so bf (or another small lang) is not only the target but the generator too... that sounds ambitious :)

A guy did a whole OS in BF, right?

@ngn Indeed: the basic working principle will be that the genetic algorithm not only can modify the program of interest (that is trying to achieve a certain task), but also modify itself. So to become good at a task it can get lucky by having "good" children -- children that are directly good at the task -- or it can get lucky having children which are themselves better at choosing the next generations. For hard tasks you'd expect that it would become quite good at generating fit children.

@Real if you're familiar with any of the dialects of lisp, it's the usual toy language for such "meta" experiments

As far as I'm aware, previous experiments did not include the program modifying itself. (to be honest I'm not sure how well that will work). This approach is called metaprogramming

@ngn I'm not, I'll have a look

@Real there's an old lecture series from MIT called SICP (structure and interpretation of computer programs), it's an excellent intro to scheme (a dialect of lisp); the lecture you would be most interested in is perhaps the one about the "meta-circular evaluator" - a scheme interpreter written in scheme: youtube.com/watch?v=0m6hoOelZH8

@ngn Cool! The general idea of the program encoding itself dates back to von Neumann I think. But details have been severely lacking as far as I'm aware. One good development is the "Godel Machine" by Schmidhuber, which also modifies itself and (he claims) can actually solve any problem as fast as possible with some startup time. But it's never been built because the starup time is astronomical. So I'm trying something a little more concrete.

ftp.idsia.ch/pub/juergen/gmAGI.pdf

people.idsia.ch/~juergen/goedelmachine.html

Poll: unary pronunciation

@Real "solves any problem as fast as possible with some startup time" - that's a bold claim :) I'm sure there must be some "if"-s and "but"-s

@ngn yea no doubt :) I didn't try to grasp the details of that paper though. But it's not unbelievable once you allow it to take millenia to write a simple "Hello world" program :P

I'm more inspired by the DNA, which is both responsible for the features of the creatures and how future creatures will generate successors, hence the DNA works like a program that "modifies itself". And genetic programming already kind of proven to work with BF (for very simple stuff), I'm interested to see if it could stumble upon small self improvements: for example, BF programs don't usually have uniformly distributed symbols, so it could learn to try the most likely symbols more often.

@Real why don't you invent your own language for that purpose? you could start from bf and add what you think might speed up evolution

well I can try, I'm not that experienced of a programmer though :X It'll be hard to tell what's "missing" from BF to make it quicker or easier

@Real bf is very easy to implement

Ideally for me would be a language like C, so later on I might just try to simplify C to something minimal and shorten the symbols (int->i, char->c, etc).

the requirement to declare variables and keeping track of their names is pretty advanced though! the genetic algorithm might have trouble with that

python is very good too, but it might be too slow

(and simply use GCC for compilation)

@Real So you want a language that's easy to compile, can do difficult things easily, and don't like errors...?

Still, if you don't have a lot of symbols, you have to re-implement the built-ins (which is not trivial), and then the code won't be short.

yea I'm asking for too much maybe :) I believe most languages have unecessary symbols for this purpose though

for C I might ditch for(;;){} and have only while(){}

for example

or I'm reading the pyth spec, it has a symbols for computing average of lists, converting to hexadecimal string, all sorts of unecessary stuff for my purposes

@Real To mimic evolution you need a language in which slow gradual mutations result in small gradual advantages. C doesn't work that way - e.g. a single open paren isn't half as good as a pair of parens.

@ngn yea good point

in theory a good "next-generation-function" could try to automatically close parenthesis but I'm going for something simple here indeed

I'm just so curious if my BF metalearner will actually be capable of modifying itself. I guess I'll just go with it and if it sucks I'll move on to something else :P

It's the simplest metalearner I can imagine

so on to learning how to do stuff in brainfuck :(

If anyone wants to help you're more than welcome

General golf lang = APL, in all honestly with how good it is at it.

@Mego I was aware of that, but thanks. Do you have a recommended way of running programs/an interpreter in general? The standard seems to be the Fast BF interpreter bff4.c

Oh my there appears to be a C to brainfuck compiler ! github.com/arthaud/c2bf

So is 8cc+ELVM.

I wonder if it is efficient. It could make my life so easy

BF is never efficient. Compare two numbers (less than or greater than) take O(number magnitude) time.

oh really? I wasn't aware of this. that's possibly bad news.

wait, by O(number magnitude), do you mean O(number of bits of number N), or simply O(N)?

csharp> double.MaxValue+9999999999999999
1.79769313486232E+308
csharp> double.MaxValue                                                                                                                        1.79769313486232E+308                                                                                                                          csharp> double.MaxValue + double.MaxValue                                                                                                      Infinity

Doubles make no sense

You could get it in O((# of bits)^2), if you stored them bitwise.

Why can't they just overflow like normal numeric types

But really it's worse.

Since it's also multiplied by O(distance between the numbers on the teape)

ouch. is there a variant that solves this to allow O(# of bits)?

You could try not using brainfuck.

^ solves most problems where it is applicable

:( but I need something very simple and I don't know any other simple language

... Exactly what do you want? ...

Have few symbols? No error? Small program changes lead to small output changes?

Easy to program in?

well it has been a long commentary chain /\ but essentially an efficient language with less than 20? or so symbols

all of those would be good, but if I had to chose it would be only that -- efficient in O() and with low symbol count

But why

to make a program that programs itself of course ;)

What does that even mean

I've explained previously, but I'll summarize

Is this homework?

no, just personal project

@feersum I doubt someone would give such a hard homework...

You can try picking an existing golfing language and remove most symbols.

I'm only familiar with Jelly now, but some stack-based languages may be useful.

Say you want to automatically program "Hello world". You can then "simply" use a genetic algorithm + brainfuck to search for programs that output "Hello World".

But genetic algorithms can be awfully slow to find large programs, if the steps are hard it can end up requiring 2^(program size) generations.

Even then, with a program, how can you verify its correctness?

@user202729 Simply run it (for at most say 10000 steps), and check output

continuing, so instead of using just a genetic algorithm, you allow the program to modify its own genetic algorithm, at the same time that it can try to modify the programs. Evolution should make it so that better versions of genetic algorithms that generate better programs may start to dominate, and overall the search will be faster.

For this, the genetic algorithm itself must be written in brainfuck.

and this is where I'm at, trying to learn brainfuck :X (if only I could write it using C would be no problem)

oohh ok. Is that usable? Or does it make the programs too large?

that's awesome if usable!

... is there any existing minimal stack-based language?

@Real Ruby, 25 bytes, albeit without neural networks: puts"puts#{gets.inspect}"

@Pavel Huh...?

You tell it what you want to output and it returns a programs that writes that output

Yea, but if I give it 1000 unsorted lists and a sorted one, can that learn to sort lists? :P

See, you could have said something like that earlier

That said, I'm still not sure how that would work

It's simple, you would just search for programs that have the correct input->output, and hope that it is correct for all inputs and outputs. Because it cannot just store all the necessary inputs and outputs, usually the program you find will indeed sort lists.

The only problem is there are too many damn programs to search through :P

So the idea to "seach for good searchers" arises

puts 'puts #{gets}[gets]' takes a dictionary as input, produces a program that maps inputs to outputs based on that dictionary. :P

>.< You do raise a valid point that it's not any program that successfully maps input->output that suffices, but small programs, so you need to search giving priority to small programs

because small programs can't just cheat by storing the given input->output

validation loss

Huh?

(for something like brainfuck you probably would be in a valley long before it overfit that badly anyways)

although... this is a GA right

Huh?

?

yes, GA

What's that?

Genetic algorithm

Oic

no idea how crossover would work for that

it'd depend

I will probably start with no sex, just random mutations (which is adding/changing/deleting a character) and killing off a fraction of the worst candidates

I can't imagine GA would work at all for anything other than fixed output.

I have just made a terrible mistake... while implementing Dijkstra algorithm, I prioritize the node with least index instead of least distance.

@Real starting to sound like simulated annealing would be better

then at least you have some control over the "mutations"

(via the annealing schedule)

@ASCII-only how should VSL print() integers? Do we want to create our own digit -> String system? That seem hard :(

how would simulated annealing work? just start random and decrease mutation rate?

@Downgoat It really isn't.

@Pavel if you do for() then it's not but that is very slow

Or override print(int x) to printf("%d", x)

the point of this experiment is for the program to modify itself though, and SA doesn't seem to fit well with the overall generational thingy

@Pavel printf is C specific

Doesn't VSL use libc

@Downgoat literally stock itoa

I can't guarantee ABI for those since those varargs

@quartata pls provide implementation that also handles floats, doubles, Nan values, infinite values, and correct +/- zeros

....stop equivocating

we were talking about ints

sorry, meant numbers in general

still point was that libc isn't magic

huh, I assumed itoa() would be more ingeniously implemented using clever bit tricks and whatnot :/

pretty disappointed 0/10 for readable libc code

Then there's the fact that it is non-standard too

@quartata i beg to differ: github.com/lattera/glibc/blob/master/stdio-common/_itoa.c#L194

// Have some horrible C pseudocode
void print(num x) {
	switch(typeof(x)) {
		typeof(int):
			printf("%d", x);
			break;
		typeof(double):
			switch(x) {
				case double.NaN:
					puts("NaN");
					break;
				case double.Infinity:
					puts("Infinity");
					break;
				default:
					printf("%f\n", x);
			}
			break;

	}
}

How is that C? ...

@Downgoat that's for GMP I think

@Pavel ... that is how python works not machine code

> pseudocode

@quartata glibc is used for more than gmp

....

I mean that the code is literally calling into GMP

so I don't think that's the default implementation

still it isn't much more complicated if you look past the weird inline macro def

@quartata still has lot of magic with lookup tables and normalization

lol

@Downgoat looking at it some more I really don't think it's the right one

@quartata it's in /stdio-common

Seriously, I could have sworn VSL used Libc

Can the OP accept flag as duplicate?

Yes

Oh not flags

@Mego And will the voters be listed with Community<>?

(ASCII diamond)

@Pavel it uses some standardized methods in which we can be sure of ABI compatibility and are portable cross-platform including things like WASM

I have literally only ever seen an OP accept a VTC-dupe vote once

Then how does this work? (I can only flag, of course)

I was hella confused how Community could close a post

@Downgoat here's newlib's: github.com/leaningtech/cheerp-newlib/blob/master/newlib/libc/…

(It's a fork but that file definitely wasn't touched)

Anyone know at what point does deleted by Community♦ (RemoveDeadQuestions) happens?

@quartata even just regarding ints, 1) still a cherrypicked counterexample 2) the fact that itoa is non-standard

@Pavel Probably 30 days, no positive vote, and <= 1 answer.

@Downgoat what are you talking about

I don't know of any libc that doesn't have itoa

The point is the implementation at any rate

@Pavel meta.stackexchange.com/questions/78048/… [no onebox]

oh thanks

Also if you look in that glibc file there's an _itoa_word that is almost identical

the other thing appears to be conditionally defined

speaking of division. @ASCII-only suggestion for int division operator?

our plan was to make it so that division returned a variant type of sorts

@Downgoat What does / do?

it defaults to float, but if you assign it to an int it performs integer division

(or cast it)

(really at that point it's just an optimization)

@Pavel normal division but if you do like let a = 1 / 2 it will assume Double since int division instead of double division is common source of error

Well you could borrow python's //.

won't work // is comment

I used ÷

Ah

in Pyt, that is

This is a practical language

That isn't Perl 6

Julia... actually does that

Is there no ASCII variant?

@quartata A lot of Julia things have ascii versions though

Can't remember

All I know was that it was the shortest for golfing

VSL also has like ÷ -> / but very often impractical

@Downgoat Perl 6 does too

Perl 6 has Unicode variants of everything

it even has an atom emoji for atomic operations

I did not know that

I wish I was kidding

It's purple and clashes with everything

Stuff like this is probably a big part of why it's so god damn slow

And I'm speaking as someone who has dedicated at least 3/4th of their entire life to finding ways to put more purple in their life

It is not a good purple

...how does that even work

Not on dark theme at least

@Pavel blog post bragging about how great the atomic operators are

God damn

perl = emojicode?

@quartata +1 for emoji operator -1 for wordpress

@Downgoat not that hard

@ASCII-only pls see following conversation

@HyperNeutrino this isn't perl

should handle not just most simple case

e.g. float stringified can be huge, so should be able to allocate correct amount of memory and all

how about we just start calling it "rakudo" to clear up confusion

@quartata it isn't?

(or are perl6 and perl completely different)

someone LLVM that when something says 'alwaysinline' that means it should be inlined

completely different

ok

I get that in complex cases it can be hard to inline

but this is basic textbook inlining case

They're made by different teams and Perl 5 is still under active development

Perl 5 code is only slightly more likely to work in Perl 6 than in Ruby.

Perl 6 is basically Larry's midlife crisis after years of getting dunked on by rabid Python fans. I'm sorry but it's true

loll okay :P

I feel bad for saying it but

I don't know if he's still active with Perl 6 anyways

I mean it started out OK

then when pugs died that's when everything went wrong

pugs?

One of the first ones

Along with Parrot

Hold on are these literal people that died

no

Ok good

implementations

pugs was written in Haskell too so you know it was p good

back when Haskell wasn't cool yet

Is Haskell cool? I'm pretty sure it's still kind-of a "hipster lang".

no Haskell is definitely cool since it's still the only one that's managed to get M:N figured out without being Erlang or Go

go being the programming equivalent of a sensory deprivation chamber

and erlang being awesome except for elixir

anyways I think Perl 6's philosophical problem is that now with only one implementation Rakudo is driving Perl 6 dev and not Perl 6 driving Rakudo dev

which seems to lead to problems for whatever reason

@Mego I like functionaling programming, I just don't like being forced into functional programming.

Which is why LINQ is basically my favorite thing

on a x86_64 machine. This seems to match the correct invocation of itoa:

public func itoa(int: Int32) -> CString external(itoa)

however I get a segfault

actually looks like itoa is not an actual function

it takes in a base and a buffer

Undefined symbols for architecture x86_64:
  "_itoa", referenced from:
      _print.$51 in .vsl-temp1699e41d.o

linking with -lc

don't want to have to dig through implementations so I'll manually implement for integers

C functions don't have a type signature, only, a name, so invoking the function wrong wouldn't cause a linker error, I think.

^ It's likely a macro aliased to actual definition of itoa

Oh, you're not parsing the header?

@quartata Resolving macros is a whole other thing compared to parsing plain headers

Are you just missing the underscore?

C symbols are "mangled" by simply prepending an underscore.

Oh right. Try removing it then!

@Downgoat pretty sure ctags will do it

Hmm, maybe that's only on Windows.

@quartata nope

But really, it's better to write your own implementation.

Then you avoid issues like slightly different behavior depending on platform.

@feersum underscores are what they are prefixed by in the compiled ELFs rather than like private stuff

^ I am just emitting .ll files for windows, I am not even bothering compiling them with msvc :P

@feersum yeah this was my original plan

What was wrong with it?

@feersum MSVC? or original plan

MSVC is just generally kinda crap

plan

quartata said to use itoa

I just want to know why it's called itoa and not itos since it's converting and int to a string

@Downgoat just checked and it does

also why then it's called puts and not puta

@quartata really? I just get this:

FILE	/usr/include/stdio.h	/^} FILE;$/
__sbuf	/usr/include/stdio.h	/^struct __sbuf {$/
__sclearerr	/usr/include/stdio.h	/^#define	__sclearerr(p)	((void)((p)->_flags &= ~(__/
__sfeof	/usr/include/stdio.h	/^#define	__sfeof(p)	(((p)->_flags & __SEOF) != 0)$/
__sferror	/usr/include/stdio.h	/^#define	__sferror(p)	(((p)->_flags & __SERR) != 0)/
__sfileno	/usr/include/stdio.h	/^#define	__sfileno(p)	((p)->_file)$/
__sputc	/usr/include/stdio.h	/^#define	__sputc(c, p) \\$/
fopen	/usr/include/stdio.h	/^FILE	*fopen(const char * __restrict __filename, co/

I never got around to it but the plan was that Pytek would just use ctags to parse the header and make stubs from that

stdio.h should have itoa somewhere

@Downgoat what version?

itoa isn't in stdio

@quartata of what? All I could find for ctags is '4th Berkeley Distribution'

@quartata what OS?

itoa might be implemented as a method on your machine?

itoa should be with atoi in stdlib.h....

it's not io

(atoi is stdlib.h)

ninja'd

@Downgoat exuberant ctags

that's the modern one

MB_CUR_MAX_L	/usr/include/stdlib.h	/^#define	MB_CUR_MAX_L(x)	(___mb_cur_max_l(x))$/
__alloc_size	/usr/include/stdlib.h	/^#define __alloc_size(...) __attribute__((alloc_siz/
abort	/usr/include/stdlib.h	/^void	 abort(void) __dead2;$/
div_t	/usr/include/stdlib.h	/^} div_t;$/
ldiv_t	/usr/include/stdlib.h	/^} ldiv_t;$/
lldiv_t	/usr/include/stdlib.h	/^} lldiv_t;$/

no itoa here either stdlib.h

IIRC itoa IS one of those things that has inconsistency between platforms

Like I think some versions accept a base and some don't.

@quartata glibc defines it in stdio but yeah point is how inconsistent this is

@quartata could you gist your ctags output

I'm on mobile but it'll be identical to yours

@quartata that is not appearing to be the case

(what I'm saying is that I'm on OS X so the headers will be the same)

I don't know what version of exuberant ctags I have