What programming language has the most beautiful syntax?

Assembly. It feels tangible, nothing is hidden, it is just bits and registers.

If I can pick anything my vote goes to Pancake Stack: https://esolangs.org/wiki/Pancake_Stack

Otherwise for a high level language and perhaps a controversial pick, but I like JavaScript. Simple and straight forward, can often be reduced to the absolute minimum.

You can of course make every language ugly by writing ugly code.

Lisp, because of the beautiful way its syntax represents code as data and data as code.

None of them! Programming languages are designed to be machine parsed and compiled to working code. For me, most languages incorporate too many punctuation characters ("fly dirt" as a co-worker once called them) with different meanings for different languages. I almost suggested Lisp, but the long-hyphenated-function-names detracts from its otherwise simple syntax.

Of regularly used languages I would go for SQL in that quite often it does just what it says. It was developed for business people to use, and I pitched it as that early on, but ... not really.

C, but beauty is in the eye of the beholder.

Perl.

I would pick ooRexx: https://sourceforge.net/projects/oorexx/ Personally, I consider its free-form and case-insensitive syntax to be amazing.

In decreasing order:

  - English (the ChatGPT/LLM programming language)
  - ML family
  - SQL (queries and DDL only - DSL)
  - Algol family (Algol 60/68, Pascal, Ada)
  - Logo

  NoSyntax is the best syntax?

  - TCL/Tk
  - Forth
  - Lisp family

  ...

  ETOOMANYSIGILS:
  - Perl / Ruby / Elixir

  ETOOMATHLIKE:
  - Prolog / Datalog / Erlang

  ETOOVERBOSE:
  - PHP / Java / C#

  ETOOANCIENT
  - SQL (Stored Procedures and Triggers)

  The worst:
  - various assembly languages
  - LaTeX
  - APL family
  - Brainf*ck

  var urlRegex = new RegExp(
    /(?:(?:(https?|ftp):)?\/\/)/.source       // protocol
    + /(?:([^:\n\r]+):([^@\n\r]+)@)?/.source  // user:pass
    + /(?:(?:www.)?([^/\n\r]+))/.source       // domain
    + /(\/[^?\n\r]+)?/.source                 // request
    + /(\?[^#\n\r]*)?/.source                 // query
    + /(#?[^\n\r]*)?/.source                  // anchor
  );

c++

I find Python and Haskell both very elegant.

I really like the syntax of Standard ML. It's pretty much the essence of that kind of static functional language, without a bunch of experiments and cruft bolted on.

Lack of cruft aside, even the basic syntactic choices are just plain better than OCaml, e.g.

- Commas instead of semicolons as separators in lists/records.

- Local declarations mirror top-level declarations.

- Distinct keyword to create a new type vs a mere type alias.

- ...

Free Pascal handles pointers in the cleanest way possible. @ is the address of something, and ^ is what something points to. There's no ambiguity about anything, and certainly no confusion with array indices. Begin/End might be a bit verbose, but it better impedance matches with my view of the world, so it works well for me.

Stoic/Stoical/MStoical is a non-Forth forth... which handles strings well, 'string is a single world "string", and "longer string which can include spaces" give you fairly good coverage of all of your string needs, and unlike forth, it just takes the top parameter (a string) as an input into : to define a word, so you can do

  'cube  : dup dup * * ;

This avoids a lot of confusion with modes and things that happen in the normal forth compilers.

Python

Typescript over Python for me. Prolog also of course.

Much less strange new characters for new concepts, whilst still elegant. Not so the semantics, they suck a bit.

Ruby and C++ are almost perl/rust like, esp. ugly.

C has to be up there.

One thing I find particularly beautiful is the elegance of how if and else work, which obviates the need for a separate elseif/elif keyword.

I also like that types are always on the left, which provides a nice symmetry for assignments. When I declare `int x` with int on the left, what I'm saying is that an assignment of x (e.g., y = x) results in an int being passed to the left of the = operator. This is different from Rust, Zig, etc., which IMO get this wrong (or at least ugly/counterintuitive).

Even though I prefer Python, I find Ruby can be very beautiful. Allowing ? and ! as part of variable and function names is very nice.

I quite like dart.

Lisp. Best syntax is no syntax.

Python. I love working with it (except when it comes to package management and distribution).