The Artima Developer Community
Sponsored Link

Weblogs Forum
Looking for Memories of Python Old-Timers

54 replies on 4 pages. Most recent reply: Jan 4, 2008 12:50 AM by Sharmila Gopirajan Sivakumar

Welcome Guest
  Sign In

Go back to the topic listing  Back to Topic List Click to reply to this topic  Reply to this Topic Click to search messages in this forum  Search Forum Click for a threaded view of the topic  Threaded View   
Previous Topic   Next Topic
Flat View: This topic has 54 replies on 4 pages [ « | 1 2 3 4 | » ]
Stewart Midwinter

Posts: 3
Nickname: midtoad
Registered: Apr, 2005

Re: Looking for Memories of Python Old-Timers Posted: May 24, 2006 7:49 PM
Reply to this message Reply
Advertisement
I was playing around with a language called ABC and having some fun with it. Then I heard that its author was working on a newer language called Python. I tried to get my mind around it, but it seemed too weird! That must have been version 0.x. But that was then, this is now. I've been using Python the past 4 years and it's my far-away favourite, after dabbling in Icon, Ruby and others. Thanks to Guido and the whole Python community for this wonderful language!

Jeremy Hylton

Posts: 193
Nickname: jhylton
Registered: Jun, 2003

Re: Looking for Memories of Python Old-Timers Posted: May 24, 2006 7:56 PM
Reply to this message Reply
I started working with Python ten years ago this spring. I've been using it for nearly my entire professional career. I posted a couple of entries about my early experiences with Python on my blog:

http://jeremyhylton.blogspot.com/2006/05/my-first-python-projects.html
http://jeremyhylton.blogspot.com/2006/05/how-i-learned-python.html

Ka-Ping Yee

Posts: 24
Nickname: ping
Registered: Dec, 2004

Re: Looking for Memories of Python Old-Timers Posted: May 24, 2006 10:17 PM
Reply to this message Reply
I encountered Python in 1995, when my friend Chris Hendrie started telling me about it. I was an engineering student at the University of Waterloo then, and Chris was my roommate. One of the first things Chris did was to explain the lambda calculus and show me how to calculate with Church numerals in Python. It blew my mind.

I had just started using Perl as a high-level language for quick hacks, but Python grew on me quickly and i began using it for just about everything. I used Python as the basis for MINSE, a project i was working on then to develop an extensible and easy way to write mathematical expressions in webpages. In 1996, i joined the comp.lang.python newsgroup and began ranting forth about my personal pet features and changes i wanted in Python.

I missed the regular expressions from Perl, so that was one of the first places i started playing with the internals of Python. I tried adding features to the built-in regular expression module and wrote a Python module called rxb that experimented with a friendlier, algebra-like syntax for regular expressions. I messed around with interpolating strings and even wrote a couple of patches to allow inline assignment to variables within expressions, again trying to make Python more like Perl. After a while, this phase passed. :)

I made my first actual contribution to Python in 1997, with some improvements to the tokenize module to make it more faithful to the actual Python tokenizer. I had a summer job at Xerox PARC that year, where we used Python heavily for developing ILU (their "Inter-Language Unification" project) and a web-based document processing service. After tokenize came inspect, another Python-related Python module. Debugging web applications was painful because it was tedious to get detailed information about errors, and so that summer cgitb was born, and both modules eventually made it into Python's standard library.

When Guido invited me to join python-dev, i was really excited. I started getting to know Guido, Tim, Barry, Martin, Andrew, and other regulars on the list. Participating in discussions there taught me about working with a group on a open-source development project -- it made me realize that there were a lot more concerns to be balanced in language design than my own. Finally getting to meet everyone at PyCon was a blast.

In 1998 i graduated and joined ILM, where i got to work with Tommy Burnette, who was busy trying to get Python into just about everything there. While i was there, we managed to replace most of the old pipeline — the stuff for managing and schlepping gazillions of files around to the people and programs that had to work on them — with Python scripts. And more excitingly, we established Python as the main embedded extension language for ILM's in-house graphics applications, so that power users could program their own tools and effects.

