Mailing List Archive

Graham Matthews <graham@sloth.math.uga.edu> wrote:
: I read the following interesting snippet at
:
: http://www.python.org/workshops/1997-10/proceedings/hugunin.html

:>6.2. Python in Java's Advantages
:>
:>Using Java as the underlying systems language for Python has a number of
:>advantages over the current implementation of Python in C. First and
:>foremost of these in my mind is the opportunity to ride the Java
:>popularity wave and let Python code run everywhere there's a Java VM.
:>It also makes the rich set of portable Java API's available from within
:>Python.
:>
:>There is also a nice collection of technical reasons why Java is a
:>superior implementation language for Python than C. These include
:>Java's binary portability, thread-safety, object-orientation, true
:>exceptions, garbage collection, and friendliness to glue languages.
:>More questions need to be answered before I can make a convincing
:>argument that Python 2.0 should be implemented in Java rather than C.
:>Nonetheless, I think that Java offers many advantages for Python as
:>both an implementation language and a widely available run-time platform.

: What particular intrigues me here is the sentence

:>More questions need to be answered before I can make a convincing
:>argument that Python 2.0 should be implemented in Java rather than C.

: I was wondering if this is seriously being considered -- that is
: implementing Python 2.0 in Java rather than C. While I understand
: that there are some technical challenges with this (notably interfacing
: to the existing C implemented extensions), I personally think there
: is a lot to be said for compiling Python to the JVM. For example:
: access to the Java apis, garbage collection, true compilation, the
: ability to write statically typed code (just write that part in Java!),
: access to Swing, promoting Python on the coat-tails of Java (free
: publicity and hype), etc.

: Comments?

Have you looked at http://www.jpython.org/? It seems to be more in
keeping with your desires.

-Arcege

On 27 May 1999 19:33:38 GMT, graham@sloth.math.uga.edu (Graham
Matthews) wrote:

>I was wondering if this is seriously being considered -- that is
>implementing Python 2.0 in Java rather than C. While I understand
>that there are some technical challenges with this (notably interfacing
>to the existing C implemented extensions), I personally think there
>is a lot to be said for compiling Python to the JVM. For example:
>access to the Java apis, garbage collection, true compilation, the
>ability to write statically typed code (just write that part in Java!),
>access to Swing, promoting Python on the coat-tails of Java (free
>publicity and hype), etc.
>
>Comments?

I have no problem with an implementation of Python in Java (see
JPython). But I would never use it (reliance on a JVM, general
dissatisfaction with Java implementations, etc).

What I *would* object to, strongly, would be the lack of a Python
implementation in C. I assume that there is no intention that this
should happen.

How would I embed Python in a C application, without a C API? And how
would I distribute a C application with embedded (Java-) Python to
machines with no JVM, assuming I don't want to (or don't have the
capability to) distribute a JVM.

Enough said.

Paul.

On Thu, 27 May 1999, Graham Matthews wrote:

[...]

>
> I was wondering if this is seriously being considered -- that is
> implementing Python 2.0 in Java rather than C. While I understand
> that there are some technical challenges with this (notably interfacing
> to the existing C implemented extensions), I personally think there
> is a lot to be said for compiling Python to the JVM. For example:
> access to the Java apis, garbage collection, true compilation, the
> ability to write statically typed code (just write that part in Java!),
> access to Swing, promoting Python on the coat-tails of Java (free
> publicity and hype), etc.
>
> Comments?
>

For many (if not most) Python programmers, this would be a disaster. In addition
to the many extensions publicly available, it seems inevitable that anyone
coding for long will pick up a number of homegrown extensions. For the
overwhelming majority of programmers who don't know Java (and especially for the
admittedly smaller number who don't *want* to know Java) implementing Python in
Java would remove the option of creating extensions.

Without this ability, many of the tasks for which I use Python would be
virtually impossible. I suspect that many others would feel the same way.

JPython has many features that make it interesting and there are environments in
which it makes more sense than does CPython, but it should not become the only
(or even primary) implementation of Python.

Hier bin ich, ich kann nicht anders.

--- Robert

--------------------------------
Robert Meegan
MCIWorldCom - Cedar Rapids, Iowa
319.375.2416

>>>>> "GM" == Graham Matthews <graham@sloth.math.uga.edu> writes:

>> More questions need to be answered before I can make a
>> convincing argument that Python 2.0 should be implemented in
>> Java rather than C.

