More Memory Questions

Which is more efficient or is there a difference:

.......
if (llListFindList (...) != -1)
or
if (llListFindList(...) + 1)

I don't personally see that as a reason not to try. I realize that other people don't agree with that stance, though.

No, but no one should be afraid (or be told to shut up) over making suggestions for improvement, either.

This actually happens a lot with the LibraryWarpPos script. I get IMs all the time with people asking how it works, IF it works, or WHAT it does. It is HEAVILY optimized, and few people can make heads or tails of it. It was INTENTIONALLY optimized to be used as a "black box", keeping the memory footprint down as low as possible for the maximum teleport distance. I would NEVER EVER recommend it for learning, unless someone specifically wanted to learn code optimization techniques. However, I have spent time in IM explaining how it works to folks who are so inclined. I probably need to upload the version I use to reabsorb it every time I come back after 6 months and decipher it.

The whole point of the forum is to help and give advice. The better the advice, the more someone can learn and apply. In the case of this thread, giving "when to optimize" tips is a valid and positive addition to offering optimization tips.

As such, I don't find it pointless at all (well, the ad hominem we could have done without). I would point out something that Jesse has also said in the past which is very relevant (paraphrased, because I can't find the original post): "There are a lot of talented people here giving help, and I think that all the different points of view help everyone immensely".

Oh, definitely. I don't think this is so much a style argument, though, as there is a significant "best practices" element, which is taught in many beginning computer science classes, and for good reason.

Sharing this info and the reasons behind it is a positive thing, I think. Not everyone agrees, though, and that's fine, but last I checked, we're entitled to express our opinions and supporting arguments here.

These two expressions generate the same parse tree, with only a couple of constants (1 vs -1, and different operands) different. The LSL compiler does not optimize them, it executes code corresponding to:

Push -1
[code generating the args to llListFindList]
Call llListFindList
Subtract top stack elements
Pop top of stack and branch if non-zero

Or:

Push 1
[code generating the args to llListFindList]
Call llListFindList
Add top stack elements
Pop top of stack and branch if non-zero

This actually happens a lot with the LibraryWarpPos script. I get IMs all the time with people asking how it works, IF it works, or WHAT it does. It is HEAVILY optimized, and few people can make heads or tails of it.