I took one of Tommy Burnette's scripts, manpy, which was like man for Python modules instead of Unix commands, and eventually turned it into pydoc. pydoc grew to generate documentation in both text and HTML, and is now part of the Python standard library. I also hacked up something to generate a dependency tree of Python modules using crazy HTML table-fu so you could browse the relationships among them while linking to their pydoc pages, but that never made it out into the wild. The software group at ILM was growing and i felt that we needed a bug-tracking system, so i wrote the first version of Roundup, which continued to be used there for quite a while after i left the company. Roundup lives on today in spirit, now completely rewritten to be much better by Richard Jones and his team, at http://roundup.sf.net/.

In 2000, i left ILM and started graduate school at UC Berkeley. I kept telling everyone i knew about Python. I thought it was too bad that none of the CS classes here taught Python, and in 2003 i got to do something about it by teaching my own Python class. The website for it is still up at http://zesty.ca/bc/. It was a lot of work and a lot of fun and i was very happy that it resulted in some very enthusiastic and capable Python programmers. But i didn't have time to keep teaching the class every semester, so it was only taught once. In 2005, i tutored with the self-paced program and helped to develop a Python course that will live on in the CS self-paced center, so that students who are interested and motivated enough can learn Python without someone like me around to give lectures about it.

Guido van van Rossum

Posts: 359
Nickname: guido
Registered: Apr, 2003

I didn't write ABC Posted: May 24, 2006 10:19 PM
Reply to this message Reply
> I was playing around with a language called ABC and having
> some fun with it. Then I heard that its author was working
> on a newer language called Python.

Um, I wasn't ABC's author. I just helped implement it (the second time around). Credit for ABC's design goes to Lambert Meertens and Leo Geurts. You might want to update your Artima bio.

(More about ABC: http://homepages.cwi.nl/~steven/abc/. The ABC manual, long out of print, is also available again: http://www.idhub.com/abc/ -- and available from Amazon.com too.)

Jurjen Bos

Posts: 2
Nickname: jneb
Registered: May, 2006

Re: Looking for Memories of Python Old-Timers Posted: May 29, 2006 2:35 AM
Reply to this message Reply
Yes, Sjoerd, you beat me by a few days, but you didn't have to walk 25 meters :-)

Mark Hammond

Posts: 1
Nickname: mhammond
Registered: May, 2006

Re: Looking for Memories of Python Old-Timers Posted: May 29, 2006 10:12 PM
Reply to this message Reply
In 1993, Sam Rushing and I were looking for a 'scripting language' to complement C++ for an application we were writing. Sam suggested this new Python language, and after a very short time, we were hooked!

At the time, Windows NT had just been released and although there was a (stale) build process for MS-DOS, Windows hadn't been touched by the Python community. Step 1 was to contribute patches for Python to build as a native 32bit application (state-of-the-art in Windows land at the time).

Sam and I intended writing our application using MFC (an MS C++ GUI framework), so one of the first tasks was to write a Python extension module for MFC - and hence Pythonwin was born! Additional Windows specific modules soon followed, and pywin32 (previously win32all) started filling out. Over the years, people such as Greg Stein (then an employee of MS) jumped onto the bandwagon and pywin32 grew to cover vast tracts of the Win32 API, including COM.

Python and pywin32 have both come along way since then, and looking back I find my professional career has almost exclusively revolved around them - so I have much to thank Python and Guido for!

Jim Roskind

Posts: 1
Nickname: jimroskind
Registered: Jun, 2006

Re: Looking for Memories of Python Old-Timers Posted: Jun 4, 2006 1:56 AM
Reply to this message Reply
Guido asked that I try to contribute something from my memories… so here are some things that come to mind….

It was in early to mid 1994 that Steve Kirsch suggested (he often suggests things in an aggressive manner) that we try using Python at InfoSeek to create a full-text searching system with a pay-by-the-drink model. We had already implemented a version in Perl, and I had spent too many hours debugging the Perl interpreter (and sadly seeing numerous cut/paste copies of the same interpreter bugs).

I was initially a bit put off by the Python indentation approach (I was a grammar guy… and got used to parsing braces and parens, and didn’t like the idea of white space having so much meaning), but I soon came to love it. Eventually I came to apply one of my favorite computer science sayings to Python as an endorsement to their indentation blocking approach: “The fundamental evil in computer science is the replication of code or data.” In almost all languages I had previously worked, the indentation of code had always been a critical PART of program nesting structure (at least for the reader). As I read and wrote more Python, its use of indentation as the ONLY way to specify blocks began to look better and better. All the silly bugs related to indentation errors (misleading the human reader) were gone in Python. The redundant use in other languages of braces AS WELL AS indentation (the former to help the parser, and the latter to help the human reader) was an effective duplication of the author’s intent. That duplication in other languages, a fundamental original sin, was missing in Python. It was cool! ;-)