GM> I was wondering if this is seriously being considered -- that
GM> is implementing Python 2.0 in Java rather than C.

It's been talked about, as has using C++ as the implementation
platform. All three (C, C++, Java) and any other more exotic ones you
can think of each bring in their own mix of benefits and problems.

IANAG, but if I had to guess I'd say Python2 will probably still be
implemented in C, with an outside chance that some parts may be C++
(e.g. built-in types -- this might resolve the types/class dichotomy),
and JPython will continue to exist side-by-side as a separate
implementation.

Two things to remember: at this point probably Guido doesn't even know
for sure, and Python2 is still years away. ;)

-Barry

In article <7ik6mi$lbk$1@cronkite.cc.uga.edu>,
graham@sloth.math.uga.edu (Graham Matthews) wrote:
> I read the following interesting snippet at
>
> http://www.python.org/workshops/1997-10/proceedings/hugunin.html
>
> >6.2. Python in Java's Advantages
> >
> >Using Java as the underlying systems language for Python has a
number of
> >advantages over the current implementation of Python in C. First
and
> >foremost of these in my mind is the opportunity to ride the Java
> >popularity wave and let Python code run everywhere there's a Java
VM.
> >It also makes the rich set of portable Java API's available from
within
> >Python.
> >
> >There is also a nice collection of technical reasons why Java is a
> >superior implementation language for Python than C. These include
> >Java's binary portability, thread-safety, object-orientation, true
> >exceptions, garbage collection, and friendliness to glue languages.
> >More questions need to be answered before I can make a convincing
> >argument that Python 2.0 should be implemented in Java rather than
C.
> >Nonetheless, I think that Java offers many advantages for Python as
> >both an implementation language and a widely available run-time
platform.
>
> What particular intrigues me here is the sentence
>
> >More questions need to be answered before I can make a convincing
> >argument that Python 2.0 should be implemented in Java rather than
C.
>
> I was wondering if this is seriously being considered -- that is
> implementing Python 2.0 in Java rather than C. While I understand
> that there are some technical challenges with this (notably
interfacing
> to the existing C implemented extensions), I personally think there
> is a lot to be said for compiling Python to the JVM. For example:
> access to the Java apis, garbage collection, true compilation, the
> ability to write statically typed code (just write that part in
Java!),
> access to Swing, promoting Python on the coat-tails of Java (free
> publicity and hype), etc.
>
> Comments?
>
> graham
>
> --
> Thanks for the trouble you took from her eyes
> I thought it was there for good
> So I never really tried
>




The only problem I see with a java implimentation of python, would be
the java security process. It is my understanding that the java sandbox
would prevent embeded programs from accessing low level hardware
functions. I presently use python-c to access the hardware abstraction
layer of both windowsNT and windows95/98. This would not be posible
under java.

Sam Schulenburg


Sent via Deja.com http://www.deja.com/
Share what you know. Learn what you don't.

Paul Moore (gustav@morpheus.demon.co.uk) wrote:
: I have no problem with an implementation of Python in Java (see
: JPython). But I would never use it (reliance on a JVM, general
: dissatisfaction with Java implementations, etc).

Sure current implementations of the JVM are not the best, but they
are improving and will continue to do so. So the "dissatisfaction
with the Java implementations" objection will disappear more and
more over time.

Paul Moore (gustav@morpheus.demon.co.uk) wrote:
: How would I embed Python in a C application, without a C API? And how
: would I distribute a C application with embedded (Java-) Python to
: machines with no JVM, assuming I don't want to (or don't have the
: capability to) distribute a JVM.
:
: Enough said.

I don't think so. Soon every machine under the sun (pun intended)
will have a JVM. Java has a C calling interface, so you can use that
to embed Python in a C application.

graham
--
I would gladly die for a man who was looking for the
truth, but would just as gladly kill a man who thought
he had actually found it -- Voltaire

Paul Moore wrote:
>
> How would I embed Python in a C application, without a C API?

Java has JNI which also allows embedding in C applications. This works
quite well for me (at least as good as embedding, personally I even like
it a bit more).

> And how
> would I distribute a C application with embedded (Java-) Python to
> machines with no JVM, assuming I don't want to (or don't have the
> capability to) distribute a JVM.

What's the difference between distributing a JVM or a PyVM ? This is
pretty much the same. Java bytecode also has the advantage that native
compilers are becoming real, eg the gcj compiler of Cygnus.

