
Avail Programming Language - FractalLP
http://www.availlang.org/about-avail/introduction/index.html
======
dcw303
I'm confused by the website. The intro has a clear example that reads like
natural language processing, but the FAQ goes out of the way to stress that
the language does not do NLP. At that stage it gets a bit ranty, vague and
dense, and I kind of lost interest. Perhaps I'm not smart enough to get what
they're trying to do. "Developing a domain-appropriate lexicon and
phraseology". Is this a DSL? Regardless, I don't see this setting the world on
fire.

It's interesting that they've called this paradigm Articulate Programming,
because articulation of the domain is where the problem both starts and ends.

How many times have you worked in a company with staff who start off
exasperated with how complex IT makes solving a business problem, only to be
surprised at just how many details are in their day to day processes once
you've spent time covering off all the edge cases and writing tests around
exceptions.

Code becomes complicated because the domain it models _is_ complicated. Hence
the reason why a good engineer's most important skill is in gaining an
understanding of the real world problem domain, and expressing that as code.
And also why I'm not worried of AI taking my job any time soon.

~~~
bbeonx
Same. I guess my takeaway is that I'm happy people are looking into this
because in ten (or twenty (or a hundred)) years this research will hopefully
have paid off. I, however, want nothing to do with it.

Also, they don't do natural language processing but allow you to write method
names like "the square-root of _x^2 + _x + _" where the underscores are
arguments.

Thus their "efficient" compiler that they parallelize the parser to find an
unambiguous parse.

I don't know. This seems like it would be super fun to write and to play with,
and that there are probably some really cool new things being discovered that,
when matured and properly integrated, may be workable into a usable
programming language.

------
cyberferret
While I believe 'plain English' type programming languages are a great
concept, the reality is that it just introduces far more ambiguity into the
mix, and you are just left trying to guess what the language designer's
vagaries are.

I came across this years ago when trying to get to grips with the then new
fangled Ruby language. I kept having to go back to the documentation to
remember the best way to convert a string to all uppercase... was it:

    
    
      str.upper
      str.uppercase
      str.ucase
      str.upcase
      str.capitalize (<- Don't even get me started on the regional differences of 'ise' vs 'ize' between US and UK English variants)
      ???
    

Even here, I would probably start using Avail, then in a few weeks I would be
scratching my head and asking, was it:

    
    
      Print 1 to 10, as a comma-separated list
    

or

    
    
      Display 1-10, in CSV format

~~~
_bxg1
"an efficient compiler that concurrently explores all possible parses in
pursuit of a semantically unambiguous interpretation."

This suggests they have a solution to the ambiguity problem

~~~
cyberferret
Thanks for the clarification. I missed that on the initial skim of the
article. (And yes, I appreciate the irony of me introducing the 'ambiguity'
arguments into a topic which deals specifically with the removal of such) :)

~~~
_bxg1
It's still arguable that there could be some ambiguity. The compiler makes
sure the statement is interpreted in an unambiguous way on the computer's end,
but the writer might still not know which of a number of ways to express what
she wants to state.

------
Joboman555
Constructive Criticism: I could not find any code examples on the website
within 3 minutes of searching, gave up, and left.

~~~
klibertp
I have a blog post from a few years back with a sample, here:
[https://klibert.pl/posts/avail-and-articulate-
programming.ht...](https://klibert.pl/posts/avail-and-articulate-
programming.html)

I'm pasting a link because I added on-hover popups explaining parts of the
snippet, but here is the sample itself:

    
    
        Module "Hello World"
        Uses
            "Avail"
        Entries
            "Greet Router"
        Body
    
        Method "Greet Router" is [
            socket ::= a client socket;
            target ::= a socket address from <192, 168, 1, 1> and 80;
            http_request ::= "GET / HTTP/1.1\n\n"→code points;
    
            Connect socket to target;
            Write http_request to socket;
            resp_bytes ::= read at most 440 bytes from socket;
    
            Print: "Router says: " ++ resp_bytes→string ++ "\n";
        ];

~~~
masklinn
This looks like the result of a drug-and-alcohol-fueled unplanned pregnancy
between COBOL and Ada.

~~~
klibertp
Yeah, plus a bit of APL - it's not visible in this snippet, but Avail uses a
lot of strange unicode characters/symbols. The `→` in `resp_bytes→string` is
one example, but there are many more symbols used:
[http://www.availlang.org/about-
avail/documentation/unicode-c...](http://www.availlang.org/about-
avail/documentation/unicode-cheat-sheet/index.html)

------
blt
IMO, the landing page of any programming language site should include some
code samples demonstrating what makes the language different from the crowd.

~~~
FractalLP
The landing page does

