VSL

ASCII-only

00:01

@Downgoat hi

Downgoat

@ASCII-only problem:

#0 0x00007f9eb1723338 llvm::sys::PrintStackTrace(llvm::raw_ostream&) (/usr/bin/../lib64/libLLVM-3.9.so+0x643338)
#1 0x00007f9eb172145e llvm::sys::RunSignalHandlers() (/usr/bin/../lib64/libLLVM-3.9.so+0x64145e)
#2 0x00007f9eb172159a (/usr/bin/../lib64/libLLVM-3.9.so+0x64159a)
#3 0x00007f9eb0ed35c0 __restore_rt (/usr/bin/../lib64/libpthread.so.0+0x115c0)
#4 0x00007f9eb407c019
#5 0x00007f9eb407c041
#6 0x00007f9eb2445a15 llvm::MCJIT::runFunction(llvm::Function*, llvm::ArrayRef<llvm::GenericValue>) (/usr/bin/../lib64/libLLVM-3.9.so+0x1365a15)

scary segfualt is scary

okay now outputting random gibberish:

þ*}Ú

Question: how to print a char with puts

oh

I think I need to add null byte

AWWW YISSS

IT WORK

YAAAASSSSSS

Downgoat

00:50

@ASCII-only halo I have quesiton

does this look correct:

unsigned int __vslcount(char* string) {
unsigned int c = 0;
while(*(string + sizeof(char) * c) != 0) c++;
return c;
}

it gets length of string

e.g. "foo\0" returns 3

ASCII-only

@Downgoat yeah

Downgoat

:/ it segfaulst

:(

ASCII-only

@Downgoat while(string[c]) c++;, or for (;string[c];c++); should work?

Downgoat

yeah but doing in LLVM

ASCII-only

@Downgoat wait is that valid llvm

Downgoat

00:54

no its C

ASCII-only

@Downgoat ok wdym

Downgoat

like i literally translated to C

tio2.tryitonline.nz/nexus/…

0/10 LLVM very difficult

ASCII-only

@Downgoat pls link to segfault

quartata

github.com/lattera/glibc/blob/master/string/strlen.c

A bit faster than doing one byte at a time

but y'know

You're going to have to link to glibc eventually

if you wish to maintain sanity

Downgoat

no

can't

@ASCII-only tio2.tryitonline.nz/nexus/…

quartata

01:01

Why?

Downgoat

1. not as portable as we like (can likely find solution but not main reason) 2. will likely be wrapped in libvsl

hm, bundling clang is totally unviable for obvious reason

also ABI problem

ASCII-only

@Downgoat why did you post hello world twie

Downgoat

wait wat

https://tio2.tryitonline.nz/nexus/llvm#lVLNasMwDL77KXQJtMEbSTZGKAz2HqUEx3FagWNnjlu6jT72zp0cN81K2WEnC38/1if53CiphVOATwW89Xs/LLBMl4w1qkVzua6qw6Afpd0bH1BI0BBzCV8MoHagRa00JI4xt6KbBOEV@h2O2jVkHJIMNpzKpKLawSaQeiJ9qqMfWSTxFvDleUSCfqu80qpTxvfeAZqaHm8GwJLD3AEPEhIE1YFE2opmpvTIQWjcGsgDoSKCaJrLezxeSrpE2fWg3klELhyyGApzQvmUreW/UrYhpVNT6@x0O61OoFlQNbaRhilRCvcRRPRia@19vDKNZEjymCmPZPTdHOvKIYsICwKl0PqvLfluGYkHoUN6ra0UsC7gSE4bFjFqIL/raOLwa5WOLrG77HJcDYp/GuSTQXSoSe7d3sg4UTF@hnLEBm/D56TV1NNaqd9bKJuRgkXLeSrTl47COI9pdxk7nc/fxj5IIXfqBw

I feel like problem is here:

%foo = getelementptr i8*, i8** %1, i64 1

idk

@quartata even if I use glibc problem is still not fix

@ASCII-only actually we can look at node.js source and copy

quartata

I just mean you'll be using glibc sooner or later. Unless you want to do this yourself.

Downgoat

looks fun

ASCII-only

01:06

@Downgoat is %0 in phi calling scope thing

Downgoat

yeah

llvm ref sucks :(

quartata

@Downgoat Really? Because it doesn't to me. That right there is just the implementation of sin and cos

Downgoat

@quartata btw have you gotten started on pytek compilation

quartata

Bits and pieces

Downgoat

I can just copy + paste into clang

but was sarcasm >_> :P

quartata

01:08

It can emit code but has trouble with certain things

Downgoat

@quartata how is your 1) ABI 2) startup code (i.e. loading argv into pytek string[], setting up process & co. items)