Maybe Python could use a lightweight/extended JVM, that is, Python could
use Java bytecodes but the JVM native interface could be done more (C)
Python like. This way one could have shared code between (C)Python and
JPython.

Hm, anyway ...
Helge

[Paul Moore, on the possibility of Python 2.0 in Java]

> How would I embed Python in a C application, without a C API? And
> how would I distribute a C application with embedded (Java-) Python
> to machines with no JVM, assuming I don't want to (or don't have the
> capability to) distribute a JVM.

And you'd only have to get it working with N different JVMs, all
without anything resembling autoconf.

#ifdef-considered-dangerous-<snort>-ly y'rs

- Gordon

Sam Schulenburg writes:
>
> The only problem I see with a java implimentation of python, would
> be the java security process. It is my understanding that the java
> sandbox would prevent embeded programs from accessing low level
> hardware functions. I presently use python-c to access the hardware
> abstraction layer of both windowsNT and windows95/98. This would not
> be posible under java.

The security stuff only applies to applets, which are the sideshow
that hijacked Java. However, you'd still have to write in C, and
then make it work not only on all the hardware you're interested in,
but all the JVMs that run on that hardware.

- Gordon

>>>>> "GM" == Gordon McMillan <gmcm@hypernet.com> writes:

GM> And you'd only have to get it working with N different JVMs,
GM> all without anything resembling autoconf.

GM> #ifdef-considered-dangerous-<snort>-ly y'rs

You ain't kiddin' Gordon! One of my recent JPython slaps has been
trying to use JDK 1.2 APIs to provide better functionality. Well,
y'can't because most JPython users want 1.1 compatibility (for good
reasons) and there's no way[1] to have a single Java codebase that
supports the new APIs and is still compilable under Java 1.1.

they-got-so-much-right-why'd-they-get-this-one-wrong?-ly y'rs,
-Barry

[1] that I know of, without growing our own Java preprocessor

On 27 May 99, Graham Matthews wrote:

> I was wondering if this is seriously being considered -- that is
> implementing Python 2.0 in Java rather than C. While I understand
> that there are some technical challenges with this (notably interfacing
> to the existing C implemented extensions), I personally think there
> is a lot to be said for compiling Python to the JVM. For example:
> access to the Java apis, garbage collection, true compilation, the
> ability to write statically typed code (just write that part in Java!),
> access to Swing, promoting Python on the coat-tails of Java (free
> publicity and hype), etc.
>
> Comments?

While an implementation of Python in Java is a very nice thing to
have (see JPython), I would not be too happy if this were the *only*
version. Java does not run on every system or OS. This would mean
that there won't be, for instance, a Python 2.0 for DOS. (And maybe
other systems. Is there Java for the Amiga, for instance?) Now I know
that most people think that DOS is dead, and technically inferior, so
it won't be a big deal, but there are still quite a few DOS users
around, and it does have its advantages over Windows.

If it will be implemented in C or C++, I can't see how Python 2.0
will *not* compile for DOS, but in Java, it's a different bowl of
soup. Anyway, my point is not really that there should be a DOS
version, but... Right now Python can be built on just about any
system. That's because there's a C compiler for just about any
system. Choosing Java as implementation language would change that.
(And, for a working graphical implementation, one would need, say,
Java, Python and Tkinter...)

This argument may seem feeble but many users of less popular systems
are very glad that there's a Python available for them. I think it
would be desirable to keep it that way.

Why not write it in Caml? At least it will have proper garbage
collection then... :o))

Veel liefs,

--Hans Nowak (ivnowa@hvision.nl)
Homepage: http://fly.to/zephyrfalcon

Hans Nowak <ivnowa@hvision.nl> wrote:

: On 27 May 99, Graham Matthews wrote:

:> I was wondering if this is seriously being considered -- that is
:> implementing Python 2.0 in Java rather than C. While I understand
:> that there are some technical challenges with this (notably interfacing
:> to the existing C implemented extensions), I personally think there
:> is a lot to be said for compiling Python to the JVM. For example:
:> access to the Java apis, garbage collection, true compilation, the
:> ability to write statically typed code (just write that part in Java!),
:> access to Swing, promoting Python on the coat-tails of Java (free
:> publicity and hype), etc.
:>
:> Comments?