I recall being blown away by the cleanliness of the Python interpreter source, and the fact that there was (from what I could see) never cut/paste code. It was nice. It was clean. And it worked very well. I certainly didn’t feel like an old timer then. I felt like I had just walked into a highly evolved kingdom. Lurking in the related forums it became clear that this “guy named Guido” was riding a tight shotgun over language evolution, and it was his will that was preventing the language from acquiring warts. I still smile today as I see his vision directing the language, and I know Python would never have gotten anywhere if not for his vision and strength of will.

One giant gain we saw in moving to Python was that it was very easy to rapidly prototype, and it was almost believable that we could write production code in Python. As a small startup, we were constantly redirecting ourselves and modifying specifications for our product. This rapid prototyping nature meant that the programmers could keep pace with the marketing changes and not work to shut down creative suggestions. We were also worried about the cost of computation to provide the services we were planning, and the vague hope that we could use our prototype to make money was always in our minds. I spent time trying to speed up some of our prototype code segments (aiming for production code), and found that the existing profiler was not giving me results which matched my tiny experiments (my tiny experiments were giving me great insight into how to speed up our code). I stepped back, read the old profiler source, and realized it was not deducting the time spent in the profiler from the code being measured. Worse yet, it was writing to disk intermittently during profiling, and even that time was being charged to the profiled code (oops). Realizing the weakness of the old profiler, it was then no surprise that our code seemed (according to the profiler) to be devoid of hot spots. The profiler was adding disk-write delays uniformly across the code, and dominating all actual measurements. This was perchance the first bit of a hint that the language was newer than I would have suspected, but the profiler was not seemingly central to the language, and I assumed it was a tangential contribution. I set off to write a more careful profiler, and that is the one that has survived till today. It is interesting (if the documentation I wrote is to be trusted) that the profiler was written after I had been using Python for only about a month, which shows what the learning curve for Python was like, even in “those days.” It was fun writing the Python profiler because this was the first profiler that I wrote that properly handled recursions vs iteration comparisons. The key to this feature was that the profiler was written in Python. In Python it was a snap to have a dynamic dictionary on hand to list all the function blocks residing on the current call stack. Usually, when I had written a profiler in the past, I didn’t have a lot of tools to work with. With Python, most support is written in Python (debugger, profiler, etc.), and powerful tools abound. It was and is a nice virtuous cycle.

I remember one early result from my profiling experiments. In retrospect, this story also hinted at how new the language was, but at the time I just saw it as something that was too hard to see with the previous profiler. One area of our code was running surprisingly slowly and almost dominating our performance. The hot area was a comparison function which was called by a sort routine. (Recall that with the old profiler, nothing ever stood out as a hot spot). At first I was surprised that there was no way I could speed up this “hot spot,” as it was already a very simple compare. Then I looked at call counts for this routine. We were typically sorting an array of length 1000. If I remember the numbers correctly, the profiler revealed that the hot comparison function was being called over 400,000 times per sort. This was a whole lot closer to what I’d expect from an n-squared sort algorithm than from an n * log(n) quick sort. Remembering that algorithms 101 taught that quick sort *can* be an n-squared sort if the pivots are “chosen poorly,” and this could commonly happen (with a simple quick sort implementation) when the list was already mostly sorted… I took a wild guess that this was the problem. To take a shot at working around this quick sort implementation, I needed to randomize the list prior to the sort. With Python, this was a snap (to try). I just put the list into a hash table, and then pulled it out (in its pseudo random order) before doing the sort. Sure enough, a factor of 20 performance improvement resulted (for our application), and a simple bug report went off to Guido. I always liked this story because it was a case where adding wasteful code was VERY helpful.

