I'm actually more of a "medium-timer", having used Python for less than 10 years.
My first exposure to Python came when I was working in Tokyo at a small company doing SGML data processing, specializing in East Asian languages (Japanese, Chinese, Korean). It was a high-stress but fun environment, where the work always had to be done *yesterday*. We'd write code and run it on (usually buggy) client data, and debug the system until it ran correctly, then the job was done. There were a lot of one-off programs, but not insignificant. A typical day saw me coding in Scheme, PostScript, shell, and Perl. Lots of Perl. From single-line filters to a multi-thousand-line program that parsed ASCII-art syntax diagrams, I was immersed in Perl for over 2 years. By the end, I was sick of Perl; it just didn't scale, and maintenance was a nightmare.
Toward the end of my stay in Japan, probably in 1997, a colleague picked up a copy of the first (1996) edition of "Programming Python" by Mark Lutz and was impressed. I took a look and liked what I saw, but was so busy that I didn't have time to get into it then. I moved back to Canada in 1998 with my wife and infant son, took some time off, picked up my own copy of "Programming Python", and delved deep. I really liked what I saw, and started a Python rewrite of a project I'd written in university in Pascal (a Pentominoes puzzle solver) to learn the language. I got it working well enough -- it was slow and buggy, but the project had served its purpose: I was now comfortable coding in Python.
The code flowed. Maintenance was a breeze. I found myself writing code that, except for the odd syntax error or typo, would often *just work*, first time. As the saying goes, Python fits my brain. I was able to tackle large projects much more easily than ever before. And thanks to Python, programming became fun again.
While learning the language I discovered docstrings and started looking around for autodocumentation systems to exploit them. The choices available then weren't exactly what I was looking for. It seemed that many people had tried their hand at autodocumentation, but nobody had produced anything sufficiently generic for my liking. Either the source code was imported (where I wanted it to be parsed), or the output was fixed (it should be flexible), or the markup was either deficient or cryptic and hard to read (it should be rich, yet implicit and easy to read). I foolishly took on this task, and eventually focused on the last aspect: the markup. Docutils & reStructuredText were born, and the rest is history (http://docutils.sf.net/docs/ref/rst/introduction.html#history).
I have contributed several small fixes and enhancements to Python's standard library, I occasionally participate in Python-Dev discussions, but my most significant community role (apart from Docutils) is probably as Python Enhancement Proposal (PEP) editor. I have also been involved with organizing PyCon, and have attended for three years running. I became a nominated member of the Python Software Foundation in 2003, and have been active with the Board of Directors, becoming an officer (Assistant Secretary in 2005 and Secretary this year), and I was elected as a director in February 2006.
I now program almost exclusively in Python. I recently revisited my Pentominoes solver, using a different approach, which works very well. Docutils still doesn't do Python autodocumentation natively though. Other autodocumentation systems use Docutils, but the "ultimate solution" has yet to be written. One of these days...
I first looked at Python in 1993 during I made a trip to France to see my later-wife. This was only my third time seeing her and I showed up with this monstrosity of a 286 laptop and pitched tent in her kitchen going through the Python tutorial. Nearly every one of my flaws was there for her to see, early on.
At that time I was working on www.navy.mil and the idea of CGI was starting to come out. I wasn't much of a programmer: anything important I've ever written was immediately rewritten by someone talented. I remember looking at the Perl book and thinking, "Only if I have to." The Python tutorial is what pulled me in.
I went to the first Python "conference" organized by Michael McLay at NIST. Though I didn't have much to contribute, I really enjoyed it. After that I got involved with efforts at a foundation, then got involved in the next few Python conferences. Rob Page and I started a company that created a platform for newspapers to publish online. Jim Fulton, who organized the second and perhaps third conferences and did a bunch of core Python stuff at the time, joined us and we got heavily involved in Python.
I'd say that nearly everything I know about groups of people working together online for a common purpose comes originally from the Python community. This thread was a nostalgic celebration with tons of evocative memories from years past. Now that I'm moving back to the US and re-joining the PSF, I hope I get to PyCons and can catch up with some friends from years past.
Thanks Guido for starting this thread and Michael for nudging me to post.
Well, my first post to comp.lang.python was in mid April 1995.
thinking back to then, I would have had one of a series of Acorn Computers at home, and would have been using Sun workstations at work. I would have been programming in AWK, C, and Cadence Skill; and would have been scouting around for a language to replace AWK, that ws NOT Perl, (Perl and I do not gell - although i have had to do a fair amount of Perl programming over the years). I wouldn't have done much with Python except admire it as I remember it took some time before it was ported to the Acorn platform.
We have been using Python in the Space Shuttle program since 1993 when I first downloaded it from the CWI in Amsterdam. At the time there was a project to re-develop our fundamental trajectory simulation capabilities as a library of reusable components. We needed a language which could be used as an executive, or control, mechanism for all these C++ classes we were developing. The web was very young then, (I think there were only a few hundred HTTP servers in the world then), but I was able to use gopher to search for "Object Oriented Programming". Behold this thing called Python popped up and I went to the URL. From CWI I downloaded I think version 0.93 and untarr'ed the source. It built without trouble on our Sun workstations in a few minutes. (I was impressed already.) We soon realized we had the perfect tool for the job. Python could bind to C/C++ libraries easily with its API, and its object oriented syntax matched the C++ objects we were writing object for object, method for method. I was a Perl user too and Python put an end to that! We've been enthusiatic Python boosters (sic) ever since. I was even able to talk my company into sending me up to Gathersburg to the first Python Workshop. Can't say that I've contributed anything to the Python language but boy have I been exploiting it!
I've been using Python on-and-off since 1992. I remember stumbling upon one of Guido's postings in comp.lang.tcl; at the time, we were using Tcl for a virtual reality project at the University of Virginia.
It wasn't long before we switched to Python (I think it was still version 0.7 in those days.) Needless to say, we never looked back. The perfect word to describe Python then and now is "elegant."
Oddly enough, 14 years later, I work with one of my fellow researchers from UVa, and we still talk about Python.
My fondest memory in demonstrating the power of Python was a project called "Dancer", a small graphical web browser that used Tk. It only took about two days to write - granted, it wasn't Mosaic, but not many other languages let you prototype that fast, even today.
Twelve years ago CNRI co-worker Barry Warsaw had discovered Python through friends Michael McLay and Ken Manheimer. He and I attended the first Python conference, along with eighteen others, held at the National Institutes of Standards and Technology (NIST) in December 1994. The author of Python mediated the conference, a Dutchman named Guido van Rossum. We were impressed with the technical merits of his small object-oriented scripting language but even more so with its inventor.
Even though Barry and I were focused on using Objective-C and the NEXTSTEP environment as our main programming tool, we had a requirement for a scripting language for a project that implemented code mobility [Knowbots]. Knowbot programs were running programs that package up their state, and migrated to a new machine resuming operation at the new location. For this effort, we were in search of a language that was interpreted but at the same time had all of the capabilities of the most powerful compiled languages. We considered other interpretive languages and drew the following conclusions:
1. Perl is a powerful scripting language that grew out of the UNIX system administrator community. It has powerful regular expressions and excels in parsing system logs when searching for particular items. We felt that Perl’s syntax was overly complicated. This made for difficult program readability and maintainability. Another problem was as the time of the evaluation Perl5 had just be introduced and was not as robust enough to be in consideration. Perl4 lacked any object-oriented features and, because of its nearly non-existent extension mechanism, was very hard to extend. Despite showing impressive runtime performance, our evaluation of Perl concluded that it was not ideal. Because of the syntax complexity issues, it would be difficult to teach Perl to new users particularly if they were not already programmers. We were in search of a simpler language with the power of Perl.
2. Tcl was considered because of its simplicity despite having strange syntactic qualities. With Tcl, we feared that large programs would be difficult to maintain. In the final analysis, we rejected Tcl because it lacked performance, any numeric data-types, intermediate compilation, and object orientation. We were in search of a language of simplicity, but not at the expense of expressiveness, scalability and power.
3. Java is an interpreted environment similar to that of Python. "Compiled" Java programs are executed by the Java Virtual Machine. The Python interpreter executes Python programs after compiling Python source code to Python byte-code. With the exception of differing byte-code formats and the existence of Just-In-Time (JIT) compilers for some Java Virtual Machines (JVM), Java and Python have somewhat similar execution environments. Despite the fact that at the time of our evaluation, Java was still a research effort, Java was the only other real consideration for our code mobility project. Java had powerful expressiveness, object-orientation, a full suite of data types, and a platform independent byte-code representation (a valuable feature for implementing code mobility). In the end we decided that Java, was not for scripting. It possesses the same lack of very-high-level-language quality as C++ and Objective-C. We found Java programs to be two to three times as many lines-of-code as the Python equivalent.
At the end of the two-day conference we were nearly convinced Python should be our mobile code implementation language for our code mobility project. We were still planning on developing most of the supporting code using NEXTSTEP and Objective-C.
CNRI hired Mr. van Rossum six months later (score!) and with him we began to inherit his responsibilities towards promoting his language. As we became more familiar with Python and comfortable with its capabilities, we found ourselves using it to test varies theories and to prototype various ideas. The final prototypes could then be re-written in Objective-C or perhaps Java. After many months of using Python as a prototyping tool, we found, to our surprise, that there was little need to choose a different language environment to re-implement anything! This realization came around the same time we accepted the fact that our previous strategy for success was based too heavily on the strategy of a commercial vendor. Because NeXT computer was the primary source of Objective-C development environments and Sun Microsystems the controllers of Java, we were confined to their marketing directions and decisions based on commercial interests. We did not like having our technology choices made for us. This final straw allowed us a greater appreciation for Python's free status and liberal licensing.
Our initial evaluation of Python was as a scripting language for a specific part of a specific project. Our eventual adoption of Python was as a general-purpose language that became the tool of first choice.
That was twelve years ago. I'm happy to say that I'm still paid to develop software and software to develop software in Python.
The CNRI knowbots project ended up being the first of many Python projects at CNRI that paid the salaries of more-than-a-few Python luminaries (and some ..err not so luminary... like me):
Anton Benard David Binger Fred L. Drake Jr. Jeremy Hylton Jim Hugunin A. M. Kuchling Roger Masse Ed Overly Guido van Rossum Neil Schemenauer Greg Ward Barry Warsaw
Even though only David and I remain, we've been able to release much open-source software (see: www.mems-exchange.org/software) thanks to momentum we've carried by riding on the shoulders of several of the aforementioned giants and through the generosity of my employer. I almost never have to use other languages. Life is good!
I was introduced to Python first probably halfway 1994, by a colleague at EMBL Heidelberg, Michael Scharf. At some point he had given a course to group members called "object oriented programming using ET++", and a little after he had discovered python he repeated the same course but reworked into "object oriented programming using python". The course attendeed were each working on different tools to work on protein and DNA sequences, and at the end of the course there were many tools that, due to the well designed framework, worked seamlessly together to perform all kinds of analysis on the most varied set of sequence databases imaginable.
I was grepped immediately by the beauty of the result and the first proper explanation I got of object oriented programming; the first time the concept started to make sense to me after reading several books.
I have been a power user of FORTRAN, a heavy user of Tcl/Tk and a moderately hacky perl user before this time, but in the beginning of 1996 I really started my first serious projects in python and dropped all other scripting languages. February 1996 is also the first time I have posted on c.l.py. The biggest difference I felt between Tcl/Tk and Perl on one side, and Python on the other, is that python really invited me to properly reuse code I had written before. Reuse rather than copy and modify.
Then, in September 1997 I was employed by a company making X-ray analytical instrumentation in The Netherlands. They asked me to write their new application software suite in a forward looking way. I was allowed to do everything from scratch. The first time we talked about the project the company proposed to do it in Java, but I managed to convince people that python was going to be a better choice. In 3.5 years of one-man work the package did grow to about 75k lines of python and 1k lines of C. It used Tk/Pmw for GUI, and Numeric for computation. The package was unix only.
In April 2001 our company merged with the biggest competition. The newly formed conglomerate decided that all of the unix only programs from one side, and all of the windows only programs from the other, had to be merged into one cross-platform suite. This is the package that we are still working on, now with a handful of developers. It is still written for 95% in python and the rest in C++ (using boost-python) about 5x the size of the first generation tool, now with a gui in PyQt and still using Numeric. And it still contains some of the same concepts I learned in that first introductory course in object oriented programming!
It must have been the summer 1996. Back from a business trip to US' east coast, I came across a mentioning of Python on the Internet, maybe in an online magazine, someone saying Python is nice and cool, with a few pointers. I looked around and got caught by a nice, colour-full and easy-to-read article by David Asher (with lots of little pythons ;) that intrigued me. I installed Python 1.4 on a Windows 3.11 machine, and although being an old Unix horse, Python on Windows was my playground for quite a while.
Ahh, the syntax, a sight for sore eyes! (I was also making inroads into Perl at that time...). I read about Guido's Christmas project. Then I bought Mark Lutz' book, with another working-from-home story.
1997 I started my first Java project, with 5-day course and all. I had to design and implement a Java API for a network based service, but after a couple of weeks I got so fed up. Java kept getting in the way. Class designs had to be re-worked, interfaces be revamped. I spent increasingly time fixing class-cast exceptions. Meanwhile, colleagues were waiting to see code using my API, to review the design.
I did the client (API-using) code in Python, not daring to mention its name, calling it "pseudo code". It was clear, easy to read, and conveyed immediately how the API was to be used. Martin von Loewis' Python book was my every-day reference.
Then, when feedback came in, I put away with Java altogether. I implemented all classes in Python, re-worked them, revamped them, got more feedback, published more client code, did more API refinement. When the whole thing was settled, and everybody seems confident with the API, I simply re-implemented the Python classes in Java. SMOP. Done.
At home, Mark Hammond's PythonWin continued to delight me. A beautiful language with a free Windows IDE! It felt like Christmas every day.
On the job, Perl was establishing itself. Colleagues were trained, books were bought, old shell scripts were re-done in Perl. Hard to come up with another language. Hard arguments were needed. Those came up, when need arose to do some scripts on Windows using COM. Python's COM interface was more stable and mature than Perl's at that time (1999/2000), again most probably due to Mark Hammond.
Perl 1986, Python 1989. Often I thought, if only Python had been these few years earlier! We might all be doing Python by now...
Me & my friend (he works on Linux kernel these days for money), started looking at this thing called Python and open source in 2001. I think it was fairly new in India, REC-Trichy and our engineering college. We got some copies of python on the local RedHat linux machine and it was rage. We had a server where our LUG members used to post snippets, and other cool python scripts.
Personally my coming of age to python was learning to do a network programming script with implementing a FTP client. Doing stuff like networking in C is pain. Python you can just juggle around these things at your own cool time without worrying much about the socket.h
I'm relatively new to Python compared the Old-Timers here but I enjoy programming in Python as much as you all do. I started using Python in 2005 and it has become my primary programming language. It has brought back the joy of programming after the boring projects in Java and I have been more productive too! I have actually added a post on why I love python and it is at http://passingbythewoods.blogspot.com/2008/01/why-i-love-python.html
I have not yet started contributing to Python but I would like to in the future.
Flat View: This topic has 54 replies
on 4 pages
[
«
|
1234
]
Previous Topic
