Formalizing class dynamic software updating
Introduction Contracts Embedded in the World Contemporary Practice Accounting Controls Electronic Data Interchange Automata as Authority Dimensions of Contract Design Mental and Computational Transaction Costs The Economics Of Security Proactive vs.
Reactive Security Online Enforceability Observability by Principals Verifiability by Adjudicators Privity: Protection from Third Parties Contracting Phases Trading off Contract Design Objectives Auditing Intermediaries Building Blocks of Smart Contract Protocols Protocols Attacks against Smart Contracts Public and Secret Key Cryptography Mutually Confidential Computation Privy Authentication Post-unforgeable Transaction Logs Mixes Quora Protection of Keys Capabilities Contracts with Bearer Bearer Certificates Unlinkable Transfer Conserved Objects Digital Cash Credentials Content Rights Management Watermarks Controlled CPUs Reputation Systems Credit Secured Credit Ripped Instruments Credit Cards Interval Instruments Known Borrowers of Unknown Amounts Pseudonymous Credit Ratings Conclusion The contract, a set of promises agreed to in a "meeting of the minds", is the traditional way to formalize a relationship.
But the digital revolution challenges us to develop new institutions in a much shorter period of time.
By extracting from our current laws, procedures, and theories those principles which remain applicable in cyberspace, we can retain much of this deep tradition, and greatly shorten the time needed to develop useful digital institutions.
If we started from scratch, using reason and experience, it could take many centuries to redevelop sophisticated ideas like contract law and property rights that make the modern market work.
If you only want one dynamic property, have a look at the property() built-in function.
Smart contracts combine protocols with user interfaces to formalize and secure relationships over computer networks.
ks = ['ab', 'cd'] vs = [12, 34] class C(dict): def __init__(self, ks, vs): for i, k in enumerate(ks): self[k] = vs[i] setattr(self, k, property(lambda x: vs[i], self.fn_readyonly)) def fn_readonly(self, v) raise "It is ready only" if __name__ == "__main__": c = C(ks, vs) print Anyway, I suspect this is why descriptors only work on classes: they're a formalization of the stuff that powers classes in the first place.
They're even the exception to the rule: you can obviously assign descriptors to a class, and classes are themselves instances of ; it's just idiomatic for descriptors to return themselves when accessed as class attributes.
Using an example based on the documentation for In Python, we expect there to be one obvious way of doing things.