I also remember one difficult aspect of our Python development. We needed to perform bookkeeping (remember, we were making a pay-by-the-drink model search system), and we ended up writing a persistent object store to record these events and charges. All the features of Python involving introspection were beyond a pleasure to use to build this system. It was “a little challenging” to handle the automatic storage and resurrection of randomly inter-related objects. The hard part was making sure that a single saved object was resurrected as a single object, no matter how many other objects pointed to it in arbitrary circuitous ways. Here the exception system provided a simple way to effectively backtrack as needed during the saving of objects in unpredictable graphs. I remember thinking that IF I didn’t have all the tools on hand in the language, the coding of this stuff would have been between hard and impossible (at least hard for a human, or certainly nearly if not fully impossible for me). In the end we had a production system running 24/7, where we evolved the types of objects stored in the database dynamically as we improved and enhanced our code. After struggling a lot I asked a very technical academic colleague if there was any clever way that we *should* have been doing all this work. I was happy to hear that it was generally considered a very hard (academic) problem, and I should be happy that we got most any of this working (in a real world problem). I know that a lot of the credit for getting this running went to the language.

As a last memory, I recall attending “The Second Python Workshop” in around May 1995. I think it was held in a small room at NIST in Palo Alto. I had already moved on to this other startup company, Netscape Corp., but I was anxious to see some of the code that I had worked on survive. There seemed like there were about 30 folks there at any time, and the attendance list (found via Google) shows that no more than 60 folks attended in total. The language seemed interesting, but it also seemed like it was more of a hobby than a tidal wave.

Over the years since then, more and more folks have tried to tell me about this new language they had started to play with… called Python…. And that it is pretty cool. I just smile and agree.

Jim

Ka-Ping Yee

Posts: 24
Nickname: ping
Registered: Dec, 2004

Re: Looking for Memories of Python Old-Timers Posted: Jun 5, 2006 6:33 PM
Reply to this message Reply
I'm going to add another favourite Python story that i forgot to include in my first comment.

A couple of years after i first learned Python, i took a software engineering class as part of my engineering degree at the University of Waterloo. The purpose of the class was to teach us how to manage and complete a large software project, so large that it would require multiple people to develop and would require some advance planning and project management to get it done on time. The project we were assigned was to develop a PBX — a telephone exchange with twenty phones that could dial each other, a limited number of touchtone receivers for decoding the dialed touchtone sounds, and a limited number of audio channels to be allocated for connecting phone calls. The job of the PBX was to keep track of the states of the various phones and to connect them to the touchtone receivers and channels, produce busy signals when necessary, and so on.

This project was supposed to be implemented in C++ and to take about four weeks to be developed by a team of three or four programmers. I asked for permission to work on the project in a two-person group, with my friend Tyler Close. I was by this point convinced that it was a good idea to program just about anything in Python, and managed to persuade Tyler that we should prototype the PBX in Python even though he wasn't that familiar with it and even though we would eventually have to do it in C++.

We got together one afternoon to work on the project. We decided what we needed to do, divided the project up into modules, and started coding. Tyler picked up Python fast — very fast. Three hours later, we had a complete working implementation. We translated the Python script into C++ almost trivially, line for line, and we were finished. I had expected working in Python to be fast, but even so i was amazed that we were already done. Just like that, my plans to work on the project for the rest of the four weeks vanished.

I just went through some old files and found the Python program, with its Tkinter GUI for testing and dialing the phones, and it still just works today.

I still recall that project as one of my most productive and pleasant programming experiences ever. Unfortunately, we failed to learn anything about managing a long-term project because the project was already done before we had a chance to do any project management. :)

