I propose that we "limit" the total number of "forging accounts" and distribute them via a "give away" at the start (i.e. we are "rebooting" the rights to forge).

EDIT: At least "initially" - we could relax that rule down the track if we thought it was okay (I agree that protecting the network is paramount).

Yes.



You would need an IP address and a "forging account #" in order to forge (you would need to "announce" your "forging account" when connecting to a peer most likely via a "signed message").

So although some people will be able to set up multiple IP addresses (using VPS/VPN or other) it won't be "easy" and it would most likely require software changes and multiple processes needing to be run (so complicated and potentially expensive on resources).

Most average nodes are simply not going to go to the effort to do this (and with the ability to "lease" your forging rights then even pools don't need to bother doing anything tricky) so although it won't be *perfect* it would be *much fairer* than how things stand at the moment.

CfB thought I might want to make my suggestion for a possible different future of TF clearer.

What I am advocating would mean that the % chance to forge would effectively be the number of "forging accounts + IP addreses" you have (for most average people that is going to be 1).

So rather than having to get 100K or more NXT to forge you would only need to purchase 1 "forging account" (say 1 NXT?) to forge.

I hope that explains it better (unfortunately sometimes I just *assume* people understand my ideas).

You would just need to re-connect to peers when your address changes (but admittedly it would not helpful if your node was running over TOR).

But aside from that problem the advantage is now everyone can forge without requiring any more "stake" than the price of an account.

Seeing we are speculating about BCNext's final plan for TF I will put forward another possibility:

Proof of stake to be changed from being the amount of NXT to simply the number of "special forging accounts" you have (that can only be created *after* this plan is released) and you will need to use NXT to purchase each account (but not much - perhaps as low as 1 NXT).

I would predict also that your special forging account number would need to be "broadcast" to your peers (with each peer only accepting forged blocks coming from the one IP address from the 1 account).

It is *free* to create a self-signed cert - just follow the instructions I linked to.

You'll need to generate a self-signed cert now (https://bitcointalk.org/index.php?topic=345619.msg5299392#msg5299392).

Just to let you guys know that we now have a 3rd "use case" for the AT prototype which is a "Crowdfunding Agent" (see http://ciyam.org/nxt for the AT docs).

So what does it do?

Basically it means you won't need to use a "website" like Kickstarter or the like at all - you will be just able to create an AT for your project then people will be able to send funds to it which will be refunded if it doesn't meet its funding target by the target time.

Of course it doesn't give you any guarantees about the project itself (and I don't think most "crowd funding" websites do either) but it absolutely guarantees the account where the funds will go if the target is met as well as the refunding if the target isn't met.

One more middle-man gone!

(sorry in advance to all investors in platforms like Kickstarter)

Thanks - not all of us are Java developers (I know how to do a self-signed cert using openssl but had never come across "keytool" before).

I don't believe it's a big deal (as HTTP should be fine locally) but it does tend to *surprise* end users when something that "just worked" before now doesn't and apparently they have to "open the hood" and "do some wiring changes" to make it work again.

I am guessing that it ain't so simple to run it using HTTPS now although really if you are running it locally I don't think HTTP is a problem (if something running locally is sniffing your packets then I'd be surprised if it wasn't also logging your keystrokes).

Just to note I've updated the specification and the "Crowdfunding Agent" use case after testing it today.

A new op code SET_PCS has been introduced and "pcs" has been added to the "persistent state". Its purpose is to hold the "program counter start" (normally zero) which is where the "pc" will start after a FIN op has occurred (or after the last op has been executed).

This allows an AT to set a new point to begin execution from if/when it is "awoken" by a new tx. In the case of the "crowdfunding agent" this will be conditionally set depending upon whether the balance of the AT had met its target amount by the target time so that if further txs occur then any balance will be either (a) sent to the project because it had met its target or (b) refunded to the sender because it had not.

The plan is to get this ready for release in April (which I think should easily be achieved provided that we can organise a team in the next week or two).

From the technical side there will still need to be quite a bit of further work done on the specification (adding "meat" to the "bones") and then a lot of test cases need to be created (both for the AT interpreter itself and for each of the use cases mentioned in the specification).

The actual coding for the AT interpreter itself is not likely to be a huge job (I'd say a week or two) so the testing is going to probably require the most effort.

I think your math is a bit out - looks more like 126 to me - James make sure you find out *correctly* how to determine this (i.e. do *not* hard-code a "magic number").

And unfortunately "general purpose" programming languages always end up with their own little quirks (because they haven't been designed to do "one thing" and "do it well").

If you are comfortable with the idea of "functional programming" (which SQL is a basic example of) then I'd suggest also looking into Haskall.

But "the future" will likely be more along the lines of lots of small "domain specific languages" and "code generators" - the CIYAM software platform itself works this way (there isn't a single line of "manual code" used in the CIYAM Open web application).

Just a post to let you guys know that I've updated the documents at http://ciyam.org/nxt and have added the 3rd use case which is a Crowdfunding Agent.

I have yet to create sample data and test this last use case (will do that by early next week) but I think the basic form of the AT concept is taking shape.

I'd have to say that I am the same - so I prefer not to "argue" with people but instead try "discuss" with them (it doesn't always work mind you especially in a forum like this one). Provided that it doesn't turn into an argument then I can remain quite patient (if it starts to head that way I would normally "move on").

They are *exactly* the number of bits their names suggest (that's why they were created). It is the normal C types like "int" and "long" which the Standard can only give vague ideas about size (such as sizeof( long ) >= sizeof( int ), etc.).

It is really hard to know which language is the best for what purpose (and in most typically non-trivial applications you'll end up using a few more than just one) but if you are keen to become a good programmer you should probably pick one "main" language and learn it "in depth".

This process is not something that will happen "over night" but if you spend the effort you will have become a much better programmer (I spent over 10 years "learning" C++ whilst I worked with it and there are still areas of it that I am not familiar with).

@James - For displaying and other non-computational purposes temporarily using a "double" and "printf" is fine.

BTW - you would be better off using "long long" (or better yet #include <stdint.h> and use int64_t) than using "long" otherwise it won't work on most (if not all) 32 bit architectures.

When you've traversed the depths of thousands of lines of code in order to find a bug that is as simple as an incorrect comma (and taken literally days to do so) then you will either have learned to be very patient with some things or you will have decided that computer programming is not for you.