if the text returned of (display dialog "Username" default answer "") is userAns

    expect(true).to eq true

    ask "Username"
    if it is "Harry" then put "Hi there, Harry!" into field Greeting
    else put "Hey, you're not Harry, you're" && it into field Greeting

I'm an amateur programmer (Python, JS) and I have been wondering for a long time if there is a language more readable than python.

  collection.map do |i|
    blah = something(i.something)
    blah.something_else
  end

  a.length
  collection.map { |x| x^2 }

  len(a)
  map(lambda x: x^2, collection)

When you're working in a large project with +10K LOC, the project structure and the quality of the code you write is much more important than the language itself.

    10.times do
       something
    end

    (1..10).each do |i|
      something_with i
    end

    for _ in range(10):
        something

    for i in range(10):
        something_with(i)

The major differences, as I see them are that ruby requires end blocks, and uses methods instead of global functions for things.

In my opinion, python takes great pains to make things consistent, which is valuable. There's one function, range, instead of two methods, times and each. The syntax is unified: `for N in range`, which `_` being a convention if `N` is unused, as opposed to Ruby where you can define the looping variable, or not, depending on the method that was called (I guess?).

Ruby does appear to read more like something you might say, although still with weirdish grammar, but on the other hand, replace ":" with "repeat" and be explicit about the elided 0 in range, and you get "for i in the range 0 to 10, repeat something with i" which is english, as opposed to Ruby which is "take the range 1-10 and for each do unto i something with i", which imo appears significantly less natural.

This actually extend's to the stuff about "len" vs ".length", where you're asking which is more natural, to "do something to the length of X" or "do something to X's length". And that's very much a subjective question, but Python's answer establishes stronger consistency.

However:

1) if one comes from Ruby, then Python is a Ruby designed by someone with a weird mind

2) if one comes from Python, then Ruby is a Python designed by someone with a weird mind

I'm coming from Ruby, a historical accident I can't change. No hard feelings.

-> sey

Quite readable and fun. I've never loved a language like I do Ruby. Everytime I am stuck, and find a simple, fun and elegant solution I like it even more.

On the other hand, maybe there is some upper limit as to how well can humans internalize programming concepts.

In the end, it's subjective. And "understandable" and "plain English" may not sit together well, as it can lead to overly verbose code.

But, here's a few examples for you to judge between. (Examples lifted from RosettaCode, which is well worth the look.)

All these languages have claimed, at some time or another, to be easy to read, and close to "plain English". Obviously, this is just a taste.

Python

    def fib(n,x=[0,1]):
       for i in range(abs(n)-1): x=[x[1],sum(x)]
       return x[1]*pow(-1,abs(n)-1) if n<0 else x[1] if n else 0

    for i in range(-30,31): print fib(i),

    with Ada.Text_IO, Ada.Command_Line;
    procedure Fib is
        X: Positive := Positive'Value(Ada.Command_Line.Argument(1));

       function Fib(P: Positive) return Positive is
       begin
          if P <= 2 then
             return 1;
          else
             return Fib(P-1) + Fib(P-2);
          end if;
       end Fib;
 
    begin
       Ada.Text_IO.Put("Fibonacci(" & Integer'Image(X) & " ) = ");
       Ada.Text_IO.Put_Line(Integer'Image(Fib(X)));
    end Fib;

    on fib(n)
        if n < 1 then
            0
        else if n < 3 then
            1
        else
            fib(n - 2) + fib(n - 1)
        end if
    end fib

    FUNCTION itFib (n)
        n1 = 0
        n2 = 1
        FOR k = 1 TO ABS(n)
            sum = n1 + n2
            n1 = n2
            n2 = sum
        NEXT k
        IF n < 0 THEN
            itFib = n1 * ((-1) ^ ((-n) + 1))
        ELSE
            itFib = n1
        END IF
    END FUNCTION

    (defn fibs []
      (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1])))

CoffeeScript (Billed as a better JavaScript, it was popular until ES2016)

    fib_rec = (n) ->
      if n < 2 then n else fib_rec(n-1) + fib_rec(n-2)

    function FibonacciI(N: Word): UInt64;
    var
      Last, New: UInt64;
      I: Word;
    begin
      if N < 2 then
        Result := N
      else begin
        Last := 0;
        Result := 1;
        for I := 2 to N do
        begin
          New := Last + Result;
          Last := Result;
          Result := New;
        end;
      end;
    end;
 

    defmodule Fibonacci do
        def fib(0), do: 0
        def fib(1), do: 1
        def fib(n), do: fib(0, 1, n-2)
 
        def fib(_, prv, -1), do: prv
        def fib(prvprv, prv, n) do
            next = prv + prvprv
            fib(prv, next, n-1)
        end
    end
 
    IO.inspect Enum.map(0..10, fn i-> Fibonacci.fib(i) end)

    fibonacci : Int -> Int
    fibonacci n = if n < 2 then
            n
        else
            fibonacci(n - 2) + fibonacci(n - 1)

      FUNCTION IFIB(N)
      IF (N.EQ.0) THEN
        ITEMP0=0
      ELSE IF (N.EQ.1) THEN
        ITEMP0=1
      ELSE IF (N.GT.1) THEN
        ITEMP1=0
        ITEMP0=1
        DO 1 I=2,N
          ITEMP2=ITEMP1
          ITEMP1=ITEMP0
          ITEMP0=ITEMP1+ITEMP2
    1   CONTINUE
      ELSE
        ITEMP1=1
        ITEMP0=0
        DO 2 I=-1,N,-1
          ITEMP2=ITEMP1
          ITEMP1=ITEMP0
          ITEMP0=ITEMP2-ITEMP1
    2   CONTINUE
      END IF
      IFIB=ITEMP0
      END

    func fib(a int) int {
      if a < 2 {
        return a
      }
      return fib(a - 1) + fib(a - 2)
    }

    fib(n) = n < 2 ? n : fib(n-1) + fib(n-2)

    function fibs(n) 
      return n < 2 and n or fibs(n - 1) + fibs(n - 2) 
    end

    proc Fibonacci(n: int): auto =
      var fn = float64(n)
      var p: float64 = (1.0 + sqrt(5.0)) / 2.0
      var q: float64 = 1.0 / p
          return int64((pow(p, fn) + pow(q, fn)) / sqrt(5.0))

The sequence f(n) of Fibonacci numbers is defined by the recurrence relation:

f(n) = f(n-1) + f(n-2),

with seed values

f(0) = 0 and f(1) = 1

And a possible variant in Python:

    f = [0, 1]
    for i in range(100):
        f.append(f[-1] + f[-2])

    @functools.lru_cache
    def fibs(n):
        if n == 0:
            return 0
        elif n == 1:
            return 1
        else:
            return fibs(n-1) + fibs(n-2)

    def f(n):
        if n in {0, 1}:
            return n
        return f(n-1) + f(n-2)

> E.g. the Python variant is for some reason not recursive

Because of the recursion limit in Python, really, as Python doesn't do tail-call elimination. That limit can make recursive code a real pain point, so iterative styles tend to work better.

Anyway, I translated the Go example to Nim for a better comparison:

    proc fib(a: int): int =
      if a < 2:
        return a
      return fib(a - 1) + fib(a - 2)