
Eul – The language - gtramont
https://eul.im/lang
======
eridius
Every single macOS download I've tried of Eul has been completely broken. It
simply won't launch. Doing so from the Terminal gives the following output:

    
    
      dyld: Library not loaded: libnanovg.a
        Referenced from: /Applications/eul.app/Contents/MacOS/./eul
        Reason: image not found
    

Weirdly, `otool -L eul` tells me that eul links against no dynamic libraries
whatsoever (not even libSystem) and `otool -l eul` backs this up. I'm really
curious how Eul managed to have zero dynamic library dependencies in the
Mach-O headers and yet clearly still depends on them (especially because on
macOS you _must_ link against libSystem or you can't even make syscalls).

~~~
sjtgraham
You can make syscalls with inline assembly (SVC 0x80).

~~~
eridius
Not on macOS. macOS does not guarantee syscall compatibility between OS
versions. The only supported mechanism for invoking syscalls is via libc.

~~~
sjtgraham
You can do it, it’s how libsystem does it. A lot of AppStore apps use it for
jailbreak testing too, e.g. testing sandbox integrity, or to call ptrace with
PT_DENY_ATTACH. Apple lets these apps pass review and onto the AppStore.

Do you know how often, if ever, Apple ever changes the syscall table other
than to add to it?

~~~
eridius
libSystem is provided by Apple. The fact that libSystem does it does not mean
you can do it without libSystem, as libSystem is the one and only supported
way to do this.

> _Do you know how often, if ever, Apple ever changes the syscall table other
> than to add to it?_

I don't know, but I'm pretty sure the answer is something other than "never".

------
ghayes
I'd love to hear more. Maybe I'm a bit confused: the documentation says that
functions are pure, and then the example functions look like they are full of
side-effects. Does anyone have a good explanation of how purity and effects
work in Eul?

~~~
andrewla
It doesn't answer your question, but the language shown on the page is called
"lang" \-- eul is an application that "lang" was invented to write. eul itself
is a multi-protocol desktop messaging client.

That said, these functions look pretty impure.

------
tathougies
Cool little language, but

> functions are pure.

I think you need to reconsider what pure means

~~~
pawodpzz
that reminded me of
[https://78.media.tumblr.com/7d824a0db91b6be904ad3a52b79e0d6a...](https://78.media.tumblr.com/7d824a0db91b6be904ad3a52b79e0d6a/tumblr_nvppcau4jq1ufyue6o1_1280.gif)

~~~
setr
is the only relevance of that touhou meme that it uses the word "pure"?

------
oconnor663
Normally I think "rewrite it in Rust!" comments are annoying, but in this case
the author's requirements sound pretty relevant:

\- integration with C libraries

\- overhead similar to C

\- more productive than C

\- "Variables are immutable by default, globals are not allowed, functions are
pure."

That does sound an awful lot like Rust, at least if we kind of squint our eyes
at the purity requirement :) I wonder if the original author considered it?

~~~
zokier
On the other hand, Rust definitely does not have "Fast compilation", and
although debatable, I would say that "Simplicity" is not one of Rusts many
virtues.

~~~
JoshTriplett
> On the other hand, Rust definitely does not have "Fast compilation",

True, though several people are now working on compiler performance.

> and although debatable, I would say that "Simplicity" is not one of Rusts
> many virtues.

I've found that Rust seems as simple as it can be given the problem it's
solving. For instance, lifetimes and borrow checking aren't _trivial_ , but I
have a hard time thinking of a simpler abstraction that has the same safety
and performance properties.

Another way to look at it: C is "simpler", in some ways, but it pushes the
corresponding complexity into the heads of developers and the code of
helper/wrapper libraries and tools.

~~~
captainbland
I think it's one of these things where C is 'simple' but using it often isn't.
Taken to the most absurd extreme, Brainfuck is even simpler. So I'm not sure
that simplicity is necessarily a virtue in a programming language.

That said, I don't think Rust is that complicated - it's just that a lot of
the concepts it uses are unfamiliar to a lot of people and 'best practices'
are not always set in stone because of that, which causes confusion - that's
more of a maturity thing than anything else. Contrast with C++ (or C# or Java)
which certainly is a complex language, but people aren't that confused by it
because there are a wealth of books which prescribe the best ways to do things
in any given scenario.

~~~
oconnor663
I'll repeat what a lot of other people have said on this one. I think Rust
puts the vast majority of its complexity up front, so that you have to deal
with it even in toy programs. However, once your toy program is working, it
can expand into a real program without uncovering bugs or running into a lot
of new complexity. C on the other hand, can make toy programs appear simple.
However, there can be a lot of undefined behavior in those programs, which
will turn into serious bugs as the programs get more interesting. I like this
article for talking about some of those cases:
[https://blog.regehr.org/archives/1520](https://blog.regehr.org/archives/1520)

------
dchest
Go: func

Eul: fn

Come on, it should be "fun".

~~~
skybrian
Maybe they want to allow for user-defined fun?

~~~
kazagistar
If the language was really cool, you could override the keyword anyways.

------
sincerely
Weird, the linux link on the front page of this website gives a 404

~~~
textmode
This works: [https://github.com/eul-
im/eul/releases/download/v0.34/eul_li...](https://github.com/eul-
im/eul/releases/download/v0.34/eul_linux.zip)

Aside: This is 64-bit. Is there a 32-bit version?

------
arsham
It sounds interesting. Is the language open-sourced?

~~~
Kudos
> The language will be open-sourced later in 2018.

~~~
hau
Given the relationship between eul author and deadlines it won't happen in
2018. Author also promised to open-source eul itself at first but last
statement is "I'm not 100% sure it's going to be possible."[0]

Current state of eul app also hinting that most likely nothing of value would
be lost if this language won't be open-sourced.

[0] - [https://github.com/eul-
im/eul/issues/45#issuecomment-3356427...](https://github.com/eul-
im/eul/issues/45#issuecomment-335642796)

------
dwighttk
how is it pronounced? Like Euler?

------
catnaroek
> Safety

> Variables are immutable by default, globals are not allowed, functions are
> pure.

This is a huge non-sequitur.

