What if, instead of releasing te whole program for a small oneline bug edit, why don't we create the framework of a patching lib, using Celtic III. The patch will include all the changes, and the patching program will interpret it. It will be able to delete, replace and insert lines. So instead of having to re-send the ahold program you can just use the patch, and if it's a one line fix, you can manuely do it by making the patch yourself, so no cable is needed.
So what do you guys think? Comments, suggestion?

No I meant using Celtic III to make a patching system for basic programs

Ah. Thanks! Well hopefully when I get my calc back I can implement it.

Well for a tiny change, this would be easier. Or for very large programs. So if you need to change line 300 in a program, you just run the thing and it changes it faster then manuelly changing it or sending the updated program.

Yeah, well the patched probably won't be that large, and it can be used for any program. So it can be something you just keep on yout calc.

What would happen if there are two changes?  Most likely, the first change would alter the position of the second one, and it might be that not everyone had implemented the first fix in the first place.

The only way I can think to do it is have the program keep track of whether it did the previous change(s) (maybe in an appVar?) and then if you hadn't, the program would implement all the previous ones first.  The problem is that with each new patch, you'd have to send the information for every previous one.

I think the patch would be used as a one time and temporary solution to betas and releases on a community forum. But good point about multiple patches.

theres an easy solution to that, rather than keeping track of all patches just do this: store a patch number,and each new patch would have a variable that would be read, it will only allow you to patch it if the number is one higher, that way it forces you to patch in order and not skip any patches, which completely solves the problem :{D the only thing about this solution is you need to make sure whatever you use to store the patch var in doesnt get deleted, if it does everything would get mucked up

Hmmmmm, I'm not seeing the benefit here.  On one hand, there is a faulty program, so you release the same program but fixed.  All the user has to do it send it to his/her calculator and they are done!

On the other hand, with these patches, not only do they have to have CelticIII on their calc, but after they send in the patch, they have to run it and/or deal with version numbers.  Seems to me just sending the fixed version would take a lot less time and effort on both ends, for the programer and for the user.