SEC Proposes Wall Street Transparency Via Python
An anonymous reader writes "A US federal agency is considering the use of computing languages to specify legal requirements. 'We are proposing that the computer program be filed on EDGAR in the form of downloadable source code in Python. ... Under the proposed requirement, the filed source code, when downloaded and run by an investor, must provide the user with the ability to programmatically input the user's own assumptions regarding the future performance and cash flows from the pool assets, including but not limited to assumptions about future interest rates, default rates, prepayment speeds, loss-given-default rates, and any other necessary assumptions.' Does this move make sense? If the proposed rule is enacted, it certainly will bring attention to Python or other permitted languages. Will that be a good thing?"
The above quotes were pulled from pages 205 and 210 of the dense, 667-page proposal document (PDF). Market expert and professor of finance Jayanth R. Varma says it's a good idea.
I think a lot of those wall-street types would suddenly admit to everything they've done wrong if you confront them with a big enough Python...
This would be a fantastic idea. Not only would the rules be transparent and non-ambiguous, but the potential for experimentation and self-analysis would be incredible. Python is definitely one of the better languages to use for this, as it tends to be very readable and self-explanatory as far as programming languages go.
I love Python and I would hate to see it abused this way.
Ruby Neural Evolution of Augmenting Topologies
Just remember that one instance of the class of person may never touch another instance of the class of person's privates. You need to use protected for that.
Science advances one funeral at a time- Max Planck
actually... they were selling a car with no brakes... claiming it is safe, then taking out a life insurance policy on the sucker they sold it to.
> cat test.legalese
The said variable 'i' hereafter referred to as "i" shall be a variable and not of unvarying or constant except for the purposes of using the said variable within a clausal computation and shall be initially equated to 1 (one) neither less nor more and "i" shall be displayed to a third party within visual distance from the visual display device but not beyond unless further provision is granted and provided by the creator of the said work. These courses of action shall be repeated for 10 (ten) times neither more nor less withstanding any systemic error which may cause the premature termination of the said operations and includes the increment of "i" by 1 (one) in a positive monotonic uniform manner performed prior to each display to the visual display device. Upon termination of the aforementioned operational sequence the operations shall cease until recommenced upon instruction of the operator.
> glegalese test.legalese
> a.out
1
2
3
4
5
6
7
8
9
10
>
I can't imagine that this would provide the average Joe Sixpack any useful information.
Joe Sixpack doesn't typically buy collateralized debt obligations. In fact, if he bought a tranche of a CDO, I think that would immediately disqualify him from his everyman status. The main customers for these sometimes obscenely complex instruments are investment firms.
Problem is, the legalese is so dense, even professional investment analysts have a hard time understanding the payout scheme. If I understand the proposal correctly, the Python code will itself authoritatively define the flow of funds from the investment vehicle. It won't simply be a model that makes predictions based on initial assumptions -- it will also "allow the use of the proposed asset-level data file that will be filed at the time of the offering and on a periodic basis thereafter". Thus given specific data about the performance of underlying assets up to any given point, the code will spit out an authoritative answer of "who gets paid what (if anything)".
Since a structured investment vehicle is essentially an algorithm wrapped in a contract, it makes sense to use a programming language to specify that algorithm. I personally like Python; but I agree with other posters who have said the regulation should ensure that other languages can be added over time.
That's a good point to make, though I think your estimate of 5 years does little justice to Python. Regardless, the problem with NOT specifying a language is that it means I can make my own proprietary language and release that source code (and not the compiler, say).
Also, Python is open source through and through : community developed, open specs, several open source implementations. This means that even if one day 25 years from now Python is a dead language as far as practical usage goes, it will be no harder to understand and execute as it is today.