@ASCII-only btw I think we're going to need full GC because ref counting isn't practical for VSL imo

we'll have to see how goes

@ASCII-only btw do we have array yet

quartata

Yes although I probably broke it a couple months ago

Downgoat

sorry >_>

quartata

I can't do much serious dev without El'endia who hasn't worked on it in 6+ months

Downgoat

D:

ASCII-only

01:13

@Downgoat syntax? yes

@quartata 0/10 you should be able to do it yourself

quartata

Eh.

ASCII-only

@quartata I could try to help, but it's more likely that I break it and take like a day to find the bug I introduced :P

quartata

ABI is regular C++ mangling + magic identifier for importing in interpreter

Downgoat

01:41

@ASCII-only pls VSL first :P

@quartata if pytek is not going anywhere ATM can you help with vsl? :O :3 :3 :3

quartata

03:21

nope

Downgoat

;_;

quartata

I mean what did you expect, look at your starboard

ASCII-only

@quartata But most of that is from last year :(

quartata

also I'm too busy anyways

Downgoat

@quartata I have question: how are you linking Pytek types with internal implementation

quartata

03:28

Hm?

Downgoat

like if you have like

\class{PytekString}{
    \func{split}(seperator) internal
}

(made up syntax based on what I think pytek looks like)

how would you make split emit internally generated code

quartata

Good question. Currently built ins are defined purely inside the compiler, but I would like to do what you're describing (which Java also does: native) and make it so you can have the signature in a source file and the implementation internal

ATaco

@ASCII-only Please grant write-access to the C9

quartata

type:PytekString {
  (native func):split(separator);
}

Backslash free :P

(@Downgoat)

ASCII-only

@ATaco done

quartata

03:41

since I forgot to use reply after that wall of text

ATaco

<3

Downgoat

@quartata so do you like check if (identifier in listOfAllNativeFunctions) identifier.replaceWith(nativeAlternative)

I was thinking of defining stuff in libvsl

but I am not sure how that would play with namespaces and all

Phoenix

What print function are you going with? There's like several dozen.

Downgoat

@Phoenix likely just print(Any)

what specifically do you mean?

Phoenix

printf, println

Downgoat

03:45

I was thinking we'd just pipe to `puts(string + "\n\0")

would be most crossplatform way i think

Phoenix

But also wondering if you were doing something edgy like PutStrLn

Downgoat

unforunetly i am suppose to support stupid windows which doesn't like normal POSIX function

@Phoenix that is haskell right?

Phoenix

Ye

Downgoat

We could do Console.print

because we might have multiple streams

e.g. File(name: "foo.txt").print("asdf")

quartata

@Downgoat Essentially. Interpreter works like that too

Downgoat

03:46

but that doesn't make much sense

quartata

I might put them in a header file though with the types

Then it's the C compiler's problem

ATaco

I'm trying to read this source, and I'm pretty lost tbh

Downgoat

so if native functions are in C/C++, with a typical C++ ABI, how are you going to handle namespaces?

Or are you going to demangle C++ stuffs

@ATaco what part is confusing

Phoenix

@Downgoat But if you want, you can do from Console static import print; and access it directly?

ATaco

The structure.

Downgoat

03:47

source code documentation: vsl-lang.github.io/VSL

ATaco

Not the language structure; the Implementation structure.

Downgoat

@ATaco so the compilation happens in a couple parts:

quartata

C++ has a builtin for demangling y'know :P

Phoenix

Is it called switching to something readable like Ruby?

Downgoat

Parser (outputs AST) -> Transformer (mutates AST, resolves scopes etc.) -> Generator (outputs LLVM IR)

Phoenix

03:48

ReSharper++ FTW btw

quartata

Check out cxxabi.h

Downgoat

@quartata ik, but that gives a string. are you going to parse the C++ type e.g. Pytek::String<...>... stuff and then use that?

@ASCII-only I was thinking we would do:

quartata

Not sure what you mean?

Downgoat

sorry I did not finish that message >_>

Phoenix

Static imports: For or against?

Downgoat

03:51

public class String {
    init(int: Int) internal("__vsl_string_init")
}

quartata

Oh OK now I get what you mean

Downgoat

then we would setup LLVM to lookup String(int:) to __vsl_string_init

quartata

I guess demangling is not so much what we need as it is mangling: we have a Pytek type signature which can be converted into a list of C++ type signatures, and from that we want the symbol

I've been hunting around for something that will do this

Downgoat

oh hey mangling, that's what I am stuck on right now

I mean it's not that difficult

but not sure best way to implement

quartata

We need it mangled to the same thing as whatever the compiler uses though

Phoenix

03:55

As far as I can tell, VSL is a language that started trying to be a scripting language, but ends up being "C, but better" with JS kludged in.

Downgoat

@Phoenix wat

quartata

C and JS are almost polar opposites

Downgoat

VSL is like Java + Haskell + C# + Swift

Phoenix

If it is, then someone changed a lot of high-level design ideas and didn't update the hackmd.

Downgoat

The only C is that it 1) compiles to LLVM (which represents C concepts_ 2) libvsl is likely to be coded in C

