
Fledgling Languages List - gabordemooij
http://fll.presidentbeef.com/
======
speps
Just taking one example (AngelScript), it's not really "fledgling" (not even
sure the meaning of that, but it says "This site provides a list of
programming languages which are just starting out in the world."). It's been
around since 2005... Maybe it's just "a list of languages that I've just
started to read about recently".

Neat in the end, but should do with more information on how they were
recognized as "fledgling".

EDIT: found the criteria (doh!)
[http://fll.presidentbeef.com/criteria](http://fll.presidentbeef.com/criteria)
and I searched "fledgling", AngelScript doesn't fit that category, it's a
mature language used in lots of video games. If a language doesn't have a book
written for it doesn't mean it's not "popular"...

~~~
tel
On the flip side, Idris is listed depite

    
    
        - a wiki article,
        - a book, "Type-Driven Development with Idris" by the language author, and
        - a subreddit
    

So I'm guessing it's just not a super well-maintained list.

~~~
commentzorro
I can't say about how the site is maintained (i.e. who makes the various
decisions about each language) but it's updated quite regularly. I have
changedetection.com monitoring the site and changes happen all the time.
Here's the recent change list:
[https://www.changedetection.com/log/presidentbeef/fll/index_...](https://www.changedetection.com/log/presidentbeef/fll/index_log.html)

Edit. Also, "This site exists to promote languages which are in development or
have not yet reached a wider audience." I'd agree that none of the listed
languages have reached a wide audience in (terms of usage anyway) regardless
of the other criteria. But it's all relative and I do really like the site.

------
chc4
In another vein, it's a lot of fun to look at random pages on Rosetta Code.
Lots of esoteric languages and snippets of examples of code, all self-added by
the community instead of added by one person like the OP's list.

I never heard of this site before, for example, and I'm sure tons of other
people never have, so it's probably missing quite a bit, while Rosetta Code is
relatively well known. I took it upon myself to create an entry in Rosetta
Code for Hoon, along with populating it with a couple examples, for example,
but never saw this site to add it to before now.

------
dbpokorny
Orange! I remember that language. It is the language which produced what I
consider to be the all time #1 hacker news comment:

> Let me put your mind at ease: If you are serious, and if you attain any
> success, I solemnly promise you the Internet will string up your language,
> dismember it publicly, douse all the pieces in gasoline, light them on fire,
> and dance around the flames. Why is that actually something that ought to
> put your mind at ease? Well, it's inevitable anyhow, so you might as well go
> ahead, have some fun, and make some decisions about what Orange is going to
> positively be.

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

it is mean but oh so vivid

~~~
andrewflnr
I remember that thread now! Looks like the creator took the advice, too

------
petke
I'm probably cynical but I dont think the world need more languages. A clean
and simple language turns ugly and complex given enough time. The programming
world is fragmented enough as it is. I think we need more libraries and tools
for the languages that already exist.

------
jack9
Quorum

[http://quorumlanguage.com/](http://quorumlanguage.com/)

------
zwetan
Interesting list but "fledgling" is not only about language, it can be about
where the language can run.

When Node.js started, JavaScript was already popular but I'm pretty sure node
could have been considered "fledgling".

~~~
lmm
A list of fledgling languages is a very different thing from a list of
fledgling language implementations. Haskell is 20+ years old but the Android
port might count as "fledgling". Python is similarly mature but PyPy not so
much.

If you want to maintain a list of fledgling language implementations/ports
that would be very cool. Probably a lot more work than just a list of
languages though.

~~~
derefr
It's not just the implementation, though. The thing that differentiates Node
from in-browser JS is something _like_ a standard library—but really it's
something we don't really have a term for in software architecture. It's the
fact that in-browser JS has a DOM to work with, while Node has processes and
files and other Unixisms to work with. Effectively, Node and JS-in-browsers
are two _sublanguages_ , each exposing the distinct set of abstractions their
underlying platforms provide.

This is distinct from the difference between, say, MRI Ruby and JRuby and
IronRuby: those all fundamentally present the same (Unix) abstractions. The C,
JVM, and CLR implementations of Ruby are effectively all composed of two
parts: first, a shim on the underlying platform allowing it to be presented as
_having_ Unix platform abstractions; and then, a compiler/interpreter written
in terms of those Unix platform abstractions. Instead of IronRuby exposing,
say, a Window with a thread-pool as the basic actor type, you still get
Processes with Threads; instead of IronRuby exposing NT Objects with ACLs, you
still get Files with read/write/execute masks.

Although this distinction is important, it's usually pretty trivial. There
just aren't that many platform _abstractions_ that existing languages really
target, other than Unix, web browsers, and (rarely) SQL databases.

There are some rare exceptions that have their _own_ set of platform
abstractions: Smalltalk, MOO games, Erlang, Lua, and Microsoft's Midori
project, to name a few. This is why you don't tend to see a language directly
"ported" to or from any of these runtimes; it'd end up a different
sublanguage, and indeed often an entirely new language. (One could argue that
Elixir, for example, is what happens when you "port" Ruby to Erlang's runtime;
or that MoonScript is what happens when you "port" CoffeeScript to Lua's
runtime.)

Point being: I don't know whether a list of fledgling _ports /implementations_
of languages would be all that interesting, where those ports/implementations
retain the original language's platform abstractions. But I'd _love_ to see a
list of fledgling sublanguages that adapt an existing language to the platform
abstractions of a new or different platform.

~~~
lmm
I don't think the distinction is as strong as you make out. Node and browsers
both implement the same language standard. They offer different "standard
libraries", but in that sense any program that embeds Lua is offering a
different "lua platform".

------
davelnewton
Not sure how Factor is remotely "fledgling".