[http://www.availlang.org/index.html](http://www.availlang.org/index.html)

I tried to link to a more interesting page though. I stumbled upon someone
mentioning the language, but don't really get it. It seems to promote building
DSLs, but lots of languages like Lisp & Rebol have been doing that for ages.

~~~
pure-awesome
Oh!

I understand your intent, but I think it unfortunately ended up confusing
matters for fellow readers.

Add to this the fact that the website itself is not very clear already...

------
seanmcdirmid
> An infinite algebraic type lattice that confers a distinct type upon every
> distinct value. Intrinsic support for a rich collection of immutable types,
> including tuples, sets, maps, functions, and continuations.

Ok, I consider myself OK at type theory but I'm still lost in what this claim
actually means. And if it is what I think it is (that all values have types),
I wonder how this doesn't run afoul of decidability of fancy dependent type
systems (perhaps 1 has a type, 2 has a type, but 1 + 2's type isn't 3?).

~~~
tathougies
Avail does not seem to have dependent types. The term 'dependent type' is
overused. It means that the type system must allow the compile-time type of an
expression to depend on the run-time value. This is not totally decidable.
Most type systems, including advanced ones, such as Haskell's, do not have
this property. Avail seems no different.

~~~
markvangulik
Haskell has infinite and recursive constructs, lazily computed. That’s what
makes their type system undecidable. Avail is constructivist in that sense, so
immutable structures must be finite (i.e., you can draw them as a dag). For
cyclic structures, you have to include mutable “variable” objects as well, but
in that case the type of the construct stops at the boundary of the variable.
The type of a tuple of variables is a composition of the declared types of the
variables, not their current content. This is essential to ensure an object’s
type is permanent, and the immutable acyclicity condition ensures everything
reachable without hitting a variable contributes to an object’s type.

~~~
tome
> Haskell has infinite and recursive constructs, lazily computed. That’s what
> makes their type system undecidable.

Haskell (98) has infinite and recursive constructs and its type system is not
undecidable.

------
pasabagi
I think there's actually a very fundamental difference between natural and
formal languages that make this kind of project wrongheaded.

Formal languages, at root, have exact reference. In a programming language, a
symbol ultimately refers to a block of memory, or an operation. The problems
of writing a formal language are ones of trying to express a given concept
when the relation between symbols and references is known, but the
relationship between concept and symbol is not.

In natural language, a symbol ultimately refers to nothing. Its meaning is
derived from context, convention, intention. As such, the relationship between
concept and symbol is basically known - we know we are talking about red
things when we use the word red. The relationship between concept and
reference is absolutely unknown - we can never know for sure whether our
concept 'red' is adequate to real red objects.

As such, natural languages are a poor model for formal ones. The problems are
essentially different. In one, you know how the symbol 'red' relates to
operations and memory. In another, you know how the symbol 'red' relates to
intention and meaning. Each has different challenges associated.

~~~
kccqzy
There are more ways to define semantics for formal languages than you
suggested. What you described seemed to be mostly operational semantics where
each term (or statement) ultimately causes some memory to be referenced or
changed or an operation carried out. It is quite possible to define the
semantics denotationally where each term (or statement) simply becomes an
element in a domain. Its ultimate meaning can change depending on which domain
you are using.

~~~
pasabagi
Good point. I'd never heard of denotational semantics before. I'm coming from
a more or less naive perspective of trying to pinpoint where the ambiguity is
that you have to wrestle with in different kinds of languages. In formal
languages, the classic problem is, what you say is not what you mean. In
natural languages, the classic problem is, what you mean is not what really
exists. So for the latter, we have the whole development of science,
epistemology, empiricism etc.

For the former, we have the whole notion of semantics, the development of
tools like valgrind, tests, etc.

Is there anything you can reccomend to read? I'm pretty familiar with how
computers work on a mechanical level, but I'm pretty ignorant about the
theoretical intuitions behind all the more functional stuff.

------
wiradikusuma
Print 1 to 10, as a comma-separated list.

In e.g. Scala, you can do that:

print( 1 to 10 mkString "," )

It's not 100% human language/grammar, but close (and you have auto-completion
using IDE). Why would you need another DSL?

(Not trying to bash Avail, nor promote Scala, just curious for its usecases)

~~~
jhall1468
I'm pretty sure the goal of these "natural language style" programming
languages extends beyond printing a comma-delimited list of numbers. This
arbitrary example doesn't mean much.

~~~
p1necone
It's not a very good example though - it's not showing me any sort of
improvement over actual programming languages - just an intentionally bad bit
of code.

~~~
jhall1468
No it's an arbitrary example of which their are many more on the site. You're
just overly obsessed with that one.

~~~
p1necone
It's the only code example on the 'Introduction' page. I'm sorry for expecting
something better.