@Phoenix yeah, this has happened

if you want to get a taste of syntax check here: github.com/vsl-lang/VSL/tree/master/src/vsl/stl

ASCII-only

03:57

@Phoenix IMO it's still supposed to be a scripting language, it's just we're doing the easy parts (compilation) first

Phoenix

GitHub is blocked ;-;. Will look at it later.

ASCII-only

so we can bootstrap

quartata

I guess I understand what you were trying to say better now which is how do you know the native isn't shadowed

Downgoat

> easy parts (compilation)

quartata

I can check the scopes but it would be better to have gcc do that for me

Downgoat

03:58

are you compiling to C/C++?

wait shit that is good idea

quartata

Which is why I'll probably move it to a header only library

Yes

Downgoat

though if you do that then JIT performance would be sub-optimal

quartata

I told you that almost a year ago

Downgoat

unless you're going to JIT some other way

quartata

We don't care

If you're not compiling then you don't care about performance

That's why we have a regular interpreter in addition

Also used to resolve compile time directives potentially

Downgoat

04:00

@quartata I mean performance is one thing, being not-very-slow is another :P >_>

quartata

We're hoping not to be Cheddar slow

I mean we aren't

Downgoat

if you JIT through GCC you will

also excuse me

quartata

More like not Perl 6 slow for comparison

Downgoat

@ASCII-only wait shit I closed LLVM tab did I send you a link

oh no

welp there goes 2 hours

quartata

@Downgoat We aren't JIT period

GCC only comes into play in AOT compilation. Then there's either regular interpreter or JS compilation

Phoenix

04:03

Why do you need an AOT compiler, a JS compiler, and an interpreter?

Downgoat

^

it took C like 30 years to get to that state :P

quartata

One for speed, one for browsers, one for portability and prototyping

Phoenix

C has a JS compiler and an interpreter?

Downgoat

@quartata why not just do C compile and emscripten

quartata

emscripten and tcc

Downgoat

04:04

I think emscripten can do DOM

@Phoenix emscripten, and lots of interpreter

quartata

@Downgoat because we can do it better than emscripten would

