I would be torn if I had to write intro documentation like this. On the one hand, people demand code examples, but on the other hand, the majority of people reading code examples will nitpick minor pet peeves in the syntax and completely detract from the actual new ideas and concepts that go way beyond just the syntax.
I found the descriptions of the concepts very enlightening and I honestly think they gave me a better idea of what the language would “feel like” to program in than a code example (or a description of the syntax) would have.
In theory, syntax should be interchangeable. It's conceivable to parse a syntax into an AST and reexpress it in another syntax without changing the AST. In practice, this is not done for many reasons (incl. tooling like diffs) but a big reason is that individual bits and bobs of the syntax are tied to the new concepts in subtle ways. There could absolutely be multiple syntaxes for the same concept, but if the concept is new, even in small and unobvious ways, then no prior existing language’s syntax will map it exactly. For this reason, a code example can't really express the new concept, especially if the syntax is superficially similar to another language that doesn't actually have that concept.
So by seeing the syntax up front I can save a lot of time because in a world where there are many languages that do the same thing it really boils down to using the one with the syntax that you like the most.
Wat? If all languages were just syntax re-skinning, we really wouldn't need more than one compiler backend...
Generally the semantic differences are much more important. Rust isn't interesting for its syntax, it's interesting for its ownership rules and borrow checker. Erlang isn't interesting because of its syntax, it's interesting for its actor model concurrency. And so on...
But just because syntax is superficial doesn't mean that it isn't important. If a language has such poor syntax that I feel the need to write my own compiler to work around its syntax, I have to seriously question the skills and/or motivations of the author. If I am capable of writing a compiler at the syntactic level, why not just go all in and write my own compiler that implements _my_ desired semantics? A language that I find subjectively distasteful at the syntactic level is nearly guaranteed to be filled with semantic and architectural decisions that I also dislike. Consider Rust, I do not think that its syntax and abysmal compilation times can be decoupled. I would rather write my own borrow checker than subject myself to writing rust. And the reason is not the syntax, which I do strongly dislike, but the semantic properties of the language, such as horrible compilation times and compiler bugs (if a language has more than 100 open issues on github, I consider it broken beyond repair).
Oh, that's very interesting. Rust tried to match C++'s syntax as much as possible.
Which parts do you find awful? Lifetimes and trait bounds?
I mean, you do you. No one is judging. The fact remains that Rust exists primarily because there are some features that C++ cannot reasonably provide
Not only didn't they made it into C++26, it isn't clear what could land in C++29, this ignoring the assumptions regarding capabilities that static analysers are yet to provide nowadays.
Err, ok, so? Don't be so afraid of criticism, I guess? Yeah, some people will nitpick. I don't see the problem.
I believe that, regardless of our personal preferences, the reality is that syntax is a major criteria for adopting a programming language.
Some people have trouble following Lisp code, and won't touch your project if it looks like chat. Others will have the opposite reaction and have their interest captured instead.
Some love short, mnemonic built-in variables and short built-in function names of the sort you see in APL or Perl (although Perl has longer-named versions optionally for a lot of things). Others love long, self-documenting names for keywords and functions. They might want no built-in variables at all.
Printing hello world is the default of the industry for this sort of thing.
The Rust playground defaults to "Hello World" but that's just because there has to be something there, it's not on the home page of the website or anything (though it used to be).
Mainly my point is it’s weird to complain about hello world. It’s been the first program for languages for decades.
You also don't get to be the chief decider of what all of us may or may not talk about.
Playground: https://playground.ponylang.io/
They're on HP https://www.ponylang.io/ unfortunately the article link points to /discover/
This bit from the About page is notable: "never write a programming language. That’s like rule #1. Everybody will just tell you it isn’t needed and then argue about syntax."
I agree for the hello world but I disagree with the syntax. It is the first thing you see and the characteristic you can never escape. It is like the layout and typesetting of a text: the substance is of course more important, but it is still very important. I personally find much more readable languages that have a concise-but-not-too-much syntax, that use not too many special characters, and that is read like fortran/pascal/c/etc (I don't how to define it, but for example lisp is different)
I don't think that Pony is claiming to be novel in the area of syntax?
As far as I can tell reading here, “reference capabilities” don’t do anything that properly-used C semaphores haven’t done for near half a century. Or that their abstraction of that isn’t nicer to use than, say, Elixir’s, or better than Rust’s borrow checker for managing mutability. A code example could convince me otherwise.
Show us code that uses “reference capabilities” to do something. This “the syntax doesn’t matter” talk just comes off as bullshit to devs wanting to actually use a language. It would be better to commit to a syntax, post some damn examples on the site, and let devs get used to “reference capabilities.” If the syntax needs revising, just do that in Pony v2.
If you want devs to be enthusiastic about your language, make it easy for them to understand why they should be enthusiastic. That means code, front and center, first thing.
Also the syntax is great, probably my favourite language ever syntactically. Dunno why there's a pointless argument about it in these comments...
The reference capabilities are fairly novel as well. Apart from the lack of tooling, writing in Pony is great.
I've been looking for platforms where one can maybe more formally encode their thoughts, so that the argumentation and debating skill barrier is lowered / eliminated, along with manipulation. And I did find some, but they don't quite hit the spot, and even if they did, people aren't really on them, so it doesn't matter sadly.
P.S. "please do flag and downvote rather."
I don't have that capability, else I would certainly use it.
"Surely you can appreciate that their comment was not written in agreement with or support for you"
No, I disagree; I think that is exactly what it was--the subject of the comment was your comment, not mine--you wrote of my statement as being a universal truth, not v.v.
Unsurprisingly, on every point where you and I disagree, I think that I am right and you are wrong.
I think it is best that, from now on, neither of us speak to or about each other.
Edit:
> No, I disagree;
Sure, costs me nothing to take your word for it. Definitely came across like that to me though, so if that was not intentional, maybe it's something for your later consideration.
https://news.ycombinator.com/item?id=44728708
https://news.ycombinator.com/item?id=44722043
It's laudable to want work like Pony to get discussed in terms of the most interesting things about it, but the best way to do this is to describe and explain more of what's interesting. It's not helpful to comment about how bad other comments are, and certainly not to cross into attack. Those things feed flamewars, as unfortunately happened badly in this thread. That's what we're most trying to avoid.
As for Pony, I'm not here to defend it or explain it ... I simply responded to casual dismissals of it on trivial grounds.
> I can't flag that outrageous personal attack and no one else has.
Why wouldn't you be able to flag it? And there's no flagged counter, it's not possible for ordinary users to tell how many times a post has been flagged or not.
I think there is a fundamental gap in communication. Your actual point is not coming across at all, anywhere in this thread.
That's why you're getting downvoted.
"For Pony in particular, the syntax is not important ... it's simply not the point of the language."
You said that in direct response to someone who was wanting to see the syntax. While I do appreciate that it's not strictly speaking necessary in the context of your reply, it doesn't communicate at all why syntax isn't important to the pony language. You're just making a definitive statement unsupported by anything. Context or even a brief explanation would have been extremely helpful and almost certainly avoided all of this fuss. Your response, given without any context as to why syntax isn't important for pony, was actually harmful, rather than useful.
Syntax is probably one of the single most important things in any language. It matters for writing, but especially for reading.
Bad syntax leads to all kinds of implementation mistakes. It comes with footguns primed ready to go off, probably at the worst possible time. Bad syntax can also make it hard to re-read code and understand what it's doing (especially if the language leans heavily on "magic"), leading to difficulties when troubleshooting, or difficulties when extending existing code.
The more developers you have involved in any project, the more important good syntax becomes, because you all have to be able to read and understand each other's code, and know precisely what is happening. A lot of the bugs that end up in production tend to stem from some disconnect in understanding of the interactions between sections of code.
That appears to be your position (and maybe even that of a majority of developers), but it apparently isn't the position of the Pony developers. If you have a language in which you can mathematically reason about code (which Pony claims very prominently), then surface concerns such as syntax seem to matter less.
It's a different design goal and it feels like many people in the comments here don't appreciate that.
Aside from this being argumentum ad populum, my upvotes and some of the other comments say otherwise. And I find comments like yours full of strawmen and taking things out of context, to the point where it's simply not worthwhile to debate the substantive points.
Although, I would point out that while your argument ad absurdum is generally reasonable (the fact that syntax can make the difference between a very good language and an unusable one), whitespace and malbolge also have terrible semantics that contribute to them being unusable.
As a former Lisp enthusiast (and still an enjoyer), I'd actually use my own darling as an example: Lisps have amazing semantics and are generally good languages. Their syntax is highly regular and structured and easy to parse...except that it's brain-hostile, and I'm convinced that it actively makes it harder to read and write - not just adopt, but actually use.
Are you talking about natural languages here? The so called Sapir Whorf thesis - in its strong or weak form - is rather controversial. There are some interesting findings, but the interpretation of them is still hotly debated.
In any case, none of the studies that I've seen (e.g. about colour perception, spatial reasoning, etc.) seem to be about syntax. I'd have to see some evidence that head-marking language speaker somehow think differently than dependent-marking language speakers and I haven't seen that.
> your argument ad absurdum is generally reasonable
it's a valid argument when somebody is speaking in absolutes, but I haven't seen GGP do that. There's a difference between saying "all syntax is completely arbitrary" and "syntax is not the point" - the latter suggests to me that if you stay within certain reasonable bounds (e.g. not be whitespace or malbolge), whether you use significant whitespace of braces, the language looks more like Pascal or like C, etc. are of minor importance in the grand scheme of things. Which is something you may disagree with, but it's a much more reasonable point that anything you can just counter with "but whitspace!".
I never said anything to the contrary. I specifically stated that syntax was not an important consideration in the design of Pony language. That does not imply the numerous strawmen that you and others attacked here. As Tainnor correctly and honestly noted:
"it's a valid argument when somebody is speaking in absolutes, but I haven't seen GGP do that. There's a difference between saying "all syntax is completely arbitrary" and "syntax is not the point" - the latter suggests to me that if you stay within certain reasonable bounds (e.g. not be whitespace or malbolge), whether you use significant whitespace of braces, the language looks more like Pascal or like C, etc. are of minor importance in the grand scheme of things. Which is something you may disagree with, but it's a much more reasonable point that anything you can just counter with "but whitspace!"."
True, it just means that it's idiotic, rather.
And so no,
> Saying that a certain kind of Scotsman puts sugar on his porridge is very different from saying that no true Scotsman puts sugar on his porridge.
I categorically disagree that these would be meaningfully distinct claims, as the "[only] a certain kind of Scotsman puts sugar on his porridge" bit specifically invokes the implicit disqualification of said Scotsman from being counted as a True Scotsman.
> not the only example of it from that source
Pretty ironic of you to say that.
[0] the literal definition of the no true scotsman fallacy: https://en.wikipedia.org/wiki/No_true_Scotsman
Whereas this follows the form more of "Murder is bad" "I dunno, a lot of Scotsmen commit murder" "Ok, but no true Scotsman would commit murder"
It's the same (annoying) assertion, but the fundamental argument is about the value of murder, not the category of "Scotsmen," so it's not the same extremely obvious fallacy of redefining the literal topic at hand whenever a counterexample is presented.
It's why I called it an outright textbook example: it's an appeal to purity, where purity is determined in a circular way - the very definition of the no true scotsman fallacy, as far as I could find and understand it.
https://www.ponylang.io/discover/why-pony/
Syntax doesn't really come into it.
Edit: I'm as fond of discussions of the design of programming language syntax as everyone else - just in this case the apparent novelty of Pony is at a more fundamental level.
The syntax is the language. To show me the language you have to show me its syntax.
This is obviously false.
That was years ago. After reading your comment, I decided to check again. The same “AAA game” link is still first, and it’s still broken.
You can’t really call that “a good presentation of a language” when the very first real-world example links to nowhere—and nobody’s bothered to fix it for years.
You are not wrong, that should be fixed but no information about it is lost, I feel like you're a bit too harsh here.
Python doesn't have a notion of public/private symbols (no, "__" prefix does absolutely nothing). It also doesn't have a good type system, so it can't have function overloading.
This is why you're required to qualify almost all imports in Python, to avoid name clashes.
Nim doesn't have this problem and also "fixes" a lot of other shortcomings[1] of Python.[2]
[1] - https://github.com/yugr/python-hate
[2] - https://github.com/nim-lang/Nim/wiki/Nim-for-Python-Programm...
When you're reading Nim code and you see a symbol you don't know, how can you tell where it comes from? In Rust, it's either qualified or you have to explicitly import it. What do you do in Nim?
In my experience, it's even faster to git clone, open a project in neovim and navigate with LSP than browsing code with some online interface.
All the languages you listed do not support function overloading. Qualified imports and namespaces exist to avoid name clashes first, dependency tracking is just a bonus (and a chore).
It’s crazy how many people build something and make a website for it, only to hide the thing they’ve built somewhere deep in the website. Just show me the damn thing!
It seems really bizarre to respond to “there should be easily-accessible examples of code that demonstrate the language’s key features on the website” with “there’s a $200 conference in South Carolina where there will be a talk on it.” Honestly, it comes across as not just bizarre, but somewhat disrespectful (though I’m sure that was not your intention).
My apologies.
Why another object language?
https://github.com/KittyMac/PonyCAT/blob/master/pony-cheat-s...
The project looks hostile to any sort of adoption.
That is indented to assist the human reader, not the compiler.
actor Main
new create(env: Env) =>
TCPListener(TCPListenAuth(env.root), Listener(env.out))
??
If so, I don't want to every see that language in my life ever again.
That's fine, we all have our preferences :D
They can tell you whether language is statically typed or not, does it have an effect typing (it necessarily needs higher order types), does it have type inference, etc,
A syntax of one is semantic of other.
Sure, some people are going to use that as an immediate gut filter for "doesn't look enough like languages I already know" or various pet peeves, but on the other side for those that love to dig deep into the syntaxes of esoteric/lesser-known languages it becomes like the first sniff when working on tasting notes of a beverage and tells you a lot up front to your "nose" faster than paragraphs of prose about the motivations of the language. "Ah, yes, I'm sensing a strong Python influence on top of earthy notes of Erlang and just a bit of floral Pascal-ness most recently from the vineyards of Typescript, perhaps?"