------
kccqzy
It'd be better if the tutorials are rewritten in a more concise manner. Do you
really need that many words to explain Guess The Number?
[http://www.availlang.org/about-
avail/learn/tutorials/guess-t...](http://www.availlang.org/about-
avail/learn/tutorials/guess-the-number.html)

------
colanderman
I find the syntax hard to follow for the express reason that variable names
and function names have no distinguishing features. If variable names were
decorated somehow (a symbol, or color) it would be much easier to visually
parse a function call. As is, my brain must remember exactly the (complex)
names of functions and variables in scope to determine how to parse a function
call. But I like the idea and am using something similar in a language I'm
developing.

~~~
markvangulik
We’re working on tools for writing/viewing Avail more easily. Stay tuned,
it’ll be worth the ride...

------
mikkom
Here is some code from their examples page if anyone else (like me) is more
interested in how the actual code looks like.

To be honest, I'm not sure how much clearer this is to read than for example
Python.

[http://www.availlang.org/_examples/guess-the-
number/Guess%20...](http://www.availlang.org/_examples/guess-the-
number/Guess%20the%20Number.avail)

------
skybrian
It looks like GitHub is active [1], but documentation hasn't kept up. The
blogs don't seem to have been updated since 2014, and the links to the mailing
lists are broken.

