> My name is Hubert Tonneau. I've been born in 1968. Legendary will soon add that I had a computer in hand, but the problem is to get an agreement on what model.
Okay, I'm hooked.
EDIT:
So I tried FullPliant for about 30 minutes.
* FullPliant is a distro. From the documentation: "operating system and administration tools" (as one layer). The administration tool can be access remotely. It feels like Redhat + Cockpit to me.
* It's a kind of web-based environment. Each view has a `loopback://` url.
* It has some interesting applications. Virtualization ones can be handy for operating mini boxes.
* The UI is, indeed, very consistent. All menu operations can be accessed with Alt+( ) combination. This feels very solid and convenient.
But, overall, UI needs some more work.
* UIs are buggy in some deeper parts.
* WYSIWYG editor is buggy.
* Doesn't support text selection nor block delete (i.e. ctrl-backspace).
* UI elements aren't kind. (i.e. calendar app requires you to punch in date-string directly.)
(TBH, these are all not so fun to work on.)
Apparently, the author used his own creation to roll some industrial boxes. If so, it does explain the application line up and the overall look-and-feel. This can be useful for driving server boxes with specific goals, but is less of a do-it-all desktop environment.
Does the site have contact info? I couldn't find any, but I feel like one of us should let Hubert know this is on HN. Maybe he'd show up to answer questions!
This looks like a true lifetime's work, started in 1999 and still developed.
From the description:
It prooves that in other softwares, the signal to noise ratio in the code is very low. Free and closed softwares are no different in this area. Counting typically brings 99% noise. No programmer can believe that, even if he can quite easily verify it through counting lines. This is just a perfect illustration of cognitive dissonance.
I trace the poor signal to noise ratio in classical softwares to four reasons:
* use of poor languages with no decent meta programming capabilities (poor expressivity)
* poor software design (code layering)
* unability to concentrate on ironing out core features instead of adding new not really usefull ones
* and finaly interfacing different pieces of software with quite different logic and conventions instead of building an overall consistent system.
It's always concerned me how we delicately stack fragile software on top of incomplete, bug-ridden platforms full of workarounds and "special cases" rather than building something that's cohesive top-to-bottom. I'll be excited to try this out when I get home!
It's a shame the documentation is a little unclear and the author could do with some help with translation.
I had to look at the overview[1] which I found to be super interesting.
The author focuses on metaprogramming (something like hygienic macros that are more efficient) as the only real needed extra feature over C. He says that with this other stuff can be built at need using libraries.
The upside is that new language features are just libraries that gain or lose popularity as time goes on, allowing the core language to be more or less the same as it was at its inception while still staying alive. This advantage is shared by Common Lisp for the same reasons.
The disadvantage is that since anybody can make a new sublanguage simply by writing a library, you're left with a fight between libraries on what language features are important for the whole group, splintering the group into different sub language dialect camps. This is part of the curse of lisp. The upside might be that it's still probably pretty difficult to write meta programming in Pliant relative to lisp because of its focus on efficiency. Perhaps this will save it from most of the curse. Time will tell.
I have never yet seen a "C++ Replacement" language's more carefully argued or justified using simpler arguments than this language. That the core language will probably endure easily is very exciting to me, especially after seeing the evolution that C and C++ has gone through over the years and how hard changing the language is nowadays. In the language overview the author makes some very good points about why he chose what he chose in his design decisions.
Other replacement languages try to simply make design decisions based on taste. This is not a bad thing; some language designers have excellent taste. But it is nice to have a plain explanation as to why specific features were included in a language.
One last thought I did have was that if language features are libraries, there had better be a very good dependency manager and packaging solution for this language from day one if it is to be usable.
This appears to be a software stack written by one guy who doesn't really believe in marketing. Moderately difficult to work out what is here from the docs but there is GPL'd source available.
There's a language and I think a bespoke database. Some web things. Probably not an OS and there are references to a patched Linux kernel.
Quite difficult to determine the language semantics. I think it's a hybrid of lisp and C.
There are places in the site that say it provides everything of an OS except the kernel. So it's basically on par with GNU or so needing a Linux or FreeBSD kernel to complete the system.
The site also refers to the language as a superset of C with an instance-based object model, dynamic compilation, reflexivity, and metaprogramming capability.
"Anyway, I find the sociological level answer more pertinent.
[...]
So, my two cents sociological level conclusion is just ... Who is really working on languages nowadays ?"
This guy has some Stallman vibes, in the good sense.
I've always thought Pliant was interesting. It is only a little out of the mainstream (imperative language, runs on Linux) so, so far, nothing that blows my head open (like Oberon, Smalltalk, Prolog, Haskell, Coq, Hypothesis, TeX, and Plan9). But it seems practical.
There are no links on the page. There are spans, styled to look like links, with an attached event handler which sends some cryptic ID associated with the pseudo-link to the server over a websocket. The server sends back messages on the websocket which look like:
The handler on the websocket reads the messages (in a slightly roundabout way) and passes them to a function which parses them (in a highly roundabout way), and then goes into a big if-else ladder which dispatches on the first token to do various things; commands supported are:
What rules there are rules? Ban my account I will make a new one until you ban Tor and make an article about how Tor is toxic. YOU ARE PART OF THE PROBLEM, DICKFUCK.
In your world, everything is okay, we can pretend the latest script kiddie software that flings local URLs around is fine. In your world, since everyone is pretending all the broken stuff doesn't exist (in order to be "civilized"), more broken stuff is made, as the developers have the illusion that garbage status quo is good. This is how HN works. It's hilariously true. Everything people here make is clones of the same terrible concepts like convention over configuration (which make auditing harder and shitcoding easier).
Internet moderation is the single most useless concept ever invented.
Okay, I'm hooked.
EDIT:
So I tried FullPliant for about 30 minutes.
* FullPliant is a distro. From the documentation: "operating system and administration tools" (as one layer). The administration tool can be access remotely. It feels like Redhat + Cockpit to me.
* It's a kind of web-based environment. Each view has a `loopback://` url.
* It has some interesting applications. Virtualization ones can be handy for operating mini boxes.
* The UI is, indeed, very consistent. All menu operations can be accessed with Alt+( ) combination. This feels very solid and convenient.
But, overall, UI needs some more work.
* UIs are buggy in some deeper parts.
* WYSIWYG editor is buggy.
* Doesn't support text selection nor block delete (i.e. ctrl-backspace).
* UI elements aren't kind. (i.e. calendar app requires you to punch in date-string directly.)
(TBH, these are all not so fun to work on.)
Apparently, the author used his own creation to roll some industrial boxes. If so, it does explain the application line up and the overall look-and-feel. This can be useful for driving server boxes with specific goals, but is less of a do-it-all desktop environment.