Kay Schluehr wrote:
http://www.fiber-space.de/EasyExtend/doc/EE.html
Well, I have not read that page yet, but the name fiber space reminds
me of old
memories, when I was doing less prosaic things than now. Old times ..
;)
Michele Simionato
It fits quite nice with Python and is
Michele Simionato wrote:
Kay Schluehr wrote:
http://www.fiber-space.de/EasyExtend/doc/EE.html
Well, I have not read that page yet, but the name fiber space reminds
me of old
memories, when I was doing less prosaic things than now. Old times ..
;)
Michele Simionato
But I
Ken Tilton wrote:
Is there any experiemntal macro package out there for Python? Maybe a
preprocessor, at least? Or are there ways to actually hack Python to
extend the syntax?
Yes. I've just released EasyExtend that does this kind of job:
http://www.fiber-space.de/EasyExtend/doc/EE.html
It
Ok, I'm sorry. This kind of discussions between two groups of people,
neither of who know the other person's language very well just wind me
up something chronic! It wasn't your post as such, just reading through
most of the thread in one go.
That will teach me to post while cross :). Sorry for
[EMAIL PROTECTED] (Alex Martelli) writes:
Bill Atkins [EMAIL PROTECTED] wrote:
...
``allow ( as an ordinary single-character identifier'' as for the
unneded feature ``allow unnamed functions with all the flexibility of
named ones''.
Not so infeasible:
(let
Ben wrote:
This kind of discussions between two groups of people,
neither of who know the other person's language very well just wind me
up something chronic!
I must say, it is pretty funny how a flamewar turned into a pretty
interesting SoC project.
Anything that makes programming more
Ken Tilton [EMAIL PROTECTED] writes:
If you want to insist on how perfect your code is, please go find
ltktest-cells-inside.lisp in the source you downloaded and read the long
comment detailing the requirements I have identified for data integrity.
Then (a) tell me how your code fails at
Lasse Rasinen wrote:
Ken Tilton [EMAIL PROTECTED] writes:
If you want to insist on how perfect your code is, please go find
ltktest-cells-inside.lisp in the source you downloaded and read the long
comment detailing the requirements I have identified for data integrity.
Then (a) tell me how
Lasse Rasinen wrote:
Ken Tilton [EMAIL PROTECTED] writes:
if any concepts have survived to the Python version. Since Python's object
model is sufficiently different, the system is based on rules being
defined per-class...
That will be a total disaster for PyCells, if true. But I do not
Nothing you have described sounds that complicated, and you never come
up with concrete objections to other peoples code (apart that it took
10 years to write in Lisp, so it must be really hard)
Why are you running a SoC project for PyCells if you dislike the
language so much. People who do
Ben wrote:
Nothing you have described sounds that complicated, and you never come
up with concrete objections to other peoples code (apart that it took
10 years to write in Lisp, so it must be really hard)
Oh, now I have to spend an hour dissecting any code you people toss-off
that does
Ken Tilton wrote:
Ben wrote:
Nothing you have described sounds that complicated, and you never come
up with concrete objections to other peoples code (apart that it took
10 years to write in Lisp, so it must be really hard)
Oh, now I have to spend an hour dissecting any code you
[I trimmed some of the newsgroups away; this mostly concerns Python and Lisp]
Ken Tilton [EMAIL PROTECTED] writes:
Lasse Rasinen wrote:
Ken Tilton [EMAIL PROTECTED] writes:
if any concepts have survived to the Python version. Since Python's object
model is sufficiently different, the
Lasse Rasinen wrote:
[I trimmed some of the newsgroups away; this mostly concerns Python and Lisp]
Ken Tilton [EMAIL PROTECTED] writes:
Lasse Rasinen wrote:
Ken Tilton [EMAIL PROTECTED] writes:
if any concepts have survived to the Python version. Since Python's object
model is
Ken Tilton [EMAIL PROTECTED] wrote:
+---
| Having the reference implementation is the only thing that makes this
| conceivably doable in a summer. What you are missing is something I have
| often also gotten wrong: the core, cool functionality always comes easy
| in the
Ken Tilton [EMAIL PROTECTED] writes:
ps. flaming aside, PyCells really would be amazingly good for Python. And
so Google. (Now your job is on the line. g) k
Here's something I wrote this week, mostly as a mental exercise ;-)
The whole code is available at http://www.iki.fi/~lrasinen/cells.py,
Lasse Rasinen wrote:
Ken Tilton [EMAIL PROTECTED] writes:
ps. flaming aside, PyCells really would be amazingly good for Python. And
so Google. (Now your job is on the line. g) k
Here's something I wrote this week, mostly as a mental exercise ;-)
It's fun, right? But what you have is a
Ken Tilton [EMAIL PROTECTED] writes:
if any concepts have survived to the Python version. Since Python's object
model is sufficiently different, the system is based on rules being
defined per-class...
That will be a total disaster for PyCells, if true. But I do not think it
is. You just
Alexander Schmolck [EMAIL PROTECTED] writes:
I think that in most contexts lexical transparency is desirable so that
deviations from lexical transparency ought to be well motivated. I also
believe that a construct that is usually used to establish a lexically
transparent binding shouldn't be
Ken Tilton [EMAIL PROTECTED] writes:
I think the point is that, with the variable actually being just
a string and with dedicated new explicit functions required as
accessors, well, you could hack that up in any language with
dictionaries. It is the beginnings of an interpreter, not Python
Alexander Schmolck [EMAIL PROTECTED] writes:
I'd like to see a demonstration that using the same binding syntax
for special and lexical variables buys you something apart from bugs.
There are 3 fundamental operations related to plain mutable variables:
A1. Making a new mutable variable with
jayessay wrote:
Michele Simionato [EMAIL PROTECTED] writes:
I can't get this to work at all - syntax errors (presumably you must
have 2.5?, I only have 2.4).
You can download Python 2.5 from www.python.org, but the important bit,
i.e. the use of threading.local to get thread-local variables is
Michele Simionato [EMAIL PROTECTED] writes:
I was interested in a proof of concept, to show that Python can
emulate Lisp special variables with no big effort.
OK, but the sort of proof of concept given here is something you can
hack up in pretty much anything. So, I wouldn't call it
jayessay [EMAIL PROTECTED] writes:
Michele Simionato [EMAIL PROTECTED] writes:
I was interested in a proof of concept, to show that Python can
emulate Lisp special variables with no big effort.
OK, but the sort of proof of concept given here is something you can
hack up in pretty much
Michele Simionato wrote:
jayessay wrote:
I was saying that you are mistaken in that pep-0343 could be used to
implement dynamically scoped variables. That stands.
Proof by counter example:
from __future__ import with_statement
import threading
special = threading.local()
def
Alexander Schmolck wrote:
jayessay [EMAIL PROTECTED] writes:
Michele Simionato [EMAIL PROTECTED] writes:
I was interested in a proof of concept, to show that Python can
emulate Lisp special variables with no big effort.
OK, but the sort of proof of concept given here is something you can
Ken Tilton [EMAIL PROTECTED] writes:
In Common Lisp we would have:
(defvar *x*) ;; makes it special
(setf *x* 1)
(print *x*) ;;- 1
(let ((*x* 2))
(print *x*)) ;; - 2
(print *x*) ;; - 1
You seem to think that conflating special variable binding and lexical
Alexander Schmolck [EMAIL PROTECTED] writes:
Ken Tilton [EMAIL PROTECTED] writes:
In Common Lisp we would have:
(defvar *x*) ;; makes it special
(setf *x* 1)
(print *x*) ;;- 1
(let ((*x* 2))
(print *x*)) ;; - 2
(print *x*) ;; - 1
You seem to think that
Ken Tilton [EMAIL PROTECTED] writes:
Alexander Schmolck wrote:
jayessay [EMAIL PROTECTED] writes:
Michele Simionato [EMAIL PROTECTED] writes:
I was interested in a proof of concept, to show that Python can
emulate Lisp special variables with no big effort.
OK, but the sort of
Alexander Schmolck [EMAIL PROTECTED] writes:
(defvar *x*) ;; makes it special
(setf *x* 1)
(print *x*) ;;- 1
(let ((*x* 2))
(print *x*)) ;; - 2
(print *x*) ;; - 1
You seem to think that conflating special variable binding and lexical
variable binding is a
Duane Rettig [EMAIL PROTECTED] writes:
Alexander Schmolck [EMAIL PROTECTED] writes:
Ken Tilton [EMAIL PROTECTED] writes:
In Common Lisp we would have:
(defvar *x*) ;; makes it special
(setf *x* 1)
(print *x*) ;;- 1
(let ((*x* 2))
(print *x*)) ;; - 2
Alexander Schmolck wrote:
Ken Tilton [EMAIL PROTECTED] writes:
In Common Lisp we would have:
(defvar *x*) ;; makes it special
(setf *x* 1)
(print *x*) ;;- 1
(let ((*x* 2))
(print *x*)) ;; - 2
(print *x*) ;; - 1
You seem to think that conflating special
Alexander Schmolck [EMAIL PROTECTED] writes:
Ken Tilton [EMAIL PROTECTED] writes:
In Common Lisp we would have:
(defvar *x*) ;; makes it special
(setf *x* 1)
(print *x*) ;;- 1
(let ((*x* 2))
(print *x*)) ;; - 2
(print *x*) ;; - 1
You seem to think
Ken Tilton [EMAIL PROTECTED] writes:
Alexander Schmolck wrote:
jayessay [EMAIL PROTECTED] writes:
Michele Simionato [EMAIL PROTECTED] writes:
I was interested in a proof of concept, to show that Python can
emulate Lisp special variables with no big effort.
OK, but the sort of proof
Alexander Schmolck [EMAIL PROTECTED] writes:
Ken Tilton [EMAIL PROTECTED] writes:
Alexander Schmolck wrote:
jayessay [EMAIL PROTECTED] writes:
Michele Simionato [EMAIL PROTECTED] writes:
I was interested in a proof of concept, to show that Python can
emulate Lisp special
Alexander Schmolck [EMAIL PROTECTED] writes:
Duane Rettig [EMAIL PROTECTED] writes:
Alexander Schmolck [EMAIL PROTECTED] writes:
Ken Tilton [EMAIL PROTECTED] writes:
In Common Lisp we would have:
(defvar *x*) ;; makes it special
(setf *x* 1)
(print *x*) ;;- 1
Duane Rettig [EMAIL PROTECTED] writes:
My reason for responding to you in the first place was due to your poor use
of the often misused term bug. You could have used many other words or
phrases to describe the situation, and I would have left any of those alone.
I'm happy to accept your
jayessay [EMAIL PROTECTED] writes:
Great -- so can I see some code? Can't be that difficult, it takes about
10-15
lines in python (and less in scheme).
Do you actually need the code to understand this relatively simple concept???
Yes. I'd be genuinely curious to see how an
Ken Tilton [EMAIL PROTECTED] writes:
Alexander Schmolck wrote:
Ken Tilton [EMAIL PROTECTED] writes:
In Common Lisp we would have:
(defvar *x*) ;; makes it special
(setf *x* 1)
(print *x*) ;;- 1
(let ((*x* 2))
(print *x*)) ;; - 2
(print *x*) ;; - 1
You
Alexander Schmolck wrote:
Duane Rettig [EMAIL PROTECTED] writes:
Alexander Schmolck [EMAIL PROTECTED] writes:
Ken Tilton [EMAIL PROTECTED] writes:
In Common Lisp we would have:
(defvar *x*) ;; makes it special
(setf *x* 1)
(print *x*) ;;- 1
(let ((*x* 2))
(print
Paul Rubin wrote:
Alexander Schmolck [EMAIL PROTECTED] writes:
(defvar *x*) ;; makes it special
(setf *x* 1)
(print *x*) ;;- 1
(let ((*x* 2))
(print *x*)) ;; - 2
(print *x*) ;; - 1
You seem to think that conflating special variable binding and lexical
variable
Everything else responded to separately, but...
I'd like to see a demonstration that using the same binding syntax for special
and lexical variables buys you something apart from bugs.
Buys me something? Why do I have to sell simplicity, transparency, and
clean syntax on c.l.python?
kenny
Chris Uppal wrote:
E.g. can you add three-way comparisons (less-than, same-as, greater-than to,
say, Python with corresponding three-way conditional control structures to
supplement if etc ? Are they on a semantic and syntactic par with the
existing ones ? In Smalltalk that is trivial (too
jayessay wrote:
I was saying that you are mistaken in that pep-0343 could be used to
implement dynamically scoped variables. That stands.
Proof by counter example:
from __future__ import with_statement
import threading
special = threading.local()
def getvar(name):
return
Chris Uppal wrote:
Petr Prikryl wrote:
for element in aCollection:
if element 0:
return True
return False
[I'm not sure whether this is supposed to be an example of some specific
language (Python ?) or just a generic illustration. I'll
Ken Tilton [EMAIL PROTECTED] writes:
David C. Ullrich wrote:
But duh, if that's how things are then we can't have transitive
dependencies working out right; surely we
want to be able to have B depend on A and then C
depend on B...
(And also if A and B are allowed to depend on each
Michele Simionato [EMAIL PROTECTED] writes:
jayessay wrote:
I was saying that you are mistaken in that pep-0343 could be used to
implement dynamically scoped variables. That stands.
Proof by counter example:
from __future__ import with_statement
import threading
special =
jayessay wrote:
Michele Simionato [EMAIL PROTECTED] writes:
jayessay wrote:
I was saying that you are mistaken in that pep-0343 could be used to
implement dynamically scoped variables. That stands.
Proof by counter example:
from __future__ import with_statement
import threading
Alex Martelli wrote...
Joe Marshall wrote:
...
If you language allows unnamed integers, unnamed strings, unnamed
characters, unnamed arrays or aggregates, unnamed floats, unnamed
expressions, unnamed statements, unnamed argument lists, etc. why
*require* a name for trivial
Alex Martelli wrote:
Stefan Nobis [EMAIL PROTECTED] wrote:
[EMAIL PROTECTED] (Alex Martelli) writes:
if anonymous functions are available, they're used in even more
cases where naming would help
Yes, you're right. But don't stop here. What about expressions? Many
people write very complex
Op 2006-05-09, Pisin Bootvong schreef [EMAIL PROTECTED]:
Antoon Pardon wrote:
Op 2006-05-09, Pisin Bootvong schreef [EMAIL PROTECTED]:
Antoon Pardon wrote:
Op 2006-05-09, Pisin Bootvong schreef [EMAIL PROTECTED]:
Is this a Slippery Slope fallacious argument?
[EMAIL PROTECTED] (Alex Martelli) writes:
But if we can agree to name every function except continuations I'll be
content
FWIW, I disagree:
A simple example, doubling each entry in a list:
map (*2) xs
vs. let double x = x*2 in map double xs
Here's another example, extracting all
Ketil Malde [EMAIL PROTECTED] wrote:
+---
| Sometimes the best documentation is the code itself.
| Sometimes the best name for a function is the code itself.
+---
And there's no reason that an anonymous LAMBDA [even if compiled]
couldn't store its source code in the name
I do wonder what would happen to Cells if I ever want to support
multiple threads. Or in a parallel processing environment.
AFAIK It should be fine.
In LW, SBCL and ACL all bindings of dynamic variables are thread-local.
Cheers,
Sean.
--
http://mail.python.org/mailman/listinfo/python-list
Ken Tilton wrote:
Now if you are like most
people, you think that means X. It does not.
As far as natural language and understanding are concerned, to mean means
conformity to what most people understand, Humpty Dumpties notwithstanding.
Cheers.
--
Bill Atkins wrote:
It's interesting how much people who don't have macros like to put
them down and treat them as some arcane art that are too *insane*ly
powerful to be used well.
They're actually very straightforward and can often (shock of shocks!)
make your code more readable, without
Chris Uppal wrote...
Alex Martelli wrote:
I think it's reasonable to make a name a part of functions, classes and
modules because they may often be involved in tracebacks (in case of
uncaught errors): to me, it makes sense to let an error-diagnosing
tracebacks display packages, modules,
Petr Prikryl wrote:
for element in aCollection:
if element 0:
return True
return False
[I'm not sure whether this is supposed to be an example of some specific
language (Python ?) or just a generic illustration. I'll take it as the
latter, since
Ken Tilton wrote:
I was not thinking about the thread issue (of which I know little). The
big deal for Cells is the dynamic bit:
(let ((*dependent* me))
(funcall (rule me) me))
Then if a rule forces another cell to recalculate itself, *dependent*
gets rebound and (the fun
Bill Atkins wrote:
My favorite macro is ITERATE [...]
Thanks for the examples.
-- chris
--
http://mail.python.org/mailman/listinfo/python-list
On Tue, 09 May 2006 05:35:47 -0500, David C. Ullrich
[EMAIL PROTECTED] wrote:
On Mon, 08 May 2006 18:46:57 -0400, Ken Tilton [EMAIL PROTECTED]
wrote:
[...]
If you, um, look at the code you see that cells.a = 42 triggers
cells.__setattr__, which fires a's callback; the callback then
reaches
Followup-To: comp.lang.lisp
Bill Atkins [EMAIL PROTECTED] writes:
The cool thing about ITERATE is that it lets you express looping
concepts in a language designed explicitly for such a purpose, e.g.
(iter (for x in '(1 3 3))
(summing x)) = 7
(iter (for x in '(1 -3 2))
David C Ullrich asked:
Q: How do we ensure there are no loops in the dependencies?
Do we actually run the whole graph through some algorithm
to verify there are no loops?
The question you are asking is the dependency graph a directed
acyclic graph (commonly called a DAG)? One algorithm to
sross wrote:
I do wonder what would happen to Cells if I ever want to support
multiple threads. Or in a parallel processing environment.
AFAIK It should be fine.
In LW, SBCL and ACL all bindings of dynamic variables are thread-local.
Ah, I was guilty of making an unspoken segue: the
M Jared Finder [EMAIL PROTECTED] wrote:
...
Your reasoning, taken to the extreme, implies that an assembly language,
by virtue of having the fewest constructs, is the best designed language
Except that the major premise is faulty! Try e.g.
M Jared Finder wrote:
Alex Martelli wrote:
Stefan Nobis [EMAIL PROTECTED] wrote:
[EMAIL PROTECTED] (Alex Martelli) writes:
if anonymous functions are available, they're used in even more
cases where naming would help
Yes, you're right. But don't stop here. What about expressions? Many
Boris Borcic wrote:
Ken Tilton wrote:
Now if you are like most people, you think that means X. It does not.
As far as natural language and understanding are concerned, to mean
means conformity to what most people understand, Humpty Dumpties
notwithstanding.
Nonsense. You are
Boris Borcic wrote:
Bill Atkins wrote:
It's interesting how much people who don't have macros like to put
them down and treat them as some arcane art that are too *insane*ly
powerful to be used well.
They're actually very straightforward and can often (shock of shocks!)
make your code
[Sorry, I missed this one originally.]
David C. Ullrich wrote:
On Tue, 09 May 2006 05:35:47 -0500, David C. Ullrich
[EMAIL PROTECTED] wrote:
On Mon, 08 May 2006 18:46:57 -0400, Ken Tilton [EMAIL PROTECTED]
wrote:
[...]
If you, um, look at the code you see that cells.a = 42 triggers
Michele Simionato [EMAIL PROTECTED] writes:
Ken Tilton wrote:
I was not thinking about the thread issue (of which I know little). The
big deal for Cells is the dynamic bit:
(let ((*dependent* me))
(funcall (rule me) me))
Then if a rule forces another cell to
Randal L. Schwartz wrote:
Alex == Alex Martelli [EMAIL PROTECTED] writes:
Alex The difference, if any, is that gurus of Java, C++ and Python get to
Alex practice and/or keep developing their respectively favorite languages
Alex (since those three are the blessed general purpose languages for
Chris F Clark wrote:
David C Ullrich asked:
Q: How do we ensure there are no loops in the dependencies?
Do we actually run the whole graph through some algorithm
to verify there are no loops?
The question you are asking is the dependency graph a directed
acyclic graph (commonly called
jayessay wrote:
Michele Simionato [EMAIL PROTECTED] writes:
Ken Tilton wrote:
I was not thinking about the thread issue (of which I know little). The
big deal for Cells is the dynamic bit:
(let ((*dependent* me))
(funcall (rule me) me))
Then if a rule forces
Ketil Malde wrote:
Sometimes the best documentation is the code itself. Sometimes the
best name for a function is the code itself.
Absolutely. When I take over someone else's code I begin by deleting all
the comments. Then I read the code. If a variable or function name makes
no sense
Ken Tilton wrote:
Boris Borcic wrote:
Ken Tilton wrote:
Now if you are like most people, you think that means X. It does not.
As far as natural language and understanding are concerned, to mean
means conformity to what most people understand, Humpty Dumpties
notwithstanding.
Alex Martelli wrote:
Joe Marshall [EMAIL PROTECTED] wrote:
...
The problem is that a `name' is a mapping from a symbolic identifier to
an object and that this mapping must either be global (with the
attendant name collision issues) or within a context (with the
attendant question of
Michele Simionato [EMAIL PROTECTED] writes:
jayessay wrote:
Michele Simionato [EMAIL PROTECTED] writes:
Ken Tilton wrote:
I was not thinking about the thread issue (of which I know little). The
big deal for Cells is the dynamic bit:
(let ((*dependent* me))
Ken Tilton [EMAIL PROTECTED] writes:
Set Kelvin, and make Celsius and Fahrneheit functions of that.
Or Rankine:-)
--
Robert Uhl http://public.xdi.org/=ruhl
Brought to you by 'Ouchies', the sharp, prickly toy you bathe with...
--
http://mail.python.org/mailman/listinfo/python-list
Cameron Laird wrote:
In article [EMAIL PROTECTED],
Alex Martelli [EMAIL PROTECTED] wrote:
... .
Of course, the choice of Python does mean that, when we really truly
need a domain specific little language, we have to implement it as a
language in its own right, rather than
Kenny replied to me saying:
Yep. But with Cells the dependency graph is just a shifting record of
who asked who, shifting because all of a sudden some outlier data will
enter the system and a rule will branch to code for the first time,
and suddenly depend on on some new other cell (new as in
Ken Tilton [EMAIL PROTECTED] writes:
sross wrote:
I do wonder what would happen to Cells if I ever want to support
multiple threads. Or in a parallel processing environment.
AFAIK It should be fine.
In LW, SBCL and ACL all bindings of dynamic variables are thread-local.
Ah, I was guilty of
Joe Marshall [EMAIL PROTECTED] wrote:
Alex Martelli wrote:
Joe Marshall [EMAIL PROTECTED] wrote:
...
The problem is that a `name' is a mapping from a symbolic identifier to
an object and that this mapping must either be global (with the
attendant name collision issues) or within
Alex Martelli wrote:
Stefan Nobis [EMAIL PROTECTED] wrote:
[EMAIL PROTECTED] (Alex Martelli) writes:
if anonymous functions are available, they're used in even more
cases where naming would help
Yes, you're right. But don't stop here. What about expressions? Many
people write very
Alex Martelli wrote:
M Jared Finder [EMAIL PROTECTED] wrote:
...
Your reasoning, taken to the extreme, implies that an assembly language,
by virtue of having the fewest constructs, is the best designed language
Except that the major premise is faulty! Try e.g.
M Jared Finder [EMAIL PROTECTED] wrote:
...
Any time you want an anonymous function (or class, or type, or number)
it would be because that thing is sufficiently small and simple that the
best name for it is the code itself. In one game I worked on, there was
That's not what I see happen
Kaz Kylheku wrote:
Now imagine you had to do this with every object.
def add_five(x)
# return x + 5 -- anonymous integer literal, not allowed!!!
five = 5 # define it first
return x + five
I mentioned that as Slippery slope fallacious argument in other reply.
[...]
[EMAIL PROTECTED] (Alex Martelli) writes:
Any time you want an anonymous function (or class, or type, or number)
it would be because that thing is sufficiently small and simple that the
best name for it is the code itself.
In the real world, people don't choose anonymous functions only in
Ken Tilton wrote:
Python has a weak lambda, statements do not always
return values, it does not have macros, and I do not know if it has
special variables.
I am pretty much ignorant of Common Lisp, but I have the impression
they are the
same as Scheme parameters, i.e. thread-local dynamically
Alex Martelli wrote:
yes, if that was my only
choice, I'd much rather use small, simple Scheme than huge, complicated,
rich, powerful Common Lisp. ((But in this case I'm biased by early
experiences, since when I learned and used Lisp-ish languages there WAS
no Common Lisp, while Scheme was
Op 2006-05-09, Pisin Bootvong schreef [EMAIL PROTECTED]:
Joe Marshall wrote:
Alex Martelli wrote:
Most languages allow `unnamed numbers'. The `VAT_MULTIPLIER' argument
is a
strawman. Would you want to have to use a special syntax to name the
increment
in loop?
defnumber zero 0
Pisin Bootvong [EMAIL PROTECTED] wrote:
+---
| No matter how scalable your language is, you cannot make a 100MHz/128MB
| server serve 100,000 client a second over the internet.
+---
Sure you can! That's ~1000 CPU cycles/request, which [assuming at least
a 100BASE-TX NIC]
Rob Warnock wrote:
Pisin Bootvong [EMAIL PROTECTED] wrote:
+---
| No matter how scalable your language is, you cannot make a 100MHz/128MB
| server serve 100,000 client a second over the internet.
+---
Sure you can! That's ~1000 CPU cycles/request, which [assuming at
[EMAIL PROTECTED] (Alex Martelli) writes:
if anonymous functions are available, they're used in even more
cases where naming would help
Yes, you're right. But don't stop here. What about expressions? Many
people write very complex expression, that are hard to understand. A
good language should
Pisin Bootvong [EMAIL PROTECTED] wrote:
+---
| Rob Warnock wrote:
| | No matter how scalable your language is, you cannot make a
| | 100MHz/128MB server serve 100,000 client a second over the internet.
| +---
|
| Sure you can! That's ~1000 CPU cycles/request, which
Antoon Pardon wrote:
Op 2006-05-09, Pisin Bootvong schreef [EMAIL PROTECTED]:
Is this a Slippery Slope fallacious argument?
(http://c2.com/cgi/wiki?SlipperySlope)
No it is not.
[...]
So the question I have is: Why is requiring me to give this function
a name considered a good thing,
Alex Martelli wrote:
I think it's reasonable to make a name a part of functions, classes and
modules because they may often be involved in tracebacks (in case of
uncaught errors): to me, it makes sense to let an error-diagnosing
tracebacks display packages, modules, classes and
Op 2006-05-09, Pisin Bootvong schreef [EMAIL PROTECTED]:
Antoon Pardon wrote:
Op 2006-05-09, Pisin Bootvong schreef [EMAIL PROTECTED]:
Is this a Slippery Slope fallacious argument?
(http://c2.com/cgi/wiki?SlipperySlope)
No it is not.
[...]
So the question I have is: Why is requiring
On Mon, 08 May 2006 18:46:57 -0400, Ken Tilton [EMAIL PROTECTED]
wrote:
David C. Ullrich wrote:
On 08 May 2006 12:53:09 -0700, [EMAIL PROTECTED] (Thomas
F. Burdick) wrote:
Ken Tilton [EMAIL PROTECTED] writes:
No, you do not want on-change handlers propagating data to other
slots, though
Stefan Nobis [EMAIL PROTECTED] wrote:
[EMAIL PROTECTED] (Alex Martelli) writes:
if anonymous functions are available, they're used in even more
cases where naming would help
Yes, you're right. But don't stop here. What about expressions? Many
people write very complex expression, that
Alex == Alex Martelli [EMAIL PROTECTED] writes:
Alex The difference, if any, is that gurus of Java, C++ and Python get to
Alex practice and/or keep developing their respectively favorite languages
Alex (since those three are the blessed general purpose languages for
Alex Google - I say general
1 - 100 of 260 matches
Mail list logo