: While an implementation of Python in Java is a very nice thing to
: have (see JPython), I would not be too happy if this were the *only*
: version. Java does not run on every system or OS. This would mean
: that there won't be, for instance, a Python 2.0 for DOS. (And maybe
: other systems. Is there Java for the Amiga, for instance?) Now I know
: that most people think that DOS is dead, and technically inferior, so
: it won't be a big deal, but there are still quite a few DOS users
: around, and it does have its advantages over Windows.

: If it will be implemented in C or C++, I can't see how Python 2.0
: will *not* compile for DOS, but in Java, it's a different bowl of
: soup. Anyway, my point is not really that there should be a DOS
: version, but... Right now Python can be built on just about any
: system. That's because there's a C compiler for just about any
: system. Choosing Java as implementation language would change that.
: (And, for a working graphical implementation, one would need, say,
: Java, Python and Tkinter...)

: This argument may seem feeble but many users of less popular systems
: are very glad that there's a Python available for them. I think it
: would be desirable to keep it that way.

Not to mention that quite a few people here have mentioned that they
have been trying to port Python to embedded systems (as opposed to
embedding in an app).

Java is a nice-to-have (and we already have it), but the JVM cannot
deal with the world at the level that C can (or ever will by the nature
of the two languages).

-Arcege

Hans Nowak (ivnowa@hvision.nl) wrote:
: (And, for a working graphical implementation, one would need, say,
: Java, Python and Tkinter...)

What about Swing?

graham
--
Je suis pour le communisme
Je suis pour le socialisme
Je suis pour le capitalisme
Parce que je suis opportuniste

Graham Matthews <graham@sloth.math.uga.edu> wrote:
: Hans Nowak (ivnowa@hvision.nl) wrote:
: : (And, for a working graphical implementation, one would need, say,
: : Java, Python and Tkinter...)

: What about Swing?

Refer to some of the other threads about the viability of Swing on
various systems.

But I do have to ask, what do you find lacking with JPython, Graham?
It is Python written in Java, on the JVM, with full API support (as far
as I have determined), and supposed "true garbage collection". JPython
functions/methods are written in Java bytecode, not in Python bytecode
(according to the docs).

Not-encouraging-or-discouraging-ly' yrs
-Arcege

On 28 May 99, Graham Matthews wrote:

> Hans Nowak (ivnowa@hvision.nl) wrote:
> : (And, for a working graphical implementation, one would need, say,
> : Java, Python and Tkinter...)
>
> What about Swing?

Sorry, I don't dance. :)

--Hans Nowak (ivnowa@hvision.nl)
Homepage: http://fly.to/zephyrfalcon

> I was wondering if this is seriously being considered -- that is
> implementing Python 2.0 in Java rather than C. While I understand
> that there are some technical challenges with this (notably
> interfacing
> to the existing C implemented extensions), I personally think there
> is a lot to be said for compiling Python to the JVM. For example:
> access to the Java apis, garbage collection,
Personally I would hate it, if Python had ever adopted a garbage
collection without keeping a reference counting.
As many people have noted before, you would not be able to use
destructors to free up resources like memory or file descriptors.

> true compilation, the
Why would JVM generate a better code than Py2C does? Does the fact
that the app is spelled using javacode instead of pycode magically
remove the type inferencing problem?

> ability to write statically typed code (just write that part in
> Java!),
Just write that part in C !

> access to Swing, promoting Python on the coat-tails of Java
What makes Swing to be better than any of the existing Python GUI
bindings ?

> (free publicity and hype), etc.
Yeah. Right. Let's rewrite everything using the hottest
language of the day! ;-)

Vadim


Sent via Deja.com http://www.deja.com/
Share what you know. Learn what you don't.

Michael P. Reilly (arcege@shore.net) wrote:
: But I do have to ask, what do you find lacking with JPython, Graham?
: It is Python written in Java, on the JVM, with full API support (as far
: as I have determined), and supposed "true garbage collection". JPython
: functions/methods are written in Java bytecode, not in Python bytecode
: (according to the docs).

I have used JPython (that's where the orginal quote that started this
message came from). My point is that I think implementation via Java is
a good idea and I am wondering if that is being considered for the
future of CPython. ie. abandoning the CPython implementation as the
main Python and adopting a Java implementation instead (reversing the
status of CPython and JPython).

graham
--
Je suis pour le communisme
Je suis pour le socialisme
Je suis pour le capitalisme
Parce que je suis opportuniste

