Complementary language?
HackingYodel
language than Python for this. The ideal situation, for me, would be to
study two languages at the same time. Probably sounds crazy, but it
works out better for me. Being a newbie, I find almost all languages
fascinating. C, D, Objective-C, Ocaml, C++, Lisp, how is a non-tech to
choose? Does any single language do a better job in Python's weaker
areas? Would anyone care to suggest one to supplement Python. That is,
if you could only use Python and one other language, which would it be?
Thank you for your time and help.
Nick Coghlan
Python (CPython - aka standard - implementation) and C would be my preferred
combination.
The reason is that I often work with hardware, and hardware means C (since every
vendor I have ever dealt with provides a C API for their drivers).
It combines well with the CPython interpreter as that, as you may have guessed
from the name, is written in C and exports a direct C/API.
Cheers,
Nick.
--
Nick Coghlan | ncog...@email.com | Brisbane, Australia
---------------------------------------------------------------
http://boredomandlaziness.skystorm.net
LutherRevisited
combines them in a way.
Haibao Tang
be productive is C# and C++, I chose C# because I am a Windows
programmer (don't throw tomato at me, I am no troll..) and I choose C++
because the algorithm was implemented in this dialect in school.
Robert Kern
Depends on what you want to get out of the second language. (Disclosure:
I only use Python, C, and FORTRAN on a regular basis. Any of my comments
about other languages should be liberally salted.)
For use *with* Python, C could be helpful. I end up writing a little bit
of C or C++ every once in a while to speed up my calculations or to use
some library written in C or C++.
If you do numeric calculations, learning just enough FORTRAN to do loops
and math can be quite useful. I find that F2PY makes writing FORTRAN
subroutines for numerical calculations over Numeric arrays much easier
than C.
If you develop on a Mac, some Objective-C could come in handy. I find
that it's object model and dynamism are quite close to Python's. The
lessons you learn in each should reinforce the other's. PyObjC makes
mixing the two languages dead easy and more convenient than indoor
plumbing. However, almost all Objective-C texts require knowledge of C
(which makes sense, since Objective-C is a true superset of C, unlike C++).
For didactic purposes, I suggest picking something distinctly *less*
like C/Java/Python. Learn something that's going to expand the way you
think about programming. And when you learn a new paradigm, implement it
in Python and share it with the rest of us. :-) For example, Phillip
J. Eby took the idea of "generic functions" from the Common Lisp Object
System and implemented it for us[1]. (BTW, thank you, Phillip.)
Common Lisp might be a good one to learn. It's even more
"multi-paradigm" than Python. You could very easily learn more
approaches to programming through Common Lisp than three other
languages. This book[2] looks promising.
Summary recommendation: Learn Python and a language that complements it
*pedagogically*. When you are fluent in Python and encounter a problem
where you want to, for example, use a library written in C, then learn
some C.
[1] http://dirtsimple.org/2004/11/generic-functions-have-landed.html
[2] http://www.gigamonkeys.com/book/
--
Robert Kern
rk...@ucsd.edu
"In the fields of hell where the grass grows high
Are the graves of dreams allowed to die."
-- Richard Harter
Mike Meyer
It depends on what your goals are. Python is an excellent language for
learning OO and procedural programming, and makes it possible to learn
functional programming as well.
Part of the Python philosphy is that there should be one obvious way
to do something. That's what makes it an attractive language to
me. Eiffel shares this philosphy, in that every feature of the
language was added to solve a specific problem that programmers
encounter. It does many other things the exact opposite of
Python. It's statically typed, with no loopholes allowed. For cases
where you're not sure that something is conformant with a variable
(meaning it's the same class as the variable or inherits from it in
some way), there's even a "work if you can" assignment operator. So
you see code that looks like:
a ?= b
if a /= Void then
doSomethingWith(a)
else
doSomethingElseWith(b)
end
As you can see, it keywords instead of :. It's pure OO, in that there
are no free-standing functions; every function is a method of a
class. Functions aren't first-class objects, so you can invoke
parameterless methods with just object.method. This allows subclasses
to change such a method to a variable without you having to change any
code anywhere else in the system. It has export rules to control what
features (shorthand for methods and instance/class variables) are
visible to what other classes. Exceptions are handled in a completely
different method as well, with a method having an optional "rescue"
clause that gets invoked when an exception is raised, should repair
things, and then retries the method.
The key feature is "Design by Contract". Each method can have a set of
boolean expressions that must be true when the method is invoked, or
an exception is raised. Likewise, each method has a set of boolean
expressions that must be true when the function exits, or an exception
is raised. Finally, there's a set of expressions that are always true
when an externally-invoked method exits. These are the contracts, and
they make debugging wonderful. You can disable all those checks for
production code.
There are tools to display the the method headers, header comment, and
contracts (short form). There is a tool to display all methods a class
has, including inherited methods (flat form), and of course there's a
tool that displays the shortflat form.
If you want to do GUI programming on Windows, Linux or FreeBSD 5.x,
EiffelStudio is probably your best bet. It comes with a standard GUI
library, an IDE built on that library, and a reasonably
standards-compliant compiler and library. It hasn't yet drifted into
the parts of the language that are undergoing experimental changes.
<mike
--
Mike Meyer <m...@mired.org> http://www.mired.org/home/mwm/
Independent WWW/Perforce/FreeBSD/Unix consultant, email for more information.
Hal Rosser
"HackingYodel" <taoiststarter@-nospam-yahoo.com> wrote in message
news:cqkuvp$l5e$1...@news.chatlink.com...
Java. Because of Jython.
Perfect partners. They can work together.
---
Outgoing mail is certified Virus Free.
Checked by AVG anti-virus system (http://www.grisoft.com).
Version: 6.0.818 / Virus Database: 556 - Release Date: 12/17/2004
gene...@gmail.com
http://advogato.org/
http://c2.com/cgi/wiki?WelcomeVisitors
www.artima.com
It's a big world out there, you can glimpse Haskell, LUA, CLU, scheme,
squeak etc.
Disclaimer: going into these sites is liking going into REM sleep when
it's 95 degrees Fahrenheit (hot) and really humid
Alex Martelli
I assume you mean _programming_ language in the strict sense, because,
otherwise, I think SQL (which is more of a _query_ language) or XML
(which is a _markup_ lanugage) might be more "urgent" learning needs
than any second _programming_ language. So, within programming...:
Probably C, but Pyrex is also a strong contender for _use_. Problem is,
there are a zillion great books on C, none on Pyrex: thus, having to
choose one of them, C enjoys a huge advantage in _learning_. Also,
while Pyrex is amazingly mature and solid, it no doubt still has some
little way to go -- for example, the pypy project had to introduce a
small extension to Pyrex (the ability to inject inline C code, namely
labels and goto statements) in order to use Pyrex as the target for code
generation -- while C's completeness and stability are indisputable.
C's key advantages: it has much the same _philosophy_ as Python --
simplicity, lack of redundancy, trust in the programmer -- while aiming
squarely at the LOW end of language levels, closer to the machine, as
much as Python aims squarely at the HIGH end, closer to application
programming needs. This makes them a great complement for each other.
Pyrex is close to "C with Python syntax" and is designed for ease of
interfacing with Python, generating on your behalf all the boilerplate
code that you'd normally need to do the interfacing with the Python C
API directly. Still, I've never taught Pyrex to anybody who didn't
already know at least _some_ C, so it feels risky to recommend as "the
one othe language besides Python"...
I haven't looked at D enough to judge whether it's fully portable, fully
stable, and just as easy to interface with Python as C; also, I don't
know how the material available for it compares to C's excellence.
Objective-C is cool... on the Mac; I'm not sure how well-supported it is
elsewhere, though. In addition to C's advantages, it would let you make
Cocoa GUIs on the Mac easily (with PyObjC &c). But then, the right way
to study Obj-C from scratch is no doubt to start with C, anyway.
OCAML and other modern functional languages are great, but not
particularly easy to use in cooperation with Python. If you had to pick
one for purely cultural purposes, though, I'd suggest Haskell... simpler
and sharper... OCAML is relatively Big and Rich, which may be a
practical plus but for study purposes is rather a minus, I think. Much
the same applies to (Common) Lisp and C++: huge languages, very rich,
which may be a plus for practical production uses but surely isn't for
study purposes.
Alex
Alex Martelli
> Common Lisp might be a good one to learn. It's even more
> "multi-paradigm" than Python. You could very easily learn more
> approaches to programming through Common Lisp than three other
> languages. This book[2] looks promising.
If you're looking for SERIOUS multiparadigmaticity, I think Oz may be
best -- <http://www.info.ucl.ac.be/people/PVR/book.html> (the book's
authors critique the vagueness of the "paradigm" concept, and prefer
"model", but that's much the same thing).
You start with pure declarative programming (aka "functional" in many
circles), move on to concurrency in a purely declarative worldview
(easiest way to see concurrency), then enrich both sequential and
concurrent models as the book progresses, by message-passing, explicit
state ("procedural"), object-oriented, _shared_ state, and finally
relational. GUI, distributed, and constraint-based programming round
out a grandiose conceptual tour.
"SICP for the 21st Century"...? (SICP: google for it!). I currently
think so, though, studying CTMCP (the Oz book) in my spare time, it will
take me a while before I've finished it and can fairly offer such a
lofty recommendation for it... still, I notice from the back-page blurbs
that Peter Norvig has no reservations drawing a parallel with SICP (aka
Abelson and Sussman), and Norvig's assessment must count for more than
mine!
Alex
Paul Rubin
> Hello all! I'm learning to program at home. I can't imagine a better
> language than Python for this. The ideal situation, for me, would be
> to study two languages at the same time.
It's less a matter of languages, than ways of approaching problems.
Have you read SICP yet? If not, that's your next task. The full
text is online:
Robin Becker
.....
>
> If you're looking for SERIOUS multiparadigmaticity, I think Oz may be
> best -- <http://www.info.ucl.ac.be/people/PVR/book.html> (the book's
> authors critique the vagueness of the "paradigm" concept, and prefer
> "model", but that's much the same thing).
according to the language shootout at
http://shootout.alioth.debian.org/benchmark.php?test=all&lang=all&sort=cpu
Mozart/Oz comes last in cpu score. I suspect that may be due to
unfamilarity or poor implementation of the test codes. Everybody 'knows'
that benchamrks are always wrong, but which score moves this language to
the top in your opinion?
>
> Alex
--
Robin Becker
gabriele renzi
He's talking of just "multiparadigmaticality", not efficiency.
The mozart/Oz platform have a stronger point on stuff like
constraint/logic/declarative concurren/etc programming, more than most
of the CL frameworks (not that this is hard in CL, it's just not as
central as in Oz). Btw, I think AliceML (which just hit 1.0) would be
better than Oz, if accompaniying with python, just to have a
dynamic/static contrast :)
Alex Martelli
Hmmm, I'm not sure how to parse this question. Robert Kern claimed:
"You could very easily learn more approaches to programming through
Common Lisp than three other languages", and I'm pointing out that, if
what you're after is to "learn more approaches to programming" via the
built-in features of a single language, Oz (with the CTMCP book) may
well be numero uno. Judging from the blurb on the book's back, as I
also mentioned, Norvig, hardly a slouch when it comes to Lisp, appears
to share this assessment.
What the "language shootout" can possibly have to do with this issue
entirely escapes me. Quite apart from "benchmarks are always wrong", I
don't think they're even _remotely_ trying to benchmark "how much does
learning this language teach you about different approaches to
programming" -- it would seem to be a mighty tall order to even set up a
controlled experiment to measure _that_ quantitatively!
Alex
Robin Becker
> Robin Becker <ro...@SPAMREMOVEjessikat.fsnet.co.uk> wrote:
>
>
>>Alex Martelli wrote:
>>.....
>>
>>>If you're looking for SERIOUS multiparadigmaticity, I think Oz may be
>>>best -- <http://www.info.ucl.ac.be/people/PVR/book.html> (the book's
>>>authors critique the vagueness of the "paradigm" concept, and prefer
>>>"model", but that's much the same thing).
>>
>>according to the language shootout at
>>
>>http://shootout.alioth.debian.org/benchmark.php?test=all&lang=all&sort=cpu
>>
>>Mozart/Oz comes last in cpu score. I suspect that may be due to
>>unfamilarity or poor implementation of the test codes. Everybody 'knows'
>>that benchamrks are always wrong, but which score moves this language to
>>the top in your opinion?
>
>
> Hmmm, I'm not sure how to parse this question. Robert Kern claimed:
> "You could very easily learn more approaches to programming through
> Common Lisp than three other languages", and I'm pointing out that, if
> what you're after is to "learn more approaches to programming" via the
> built-in features of a single language, Oz (with the CTMCP book) may
> well be numero uno. Judging from the blurb on the book's back, as I
> also mentioned, Norvig, hardly a slouch when it comes to Lisp, appears
> to share this assessment.
Well your utility function seems to be related to "learn more approaches
to programming". I suspect there may be some programming language
measure which would push really high level languages way up. Simply
scanning the Mozart documentation seems to indicate it has a number of
interesting, but not unique features. From the outside it seems
difficult to say whether say "distributed programming" is uniquely
easily implemented in Oz or whether it's something like pyro built using
more primitive constructs.
>
> What the "language shootout" can possibly have to do with this issue
> entirely escapes me. Quite apart from "benchmarks are always wrong", I
> don't think they're even _remotely_ trying to benchmark "how much does
> learning this language teach you about different approaches to
> programming" -- it would seem to be a mighty tall order to even set up a
> controlled experiment to measure _that_ quantitatively!
...
I agree entirely with this last, but this is about language comparisons
and if we're being objective we need to do some measurements. If this is
impossible then discussion reduces to 'my language is better than yours'
which is pretty futile.
> Alex
>
--
Robin Becker
beli...@aol.com
>If you do numeric calculations, learning just enough FORTRAN to do
loops
>and math can be quite useful. I find that F2PY makes writing FORTRAN
>subroutines for numerical calculations over Numeric arrays much easier
>than C.
I agree with this and would add that Fortran, from the 1990 standard
onwards, is one of the few compiled languages that support both array
operations and multidimensional array slices, like the Python Numeric
and Numarray modules (and lists for 1-D arrays). There is a free
Fortran 95 compiler called g95 at http://www.g95.org .
In some ways, the syntax of Python is closer to free format Fortran
than C.
Maybe the message
http://groups-beta.google.com/group/comp.lang.python/msg/5de999e28ead0dd9
I wrote with comparative statistics on some programming languages could
be informative.
Alex Martelli
...
> >>>If you're looking for SERIOUS multiparadigmaticity, I think Oz may be
> > Hmmm, I'm not sure how to parse this question. Robert Kern claimed:
> > "You could very easily learn more approaches to programming through
> > Common Lisp than three other languages", and I'm pointing out that, if
> > what you're after is to "learn more approaches to programming" via the
> Well your utility function seems to be related to "learn more approaches
> to programming".
Which part of "if" do you find hard to parse?
> I suspect there may be some programming language
> measure which would push really high level languages way up. Simply
"Language Level" as defined in
<http://www.theadvisors.com/langcomparison.htm> (first google hit for
"language level" _without_ quotes) might be a starting point. If one
were to study accurately (as opposed to "eyeball it", as theadvisors.com
does too often) LL for, say, Lisp, Oz, OCAML, Ruby, Perl, Python, I
doubt one would find statistically significant consistent differences
across a broad range of domains, though.
> scanning the Mozart documentation seems to indicate it has a number of
> interesting, but not unique features. From the outside it seems
> difficult to say whether say "distributed programming" is uniquely
> easily implemented in Oz or whether it's something like pyro built using
> more primitive constructs.
I've browsed just enough Erlang to get a taste for a way to do
distributed programming that's reasonably higher-level -- Michael Hobbs'
candygram.sf.net might be the Python equivalent, but I believe it only
does the concurrency, not the distribution. What I expect from Oz
(haven't gotten that far in the book yet) is "more of the same",
didactically speaking -- encompassing various degrees of statefulness in
an elegant and conceptually clear way -- while I believe Erlang only
reaches to single-assignment level.
> I agree entirely with this last, but this is about language comparisons
> and if we're being objective we need to do some measurements. If this is
> impossible then discussion reduces to 'my language is better than yours'
> which is pretty futile.
I do not agree with the underlying axiom that all human endeavours
_must_ be numerically measurable or else can't be meaningfully
discussed. One could see this restrictive view of discourse as
equivalent to what Wittgenstein in his '20s was exposing in the
Tractatus (although I'd argue that would be a too-narrow reading of the
Tractatus) and my preferred stance as equivalent to Wittgenstein's more
mature reflection e.g. in the Untersuchungen. There, this is a
self-referential example: would it be futile to compare the worldviews
in Wittgenstein's major works and see the latter, more mature one as
wider and more useful and applicable than the extremist, youthful one,
just because it's silly to even think about quantifying the difference?
I most definitely don't think so. Ultimately, it's about the natural
history of human beings -- this applies to programming just as well as
(per Wittgenstein) to other allegedly "rigorous" discourse (say, on the
foundations of logic, set theory, &c).
It's not _conceptually impossible_ to measure the didactical values of
different endeavours in terms of enhancing skills at some given target
tasks; it _is_, however, prohibitively costly, in most cases, to perform
properly controlled double-blind experiments of this nature. In this
case, as in most other similar ones in real life, we're not even given a
precise set of target tasks, just (as is perfectly reasonable) a generic
potential desire to _learn about different approaches to programming_.
I think it would be silly to try to stop people from desiring to learn
something even when they can't quantify the eventual success at such
learning endeavours. It's not just a matter of _programming languages_:
I have argued in the past that studying Borges or Calvino, Korzibsky or
Wittgenstein, category theory or nonmodal logic, can all be very
effective ways to broaden your thinking towards different approaches to
reasoning about the world, and therefore to design programs. Can I
quantify the benefits, from this POV, of studying Korzibski for a
semester, versus those of spending the same amount of time and energy
studying Borges? No, and I believe it's silly to even try to.
Alex
Alex Martelli
> The mozart/Oz platform have a stronger point on stuff like
> constraint/logic/declarative concurren/etc programming, more than most
> of the CL frameworks (not that this is hard in CL, it's just not as
> central as in Oz). Btw, I think AliceML (which just hit 1.0) would be
> better than Oz, if accompaniying with python, just to have a
> dynamic/static contrast :)
Nolo contendere (not having looked much into Alice yet), but are there
stand-alone didactical materials for Alice as there are for Oz? It
seemed to me that the available materials for Alice basically take SML
somewhat for granted, while Oz does come with tutorials which make no
analogous assumptions. If you're recommending Alice as the second
language for somebody whose first and only language so far is Python,
what URLs and/or books would you point them to, for self-stufy?
Alex
Cameron Laird
Robin Becker <ro...@SPAMREMOVEjessikat.fsnet.co.uk> wrote:
.
.
.
>interesting, but not unique features. From the outside it seems
>difficult to say whether say "distributed programming" is uniquely
>easily implemented in Oz or whether it's something like pyro built using
>more primitive constructs.
.
.
>I agree entirely with this last, but this is about language comparisons
>and if we're being objective we need to do some measurements. If this is
>impossible then discussion reduces to 'my language is better than yours'
>which is pretty futile.
.
.
"... distributed ...", "mine is better than yours", and
complements Python: 'sounds like Erlang <URL:
http://phaseit.net/claird/comp.lang.functional/Erlang.html >
to me.
Robin Becker
>
>>Well your utility function seems to be related to "learn more approaches
>>to programming".
>
>
> Which part of "if" do you find hard to parse?
>
no part
>
>>I suspect there may be some programming language
>>measure which would push really high level languages way up. Simply
>
>
> "Language Level" as defined in
> <http://www.theadvisors.com/langcomparison.htm> (first google hit for
> "language level" _without_ quotes) might be a starting point. If one
> were to study accurately (as opposed to "eyeball it", as theadvisors.com
> does too often) LL for, say, Lisp, Oz, OCAML, Ruby, Perl, Python, I
> doubt one would find statistically significant consistent differences
> across a broad range of domains, though.
>
so if these languages are equivalent the cpu measure might have some
value ;)
....
>
>
>>I agree entirely with this last, but this is about language comparisons
>>and if we're being objective we need to do some measurements. If this is
>>impossible then discussion reduces to 'my language is better than yours'
>>which is pretty futile.
>
>
> I do not agree with the underlying axiom that all human endeavours
> _must_ be numerically measurable or else can't be meaningfully
.....
I take this to mean that comparisons can be done some other way. If so a
rationalist such as myself would want them used. Discussing
Wittgenstein will probably not assist me if logic/mathematics can't.
Human languages are also not comparable numerically, but that doesn't
stop linguists from comparing and classifying them. I suppose there must
be an equivalent dissection for the fundamental concepts of CS languages.
> It's not _conceptually impossible_ to measure the didactical values of
> different endeavours in terms of enhancing skills at some given target
> tasks; it _is_, however, prohibitively costly, in most cases, to perform
> properly controlled double-blind experiments of this nature. In this
> case, as in most other similar ones in real life, we're not even given a
> precise set of target tasks, just (as is perfectly reasonable) a generic
> potential desire to _learn about different approaches to programming_.
>
I was thinking that perhaps indirect measures might assist; perhaps
teachability, popularity etc could be used. I work with some student
interns. They are asked to learn haskell, their teachers like it and the
students mostly hate it. I suspect that Oz has more 'features' so
teachers will like it.
> I think it would be silly to try to stop people from desiring to learn
> something even when they can't quantify the eventual success at such
> learning endeavours.....
I'm certainly not attempting to stop any doing anything.
>
>
> Alex
--
Robin Becker
HackingYodel
I'm going to investigate all of them as time allows. I must say that
Eiffel would most certainly expand my mind. My initial reaction, when
looking at a "Hello World!" program, was "No way!". I had just read
some of SICP and "Pascal is for building pyramids imposing,
breathtaking, static structures built by armies pushing heavy blocks
into place. Lisp is for building organisms imposing, breathtaking,
dynamic structures built by squads fitting fluctuating myriads of
simpler organisms into place." sprang to mind, with Eiffel replacing
Pascal in this quote. Attempting to be fair, I surfed over to
eiffel.com. Eiffel has a lot of "high-minded" concepts, and it's easy
for a rookie, such as myself, to become inundated. Ironically, while
watching Eiffel.com's presentation of "Design by Contract", my Gnome
desk top's control-panel crashed with a segmentation fault error
(seconds before the spill about how reliable DBC made Eiffel). Much I
could learn from Eiffel.
SICP was another invaluable suggestion! MIT uses it as part of their
OpenCourse program, so now I have a complete and free course in addition
to this excellent text. Thank you.
I will inspect Fortran, Mozart/Oz, Erlang, AliceML, and all other
recommendations. Thanks again for the help. Perhaps I will be able to
contribute to the Python community soon.
gabriele renzi
> Nolo contendere (not having looked much into Alice yet), but are there
> stand-alone didactical materials for Alice as there are for Oz?
> It
> seemed to me that the available materials for Alice basically take SML
> somewhat for granted, while Oz does come with tutorials which make no
> analogous assumptions. If you're recommending Alice as the second
> language for somebody whose first and only language so far is Python,
> what URLs and/or books would you point them to, for self-stufy?
>
>
> Alex
probably not, AFAIK, and that's something I did'nt think of, thanks for
pointing out.
Anyway, the Alice homepage references some ml tutorials for that subset
of the language and documentation for the specific extensions.
Probably a unified tutorial would be much better, anyway, I agree.
Mike Meyer
> Objective-C is cool... on the Mac; I'm not sure how well-supported it is
> elsewhere, though. In addition to C's advantages, it would let you make
> Cocoa GUIs on the Mac easily (with PyObjC &c). But then, the right way
> to study Obj-C from scratch is no doubt to start with C, anyway.
Objective-C is part of the Gnu Compiler Collection. As such, it's
probably easy to find a working compiler. But I agree - you probably
want to start with C.
As an aside, if you want to study Eiffel, the book to buy is _Object
Oriented Software Construction_, second edition, by Bertrand
Meyer. Everybody doing OO software should read this book, as the
lessons about constructing inheritance hierarchies are invaluable,
even if the language won't enforce them for you.
Alex Martelli
> ale...@yahoo.com (Alex Martelli) writes:
>
> > Objective-C is cool... on the Mac; I'm not sure how well-supported it is
> > elsewhere, though. In addition to C's advantages, it would let you make
> > Cocoa GUIs on the Mac easily (with PyObjC &c). But then, the right way
> > to study Obj-C from scratch is no doubt to start with C, anyway.
>
> Objective-C is part of the Gnu Compiler Collection. As such, it's
> probably easy to find a working compiler. But I agree - you probably
> want to start with C.
BTW, I wouldn't give the same advice re C++ -- if C++ is what you want
to know you're probably better off studying C++ itself. But ObjC is
neatly partitioned into two sublanguages... C plus a smalltalk-like OO
part... and it seems to me that this makes C the natural starting point.
> As an aside, if you want to study Eiffel, the book to buy is _Object
> Oriented Software Construction_, second edition, by Bertrand
> Meyer. Everybody doing OO software should read this book, as the
> lessons about constructing inheritance hierarchies are invaluable,
> even if the language won't enforce them for you.
Even though I'm not enthusiastic about Eiffel per se, I can second the
recommendation about Meyer's book; it's interesting and instructive as
one very thorough and well-developed vision of OOP.
Alex
Donn Cave
I can't disagree very much with that, but in the vein of
answering the original question I think it's fair to
assign some weight to a language's practical utility.
For me, anyway, a language will be more instructive if
it really is a practical alternative, because then I will
obviously be much more motivated to use it.
Accordingly I should put in a vote here for Objective CAML.
Cf. http://caml.inria.fr/ . (Note the separate documentation
for Camlp4, specifically the "revised syntax". Objective CAML's
original syntax has some bad warts, but it's optional.) It's
a modern functional programming language, so it's good for
knowing what you're missing when people talk about using Python
for FP. There's also a rigorously typed OOP layer, which
introduces a few issue that Python sort of "ducks". (I haven't
spent a lot of time in the OOP layer, but I believe in a way
it formalizes "duck typing", rather than the inheritance based
type system that some languages are saddled with.) So for a
Python programmer it's all about learning different approaches
to programming, but this one is also a really competitive
language for software development. Not a gem, but not a toy.
Someone who already has Objective CAML and Python on hand
might be interested in Felix, http://felix.sourceforge.net.
I haven't actually used it, and for all I know it fails my
utility test since it is not a very mature language, but
I mention in in case anyone is interested in what the author
of the "vyper" Python implementation is up to these days.
Donn Cave, do...@u.washington.edu
Martin Drautzburg
> Does any single language do a better job in
> Python's weaker areas? Would anyone care to suggest one to supplement
> Python.
My first real OO language was Smalltalk. But the existing Smalltalk
implementations all have some severe shortcomings. Either they are
incomplete (Squeak), have no active community (Smalltalk/X) or they
are real expensive and bulky (VisualWorks, VisualAge). But
conceptually all these Smalltalk systems give me the feeling "thats
what OO should be like".
Python OTOH was the best compromise I could find, beeing reasonably
OO, fairly complete and free - and I am very happy with it.
I am one order of magnitude more productive in Python than in Java but
a little less productive than in Smalltalk. To wet your appetite let
me telly you, that in Python you have much shorter turnaround times
than in Java, because you don't have to compile your code after you
fixed a bug. In Smalltalk you don't even have to restart your
application, i.e. developping and running an application melts
together. It's like "doing brain surgery to yourself" as someone said.
So if you are interested to look at something even more radically OO
than Python you might want to give Squeak (http://www.squeak.org) a
try. Alan Kay, the guy wo coined the term "Object oriented" is one if
its fathers.
Alan Gauld
<taoiststarter@-nospam-yahoo.com> wrote:
> Hello all! I'm learning to program at home. I can't imagine a better
> language than Python for this. The ideal situation, for me, would be to
> works out better for me.
Me too, thats why my web tutorial features Python, VBSCript and
Javascript. (The previous version had BASIC and Tcl with Python)
> fascinating. C, D, Objective-C, Ocaml, C++, Lisp, how is a non-tech to
> choose? Does any single language do a better job in Python's weaker
> areas?
C is better at low level stuff, Prolog is better at declaratie
programming and Haskell is better at functional programming.
Lisp/Scheme are good for giving a good theoretical understanding
(try the SICP and HTDP web sites). And Tcl has a really different
approach which is plain fun to grapple with :-)
I chose VBScript and JavaScript because they have similar
structure to Python (traditional imperative programming
with OOP) but very different syntax. Plus they were free and
easily available (albeit with VBScript limited to Windows
users, who are 80+% of my visitors). Javascript is especially
useful since its an easy lead in to learning C/C++, Java,
even Perl to some extent and a lot of sample code sites
use those languages.
Alan G.
Author of the Learn to Program website
http://www.freenetpages.co.uk/hp/alan.gauld
Premshree Pillai
<alan....@btinternet.com> wrote:
> On Sat, 25 Dec 2004 18:40:31 -0500, HackingYodel
> <taoiststarter@-nospam-yahoo.com> wrote:
> > Hello all! I'm learning to program at home. I can't imagine a better
> > language than Python for this. The ideal situation, for me, would be to
> > study two languages at the same time. Probably sounds crazy, but it
> > works out better for me.
Yes, the best way to learn a new language is probably to compare it
with some other language (of the same paradigm) that you are already
familiar with. The best part about Python is that there really isn't
much "learning" involved. Python comes closest to what you'd call
"pseudocode".
If you know your English, you probably know Python. :D
>
> Me too, thats why my web tutorial features Python, VBSCript and
> Javascript. (The previous version had BASIC and Tcl with Python)
>
> > fascinating. C, D, Objective-C, Ocaml, C++, Lisp, how is a non-tech to
> > choose? Does any single language do a better job in Python's weaker
> > areas?
>
> C is better at low level stuff, Prolog is better at declaratie
> programming and Haskell is better at functional programming.
> Lisp/Scheme are good for giving a good theoretical understanding
> (try the SICP and HTDP web sites). And Tcl has a really different
> approach which is plain fun to grapple with :-)
>
> I chose VBScript and JavaScript because they have similar
> structure to Python (traditional imperative programming
> with OOP) but very different syntax. Plus they were free and
> easily available (albeit with VBScript limited to Windows
> users, who are 80+% of my visitors). Javascript is especially
> useful since its an easy lead in to learning C/C++, Java,
> even Perl to some extent and a lot of sample code sites
> use those languages.
>
> Alan G.
> Author of the Learn to Program website
> http://www.freenetpages.co.uk/hp/alan.gauld
> --
> http://mail.python.org/mailman/listinfo/python-list
>
--
Premshree Pillai
http://www.livejournal.com/~premshree