
Computer History Museum 2018 Fellow: Guido van Rossum - rbanffy
http://www.computerhistory.org/fellowawards/hall/guido-van-rossum/
======
HenryBemis
Congrats for Guido and Python.. the point I wanted to make is: Oh how much I
miss this place!!It's a techie's-over-40-dream-place. So many memories when
you walk around there, all the hardward and floppy disks.. such a beauty!!

~~~
AndrewOMartin
If you miss it because you're now in the UK, there's a museum with an
impressive collection (especially of the very first machines; EDSAC, WITCH,
and Colossus) just outside of London.

[http://www.tnmoc.org/](http://www.tnmoc.org/)

~~~
jaymzcampbell
I highly recommend a visit! I went a few years ago and had a great time. It's
right at the top of Bletchley Park and only costs a few pounds. It's a bit of
a shame that it feels neglected by the main museum (it's a separate
area/exhibit/entrance to the main Bletchley Park museum). Easy to get to from
London, regular trains run from Euston all day.

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.

[1]
[https://photos.app.goo.gl/uhYyF3qgRnXtLy183](https://photos.app.goo.gl/uhYyF3qgRnXtLy183)

~~~
shervinafshar
Also, a while back CHM did a live event talking to the author of _The
Preservation Game: Saving Bletchley Park_:
[http://www.computerhistory.org/atchm/the-preservation-
game-h...](http://www.computerhistory.org/atchm/the-preservation-game-how-
social-media-saved-bletchley-park/)

------
santiagobasulto
Guido is a great example of the right leader for a software project. Always
kind, knowing how to delegate, knowing which are his limitations and
encouraging other people to step up.

~~~
vanderZwan
Somewhat related: the origins of the title _Benevolent Dictator-For-Life_

[https://www.artima.com/weblogs/viewpost.jsp?thread=235725](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.

~~~
nerdwaller
The last few years we’ve seen a few others help carry the torch (from active
discussion on the python-ideas mailing list, core contributions, and major
library compliments driving the ecosystem forward):

* David Beasley * Raymond Hettinger * Yuri Selivanov

I’m sure there are more but those are the first few that come to mind.

~~~
leoc
Tim Peters definitely had a high profile back in the day.

------
caio1982
It will be nearly impossible to find someone who disagree with him getting
this award IMHO. That's so well deserved. Slow clapping time here.

~~~
jokoon
Mmmmh I don't disagree, but python is a little slow.

Python is my favorite language, but I wish it was faster.

~~~
simonh
Simplicity, speed, abstraction: Choose two

[https://cs.stackexchange.com/questions/57904/why-do-we-
have-...](https://cs.stackexchange.com/questions/57904/why-do-we-have-to-
trade-abstraction-for-speed)

~~~
fhood
Correct me if I am wrong, but I believe that interpreted vs compiled has far
more to do with python's speed then abstraction in this case. Also the post
you linked literally states that abstraction doesn't necessarily mean slow.

~~~
mirashii
If making a language compiled is a magic bullet for speed, why isn't every
language compiled? Because they have different levels of abstraction that lend
their implementation to compilation or interpretation. You're just citing a
specific example of one of the tradeoffs made in the language design that
falls along those three axes.

------
DC-3
Well deserved. Few other language even come close to Python in filling the gap
between scripts and larger projects.

------
friendlydude12
Very well deserved, many congratulations to Mr. van Rossum

------
closed
Glad to hear! As I was typing away at python the other day, the thought
occurred to me that Guido (and every python contributor) have had an eerily
strong impact on my day-to-day life.

------
jrwiegand
I remember 'discovering' Python in my old Programming Languages class and it
is still as fascinating now as it was then. Congrats to Guido.

------
peter_retief
Interesting, I didn't know there was such a thing, well done Guido

------
varenc
Congrats Guido! :-)

------
raymondh
Congratulations.

------
zsgoldberg
That grey on grey text is awful

~~~
erokar
Look who's talking.

------
jacquesm
While I'm very much in support of Guido winning this award the 'Its code
should be understandable as plain English.' goal was clearly not met.

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?

~~~
shakna
> Is Python the language that comes closest to this goal? And if not, which
> is?

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),
    

Ada (A safety-oriented language)

    
    
        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;
    

AppleScript (Seeing less support from Apple these days, but part of macOS)

    
    
        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
    

BASIC (Easy to read, easy to use, easy to get lost.)

    
    
        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
    

Clojure (A modern Lisp, bits of Scheme, Common Lisp and Java)

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

COBOL, it's so ridiculously verbose, I'm not adding it here. See
[https://www.rosettacode.org/wiki/Fibonacci_sequence#COBOL](https://www.rosettacode.org/wiki/Fibonacci_sequence#COBOL)

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)
    

Delphi (One of my first programming languages. Probably the least verbose
staticly typed language without inference I've seen.)

    
    
        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;
     

Elixir (Kinda like Ruby, but running atop Erlang's massively-concurrent VM.)

    
    
        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)
    

Elm (A new language for the web. More a framework that replaces HTML, CSS and
JS than just JS.)

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

FORTRAN (I've done too much professional work with FORTRAN to like it. It
looks straight-forward, but you can do pretty much whatever you feel like with
memory, and it'll let you.)

    
    
          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
    

Go (Google's somewhat naive language, can be odd to set up, but is fast,
static and fairly readable. Lots of people switch from Python to Go.)

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

Julia (It's a language aimed at scientific application. That means a great
number system, a really good compiler, and access to things you usually need
FORTRAN for.)

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

Lua (Fast but small. Standard library isn't much bigger than C, but has
LuaRocks, a decent package manager, with an active community. Some think of it
as a better JavaScript, though it was designed for embedding and has a
fantastic C-interop story.)

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

Nim (Think Python, but staticly typed, and much faster.)

    
    
        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))

~~~
analog31
To be fair, here's plain English (from Wikipedia, re-entered by me):

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])

~~~
joshuamorton
heck, if you really want that:

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

Technically you could also write it as

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

which is a bit trickier, but arguably better matches the way the seed values
are described in english.

------
TheLostOne
More than deserved.

