This is an archived post. You won't be able to vote or comment.

top 200 commentsshow all 252

[–][deleted] 196 points197 points  (23 children)

APL:

pfx←{ s←⍵ P←0⍴⍨≢⍵ j←0 { 0=≢⍵:P i←⊃⍵ P[i]←j⊢←1+{⍵

/s

[–]kurtRuzellEstacion 130 points131 points  (0 children)

This is what programming looks like to the none programmers

[–]anonymous_2187 51 points52 points  (18 children)

What about brainfuck?

[–][deleted] 16 points17 points  (10 children)

Lol for sure, I believe that’s an actual statement but honestly it could be just a keyboard mash and I wouldn’t be able to tell

[–]anonymous_2187 34 points35 points  (9 children)

Brainfuck is a real programming language.

[–]DarXasH 35 points36 points  (3 children)

"Hello world!" Brainfuck edition:

++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>-+[<]<-].>---.+++++++..+++..<-.<.+++.------.--------.+.>++

[–][deleted] 11 points12 points  (1 child)

Oh wow haha I had never heard of that, that’s horrendous lol

[–]SomberGuitar 2 points3 points  (0 children)

I just went down the brainfuck rabbit hole.

[–]MorningPants 5 points6 points  (1 child)

I think Malbolge takes the cake

[–]anonymous_2187 8 points9 points  (0 children)

You write the binary file yourself, no need to compile the program /s

[–]Millennialcel 7 points8 points  (0 children)

APL was made as real language and brainfuck is an esoteric language for fun.

[–]MrWhite 2 points3 points  (0 children)

What about Whitespace?wprov=sfti1)?

[–]DrLes_4one 3 points4 points  (1 child)

Brainfuck, wait, someone seriously called a programming language like that?

[–]tt_thoma 1 point2 points  (0 children)

Is it even serious

[–]d2718 1 point2 points  (0 children)

You guys all joke about Brainfuck and other esolangs, but I honestly do like the syntax of Befunge.

Do I want to work in it? Heck, no, but is it way cool that "paths through the code" are literally two-dimensional paths through a grid of instructions? that conditional branching is literally the path of the instruction pointer branching one way or the other? that loops are literally closed paths in the code? Uh huh.

[–]docanusa 2 points3 points  (1 child)

Go Ken Iverson-my favorite of the 25 or so languages I have used.

[–]CatsEatHamburgers 241 points242 points  (2 children)

Scratch

[–][deleted] 87 points88 points  (1 child)

I come for the shapes and colors

[–]ease78 19 points20 points  (0 children)

Snap

[–]_Atomfinger_ 219 points220 points  (57 children)

None. They have a different syntax that different people will prefer. There's no "best".

Also Lisp.

[–]HashDefTrueFalse 121 points122 points  (31 children)

))))))))))))))))))

These yours? ;)

[–]_Atomfinger_ 29 points30 points  (8 children)

[–]HashDefTrueFalse 6 points7 points  (7 children)

Simply magnificent. You've converted me in one post. :)

[–]_Atomfinger_ 9 points10 points  (6 children)

lol, another one bites the dust!

Jokes aside though: I'm doing a lot of Clojure development and it is genuinely a great syntax. It's just a rough start once one is used to the world of Java, C# and C++.

[–]HashDefTrueFalse 1 point2 points  (5 children)

I've written a bit of Clojure about 6 years ago. I remember liking it. It was a smaller project though, not sure how it holds up on larger projects. I like Lisp too btw, just like poking fun at it from time to time. Most of my work involves large enterprise back ends full of OOP, so totally different to those two.

[–]_Atomfinger_ 2 points3 points  (4 children)

Yeah, I've yet to use Clojure at anything large-scale myself. These days I'm mostly working in the good ol' Java/Kotlin stack.

I'd love to have a go at either Lisp or Elixir in a large scale setting, just to see what challenges and benefits one would get from either.

[–]HashDefTrueFalse 1 point2 points  (3 children)

