Computer History Museum 2018 Fellow: Guido van Rossum
computerhistory.org
computerhistory.org
I took a bunch of photos when I visited [1], I could've easily spent days there. It's unlike any museum I've been to before, towards the "end" there are lots of rooms with just piles of books and computers you can sit down with for however long you wanted - lots of tactile interaction! It was also wonderful to see machines like Colossus running as well as all manner of oddities like early UNIX systems, air traffic computers and calculators.
I frequently go to London, and it's definitely worth popping to MK for a day just for this!!
https://www.artima.com/weblogs/viewpost.jsp?thread=235725
I have to say though, and this probably is me because I'm not that deeply invested into the Python community, but I don't really know anyone else in the Python community who represents the core language. In most other programming language projects of this size there are a multiple people who are public faces of the language itself, beyond the first people who designed it.
Alex Miller and Stuart Halloway immediately jump to mind as lieutenants that could jump in and take over without too much disruption.
> Erlang
Well, there's also Roberts and Mike (reference, for those not familiar: https://youtu.be/xrIjfIjssLE?t=213).
* David Beasley * Raymond Hettinger * Yuri Selivanov
I’m sure there are more but those are the first few that come to mind.
Just wait a few minutes. I can already see one.
Python is my favorite language, but I wish it was faster.
https://cs.stackexchange.com/questions/57904/why-do-we-have-...
> Simplicity, speed, abstraction: Choose two
https://cs.stackexchange.com/questions/57904/why-do-we-have-...
It is interesting to me because many high level languages have had this exact same goal (COBOL for instance!) and none have ever delivered.
Is Python the language that comes closest to this goal? And if not, which is?
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.
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.
-> 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.
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)
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.
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))> 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)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)
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 GreetingOn the other hand, maybe there is some upper limit as to how well can humans internalize programming concepts.