Yes they do, and, AFAICS from the docs, the power consumption for the Athlon 64 Mobiles are comparable to the P-Ms'. They're also ~1/2 as expensive as comparable P-Ms (savings are on the order of 150-250 USD/unit in bulk, iirc). But A64 doesn't give you Internet access on the K2. Seriously, it is a question of marketing and semi-knowledgeable people believing that AMD => hotter.
*Adds more content* BTW, rabies has quite an itneresting way of spreading. Our neurons can be a meter long or more, and there's next to no metabolic activity on the axonal end (when compared to the pericaryon, the neuron's body). So, for the rest of the neuron to feed and communicate with the axon, there are two transport systems that go both ways. Rabies simply hitchhikes the slow stream that goes upstream to the pericharyon to travel from the periphery to the middle of the body:) That explains why we vaccinate people against rabbies after the fact: if the virus entered the body far enough from the central nervous system, the vaccine may have enough time to do its job. So, erh, if you ever have to be bitten by a rabid animal, make sure it bites you on the foot and not on the face!
Think of it on a larger scale. It wouldn't trigger all the time, so it's not immediately a disadvantage. However, once the group has gotten large enough, it could evolve faster by quickening the death of weaker elements. And, then, the group could become dominant.
Note, I'm on win32, but I found allegro (Franz) to have a very nice environment. However, the constraints it puts on the evaluation/student version are very harsh, and it tends to crash very hard if you use badly-defined foreign-functions:) The problem is, I really don't feel like using another GUI interface... Anyway, if you go to http://alu.cliki.net/Success%20Stories, you'll find more information on large applications developped in CL.
Depending on the implementation, you can get some type checking (CMUCL and SBCL do type inference a lot, iirc).
While ML has type checking, it also needs a different operator for each type of argument. It probably affects refactoring a little and is sort of annoying, but nothing serious.
Just consider the Lisp "system" as a library. Depending on the smartness of the compiler, it can be shaken down to a smaller size.
FFI isn't exactly hard to do. From UFFI's (LGPL) manual: def-function name args &key module returning
Bah syntax. Both our opinions are probably extremely well anchored:)
How's Lisp harder to use imperatively? Just about every control operator has an implicit progn.
Faster. Often true, but how much so? Lisp, with annotations and compiled for speed instead of safety, is pretty to close to C. (Here's the last troll-induced response I can remember: http://home.comcast.net/~bc19191/blog/040308.html) . However, how much and how often does it matter?
For some reason, even normal unflavoured vodka has an aroma for me:( It might be placebo or something, but the aroma is why I prefer Polar Ice (go canucks!:) to Absolut, not because it scored better or worse on some test. So, while I agree that there's a lot of marketing going on, and that vodka is the _current_ fad (even teen chick lit does it! see Gossip Girl), I believe that many people would be able to distinguish their favourite vodka from another one.
I love both series, and I don't believe a lot of ripping off happened, if at all. The "baddies" are diametrically different and DA's storyline had potentially (grr) more depth. Still, kudos to the DA team for giving us tridimensional antagonists. I loved Lydecker in so many ways;)
a) Infix? Because we all know that familiarity makes right. COBOL, is that you? Precedence is messy, and we all know how to disambiguate: parens. The only time it could be a disadvantage is when you are copying a formula. Even then it only means that you must assimilate the formula instead of mindlessly typing it (usually a Good Thing, especially with "special" numeric towers). But then, I also prefer RPN.
b) First/rest, etc. But those are the only ones i can think of in common use. When you get to low-level stuff like handling individual bits or bytes, you get a nice taste of PDP assembly mnemonics, but that's it. The p-convention is pretty clear. PROGN? PROG -> a block (a program), N -> return the nth (last) value). Prefix something with n -> it's destructive. Postfix with f -> it works with places (usually meaning it side-effects). I suppose */&, ++/--, unary_-, ^, >, += (et al), camelCaseClasses/NotCamelCaseClasses/reallybadclas ses (Java...) are all much more intuitive. In the end, things like that don't really affect the learning curve that much, especially with the CLHS's concept dictionaries and the fact that most of the more obscure ones aren't needed very often. And, a more important point, apart from certain particularly abusive cases (mostly graphics apps, imho), the learning curve doesn't matter as much as the usage. I wouldn't recommend choosing languages based on how easy they are to learn in the first minutes. One might as well stick to recorded macros in that case.
c) It's called indentation. C-M-q, or something else in your favourite editor. What's nice about it is that, when lines get too long you can simply put a new line where you want. The indenting rules are clear and regular enough that it'll still work fine. I find it is much simpler for me to arrange sexps as I like, instead of having to indent even extremely small ones. It also means that even when indentation is ambiguous (badly formatted code, use of tabs, different views on what is important), you can re-indent it with your editor or reshape the lines a bit to put in evidence what you think is important. Plus, parsing sexp is so easy that building another way of expliciting scope is easy. In fact, that was my first foray into real emacs scripting.
http://www.pvk.ca/misc/misc.jpg (a screenshot of the script, used on itself) http://www.pvk.ca/misc/spectrum-density.J PG (to show the size of the possible colour/saturation[not exactly the right word, but i carries the meaning alright] - the bottleneck is with my eyes)
I don't use it, because I don't need it, but it was a nice experiment. Arguments further right go further in the reg-green-blue spectrum, and deeper sexps are more saturated.
d) Lisp is more than 2.5 times as old as me. How can I be a "Lisp die-hard [who] sticks to Lisp", and not a new user? Guess what, most of us have been virgin new users once too. If you can't see past car/cdr, see b).
TI = what students buy because school tells them to/everyone has them. HP, with its RPN, is still about loyalty and catering to those who know better;) Check out c.s.hp48 - the user base has written a ******* manual that's better than the original! Hopefully, we'll have an alternative by the time Carly will have totally killed off the calculator division.
"The discoverers sought such a formula because they were aware that it could be used to compute the nth digit of Pi (in base 16), without computing any prior digits. This goes completely against conventional wisdom, and totally eliminates high-precision requirements from a computation of, say, the billionth hexadecimal digit!"
And braino on my part: the advantage is that you CAN use FP, without having to use arbitrary precision math.
Still, by your logic, we should add integers on the FPU instead of the ALU, right? Integer operations are still faster.
Well, depending on the architecture and the languages, linked lists can be easy:)
http://en.wikipedia.org/wiki/VList
"In computer science, the VList is a persistent data structure designed by Phil Bagwell in 2002 that combines the fast indexing of arrays with the easy extension of cons-based (or singly-linked) linked lists.
Like arrays, VLists have constant-time lookup on average and are highly compact, requiring only O(log n) storage for pointers, allowing them to take advantage of locality of reference. Like singly-linked or cons-based lists, they are persistent, and elements can be added to or removed from the front in constant time. Length can also be found in O(log n) time."
"The underlying structure of a VList can be seen as a singly-linked list of arrays whose sizes decrease geometrically; in its simplest form, the first contains the first half of the elements in the list, the next the first half of the remainder, and so on."
For some reason, the article affirms that the VList is immutable.
Slashdot Mirror
negative versus positive right.
Well if that's how they call themselves...
I don't think the PRC is popular or a republic, but I'm still calling it by the name they give themselves.
RISC Vs CISC was over years ago. They've both have sort of CISCy frontends (look at that OoO scheduling :/) with RISC core.
Again, we use for GUI programming. There are OpenGL bindings (etc). I don't see how games are not a subset of GUIs.
Yes they do, and, AFAICS from the docs, the power consumption for the Athlon 64 Mobiles are comparable to the P-Ms'. They're also ~1/2 as expensive as comparable P-Ms (savings are on the order of 150-250 USD/unit in bulk, iirc). But A64 doesn't give you Internet access on the K2. Seriously, it is a question of marketing and semi-knowledgeable people believing that AMD => hotter.
It was, however, an educated guess. They didn't just play darts on a list of meds.
Lisp is a general purpose programming language. If it can be used for GUIs, why can't it be used for game programming?
Yeah, but were the three other people vaccinated?
:) That explains why we vaccinate people against rabbies after the fact: if the virus entered the body far enough from the central nervous system, the vaccine may have enough time to do its job. So, erh, if you ever have to be bitten by a rabid animal, make sure it bites you on the foot and not on the face!
*Adds more content* BTW, rabies has quite an itneresting way of spreading. Our neurons can be a meter long or more, and there's next to no metabolic activity on the axonal end (when compared to the pericaryon, the neuron's body). So, for the rest of the neuron to feed and communicate with the axon, there are two transport systems that go both ways. Rabies simply hitchhikes the slow stream that goes upstream to the pericharyon to travel from the periphery to the middle of the body
If you read the RFC for IRC, you'll see that they have planned for a secure model. The only problem is that no one uses the mode.
But then, using equal temperament on normal intruments is a sick travesty :)
But the same note (B#) is the same note (B#).
Think of it on a larger scale. It wouldn't trigger all the time, so it's not immediately a disadvantage. However, once the group has gotten large enough, it could evolve faster by quickening the death of weaker elements. And, then, the group could become dominant.
Note, I'm on win32, but I found allegro (Franz) to have a very nice environment. However, the constraints it puts on the evaluation/student version are very harsh, and it tends to crash very hard if you use badly-defined foreign-functions :) The problem is, I really don't feel like using another GUI interface... Anyway, if you go to http://alu.cliki.net/Success%20Stories, you'll find more information on large applications developped in CL.
(here, Lisp = Common Lisp)
:unsigned-char)) :int)) :returning :int)
:)
) . However, how much and how often does it matter?
Depending on the implementation, you can get some type checking (CMUCL and SBCL do type inference a lot, iirc).
While ML has type checking, it also needs a different operator for each type of argument. It probably affects refactoring a little and is sort of annoying, but nothing serious.
Just consider the Lisp "system" as a library. Depending on the smartness of the compiler, it can be shaken down to a smaller size.
FFI isn't exactly hard to do. From UFFI's (LGPL) manual:
def-function name args &key module returning
(def-function "gethostname"
((name (*
(len
Bah syntax. Both our opinions are probably extremely well anchored
How's Lisp harder to use imperatively? Just about every control operator has an implicit progn.
Faster. Often true, but how much so? Lisp, with annotations and compiled for speed instead of safety, is pretty to close to C. (Here's the last troll-induced response I can remember: http://home.comcast.net/~bc19191/blog/040308.html
Better metaprogramming support.
For some reason, even normal unflavoured vodka has an aroma for me :( It might be placebo or something, but the aroma is why I prefer Polar Ice (go canucks! :) to Absolut, not because it scored better or worse on some test. So, while I agree that there's a lot of marketing going on, and that vodka is the _current_ fad (even teen chick lit does it! see Gossip Girl), I believe that many people would be able to distinguish their favourite vodka from another one.
OK, so they're not math majors. Nice ad hominem. If you see a problem with their methodology or their calculations, just show where it is.
He means this http://jajatom.moo.jp/E-top/Egunnm/Egunnm%20top.ht ml
;)
(That's the artist's page, expect some engrish).
I love both series, and I don't believe a lot of ripping off happened, if at all. The "baddies" are diametrically different and DA's storyline had potentially (grr) more depth. Still, kudos to the DA team for giving us tridimensional antagonists. I loved Lydecker in so many ways
a) Infix? Because we all know that familiarity makes right. COBOL, is that you? Precedence is messy, and we all know how to disambiguate: parens. The only time it could be a disadvantage is when you are copying a formula. Even then it only means that you must assimilate the formula instead of mindlessly typing it (usually a Good Thing, especially with "special" numeric towers). But then, I also prefer RPN.
s ses (Java...) are all much more intuitive. In the end, things like that don't really affect the learning curve that much, especially with the CLHS's concept dictionaries and the fact that most of the more obscure ones aren't needed very often. And, a more important point, apart from certain particularly abusive cases (mostly graphics apps, imho), the learning curve doesn't matter as much as the usage. I wouldn't recommend choosing languages based on how easy they are to learn in the first minutes. One might as well stick to recorded macros in that case.
J PG (to show the size of the possible colour/saturation[not exactly the right word, but i carries the meaning alright] - the bottleneck is with my eyes)
b) First/rest, etc. But those are the only ones i can think of in common use. When you get to low-level stuff like handling individual bits or bytes, you get a nice taste of PDP assembly mnemonics, but that's it. The p-convention is pretty clear. PROGN? PROG -> a block (a program), N -> return the nth (last) value). Prefix something with n -> it's destructive. Postfix with f -> it works with places (usually meaning it side-effects). I suppose */&, ++/--, unary_-, ^, >, += (et al), camelCaseClasses/NotCamelCaseClasses/reallybadcla
c) It's called indentation. C-M-q, or something else in your favourite editor. What's nice about it is that, when lines get too long you can simply put a new line where you want. The indenting rules are clear and regular enough that it'll still work fine. I find it is much simpler for me to arrange sexps as I like, instead of having to indent even extremely small ones. It also means that even when indentation is ambiguous (badly formatted code, use of tabs, different views on what is important), you can re-indent it with your editor or reshape the lines a bit to put in evidence what you think is important. Plus, parsing sexp is so easy that building another way of expliciting scope is easy. In fact, that was my first foray into real emacs scripting.
http://www.pvk.ca/misc/misc.jpg (a screenshot of the script, used on itself)
http://www.pvk.ca/misc/spectrum-density.
I don't use it, because I don't need it, but it was a nice experiment. Arguments further right go further in the reg-green-blue spectrum, and deeper sexps are more saturated.
d) Lisp is more than 2.5 times as old as me. How can I be a "Lisp die-hard [who] sticks to Lisp", and not a new user? Guess what, most of us have been virgin new users once too. If you can't see past car/cdr, see b).
TI = what students buy because school tells them to/everyone has them. HP, with its RPN, is still about loyalty and catering to those who know better ;) Check out c.s.hp48 - the user base has written a ******* manual that's better than the original! Hopefully, we'll have an alternative by the time Carly will have totally killed off the calculator division.
Bliz/Valve is debatable too.
An 1992HAEDW of morphine... That would be nic..
CARRIER LOST
(Figuring out how the post could make sense is left as an exercise to the reader(s))
Oh, you mean Lisp? :p
ISTR that Stunts had a sports camera -like replay. Not exactly God's Eye, but it does seem to be what the OP is looking for.
http://www-2.cs.cmu.edu/~adamchik/articles/pi/pi.h tm
"The discoverers sought such a formula because they were aware that it could be used to compute the nth digit of Pi (in base 16), without computing any prior digits. This goes completely against conventional wisdom, and totally eliminates high-precision requirements from a computation of, say, the billionth hexadecimal digit!"
And braino on my part: the advantage is that you CAN use FP, without having to use arbitrary precision math.
Still, by your logic, we should add integers on the FPU instead of the ALU, right? Integer operations are still faster.
It doesn't have to be though. It's just like a normal array wrt mutability, afaics.
Well, depending on the architecture and the languages, linked lists can be easy :)
http://en.wikipedia.org/wiki/VList
"In computer science, the VList is a persistent data structure designed by Phil Bagwell in 2002 that combines the fast indexing of arrays with the easy extension of cons-based (or singly-linked) linked lists.
Like arrays, VLists have constant-time lookup on average and are highly compact, requiring only O(log n) storage for pointers, allowing them to take advantage of locality of reference. Like singly-linked or cons-based lists, they are persistent, and elements can be added to or removed from the front in constant time. Length can also be found in O(log n) time."
"The underlying structure of a VList can be seen as a singly-linked list of arrays whose sizes decrease geometrically; in its simplest form, the first contains the first half of the elements in the list, the next the first half of the remainder, and so on."
For some reason, the article affirms that the VList is immutable.