Downgoat

ok we'll see

quartata

when one's type system has already been through one transpiler a lot is lost in translation

Phoenix

If I'm understanding this properly, VSL uses the C/++ standard library?

quartata

cut the middleman and get sane output

Downgoat

04:07

@Phoenix no

but we are planning to implement VSL standard library in C

quartata

Like translating from Klingon to Chinese then to English

Downgoat

@quartata more like English to Spanish to Chinese

Phoenix

You could have made this a JVM/.NET language. And then you don't need to write a standard library.

Downgoat

aaaahhhhhhh

quartata

Also emscripten couldn't transpile some things we'd do

like context switching

Downgoat

04:09

example?

quartata

Coroutines

I haven't gotten to it yet but assembly magic may be required

Downgoat

like code example of JS you need

because you can always write pytek_lib.js and include

quartata

Not a standard library thing really

Downgoat

in JS everything is library thing

lets not forget we literally outsourced entire DOM management/state mangement/network requests to a shitty JS library for like years

Phoenix

Which one was that?

quartata

04:11

jquery

It would compile to a chain of function*s I guess

Phoenix

Right

I never figured out JQuery. It didn't like me.

quartata

One global context that switched to child generator "coroutines" when yielded out

Hmm

Phoenix

Allow executing arbitrary V code for text manipulation.

That is a good and not a terrible idea

quartata

I almost fantasized about adding a Grime interpreter to the standard library

I'm still not convinced it would be a terrible idea

It's written in Haskell right now which wouldn't be too hard to rewrite

Phoenix

.NET/Java interop would be amazing. I wonder how difficult that would be to achieve.

quartata

04:18

It's been done

At least in the .NET -> Java direction

Phoenix

Well, to be fair, they did rewrite Java for .NET and called it J#

quartata

ikvm.net for .NET -> Java

Java on JVM -> .NET is a different story

Phoenix

Right, but what we're considering is VSL -> Java

Downgoat

this is possible

quartata

JVM is a pretty nice VM.

Jasmine can be used as a human readable IR for it

Phoenix

04:23

Or VSL -> .NET, depending on how much you trust Mono.

quartata

.NET core

Mono will be dead in ~5 years

Phoenix

Hopefully, but apparently .NET Core is also unstable.

Downgoat

the way VSL is written it should be trivial to port to another assembler

quartata

It's getting better, but more importantly MS seems willing to throw money at it

That gives me confidence that they'll make it work

There's a difference between "hobby project by MS employees" and "something they're spending money on"

Phoenix

This recent Open Source/Linux trend from microsoft has been pretty great overall.

12

A: How do I call a .NET assembly from C/C++?