Thank you, Guido, for this and many, many other productive and pleasant programming experiences!

Kevin Dangoor

Posts: 1073
Nickname: tazzzzz
Registered: Jul, 2003

Re: Looking for Memories of Python Old-Timers Posted: Jun 6, 2006 8:51 PM
Reply to this message Reply
I started with Python sometime in 1995 (my first posting to c.l.py was in January 1996, and Guido responded with a detailed followup. Thanks, Guido!)

I was with ANS at the time (the folks that ran the NSFNet network), and I spent I good chunk of 1995 working in Perl. Compared to the various things I had been working with previously, Perl was nice.

Then a colleague of mine introduced me to Python. I was a big fan of OO and Python felt so natural to work with and write. After a very short time, I hardly felt like I needed the docs. I could just guess how something would naturally work in Python and it did.

I have not been as fortunate as many here to use Python continually over the years. But, whenever I've had a say in the matter, Python has been a great and faithful tool of choice.

david ascher

Posts: 1
Nickname: ascher
Registered: Jun, 2006

Re: Looking for Memories of Python Old-Timers Posted: Jun 7, 2006 1:22 AM
Reply to this message Reply
I figured I'd use the excuse for a blog topic:

http://blogs.activestate.com/davida/2006/06/old_timer_memor.html

(go there for the link'ed version):

I did a little digging in Google Groups, and I was a bit stunned by what I found. My first post in comp.lang.python (although I was using the python-list@cwi.nl at the time) was about emacs and used regular expressions:

I just whipped up this code to make hilit19 deal w/ python code relatively properly. Put it in your .emacs file.


Note: detecting documentation (e.g. triple quote strings after class or function definitions) as comments rather than strings would be nice, if anyone is motivated enough...

(hilit-set-mode-patterns
'(m2-mode python-mode)
'(("\\s #.*$" nil comment)
("^#.*$" nil comment)
(hilit-string-find ?\\ string)
("^[ \t]*def[ \t]+\\w+[^ \t(;]*" nil defun)
("^[ \t]*class[ \t]+\\w+[^ \t(;]*" nil define)
("^[ \t]*import[ \t]+\\w+[^#\n]*" nil include)
("^[ \t]*from[ \t]+\\w+[^ \t(;]*[ \t]+import[ \t]+[^#\n]*" nil include)
("\\<\\(access\\|and\\|break\\|continue\\|def\\|del\\|elif\\|else\\|except\\ |finally\\|for\\|global\\|if\\|in\\|is\\|lambda\\|not\\|=
or\\|pass\\|print\\|\\raise\\|return\\|try\\|while\\)\\>"
nil keyword)
)
nil 'case-insensitive)

So, here we are, 11 years later, and I'm still writing code to make better tools for hacking Python. Depressing in a way, but we won't dwell on that. (This post is even scarier!)

Instead, let's go a little bit earlier, a few months earlier in fact, because what led me to Python is maybe more important than my particular obsession within it. I was a grad student doing work in auditory research. Like a lot of grad students, what I was actually doing was writing C++ code and then trying to get my fellow grad students to appreciate the beauty of my code. It became pretty quickly clear that that wasn't going to happen with C++ code, so I figured I would write a scripting front-end. As a victim of a compiler class, I grabbed my copy of the Dragon book, and started defining a grammar, fighting the parser generator, and got really, really frustrated. After too many days of pain, I realized that I wasn't in a class, and that what really mattered was getting a scripting front-end, not being the one to invent is. I did a little altavisting (somehow doesn't work as well as Googling', but those where the days), and came across two languages: Phantom and Python. (Phantom didn't grab me, go wonder). I don't know why I didn't think of using Tcl and Perl, two languages I already knew. Anyway, I quickly downloaded the tutorial, read it, and was immediately quite excited (my officemate was then quickly subjected to long raves about this language which "was even cooler than MetaPost", which was my newest toy at the time).