o.O so that`s how it works!

Yeh, it's a pure stack machine. The CIL code it generates for Mono is functionally the same, right down to the backwards stacking order... there's occasional swaps thrown in where they're generating plain CIL opcodes... to avoid breaking Strife's list optimization hack.

Yes, and the converse of that assumption is also true. Just because you can read something doesn't mean it is readable for anyone else. Can you at least stipulate to that truism? No one here is saying that they shouldn't do something for themselves, only if they care about doing it for others. If they don't (and I am aware that you don't), then fine, do whatever you want. No one here is saying otherwise.

"No one here is saying otherwise" It is sugar coated but look closely at this paragraph because it directly translates to "Code however you want but if you post code here in the forums it has to be to my specifications and if it isn't then you are not a nice person".

And my history here shows very clearly just how much I do care about other people. I just do not like people saying, once again, that they have to write code a certain way.

Now do we really want to start this all over again. Do you intend to continue throwing out little barbs?

A) Yes, it was intended as an example, probably a poor one, but some folks have actually done things like that, sometimes to be cute, but once in a while, that is what a serious programmer did, thinking it was the best and most efficient way to do it.
B) Like I said, it was an example, but you make my point, even in your optimized version, because my first impression is "Is there something missing in this code?" and I have to start deconstructing it my mind, wasting my valuable time. Usually, once I have gone to that kind of trouble, I replace the offending code with what I consider is its proper equivalent so I don't (or someone else doesn't) have to waste time in the future, and continue on.
C) Exactly, so if you expect to publish the code for anyone else to read and/or support, why not make their task easier? It probably won't ever matter to you if you are the only one whose eyes ever grace it but, I can tell you from experience that It Just Ain't So.
D) Which, unless there was a significant and/or necessary savings in memory or speed, is not better than the savings in time for anyone else having to understand/maintain it later. In my mind, anyway, human time >>> memory/computer time.



That's true. You like code puzzles. You do well at them. However, I daresay most people who are in the mainstream don't have time for them, and when that deadline looms large, cute obfuscated code puzzles are expensive for the time required, if not downright hated by your coworkers.

I think you've done a lot of cool stuff with your optimizations in LSL; this isn't meant to be an indictment of them in the least. However, if I have to comprehend and support your code, I generally do de-obfuscate it and put it into a more readable format, unless the optimizations are of the kind required for proper operation or necessary efficiency. Then, I just leave them alone and treat them as black boxes (though that is very rare; my mind hates black boxes ).

At the end of the day, that's what it boils down to for me: necessary efficiency at the cost of readability, or readability at the cost of unnecessary efficiency.



I don't agree with that. Certainly, to master any language, you must also master all of its quirks and nuances. However, I would say that better computer languages allow you to express the more abstract concepts of algorithms without having to resort to quirks and nuances. Not just better languages, but also better implementations of certain languages. In any language, colloquialisms are an impediment to understanding and timely communication; they are no less so in a computer language, either. This concept is especially true in terms of the "learning curve" of a language, and if you are writing code which is, in any way, intended to be instructive or helpful to neophytes, you are not doing them any favors by choosing obfuscation over readability.

I mean, what is the point of a computer language anyway? It simply just isn't for providing a method of telling the computer what to do, it is what any language, natural or artificial, is primarily for... communication. In fact, I daresay that computer languages have to pull double duty, not only to communicate to the computer what you want it to do, but to also communicate to other people what you are trying to do. To take this to the most absurd level, why use a human readable computer language at all? If the goal is to make the most efficient, speediest program possible, hand-tuned machine code is the way to go. There are no intervening assumptions or high-level abstractions to get in the way of you telling the computer EXACTLY what you want it to do. It is the ultimate puzzle (and, yes, I have done it, from flipping Address/Data/Step/Load/Store/Run/Stop/Reset switches on the front of Altair and IMSAI 8080A-based systems, to hand-optimizing COMPASS output for CDC Cyber series mainframes), and can be quite entertaining, but the amount of time expended for the benefit, at least nowadays, just doesn't scale.



Correct, within the language model, Booleans are interpreted and handled separately from all other data types. In Pascal, for example, Booleans are their own separate data type, and the language syntax enforces Boolean usage in conditionals. IE, this won't work:

If X - 7 Then Do_Blah;

Because the language expects, as the final result of the conditional expression, a value of Boolean type. Conditional operations result in Boolean values, you can specify Boolean-typed variables or functions, and string together multiple Boolean expressions with the logical AND / OR / NOT operators. It is only really in C and similar languages where non-Boolean expressions can be treated as Booleans by virtue of a value-equivalence quirk which can be non-portable, not only to other implementations of the language, but to other languages in general.

Non-portability when it comes to high-level language constructs is another form of that "quirkiness" or colloquial aspect of the language, which is not something to be cherished, but to be avoided, because it simply acts as an impediment to understanding and, ultimately, wastes human time. In some cases, it is important for it to exist, and in those cases, it can at least be accepted as a necessary evil. However, in the balance of cases, it is just problematic.

Just as a parting analogy, I don't think anyone can argue with the concept of using the right tool for the job. While you can use a screwdriver as a chisel, and it will be serviceable in some cases, if you hand someone a screwdriver and a block of wood, and tell them to carve a duck, they will invariably spend time figuring out how to properly apply the tool to the job, whereas if you had handed them a wood chisel instead, they would be done already.

"No one here is saying that they shouldn't do something for themselves, ONLY if they care about doing it for others."

Are you and others not saying "This is not readable to me so you should not post code with it here in the forums"? And in fact you shouldn't use it yourself, because if I can not read it with 30 years expireince then you poor mortals will surely forget what it means a year from now? How have I misread anything? Anyone can look back and see where it was stated in one form or another, several times here. This is what I am saying is flat out wrong.

Then if we expand that quotation it says: "No one here is saying that they shouldn't do something for themselves, only if they care about doing it for others. If they don't (and I am aware that you don't), then fine, do whatever you want." Then what exactly was the "and I am aware that you don't)" referring to?

wished we had classes in lsl and such tools, think it would do wonders to be able to access "unreadable" optimized code with a single call unlike now with using entire scripts to get lost in, what i was expecting with the implementation of mono (atleast kept hoping )

but the 2 of you argueing is anything but efficient and unreadable debacle(sp) for the rest as we miss the underlying history

btw, using ^ in an if statement, so:

integer DEBUG = TRUE;
if (^DEBUG) bla;

is more efficient then:
if (DEBUG) bla;

?

Then it wouldn't be LSL anymore.

No, seriously, the eventual hope is that they get full language support with Mono so that we can actually build things like classes and put them in libraries, but I think that is another 2 years out right now.

Ehh.. it's not worth worrying over. We'll get over it and kiss and make up eventually. Jesse is cool, and has done a lot for a lot of people. We just sometimes let our pet peeves get in the way of remembering those things.

^ is a bitwise (integer) operator which requires two params, like & or |. So I think you might be looking for !.

You're using DEBUG as a Boolean, so I would recommend sticking with only Boolean operators with it: ! (not), && (and), || (or)

And also please understand this; Lear, Cale, Talarus, Heewee, Tyken, Strife and everyone else in this thread are respected.

And also please understand this; Lear, Cale, Talarus, Heewee, Tyken, Strife and everyone else in this thread are respected. They have all sacrificed a great deal of their personal time to this very forum. And without Talarus and Strife, we would not have much of a wiki.

EDIT: You also have to remember that I am a 50 yr old female (who just so happens to also be a Taurus ) that has worked in male dominated environments all of my life and succeeded. I was never the type to bat my eyes and try to use my charms (I don't have much charm) so I had to learn to stand up for myself, against overwhelming pressure sometimes, because no one else would. Look in the dictionary and you will see my name beside the definition for feisty.

HP, TI, or Casio/Sharp (the later used basic IIRC) ?

I mean, what is the point of a computer language anyway? It simply just isn't for providing a method of telling the computer what to do, it is what any language, natural or artificial, is primarily for... communication. In fact, I daresay that computer languages have to pull double duty, not only to communicate to the computer what you want it to do, but to also communicate to other people what you are trying to do.

Just as a parting analogy, I don't think anyone can argue with the concept of using the right tool for the job. While you can use a screwdriver as a chisel, and it will be serviceable in some cases, if you hand someone a screwdriver and a block of wood, and tell them to carve a duck, they will invariably spend time figuring out how to properly apply the tool to the job, whereas if you had handed them a wood chisel instead, they would be done already.

Early TI-83, I think it had 64 KB of memory (I don't really remember anymore). It ran Basic, I think it was bytecode. You had to access all the built in commands by menu, you couldn't write in the names.

A good example of a new language feature is LINQ (you can find it in C#), the syntax is decent and with it you can write code that is easier to read without sacrificing functionality or speed. It turns ugly loops into fluid, beautiful code.

haha. Just found a code snippet of what was used in the TI products back then. After 3 decades I had forgotten what it even looked like:

000  'Incomplete Gamma'
016  DFN F1:GMA@AA
023  HLT
024  LBL AA
027  STO 002
030  x~t
031  STO 001
034  y^x
035  RCL 002
038  /
039  RCL 001
042  INV
043  LN
044  /
045  RCL 002
048  =
049  STO 003
052  LBL QQ
055  STO 000
058  RCL 003
061  *
062  RCL 001
065  /
066  (
067  RCL 002
070  +
071  1
072  )
073  STO 002
076  +
077  STO 003
080  RCL 000
083  =
084  IF> 000
087  GTO QQ
090  RTN

For the new ones, this was unbelievably powerful at the time. Especially when you consider that in the decade or so before, we made it to the moon and back using sliderules! Yep, I was a geek even then, was in the math & chess clubs and had a speed draw holster for my sliderule . I could have made that sliderule pluck that duck of Strife's, throw it in the oven and stir up the orange glaze sauce.

I had a TI-95. It was more then a decade before there were other calculators that could do half of what it could. This was the only pre-lsl programming I ever did outside of troubleshooting a bit of ladder logic. It had the magnetic strips that you could put code on and with it I made a very cool trig func. Input any 3 variables and it gave all sides and angles. Didn't matter if it was obtuse, acute or right.