[Guid("123565C4-C5FA-4512-A560-1D47F9FDFA20")] public interface IConfig { [DispId(1)] string Destination{ get; } [DispId(2)] void Unserialize(); [DispId(3)] void Serialize(); } [ComVisible(true)] [Guid("12AC8095-BD27-4de8-A30B-991940666927")] [ClassInterface(ClassInterf...

Probably not as scary for people who know C++, but to me it's pretty scary.

ASCII-only

05:55

@Phoenix pls no, JVM/.NET is fine, Java/C# is not

Phoenix

I meant VSL -> .NET

@ASCII-only I fully concur, I kind of thought it was implied. Personally I would prefer .NET Core

ASCII-only

@Phoenix so we're still doing LLVM IR right?

so the CLR will just be another target

also wasm and the JVM

Phoenix

If it was my decision, it would be a .NET language, but it is not my decision, and I can see why people wouldn't want to do that.

ASCII-only

@Phoenix It's fine

just the .NET VM si overkill for some things

Phoenix

You are trying to make a practical language though, right? I think a lot of people could get behind "C#, but better"

Phoenix

06:22

Idea: env.command("arg") is the equivalent of executing command arg in bash, e.g. env.rm("-rf", "~/foo")

env.eval("foo") lets you execute long complex commands.

Actually that doesn't work if you're trying to invoke something like ./foo

Phoenix

06:38

Other idea: func type.foo( x : int) -> Void { ... } is equivalent to func foo( this : type, x int ) -> Void { ... } and can also be called as object.foo(3) being the same as foo(object, 3), however it requires that type does not already have such a function.

So many times I've wished I could define my own e.g. string reverse function that I could call as "foo".reverse() and not necessarily reverse("foo")

ASCII-only

@Phoenix pls no

Phoenix

I kind of realized why it doesn't work halfway through

ASCII-only

syntax for shell command is `command`

@Phoenix In JS?

Phoenix

In Java and C#

ASCII-only

@Phoenix pls no this is not OOP

@Phoenix ... They both have extension methods, so you can do that

Phoenix

06:50

I can

I think my life has just been changed

*StackOverflows*

I should sleep it's getting late.
I *might* still think of an actual good idea though

ASCII-only

For extension methods we're stealing Ruby's class reopening

Phoenix

Can we steal Mathematica's Apply syntax?

foo[bar] is equivalent to foo@bar, foo[bar, baz] is equivalent to foo@@{bar, baz}

Where [] denote function arguments and {} denote lists

ASCII-only

@Phoenix JS has that, [].__proto__.map.call([1,2,3], _=>_*2), [].__proto__.map.apply([1,2,3], [_=>_*2])

Phoenix

Is most of that just noise that you used to show an example, or do you actually need the .__proto__?

Because @ is actually convenient to use.

ASCII-only

@Phoenix well you need it for class methods (which Mathematica does not have)

eval.apply(null, ['1+1'])

Phoenix

06:57

I think I like Mathematica's way more.

I'm also fond of it's lambdas, but I know they aren't for everyone.

ASCII-only

@Phoenix well in general too many globals = bad

Phoenix

They don't have to be for globals.

ASCII-only

But I think it's fine

Phoenix

Instead of foo.bar(baz), foo.bar@baz

ASCII-only

@Phoenix why @

Phoenix

07:03

Because that's how Mathematica does it.

ASCII-only

@Phoenix pls no this is not a wolfram language implementation

Phoenix

I suppose it doesn't need to be @, but I can't think of any other character that would fit.

ASCII-only

@Phoenix @ is fine but what i mean is: When is this useful?

Phoenix

It's not that useful, but it does help prevent foo(bar(baz(bla(dur())))) parenthesis bloat. It's mostly for code readability.

ASCII-only

@Phoenix oh that is what function chaining is for in sane functional languages

foo, bar, baz ~> quux :> somefunction, someotherfunction :> alsoafunction

Stolen from pytek

Phoenix

07:09

The @@ and @@@ notations are useful though. (@@@ is @@ but it flattens the list)

ASCII-only

@Phoenix hmm ok will add

Phoenix

If I have a function f that returns {"foo%d/%d",5}, I might do printf@@@{f(),3}

That isn't the best example, but it does show show it could be used.

ASCII-only

hmm ok any other ideas?

Phoenix

Mostly mathematica inspired ones which are largely impractical.

ASCII-only

@Phoenix pls give example

Phoenix

07:15

Instead of (n,m)->n+m lambdas, #+#2& lambdas.

It's golfier but less readable.

Symbols for irrational numbers which have an N method to yield a decimal representation

ASCII-only

@Phoenix Well in VSL it will be {$1+$2}

Phoenix

And $ is shorthand for $1?

ASCII-only

@Phoenix no it's shorthand for current scope

Phoenix

In mathematica style that would be $$

ASCII-only

$$var is shorthand for var in parent scope

$$ is parent scope

Phoenix

07:18

I like your thing though.

ASCII-only

but hmm # may be a good character to use for whatevers

Phoenix

It's a scripting language, you need #! support.

There is a problem with the Mathematica lambda syntax. Lambdas that return lambdas are a PITA.

ASCII-only

@Phoenix {{;}} (because {} is object)

Phoenix

I mean it get's confused which variables belong to which lambda.

ASCII-only

@Phoenix true

@Phoenix oh haha

that's not a problem with the syntax then, it's a problem with the implementation

on second thought: ? can be ~~overloaded~~ used for whatevers

Phoenix

07:23

It is a problem with the syntax. $1 references an argument in the inner lambda, how do you reference the first argument to the parent lambda?

? should be ternary.

ASCII-only

@Phoenix Each lambda has its own scope: {let foo = 1; {$$foo += 1}()}

Phoenix

?. should be C#'s null safe operator.

ASCII-only

@Phoenix It will be

@Phoenix Yeah, it already is

Phoenix

?: is the null coalescing operator?

ASCII-only

@Phoenix ||

Phoenix

07:25

Oh right

?: could still be useful if you care specifically about null and do want to accept 0

ASCII-only

@Phoenix ok true

Phoenix

I hear that some people like the Maybe monad/Java's Optional, but tbh I don't see the point when null is a thing that exists.

ASCII-only

@Phoenix ...

Phoenix

That's a nullable int

That's not an Optional

ASCII-only

@Phoenix Oh that's to prevent NullPointerExceptions

Phoenix

07:31

So instead of NullPointerException you have NoSuchElementException

ASCII-only

Since we're solving that the C# way (?.) we don't need that

Phoenix

Yep

ASCII-only

@Phoenix yes that's why people don't use java :P

Java: hey look we solved the NullPointerException problem, here's another exception that is thrown instead

Phoenix

Idea for lists: ?{foo,bar,baz} becomes {foo,baz} if bar is null.

(That particular syntax is bad but you get the idea)

ASCII-only

@Phoenix 0/10 remember this is a scripting language (also a sane one) so it uses [] for lists and {} for sets

Phoenix

07:34

Right.

[?element1,element2] is a nonnullable list literal, which acts like a normal list but any null is removed.

It's a distinct type from a normal lists, so if you try to put null in there later nothing will happen.

ASCII-only

@Phoenix hmm when is that useful

Phoenix

Golfing and no other application I can think of at the moment.

I'm trying though

Maybe if you have a list of the first indices of a in some strings, and you end up with a bunch of nulls for strings that don't have a in them, so you don't want to do anything with those.

ASCII-only

@Phoenix it's normally -1 for not found

Phoenix

That's a remnant from when ints couldn't be nullable. I think having it be null makes more sense.

int?s are

I'm told nullable ints are like the reason F# works

I don't know F# though so I can't tell.

ASCII-only

@Phoenix yeah but nullables are slower so bad idea most of the time, plus in normal languages it's super verbose to unbox

Phoenix

07:43

Right, or you could do the trick where instead of Integer.MIN_VALUE being -2^32, it's -2^32+1, and -2^32 represents null

@ASCII-only it's not at all verbose in C#

Actually, that trick is what C# does iirc

Fuck it, why not just use .NET System.int32 and make it a .NET lang

...

I need sleep

ASCII-only

because .NET is overkill

Phoenix

Yes

ASCII-only

@Phoenix hmm true

Phoenix

Nullable value types should be a thing either way

ASCII-only

@Phoenix yeah definitely

Phoenix

07:52

Small idea: deprecated keyword, e.g. deprecated public foo() -> Void { ... }. Doesn't do anything but causes a compiler warning: "function foo is deprecated". deprecated<bar> public foo() would say "function foo is deprecated, use bar instead."

ASCII-only

@Phoenix that will be an annotation: @Deprecated

Phoenix

Annotations are neat.

Maybe C# style annotations, if @ is apply? They wouldn't actually be confused by the compiler since there wouldn't be anything before the @ in annotations, but for readability.

ASCII-only

@Phoenix I don't think that makes it more readable

annotations and apply should generally not be used together

Phoenix

yeah you're probably right.

ASCII-only

since apply is a functional thing, annotations are an OOP thing

Phoenix

07:57

Also [annotation] is a list, so that's even worse.

ASCII-only

hmm ok

Transcript for