Graham Matthews:
: > true compilation, the
Vadim Chugunov (chega@my-deja.com) wrote:
: Why would JVM generate a better code than Py2C does?

Sure one can use Py2C. But with Java you get dynamic compilation of
all your code with no need to use some auxiliary program like Py2C.
cf. HotSpot.

Graham Matthews:
: > ability to write statically typed code (just write that part in
: > Java!),
Vadim Chugunov (chega@my-deja.com) wrote:
: Just write that part in C !

Techically you are correct that C is statically typed. But my post
clearly implies that I am interested in strong static typing. That
is type systems that ensure that code cannot have type errors at
runtime. You cannot do this in C. You can't quite do it in Java yet
either, but I am confident that will be so in the future via the
facilities for parametic polymorphism.

Graham Matthews:
: > access to Swing, promoting Python on the coat-tails of Java
Vadim Chugunov (chega@my-deja.com) wrote:
: What makes Swing to be better than any of the existing Python GUI
: bindings ?

Have you ever used Swing for anything? It is much cleaner that Tkinter
for example. It has a huge range of widgets, etc -- much more than
other toolkits. etc. etc. Sure there are bugs etc but Java is a new
product. Give it a few years and they will have gone away.

Graham Matthews:
: > (free publicity and hype), etc.
Vadim Chugunov (chega@my-deja.com) wrote:
: Yeah. Right. Let's rewrite everything using the hottest
: language of the day! ;-)

At this point it's the end of the thread for me. I was making a
serious suggestion that Python's use could be improved by pig
backing off the hype for Python. And you ...

graham
--
Je suis pour le communisme
Je suis pour le socialisme
Je suis pour le capitalisme
Parce que je suis opportuniste

>>>>> "GM" == Graham Matthews <graham@sloth.math.uga.edu> writes:

GM> Michael P. Reilly (arcege@shore.net) wrote: : But I do have to
GM> ask, what do you find lacking with JPython, Graham? : It is
GM> Python written in Java, on the JVM, with full API support (as
GM> far : as I have determined), and supposed "true garbage
GM> collection". JPython : functions/methods are written in Java
GM> bytecode, not in Python bytecode : (according to the docs).

GM> I have used JPython (that's where the orginal quote that started
GM> this message came from). My point is that I think implementation
GM> via Java is a good idea and I am wondering if that is being
GM> considered for the future of CPython. ie. abandoning the CPython
GM> implementation as the main Python and adopting a Java
GM> implementation instead (reversing the status of CPython and
GM> JPython).

That sounds like a good way to answer the question, because it allows
for any easy answer :-). I think it's safe to say that there is
absolutely no consideration given to abandoning CPython in favor of
JPython. Both versions will exist through Python 2.0.

The investment in C-based code and C programming expertise is large;
and it is unreasonable to expect that all that code and all those
people will be replaced by Java programs and programmers. Nor is it
likely that all that existing C code will be easily integrated into a
JVM via some Java native code interface. So there is going to
continue to be a need for CPython.

Jeremy

Speaking for myself, we are using Python as an embedded language for an
application to add scripting abilities to it. We decided to go with Python
instead of Java because of the C-Level interface. It gave us the confidence
that we could "hack" into Python when it was required. That would not be
practical for a Java version of Python.

The main thing I would like about JPython would be the Just In Time
compilers available for it.

-----Original Message-----
From: graham@sloth.math.uga.edu [mailto:graham@sloth.math.uga.edu]
Sent: Friday, May 28, 1999 4:14 PM
To: python-list@cwi.nl
Subject: Re: Python 2.0


Michael P. Reilly (arcege@shore.net) wrote:
: But I do have to ask, what do you find lacking with JPython, Graham?
: It is Python written in Java, on the JVM, with full API support (as far
: as I have determined), and supposed "true garbage collection". JPython
: functions/methods are written in Java bytecode, not in Python bytecode
: (according to the docs).

I have used JPython (that's where the orginal quote that started this
message came from). My point is that I think implementation via Java is
a good idea and I am wondering if that is being considered for the
future of CPython. ie. abandoning the CPython implementation as the
main Python and adopting a Java implementation instead (reversing the
status of CPython and JPython).

graham
--
Je suis pour le communisme
Je suis pour le socialisme
Je suis pour le capitalisme
Parce que je suis opportuniste

