OT(Slightly): Thanks to Python.

[Adonis]

This is my .02 as to why Python is excellent for academic use for
upcoming CS graduates. Since I have been 14 I have been programming, mainly
BASIC/VB/C/C++ so I was familiarized with basic programming concepts. Then
up until more than 1 1/2yr ago I stumbled into Python, looking for a C/C++
compiler for windows, and Python kept coming up, so I go to check it out
(this was on www.downloads.com) I download it, installed it, and ran to the
all common newbie problem of running IDLE and thinking that this is all that
Python had to offer, I naivly deleted it, thinking it was probably some
novelty language, that had no support for it. I check out python.org and
notice it was very active, and there was a more up to date version out, so I
download it again, this time I read the documentation and followed the
tutorial, within 15 minutes I already had enough under my belt to start on
small projects, which within a week I already had made a great deal, I was
hooked! Cutting to the chase, Python introduced me to the world of OOP,
which in VB I mildy touched its pseudo OOP methods, but have not been fully
exposed to it.
Now Python being a fully OOP language, it made it easier for me to
understand what all this OOP stuff was, from generating events to
inheritance, and organizing my code into reusable modules and the such.
Also, the clarity in which Python syntax is presented made it MUCH easier to
understand any source, this was a big plus as I was studying other persons
works to enhance my knowledge of Python.
Then this year I started in a local university to persue my CS degree
after undergoing a 2yr college, in my university the language of choice for
the CS program is Java which I was actually dissappointed as I wanted to
expand my knowledge of C/C++ which I already had some prior knowledge about,
but nevertheless with my background in Python, giving me the knowledge of
OOP I dove into Java like a pro, everything came easy to me, I fully
understood the language, everything was just some clarification and learning
the syntax (I still dislike Java, but to each its own), so I am writing this
as a thank you to everyone who contributes to Python.

Sincerely,
Adonis

 

[Ben Finney]

with my background in Python, giving me the knowledge of OOP I dove
into Java like a pro, everything came easy to me, I fully understood
the language, everything was just some clarification and learning the
syntax (I still dislike Java, but to each its own), so I am writing
this as a thank you to everyone who contributes to Python.

Python has introduced many students to the benefits of
properly-implemented OOP. It's good to know that you've got this strong
start.

It may interest you to know that Python's suitability as a language for
teaching programming has long been a conscious goal of the language's
creator, and something with which he actively involves himself:

<http://www.linuxjournal.com/article.php?sid=5028>
<http://www.artima.com/intv/pyscale.html>

 

[Guest]

I hear that quite a few people who were working with Java in the past are
now switching to Python, especially as Java code balloons in size when
compared to Python.

 

[Aahz]

Python has introduced many students to the benefits of
properly-implemented OOP. It's good to know that you've got this strong
start.

Gee, I must be *really* sick: it took me four tries before I stopped
reading this as "poorly-implemented OOP".

 

[David M. Cook]

Gee, I must be *really* sick: it took me four tries before I stopped
reading this as "poorly-implemented OOP".

I would call it *pragmatically* implemented OOP. It's not "proper" as some
would see it.

Dave Cook

 

[Ville Vainio]

David> I would call it *pragmatically* implemented OOP. It's not
David> "proper" as some would see it.

Elaborate?

 

[John Roth]

David> I would call it *pragmatically* implemented OOP. It's not
David> "proper" as some would see it.

Elaborate?

As I understand it, there are a number of issues.

1. Lack of method polymorphism

2. Use of built-in functions instead of "proper" methods.

3. ability to declare functions and variables at the
module level.

As far as I am concerned, 2 and 3 are so whats.
1 would be nice at times, but there's no way it's
going to happen in a language that doesn't have
static typing.

John Roth

 

[Michael Hudson]

As far as I am concerned, 2 and 3 are so whats. 1 would be nice at
times, but there's no way it's going to happen in a language that
doesn't have static typing.

Well, it's called multiple dispatch. Could be done, but it's quite a
paradigm shift.

Cheers,
mwh

 

[Bob Ippolito]

Well, it's called multiple dispatch. Could be done, but it's quite a
paradigm shift.

I've seen quite a few implementations of multiple dispatch in Python,
based on types, tests, or adaptations/interfaces... but obviously none
of them can be represented in the function signature [yet, ...]

-bob

 

[David M. Cook]

David> I would call it *pragmatically* implemented OOP. It's not
David> "proper" as some would see it.

Elaborate?

Python lacks access controls (private/protected etc), though you can use __
name munging.

Dave Cook

 

[Christopher Koppler]

[David M Cook]:

I would call it *pragmatically* implemented OOP. It's not
"proper" as some would see it.

[Ville Vainio]:

Elaborate?

[John Roth]

As I understand it, there are a number of issues.

1. Lack of method polymorphism

2. Use of built-in functions instead of "proper" methods.

3. ability to declare functions and variables at the
module level.

Ad 2 and 3... well, practicality/pragmatism beats purity, once again.
Right now I'm struggling with the stupidity of Java (whether it's got
properly implemented OOP is another issue) in order to get certified
(since doing Python for a living is as yet a severely limited option
for me, despite evangelism). Guess I'm just spoiled.
Ad 1... I've yet to get involved in projects big/complicated enough
where I could conceivably benefit from that, so I don't miss it.

Christopher

 

[Jacek Generowicz]

David> I would call it *pragmatically* implemented OOP. It's not
David> "proper" as some would see it.

Elaborate?

As I understand it, there are a number of issues.

1. Lack of method polymorphism
[...]

1 would be nice at times, but there's no way it's
going to happen in a language that doesn't have
static typing.

Sigh ...

* (defmethod foo ((x integer))
(format t "~&~s is an integer" x))
#<Standard-Method FOO (INTEGER) {480054CD}>


* (defmethod foo ((x string))
(format t "~&~s is a string" x))
#<Standard-Method FOO (STRING) {4800ABED}>


* (foo 2)
2 is an integer


* (foo "hello")
"hello" is a string


The ANSI standard for the _dynamically typed_ language shown above,
which implements the behaviour you claim will "never happen in a
language that doesn't have static typing", is about a decade old. (The
capability itself is at least another decade older.)

 

[JanC]

* (defmethod foo ((x integer))

* (defmethod foo ((x string))

The ANSI standard for the _dynamically typed_ language shown above,

Maybe someone can explain, but the above doesn't look like "dynamic typing"
to me...?