[1] [https://github.com/AvailLang/Avail](https://github.com/AvailLang/Avail)

~~~
markvangulik
Working on it, sorry about that. We lost some things when rehosting some time
ago and have prioritized other things. There is no mailing list any more.

------
qop
Someone smart needs to explain what an infinite algebraic lattice is, because
it sounds awesome. Potentially.

Edit: (I just googled "algebraic type lattice" and while ymmv, I don't
recommend it unless you're well versed in scary black mathic)

I didn't get too in depth with reading the docs, but any language that goes
for non ascii symbols a la APL is going to be fighting an uphill battle right
from the get go.

Maybe it was a bit easier even for apl because there were interfaces more
immersive than what we have now for non ascii, especially when mixed with
regular ascii.

Type type type, oh wait, backslash, dropdown, there's my symbol, enter, type
type type. That's not very fun. That's less fun when youre dividing your
cognition between what things im actually trying to accomplish and what things
I have to type.

Just my two cents, no ill will

~~~
tathougies
A lattice is a partial ordering where any two elements have a supremum and
infinum. I.E., for any two types in avail's lattice, there is a unique super
type, and a unique sub type. A partial ordering means that -- given any two
elements -- I can say that either one is a subtype of the other or that the
types are not in relation. The super type of every type is known as 'top', and
the sub type of every type is known as 'bottom'. An infinite lattice just
means that there is an infinite amount of types in the Avail type system.

~~~
markvangulik
Well said, that’s exactly right. Most languages lack a bottom type, or screw
it up by pretending that “null” fits that role and falsely promises everything
that every other type promises.

Languages like Java (and many more) fail to even have a top type, which leads
to kludgey add-ons to the type system — boxed, @Nullable, erased generics,
annotations, dependency injection, purity annotations, etc., all of which
should have been part of a single type system.

~~~
markvangulik
I forgot to add the interfaces versus classes, inner classes, and lambda
notation, with the _tons_ of trivial FunctionalInterface interfaces to deal
with a smattering of the combinations of number of inputs, void or primitive
or class output, which inputs or inputs can be null, and which exceptions can
be thrown by the evaluation method (having many different names, etc).

Almost all of these monstrosities are caused by the “object purity” mindset
that kept the designers from including first-class functions in the language.
Avail attempts to include a large set of paradigms instead of trying to
“axiomatize” the exposed surface (although we do axiomatize the construction
of these constructs).

------
p1necone
The example at the beginning strikes me as a bit over the top. Something like
'String.Join("," Range(1,10))' (pseudocode, but you get the picture) would be
better, and avoid all the ambiguities of the plain english version.

~~~
3131s
My ideal syntax for that expression is very close to yours, something like
_str.join(1..10, ', ')_. Looking at our two approaches I noticed something --
yours has no space after the comma, and mine does, so how would Avail express
that distinction without becoming even more verbose?

------
geoelectric
I really hate programming in AppleScript, which also attempted a similar
syntax, because it's in the uncanny valley of semi-structured English. It's
too close to the language I speak such that remembering all the special cases
(which prepositions link which operations, sentence structure, etc.) becomes
really difficult.

I _like_ some well-structured separation in my coding languages. It's not a
downside for me at all.

~~~
markvangulik
The core syntax of Avail does have a prose-like feel to it, and that’s
intentional. But when you narrow it or extend it for specific linguistic
domains (CSV, tensors, business rules, build rules, expert systems, or a vast
number of existing notations), it makes the code read exactly at the right
level. No noise. Have a look at the Silly Quiz example for what I mean about
getting the right level.

------
dang
From 2014:
[https://news.ycombinator.com/item?id=7667706](https://news.ycombinator.com/item?id=7667706)

From 2015:
[https://news.ycombinator.com/item?id=9043561](https://news.ycombinator.com/item?id=9043561)

------
jillesvangurp
Reminds me a bit of intentional programming, something that Charles Simonyi
has been pushing for a few decades. As far as I know he might still be pushing
this but I haven't seen much progress since 2002.

------
sanxiyn
This reminds me of The Osmosian Order of Plain English Programmers.

~~~
GerryRzeppa
The Osmosian Order is alive and well.

[https://osmosianplainenglishprogramming.blog/](https://osmosianplainenglishprogramming.blog/)

And we're about to release Español Llano, the Spanish version of Plain
English. This new compiler compiles Spanish and English. Or both, even in the
same sentence. Kind of like a bi-lingual human.

------
IshKebab
First rule of programming language home pages - have a good selection of
examples on the first page! This fails that horribly.

------
IvyR0gue
Super cool. Going to have to check this out.

------
beojan
Someone looked at COBOL and thought, " _That_ looks great".

------
thepratt
> But there are many career programmers who would rather say: > Print 1 to 10,
> as a comma-separated list.

No, I would not. Don't make assumptions on behalf of others.

~~~
stefanve
There are many career mathematicians who would rather say: " add two to four
and multiply the sum with three". Natural language mathematics (arithmetics)

~~~
markvangulik
Right, and that’s why Avail is nothing like that. Kind of the opposite when it
gets down to it...

Cheesy, closed languages like C forgot that exponentiation was even a thing,
or complex numbers. If you shift over to using C++’s “clevernesses”, you still
don’t get exponentiation, because the traditional caret symbol is already used
for exclusive-or, which has no sensible ASCII punctuation.

As for someone’s distant comment that Lisp has been used to create languages
for years... sure, if the language you wanted was parenthesized lists with
keywords inside the left parenthesis. Which is just Lisp with a few more
operations and macros. Yuck.

~~~
lispm
A few languages implemented in Lisp: C, Pascal, Ada, Prolog, Python,
JavaScript, Fortran, Haskell, ML, ... none of that had parenthesized lists...

~~~
kazinator
All those and SHRDLU.

[https://news.ycombinator.com/item?id=17156049](https://news.ycombinator.com/item?id=17156049)

~~~
markvangulik
“Implemented in” is the key. If you want, say, a C compiler written in Lisp,
you end up writing a compiler. If you want a Haskell compiler written in Lisp,
you write another compiler.

If you want Avail to include all of C, you define C language capability in an
Avail module and subtract the rest. Then your C program is also an Avail
program, so you have the same tool chain you had with core Avail (still
lacking, but getting there), you have dynamic optimizing compilation to JVM
(and eventually native, perhaps), and you have a program that not only
interoperates with programs written in other dialects, but allows direct
connection between them. Like if you want Avail exceptions with your C code,
you import exceptions and just use them. You don’t build them over and over
again for each language. And if you want to support closures in your C, you’d
probably just _remove_ the limitation that treated the closures of Avail as
contextless C functions. Similarly for backtracking, universal serialization,
and sensible module dependencies (maybe call it #import, versus the horrible
textual #include mess of C).

And finally, if you want your existing vanilla C code to be able to call “out”
efficiently to some FORTRAN or Python code, you no longer have an impedance
mismatch. Define those dialects as Avail, and you’ll have real garbage
collection, multiplexed lightweight threads (fibers), dynamic optimization,
and objects and functions that are reasonably compatible between these
dialects.

------
toolslive
obligatory xkcd: [https://xkcd.com/568/](https://xkcd.com/568/)

------
dwarfylenain
Cobol 4ever ;)

~~~
markvangulik
Perhaps. But wouldn’t you prefer that COBOL become a mere dialect of Avail?

------
bbeonx
To be honest, this project is going the wrong direction.

Rather than trying to get programming languages to look like human language,
we need to get human language closer to computer language.

By this I mean that every argument I've ever been in has turned out to either
be an intrinsic disagreement about definitions (fixable, and usually we agree)
or an intrinsic argument about god (probably not fixable, we will probably not
agree).

If the average person understood the beauty of a solid (and unambiguous)
definition, I dunno, world peace and rainbows and butterflies? Probably not,
but I'd definitely not have to rage-quit socializing so often.

Still, with that said, from a purely intellectual curiosity standpoint this is
neat. I hope that the general saltiness of the internet doesn't discourage the
devs from working on this some more.