I quickly got involved on the newsgroup, threw out ideas, and got answers from Really Nice Folks. People were just so incredibly encouraging, from Guido ("ooh, Guido wrote to me!") to Tim Peters, to /F (back then he was more cheerful =), Uncle Timmy, Don Beaudry, Ken Manheimer, Barry Warsaw, and lots more. I will always be very grateful to them all. It's truly amazing how much fun was had by all over so many yerars. The conferences were very important, but the mailing list is what kept people involved every day for years, long before anyone was making any money with the stuff.

I'm extremely lucky that for me it became more than fun, as it slowly turned into a job, a book, another job, another book, yet another job.

The world would be a much better place if everyone could experience this kind of long-term involvement in activities that combine intellectual curiosity, learning, fun, and real friendships. It's hard to recall the last 11 years and not think that the internet is so damn cool, that programming is fun, and that there are a lot of nice people out there.

Cheers.

Wolfi Grafen

Posts: 1
Nickname: spalbird
Registered: Jun, 2006

Re: Looking for Memories of Python Old-Timers Posted: Jun 7, 2006 9:01 AM
Reply to this message Reply
In 1996 funny enough it was Perl I didn't know at all which brought me to learning Python. Having bought a Perl O'Reilly book I realised after one week that it was about Perl 1.4 but not the new version Perl 1.5. I returned it to the book store and asked to order the new one. I looked around and discovered under another copy of that Perl book "Das Python Buch" published by Addison-Wesley. I browsed through it and fell immidiately in love with that language whose syntax looked much more familiary to me than the Unix script based language Perl. Fortunately it was easy to read and understand during the 10 minutes bus drives in the morning. No surprise I sticked with Python until today.

In the beginning I was promoting Python for our work. There was a strong opposition against Python - We use TCL and Perl but nobody uses Python - Most of our scripts are Perl - Python is inferior to Perl and so on. After I gave up and used Python only for my own problem solvings more and more people in other departments began programming in Python. I helped another collegue how to solve his communicating problems with an embedded controller. He restraining using Python years ago is now so enthusiastic that even his 10 year old son got "Python for Kids" as a Christmas present. His Python programs are also reaching some other departments of our company.

Just recently - Python hit our group!!! Our system administrator substituted his commercial family tree program with a Python equivalent. This was enough reason for him to learn Python. After some time he prefered writing our scripts in Python instead of Perl. Recently we rewrote one of his Perl programs relying heavily on external Unix commands completely in Python - cutting its execution time from tree minutes to five seconds. Recently working in a mixed Sun/Solaris and Intel/Redhat environment some of the old scripts show ugly errors which can be easily avoided with rewriting them in pure Python. Also my collegues ask our Sysop for help with their problems. He shows how to solve them in Python - and they are starting reading Python books as well.

In the end - 10 years after my Python promotion - Python is settling in our group. Collegues outside my group are using Python for years now - we are the last. It is not exactly a success story for me.

S Deibel

Posts: 9
Nickname: sdeibel
Registered: Apr, 2003

Re: Looking for Memories of Python Old-Timers Posted: Jun 7, 2006 9:17 AM
Reply to this message Reply
I started with Python in 1998. I am not sure that makes me an old-timer. I'm one of those people that should have started 5 years earlier and the huge complicated project I had been working on in C++ might have succeeded.

I came to Python as a way to prototype some GUIs for a medical workstation, and learned it from example and reading the manual. By that time, it was too late and the project as a whole had pretty much failed. But boy was I blown away with the productivity and clarity of code when working in Python. I was looking to move on anyway, so I took my enthusiam for Python and co-founded Wingware (makers of a commercial Python IDE).

Best career change I ever made! :-)

Vincent O'Sullivan

Posts: 724
Nickname: vincent
Registered: Nov, 2002

Re: Looking for Memories of Python Old-Timers Posted: Jun 9, 2006 5:38 AM
Reply to this message Reply
> I helped another collegue how to solve his
> communicating problems with an embedded controller. He
> restraining using Python years ago is now so enthusiastic
> that even his 10 year old son got "Python for Kids" as a
> Christmas present.