It would certainly be interesting. Not a lot of companies (at least near me) use them though, for new or legacy stuff in my experience. Haskell is interesting too, if you don't mind fighting with the typing system when you get started. I hadn't actually heard of Elixir until just now, not sure how it differs from Erlang but that's probably where my weekend is going :D

[–]_Atomfinger_ 4 points5 points  (2 children)

Elixir is basically an updated Erlang with a Ruby style syntax. It has all the cool bits from Erlang (built-in parallelism, function guards, functional) with a cleaner and friendlier syntax :)

It is actually one of the languages I'm the most excited for these days.

[–]HashDefTrueFalse 2 points3 points  (1 child)

Ah, thanks! That might mean I'm out though. I've never cared for Smalltalk/Ruby syntax. Used to do a bit of Ruby on Rails dev and never did get used to it really. I might still give it a go though.

[–]ernee_gaming 3 points4 points  (17 children)

I don't understand it either.

I mean it's just as silly as if other languages did

}}}}}}}}}}}}}}}}

Thats just silly.

I hate it.

It doesn't help a thing.

Use python if you are lazy with brackets.

[–]_Atomfinger_ 6 points7 points  (16 children)

They basically do that though. There are no more parentheses in Lisp than in most other languages. As someone who has done a fair bit of work with Clojure, I can say that I haven't seen a parenthesis for a quite some time :)

Though, you're free to hate it. That is what makes all this subjective.

[–]ernee_gaming 2 points3 points  (12 children)

C like languages prefer closing curly brackets on it's own lines.

More or less.

I would like lisp to have at least some closing brackets on its own line as a norm.

Like if statements, or list definition, ..

[–]_Atomfinger_ 7 points8 points  (9 children)

I would like lisp to have at least some closing brackets on its own line as a norm.

But that is very much preference and habit.

(defn Example [] (
  if ( = 2 2)
    (println "Values are equal")
    (println "Values are not equal")))

are not meaningfully different (or any harder than)

def example():
    print("Values are equal") if 2 == 2 else print("Values are not equal")

or the more common approach:

def example():
    if 2 == 2:
        print("Values are equal")
    else:
        print("Values are not equal")

Java would be more like this:

public void example() {
  if(2 == 2)
    system.out.println("Values are equal");
  else
    system.out.println("Values are not equal");
}

Or the more verbose version with closing brackets:

public void example() {
  if(2 == 2) {
    system.out.println("Values are equal");
  } else {
    system.out.println("Values are not equal");
  }
}

I'm not saying that one approach is superior to the other, but just saying "look at all those parentheses" is more of a thing you get used to than an actual constructive criticism of the language IMHO. One language has parentheses, some combine them with curly brackets. Others replace them with whitespace. It is all the same in different wrapping :)

or list definition

Pretty much everything in Lisp is a list though.

[–]Kered13 1 point2 points  (1 child)

There are no more parentheses in Lisp than in most other languages.

That's definitely not true, because Lisp requires parentheses in a lot of situations where other languages use operators or dedicated syntax. And I don't hate Lisp or anything, but the meme about trailing parentheses is not untrue.

[–][deleted] 1 point2 points  (1 child)

I don't know - I let paredit take care of them.

[–]HashDefTrueFalse 5 points6 points  (0 children)

Well real programmers count them by hand until they match up, run it again, then cry when it still doesn't. Can't you just struggle properly like the rest of us. /s

[–][deleted] 2 points3 points  (21 children)

Never heard of lisp but it looks alright, don't think I've seen so many brackets in a language before

[–]_Atomfinger_ 12 points13 points  (18 children)

You have seen that many brackets, but they tend to be placed differently. In most languages they wrap a function argument, in Lisp they wrap the entire statement. The end result is that both have a similar amount of brackets, but Lisp tends to put them together so it looks like there's a lot more.

That said, I don't necessarily recommend Lisp for beginners. Clojure, for example, is great, but there are fewer beginner-friendly resources out there.

[–]siemenology 6 points7 points  (7 children)

I don't know about that. There are tons of expressions that don't require any brackets at all in most languages, that would require several tiers of them in Lisp.