"Stidolph, David" wrote:
>
> Speaking for myself, we are using Python as an embedded language for an
> application to add scripting abilities to it. We decided to go with Python
> instead of Java because of the C-Level interface. It gave us the confidence
> that we could "hack" into Python when it was required. That would not be
> practical for a Java version of Python.

I wonder if this is truth of perception. I have not tried to extend a JVM
in many years but I wonder how easy/hard it woud be today. JNI is supposed
to do it and I know that Microsoft's proprietary extensions made it very
easy on Windows. I also know that Cygnus working on making C/Java
integration easy. I'd be interested in hearing about people's modern
experiences with Java/C integration.

Another thing to consider is whether we should really still be in the
mindset of manually hacking together languages. Isn't that what
COM/CORBA/OLE and a dozen other standards are supposed to do for us? I
kind of feel that things like SWIG and Perl's XSUB are too useful in that
they don't give us enough impetus to solve this problem once and for all
properly.

I hate to say it but you can do some pretty neat stuff on Windows talking
between languages without a bunch of custom glue code. Why is Unix so far
behind in this regard?

--
Paul Prescod - ISOGEN Consulting Engineer speaking for only himself
http://itrc.uwaterloo.ca/~papresco

Alabama's constitution is 100 years old, 300 pages long and has more than
600 amendments. Highlights include "Amendment 393: Amendment of Amendment
No. 351", "Validation of Laws Regulating Court Costs in Randolph County",
"Miscegenation laws", "Bingo Games in Russell County", "Suppression
of dueling". - http://www.legislature.state.al.us/ALISHome.html

On Thu, 27 May 1999, Paul Moore wrote:
>
> How would I embed Python in a C application, without a C API?

A Java-bytecode version of Python could have a C API. It could either
have a Python-specific C API or it could use JNI.

> And how
> would I distribute a C application with embedded (Java-) Python to
> machines with no JVM, assuming I don't want to (or don't have the
> capability to) distribute a JVM.

If you could distribute a PVM (Python Interpreter) then you could
distribute a JVM or PyJVM as easily, right?

Paul Prescod

Fred Pacquier wrote:
> Good point. As an example, a port of Python for the Psion Series 5
> (under the EPOC OS) came out shortly after the machine's release,
> thanks to a British hacker.

Since this will be the underlying OS for many cell phones (Nokia,
Erikson, Motorola, etc.) I suppose it won't be long before we
can starting hacking Python on our mobile telephones, yes?

Comments, Harri Pasanen?

just-because-you've-absconded-to-the-French-Riviera-doesn't
-mean-you-can-escape-the-Spanish-Inquisition-ly yr's,

-Jeff Bauer

James Logajan wrote:
>
> > I hate to say it but you can do some pretty neat stuff on Windows talking
> > between languages without a bunch of custom glue code. Why is Unix so far
> > behind in this regard?
>
> Unix is behind? In what way? Last I checked, Unix was an OS that has evolved
> to include useful things like threads, IPC mechanisms up the gazoo, dynamic
> linking, and other handy stuff. Now if you meant to say that Unix
> APPLICATIONS are behind, then you need to take your compliant to Unix app
> writers. CORBA is available on Unix and if app writers don't use it, well,
> what can I say?

You _could_ say that Unix apps are behind in this regard and you can push
application writers and OS vendors to fix it.

Of course I wasn't talking about the Unix *Kernel* but I also wasn't just
talking about Unix applications. What about "distributions" as they are
now called? Does AIX itself with CORBA? Is it source-level compatible with
CORBA on Solaris? Can I write a portable Unix app and depend on an ORB
being available? App writers don't use CORBA so vendors don't always
provide it. Vendors don't always provide it so app writers don't use it.
Result: Unix is behind.

When I can install a Linux distribution and use the same ORB to talk to
Gnome apps, KDE apps, Netscape and Apache then I will feel that at least
that variant of Unix will have caught up in this regard.

--
Paul Prescod - ISOGEN Consulting Engineer speaking for only himself
http://itrc.uwaterloo.ca/~papresco

Alabama's constitution is 100 years old, 300 pages long and has more than
600 amendments. Highlights include "Amendment 393: Amendment of Amendment
No. 351", "Validation of Laws Regulating Court Costs in Randolph County",
"Miscegenation laws", "Bingo Games in Russell County", "Suppression
of dueling". - http://www.legislature.state.al.us/ALISHome.html