It sounds like you may be referring to "Mit Python Programmieren für Kids" by Georg Lingl (ISBN: 3826609514).

I I'm not sure my kids could cope with simultaneously learning Python and German in one hit, so there could be a nice (very) little earner for someone willing to port the book to English.

Thinking about it; With some decent artwork and a lively written style ("Head First Programming for Kids (using Python)" perhaps?) the opportunity exists to create an audience for whom Python is their first programming language - and consequently their language of choice in the future.

V.

(PS. As a ten year old kid, I'm sure I would have preferred a new bicycle but that's another story.)

Konrad Hinsen

Posts: 1
Nickname: khinsen
Registered: Jun, 2006

Re: Looking for Memories of Python Old-Timers Posted: Jun 12, 2006 9:54 AM
Reply to this message Reply
I discovered Python in 1995 and have been using it ever since as my main programming language.

Back then, I was starting to work on biomolecular simulations, using a package well-known in the field that was a pain to use and a nightmare to modify: large amounts of Fortran code written by dozens of graduate students who had been learning Fortran programming on the job. I was spending way more time analyzing badly written code than working on my own project.

Since I expected to stay in biomolecular simulations for a while (I still do), I started to look around for better tools. Unfortunately, there was no package that had the functionality I needed and the quality of code that I expected. I decided to write my own. I knew that to do in a few years alone what groups of dozens of people had done in two decades, I had to be a lot more efficient. I also knew that both C and Fortran, the two languages I was fluent in at the time, were too low-level for the task.

I began a systematic exploration of programming languages as a side project. Some candidates were eliminated quickly (e.g. Lisp for its overdose of parentheses, and Smalltalk for its bad integration with the world of file systems), others were examined more seriously by using them in a small programming project: C++, Perl, and Python. Python convinced me immediately: clean syntax, a clean object model, a good C interface, a rich standard library, and a community of smart and helpful people. The Numerical Python project, in which I was involved from the start, removed another barrier to the use of Python in scientific computing.

Since then, I have written a large amount of scientific computing code in Python, using just as much C as strictly necessary. Most of my code is contained in two libraries that I distribute as Open Source code: ScientificPython (http://dirac.cnrs-orleans.fr/ScientificPython/) and MMTK (http://dirac.cnrs-orleans.fr/MMTK/).

Back in 1995, using Python for scientific computing required a good bit of courage. Most of my colleagues just didn't take Python serious, and even the more open-minded ones considered the idea of using an interpreted language an obvious stupidity. In the 11 years that followed, the situation has changed for the better: scientists and engineers are starting to use Python now everywhere around me, and I am invited regularly to teach Python classes for scientists or to present my packages written in Python.

wesley chun

Posts: 1
Nickname: wesc
Registered: Feb, 2006

Re: Looking for Memories of Python Old-Timers Posted: Jun 12, 2006 9:23 PM
Reply to this message Reply
Not a Python old-timer really... started in early 1997 with 1.4 at Four11.com where we developed Yahoo!Mail (called RocketMail back then... anyone remember that or still have an acct?).

We used Python and C++ plus our own home-brewed templating system well before such things existed... the closest I guess would be Cheetah. I haven't made any real serious patches to the source, just various bugfixes and enhancements over the years.

Back then, the only Python books available were Aaron Watters "Internet Programming with Python" and Mark Lutz's "Programming Python". I picked up most of my Python from the Library Reference, and with the development of Python training courses and the aging of those books, I was highly motivated to write "Core Python Programming" (http://corepython.com).

My how Python has changed since then. We've come full circle as 2nd ed is coming in a few months! I look forward to another session of reminiscing when Python is 2 ** 5 years old.

Flat View: This topic has 54 replies on 4 pages [ « | 1  2  3  4 | » ]
Topic: Looking for Memories of Python Old-Timers Previous Topic   Next Topic Topic: The Third State of your Binary JUnit Tests


Sponsored Links



Google
  Web Artima.com   

Copyright © 1996-2014 Artima, Inc. All Rights Reserved. - Privacy Policy - Terms of Use - Advertise with Us