Stories
Slash Boxes
Comments

SoylentNews is people

SoylentNews is powered by your submissions, so send in your scoop. Only 17 submissions in the queue.
posted by martyb on Friday July 13 2018, @12:58PM   Printer-friendly
from the pass-it-on dept.

On a python developers' mailing list for the core developers, Python Committers, Benevolent Dictator for Life Guido van Rossum has announced that he is stepping down effective immediately and with out appointing a successor.

Now that PEP 572 is done, I don't ever want to have to fight so hard for a
PEP and find that so many people despise my decisions.

I would like to remove myself entirely from the decision process. I'll
still be there for a while as an ordinary core dev, and I'll still be
available to mentor people -- possibly more available. But I'm basically
giving myself a permanent vacation from being BDFL, and you all will be on
your own.

After all that's eventually going to happen regardless -- there's still
that bus lurking around the corner, and I'm not getting younger... (I'll
spare you the list of medical issues.)

I am not going to appoint a successor.

[...] I'll still be here, but I'm trying to let you all figure something out for
yourselves. I'm tired, and need a very long break.


Original Submission

 
This discussion has been archived. No new comments can be posted.
Display Options Threshold/Breakthrough Mark All as Read Mark All as Unread
The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
  • (Score: 2) by DannyB on Monday July 16 2018, @02:30PM

    by DannyB (5839) on Monday July 16 2018, @02:30PM (#707892) Journal

    I just want to point out that I was a HUGE BASIC fanboy back in the day. While I was in college I had started a 3 ring binder, sort of a BASIC reference manual, as it were, for my ideal dream BASIC language. Since in my inexperience I thought BASIC was the cat's meow compared to other minicomputer languages.

    I also gave significant thought on how to build an interactive BASIC compiler. That is, it would act like a BASIC interactive interpreter. You type in program lines. Type RUN, etc. My first thought was about how to build a much faster BASIC interpreter. My idea was that the interpreter stores the program text in an internal tokenized form, which was common. But this tokenized form should allow for a two-byte (woo a whole 64K) pointer into another part of the program text, whenever there was any kind of line number, or other reference.

    For example, if line 180 said:

    180 IF A = B THEN 430 ELSE GOTO 670

    then the internal tokenized representation would represent it like:

    180 IF A = B THEN IGOTO 430 ELSE GOTO 670

    The IGOTO is an "invisible" GOTO. When LISTing the program text, you never see the text IGOTO, it would LIST like the original line 180. Now both the GOTO and IGOTO internal representation is the token of course, plus a two byte slot which is the pointer to the respective lines.

    Similarly, when you execute a FOR loop, the stack records a pointer to the FOR token back in the tokenized program text. That way when you hit a NEXT, the top stack entry can directly and immediately proceed back to the FOR statement. No searching the text. No table lookup.

    When any kind of line number reference occurs, even say, PRINT USING, there is a two byte pointer in the stored program text.

    When you type RUN, the interpreter makes a single pass over the tokenized text and fills in all the line number pointers. The program execution could be significantly faster. This would also give you an immediate fatal error if your program had a line number reference to a non-existant line. Most BASIC interpreters would happily begin execution and you wouldn't get invalid line number reference until much later.

    Next, I turned my thoughts to an interactive compiler. If memory were less of a problem, as I knew it would soon the case due to Moore's Law, I mean geez, there were now 64 K boards on a single board!; I thought the "interpreter" could also store a compiled representation. Each BASIC program line would be a single heap object. (Yes, even then I was thinking about heaps, allocators, etc.) There would be a table of line numbers, with pointers to the heap object representing that compiled line. The compiled code might consist of many JSR (jump to subroutine) instructions back into the runtime library for PRINT, INPUT, etc. But it's still a lot faster than an interpreter.

    Next a batch compiler could do basically the same compilation, but in batch mode. Now you have both a fast interactive compiler along with a batch compiler for the SAME dialect of BASIC. And I wanted a rather expansive dialect. More advanced string and array capabilities. Date / Time values. BCD as well as floating point. (The idea of using a large integer for business currency values hadn't occurred to me yet.)

    But as I become more advanced, I soon met Pascal. Fell in love. Never looked back at BASIC, except with fond memories -- even to this day fond memories of BASIC.

    --
    Reminder: March is National Procrastination Week.
    Starting Score:    1  point
    Karma-Bonus Modifier   +1  

    Total Score:   2