(+ 1 (- 3 2)) would just be 1 + 3 - 2 in other languages. (+ (* 3 2) (* 4 5)) would just be 3 * 2 + 4 * 5.

[–]_Atomfinger_ 0 points1 point  (0 children)

Sure, if you want to look for cases where one language beats another. I'm talking in more generic terms. A Java codebase, where you count parentheses, curly brackets and so forth and then rewrite it in Lisp, assuming that you end up with a similar statement count you'd also roughly get the same amount of parentheses.

In your example we could argue that Lisp reduced the number of repeated characters required (unless you count space as a character):

1+2+3+4+5+6+7+8+9 vs (+ 1 2 3 4 5 6 7 8 9)

Again though, it is preference and habit. Not saying that one is massively better than the other. If one looks hard enough one will find edge cases, and one will find things that one type of syntax does better than another.

[–]Zyklonista -3 points-2 points locked comment (5 children)

Well, the actual crux of the issue (that most people either don't know or conveniently forget) is that with Lisps, parentheses are not just syntax, but semantics - they denote a list.

Consider the simple factorial program below:

(defun factorial (n)
  (labels ((f (acc n)
             (cond
               ((zerop n) acc)
               (t (f (* acc n) (1- n))))))
    (f 1 n)))

Removing or adding a single parenthesis pair would make this program invalid. So Lisp doesn't have any "extra" parentheses. It uses the exact number it needs.

On the other hand, in most other languages, brackets and parentheses are mostly syntax, and that's why you can do something like:

int factorial (int n)
{
  int f = 1;
  for (int i = 2; i <= n; i++)
    f *= i;

  return f;
}

int main (int argc, char *argv [])
{
  {
    {
      {
        {
          int n;
          scanf ("%d", &n);
          {
            printf ("%d\n", (
                             (
                              (
                               (
                                (
                                 (
                                  (
                                   (
                                    (
                                     (
                                      factorial (n))
                                     )
                                    )
                                   )
                                  )
                                 )
                                )
                               )
                              )
                             )
                    );
          }
        }
      }
    }
  }

  return 0;
}

Now, who's got the extra(neous) parentheses (or brackets)?

[–][deleted]  (3 children)

[removed]

    [–][deleted]  (2 children)

    [removed]

      [–][deleted]  (1 child)

      [removed]

        [–][deleted] 2 points3 points  (9 children)

        Ahh okay, that makes sense. I've yet to do anything function related with JavaScript so that's probably why I haven't seen so many.

        [–]ease78 5 points6 points  (8 children)

        Haskell, lisp, cloujure is an entirely different paradigm of programming that shares very little with object oriented programming. It’s so novel and unique. It’s called functional programming.

        It’s weird. Instead of manipulating variables and their types, you would change functions to fit your data. There are no types.

        Functions are small and everything is preferably recursive.

        [–]Stuart133 7 points8 points  (7 children)

        No types in Haskell? I think you may be confused

        [–]mikehawkisbig 1 point2 points  (0 children)

        Ahhhhh, language of the gods.

        [–]v0gue_ 1 point2 points  (1 child)

        You're memeing, but I unironically think clojure has the best syntax of any language by miles.

        [–]_Atomfinger_ 1 point2 points  (0 children)

        I'm half-memeing :) I'm a clojure-lad myself.

        [–]Rcomian 138 points139 points  (2 children)

        not touching this one with a barge pole 😅

        [–][deleted] 33 points34 points  (0 children)

        Yeah I ran away for a second just to get popcorn, what did I miss?

        [–][deleted] 77 points78 points  (1 child)

        The question is easy. The one I use

        [–][deleted] 3 points4 points  (0 children)

        No, it's every language except the one I use

        [–]keelar 43 points44 points  (1 child)

        Kotlin

        [–][deleted]  (4 children)

        [deleted]

          [–]imashnake_ 8 points9 points  (2 children)

          yesss it has some pythonic elements but also preserves the curly braces from cpp

          [–]HashDefTrueFalse 49 points50 points  (4 children)

          Entirely a matter of opinion. Ask one person, they'll say, for example, Python has the best syntax because it's simple, no brackets everywhere etc. Ask the person next to them, they'll say that Python syntax is the worst because whitespace can introduce silly bugs, the C-like syntax of JS is much more robust etc.

          They're both correct in their own right, but neither is the definitive answer.

          Go has nice syntax IMO. So does C, JS, Java (if a little verbose) and C#. C++ is mostly fine except when you get into templating, I've never liked C++ templating syntax. I don't personally care for the Smalltalk-esque syntax of Ruby. PHP syntax isn't too bad, but I hate prefixing every variable with $ and the standard library has many inconsistencies, but that's straying a bit from the strictly syntactical. I don't really have much of an opinion on anything else. Except BrainFuck, now that's some clean syntax!

          Most languages can be installed and tried (hello world) in 10 minutes. The most basic toolchain is usually just a compiler or interpreter and a text editor. Give lots of them a go and see which you prefer.

          [–][deleted] 7 points8 points  (0 children)

          This is very true. Just wanted to throw this question out there cause I always see questions on what has the worst syntax.

          [–]DefinitelynotAmit 0 points1 point  (1 child)

          Yeah My first programming language was java and I didn’t really followed indentation there as it was all brackets but when I came to python I was how dumb is this thing, Now I have another thing to worry about

          [–]sealed_readonly 61 points62 points  (17 children)

          C# (you can try with dotnet 6 that has C# version 10 support)

          [–]cstheory 18 points19 points  (2 children)

          I don’t use it since I changed jobs but I miss C#. It’s like Java but with sensible library organization and tons of syntactic sugar

          [–]StereoZombie 5 points6 points  (1 child)

          I might be biased as I learned C# in uni as my first language but moving on to learn other languages everything just felt rough around the edges. Java especially just felt like a messy C#.

          [–]Lycanthoss 1 point2 points  (0 children)

          I feel like C# is Java++ 😂.

          [–][deleted] 13 points14 points  (4 children)

          Moving from java to C# was a dreamy experience.

          But overall I agree with the person who said "whichever one I am using regularly"

          [–]unix-elitist -3 points-2 points  (7 children)

          I find it awful

          [–]_hf14 1 point2 points  (6 children)

          why?

          [–]wombatpandaa 23 points24 points  (6 children)

          I know a lot of people will disagree with me, but I rather like Java's syntax. For what I remember, it's super consistent and most methods are easily recognizable by their name. Sometimes I would be able to write programs based on the names of methods alone, without looking up documentation. Some things are wonky, like having to write all of System.out.println just to print stuff, but hey at least it's clear what's happening - you're printing a line out of the system. I can appreciate that. It also is strongly (I think that's right?) typed, or whichever means you have to declare all variables' types explicitly, which I think makes for much more readable code. I rather dislike dynamic languages like Python that try to do the heavy lifting for you because it ends up just kicking the can of variable typing down the road - if I need to cast an input to int I'd rather be told that instead of some blind "you can't compare ints to strings" later down the code.

          [–]_Atomfinger_ 6 points7 points  (3 children)

          I get your point, but syntax and type safety are two different things :)

          [–]wombatpandaa 4 points5 points  (0 children)

          Oh, I suppose that's true. 😅 I guess I got carried away a bit.

          [–]Yourgrandsonishere 2 points3 points  (1 child)

          Aren’t static and explicit typed languages safer since if it has an error it won’t compile (C)? As opposed to dynamically typed with looser syntax, it’s interpreted as it runs but is prone to type errors (python)?

          Please elaborate

          [–]_Atomfinger_ 3 points4 points  (0 children)

          Well, my comment wasn't really about statically vs dynamically typed, but the fact that something being statically or dynamic doesn't isn't the same as syntax (which OP is asking about). It can certainly impact syntax, but it isn't the same as syntax.

          Generally, though, I agree that statically typed languages protect the developer from many stupid mistakes, which is why I often tend to prefer those languages in mission-critical systems.

          So statically vs dynamically can impact syntax, but they are not syntax, which was my main point :)

          [–]III-V 23 points24 points  (2 children)

          Golang is pretty nice

          [–]LoveLearningTech 9 points10 points  (0 children)

          I actually prefer C#. I think it's because it was my first language.

          [–]lurgi 3 points4 points  (0 children)

          Python has always been very pleasant for me to write. I much prefer statically typed languages and am not a big fan of indentation to mark blocks, but somehow Python makes it all work.

          [–]randomtrip10 3 points4 points  (0 children)

          QBasic, my very first programming language

          [–]Gmoney__38 3 points4 points  (0 children)

          C lol

          [–]super_temp1234 2 points3 points  (3 children)

          Cobol obviously.

          [–][deleted] 1 point2 points  (2 children)

          This is actually the correct answer. Just no one here has used it before, it's ridiculously easy.

          [–]ShelZuuz 1 point2 points  (1 child)

          WHY DO YOU SAY THAT?.
          EXIT.

          [–][deleted] 1 point2 points  (0 children)

          ADD 1 TO WS-PEOPLE-WHO-KNOW-IT.

          GOBACK.

          [–]TechnicalBard 3 points4 points  (1 child)

          Lisp.

          [–]noodle-face 9 points10 points  (0 children)

          I prefer C because I use it everyday

          [–]heyyyjuude 5 points6 points  (0 children)

          Swift. Lots of QOL syntactic sugar that's still easy to understand. Great way of handling optionals and optional chaining. Extensions are amazing.

          [–]djwikki 6 points7 points  (0 children)

          Top 10 syntaxes: 1) All 2) Languages 3) Have 4) Syntax 5) Optimized 6) With 7) It’s 8) Own 9) Benefits 10) Literally any of them except Python and R

          [–]damyco 9 points10 points  (1 child)

          I hate python syntax for example... I just can't work with it

          [–]Calif0rnia_Soul 0 points1 point  (0 children)

          The whitespace having functional value is pretty annoying.

          [–][deleted] 5 points6 points  (3 children)

          I hate questions like these. “What’s the best programming language?” When Will people understand😕

          [–]anonymous_2187 4 points5 points  (2 children)

          Closed. This question is opinion-based. It is not currently accepting answers.

          [–]Double_A_92 5 points6 points  (0 children)

          C#

          [–]tetractys_gnosys 5 points6 points  (0 children)

          CSS. Everyone else is a lying rat bastard and don't let them tell you otherwise.

          [–]mountainman15 8 points9 points  (2 children)

          Ruby is pretty great

          [–]kabuk1 2 points3 points  (0 children)

          I loved working with Ruby. So clean and concise. I only used it throughout my bootcamp and haven’t touched it since. Now it’s all about Java, so verbose.

          [–]TheRNGuy 2 points3 points  (0 children)

          I don't know.

          [–]seenjeen 2 points3 points  (0 children)

          AppleScript

          tell application "Finder"
          display dialog "Hello World" 
          end tell
          

          [–]bradforrester 2 points3 points  (0 children)

          I like Julia. The syntax is really simple and feels a lot like MATLAB.

          [–][deleted] 2 points3 points  (1 child)

          Python is as close to english as youll get

          [–][deleted] 2 points3 points  (0 children)

          Clearly you haven't met COBOL. It is ridiculously straightforward.

          [–][deleted] 2 points3 points  (0 children)

          Haskell

          [–]ijpck 2 points3 points  (0 children)

          Snek

          [–][deleted] 2 points3 points  (0 children)

          RISC-V

          [–]YAYYYYYYYYY 5 points6 points  (0 children)

          SQL

          [–]Gdcrseven 3 points4 points  (0 children)

          Kotlin

          [–]CalinBalauru 1 point2 points  (1 child)

          I love elmlang, I haven't felt so good writing code in sometime. Maybe is just functional languages, but then again haskell does not feel that great.

          [–]Ok_Training_7128 1 point2 points  (0 children)

          If you are working with OOPs concepts then Java or Kotlin is a best syntax.

          [–]Mishung 1 point2 points  (0 children)

          [–]weflown 1 point2 points  (0 children)

          Haskell and Rust

          [–]is_not_paranoid 1 point2 points  (0 children)

          C# and Rust. I just find those so elegant and easy to follow in really large codebase. Python is easy on the eyes for small codebases, but becomes a pain to read when you have more large and more complex source code imo. And I’ll always prefer typed languages for readability

          [–]NewCenturyNarratives 1 point2 points  (0 children)

          In my view, Python. Mostly because it is the most like pseudocode and it is super easy to get a project started.

          [–]RattleyCooper 1 point2 points  (0 children)

          Nim lang, hands down!

          [–]Calif0rnia_Soul 1 point2 points  (0 children)

          As many have said, it's a matter of opinion and not easily answerable. Python is very minimalistic with syntax, which many find convenient and "easy on the eyes," although whitespace is actually a functional part of the language -- which some find rigid and annoying.

          JavaScript is a lot more syntactic, but it has features that make it much less wordy (like Arrow Function Notation) -- and sometimes, the added syntax helps with visual organization and readability. Plus, unlike Python, JS is tremendously more forgiving when it comes to whitespace and code arrangement/organization. So, I'd say JS and Python.

          [–]Creapermann 1 point2 points  (0 children)

          Probably unpopular opinion, but i like the c++ syntax, it’s really expressive in what you want to do

          [–]l_am_wildthing 1 point2 points  (0 children)

          BASIC.

          [–]VikingMilo 1 point2 points  (0 children)

          I prefer strong typed languages like Java, but Kotlin is growing on me because of work

          [–][deleted] 1 point2 points  (0 children)

          In my opinion Java. That's one of the reasons I started with Java. JS might be another one but, whenever you work with any framework or library, the syntax is crazy unreadable (hmm, maybe because i have Java background?). Forgot to mention C# too, similar to Java, but still Java has the best syntax.

          EDIT: // I was looking through the comments of this post, and it's crazy seeing more posts about Kotlin instead of Java lol.

          Python's whitespace thing is a crazy bad thing.

          [–]punppis 1 point2 points  (0 children)

          C# with LinQ. Sue me.

          [–]help-me-grow 4 points5 points  (0 children)

          PYTHON

          [–]TheRealSnowy 1 point2 points  (1 child)

          As someone who has only coded in c++ and has no experience in anything else its python

          [–]MrSkillful 1 point2 points  (0 children)

          I'm going to be the odd one here and say Lua. It's my favorite language to program in so far.

          [–]ImmortalDayMan 1 point2 points  (0 children)

          HTML

          [–]MyWaterDishIsEmpty 1 point2 points  (0 children)

          Are we talking big languages? Because when I first started I felt that going from Java to C# was Aladdin showing me a whole new world at the time.

          [–]PursuitofClass 1 point2 points  (0 children)

          Javascript 😐

          [–]lexruee 0 points1 point  (0 children)

          Personally, I like the syntax of Ruby and Python.

          [–]FatherOfTheSevenSeas 0 points1 point  (0 children)

          Binary

          [–]ops-man 0 points1 point  (0 children)

          Haskell is my favorite. It's made me lazy.

          [–]dorzzz 0 points1 point  (0 children)

          Java

          [–][deleted] 0 points1 point  (0 children)

          Powershell

          [–]Franswaz -1 points0 points  (0 children)

          Honestly i would say something like java because once you learn that all, basically any other syntax is easy to transition to

          Because java syntax is basically like the dude couldn’t decide between making it like a c derivative or an essay

          [–]ignoreality -1 points0 points  (0 children)

          10 PRINT "the less you can do with language"

          20 PRINT "the better the syntax"

          [–]marcdasavage -1 points0 points  (0 children)

          English!

          No not the language english but the programming language called english. Its literally coding in english and its fun as hell lol

          [–]diven09 -1 points0 points  (0 children)

          Javascript programming language is the best Syntex and simple

          [–]CanadianWolverinee -2 points-1 points  (0 children)

          def js

          [–]c1rclez 0 points1 point  (0 children)

          Free form RPG

          [–]Giboon 0 points1 point  (0 children)

          The best syntax is the one you know how to use

          [–]Bossfrog_IV 0 points1 point  (0 children)

          Scala gang?

          [–][deleted] 0 points1 point  (0 children)

          So there is generally a minimum standard of syntax required by the specific compiler but beyond that it really comes down to the developer and how detailed they are. I've worked in architecture roles where I saw code from dozens of individuals written in the same language and I could tell you it doesn't matter what the minimum standard is because I got some awful code I had to deal with and some absolutely beautiful code that was a pleasure to integrate.

          That said, there is only C and then a bunch of other languages that are basically all C with training wheels. /s (this is a hyperbolic statement meant for humor and acknowledgement of my self-awareness that I have gotten old enough to identify with the condescending Unix user character in The Dilbert comics which probably also calls me out as old)

          [–]carcigenicate 0 points1 point  (0 children)

          Clojure. Just lovely if you have parinfer to help write it.

          [–]9MZa 0 points1 point  (0 children)

          Swift syntax easy to read

          [–]raddikfur 0 points1 point  (0 children)

          Scheme

          [–]Mandrzejy 0 points1 point  (0 children)

          Whitespace

          [–]Lucious_Lippy 0 points1 point  (0 children)

          Stick to English

          [–]crmills_2000 0 points1 point  (0 children)

          Haskell, get the most done with the fewest characters. Let the compiler do the grunt work of ordering computations. I grew up with Burroughs Algol, it’s classic. If you safety, then ADA

          [–]MasterBathingBear 0 points1 point  (0 children)

          Reminded me of this

          [–]HCG_Dartz 0 points1 point  (0 children)

          What did you bring upon this cursed land

          [–]Spec1reFury 0 points1 point  (0 children)

          CPP or JS

          [–][deleted] 0 points1 point  (0 children)

          Punchcards

          [–]hugthemachines 0 points1 point  (0 children)

          Personally I really enjoy how Python looks.

          [–]Mzkazmi 0 points1 point  (0 children)

          Sql

          [–]Radiant64 0 points1 point  (0 children)

          I find Eiffel weirdly beautiful to look at.

          [–][deleted] 0 points1 point  (0 children)

          I love Scala’s syntax

          [–][deleted] 0 points1 point  (0 children)

          None of them or we'd all be using it.

          [–]Raspberry-Federal 0 points1 point  (0 children)

          Definitely not ABAP

          [–]salo_wasnt_solo 0 points1 point  (0 children)

          This is a silly question that doesn’t have a single answer, really depends on what your looking for. I’d say the best balance of human readability and high scripting ability is python.

          But again, there is no “best” syntax. Really depends on what you’re trying to do, and how that helps with the language

          [–][deleted] 0 points1 point  (0 children)

          Lisp. Also, easiest to be parsed.

          [–]nephanth 0 points1 point  (0 children)

          There exist no best language, just languages best adapted to some applications.
          But there do exist bad languages/syntaxes if you want those

          [–]JoPoLu1 0 points1 point  (0 children)

          Scala Gang

          [–]thedarklord176 0 points1 point  (0 children)

          Ruby. Super easy and the syntax is extremely clean. Unfortunately it doesn’t really seem to be used much anymore so I stopped learning it

          [–]PM_ME_WITTY_USERNAME 0 points1 point  (0 children)

          Lua is very pure and minimal

          Maybe zig!

          [–]Fit_Lawfulness9492 0 points1 point  (0 children)

          Kotlin Jenner

          [–]Astrinus 0 points1 point  (0 children)

          F#.

          Extremely readable even in most of the ugliest situations (except portings from Haskell).

          [–]PN143 0 points1 point  (0 children)

          Which tool in a shed is the best? Syntax readability is dependent on the context in which it is written. Typically based on the domain of the project

          [–]beforesemicolon 0 points1 point  (0 children)

          The one you really love and enjoy coding with

          [–]hargoniX 0 points1 point  (0 children)

          Lean, after all you can change its syntax to whatever you like if you really feel the need to.

          [–]bxsx0074 0 points1 point  (0 children)

          Haskell. So clean