Slashdot Mirror
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...
Now, in addition to lawyers and accountants, you need computer programmers to invest. This smells like a racket. On the other hand, it can't get any worse than the legalese, and maybe that is the point.
Fuck systemd. Fuck Redhat. Fuck Soylent, too. Wait, scratch the last one.
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
Maybe if the languages accepted are functional, and therefore logically provable without side-effects.
meh
If you want to confront the devil, a programming language is a good place to do it, since it's all about the details.
Any legal framework, if it does include a specific language, should be based on what the common languages that are currently used, i.e. they should have company XYZ submit that they are using language "ABC" and here is the source code. The problem with mandating a particular language(s) is that these are subject to change with time. A legal framework should stand the test of time, and thus not include requirements for "Python". Python might not exist in five years, or may become obsolete in five years.
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.'
...it is forbidden to have a straightforward sentence with less than two conjunctions.
'We are trying to prove ourselves wrong as quickly as possible, because only in that way can we find progress.' RPF
In commercial real estate, investors use their own spreadsheets or Argus to make their own assumptions. The same holds true for investors investing in stocks, bonds, derivatives, etc. Investing is a bet and sometimes assumptions turn out to be wrong. The government doesn't need to hold the investors' hands when it comes to investing money.
Something that needs to be considered is the existence of so called "Filing Agents". I work for such a business.
Right now, the SEC requires companies to file documents in a specific subset of HTML, as well as (in some cases) XBRL, which is an XML-based reporting language. In some rare cases, documents are another type of XML, or even specially formatted ASCII documents (ugh).
Securities lawyers and company administrators don't want to understand the highly technical processes involved, so they outsource their technical reporting requirements to filing agents. We take care of all the nitpicky details that they don't want to consider. Looks like we'll have to learn Python as well. We've been meaning to graduate from Perl anyway, so no big deal. :-)
Occam's Razer does not apply to matters of finance. Ever.
'We are trying to prove ourselves wrong as quickly as possible, because only in that way can we find progress.' RPF
ECMAScript or JavaScript would be a much better language to make this requirement for. Python would be a mistake. JavaScript is a much more limited language in terms of dialect and concepts and is much more neutral than Python is; yet JavaScript can express nearly any level of complexity. It is also readable by majority of the programming world. It is also an excellent data transport language. Python is not readable by the majority of the programming world. It is also terrible as data transport language.
JavaScript is about as neutral a language as you'd be able to find. Plus it is ubiquitous and public financial calculations and records could readily be used in straight HTML/JavaScript webpages - no plugins or server code necessary.
Specially after the final revision, when our serfs vote to change it to Visual Basic.
Then we get to change the meaning of the keywords in the next release...
Mwahahahahahahaha...cough.. cough...
-- Your medicine, Mr. B.
-- Thanks, S.
(*) B== Burns ; S==Smithers.
Not any other name, like, say, for instance, Bill or Steve or whatever...
All trademarks are not mine, but their legal owners'.
I can see it already, the financial institutions will all cry "but these magical formulas are what makes us money and if we make them available our competitors will be able to use them too"! And of course they would also scramble to hire some of the winners of the Underhanded C Contest: http://underhanded.xcott.com/
You're missing the point. The point is to make sure that the companies taking money are providing transparency to their investment strategy, not only to the investors but to the credit rating agencies as well. The firms in question purposefully obscured CDOs and other exotic financial instruments so they could play hot potato with the emperor's clothes and cash in on the commissions.
Frankly using a mathematically provable means of describing all manner of (if not all) legal requirements would be an excellent idea. The notion of gray-areas wherein judge and jury have traditionally run wild would be non-existent. One could apply legal requirements to any case with absolute confidence of the outcome regardless of venue. Court proceedings would consist of nothing but what they were intended to consist of, the determination of givens.
Two of my imaginary friends reproduced once
I assume that the future will hold an increasing amount of law (or what amounts to law) encoded as software. Given that will be the case, I am very happy to hear of legislation which will propose Python as a lingua franca of law. Python is inherently easy to read. Mandatory formatting at first seems a weakness but ultimately creates a standardized "look" for Python source code. This allows the experienced eye to trace Python code with less change of misunderstanding the intent of the code.
I support strongly the introduction of Python as the lingua franca for encoding law into computation models.
That written, I am not convinced that the use of a computational model as part of the representation of an investment would have fore-stalled the current U.S. debacle. Recent news regarding corrupt moves by investment companies would indicate that the U.S. housing credit instrument collapse was in fact inadvertently orchestrated by certain companies creating mortgage instruments which "looked good on paper" but which the investment company believed would fail. For example, the investment company might have looked into additional information on the mortgage holders, determined those mortgage holders who did not get a raise last year, and lumped those mortgages into a 10,000-mortgage bond which was then "insured" with a Credit Default Swap. The information about paycheck could come from examining direct deposit receipts. The relevance of a person not getting a raise is that the person is more likely to be fired within a year.
In light of the type of corruption which led to the credit problem in the U.S., it seems that regulations requiring financial instruments be specified in such-and-such amount of detail don't seem like a remedy. If the investment bank is privy to additional information than specified by the model, it doesn't matter whether the model is expressed as a Python program or a diagram -- the information which is left out of the representation can still be used by the corrupt investment bank, to "structure" the investments to perform other than as predicted.
Some derivative instruments, such as Credit Default Swaps (CDS), gain value only if the instrument they derive from fails. A CDS for a mortgage pays the holder only if the mortgage enters default. In a way, this can be thought of as "insurance" on the original instrument. For simplified example, the holder of a mortgage note (the bank), might buy a CDS for that mortgage, to cover the loss in the event of default. The CDS must be paid for, so a cost is incurred in the event that no default transpires on the original instrument. The "insurance" that AIG was selling, which the U.S. Fed had to pay off on behalf off, were in the form of CDS-like instruments. AIG had sold many-fold more CDS than there were actual mortgages in default -- because 'savvy' investors who had no interest in the actual original instruments, who stood to lose nothing in the event of defaults, purchased CDS on mortgages as an "investment gamble" that certain packages would pay off.
In the recently revealed collusion by an investment bank in the United States, it has been claimed that a prominent bank colluded with a prominent hedge fund manager to created CDS-related instruments (CDOs), which were promoted to succeed, but the investment bank held additional information indicating would fail.
If the same scenario of corrupt investment company and corrupt hedge fund manager recurred under the proposed, Python-specifying, legislation, then the corrupt players would pay someone to write that Python. The Python would make a certain "representation of fact" about the security being sold. That representation would only be as factual as the real players let on to the programmer writing the statement.
In other words, while the choice of Python is excellent, and the attempt to over-specify and codify honest and disclosure is excellent, even Python does not give us the power to force market players to disclose informa
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.
The Street has always been full of sharks, now you want to allow snakes?
09 F9 11 02 9D 74 E3 5B - D8 41 56 C5 63 56 88 C0 45 5F E1 04 22 CA 29 C4 93 3F 95 05 2B 79 2A B2
def getPerformance(self, assumptions):
"""Return performance estimates.
Arguments:
assumptions: dict, for keys see spec #54
Returns:
How much money you will make
"""
# BUG 91423: was sometimes giving poor results
# workaround fix is to ignore assumptions.
return "Millions and millions"
So rather than actually explain what the item is, they'll just build a model of what it is, and let you put in your own assumptions.
So we'll create a bunch of programming overhead, and end up with huge improvements.
Namely that iInstead of descriptions nobody reads or understands, we'll have programs nobody runs or understands.
I've got an idea, I know it might sound crazy but here it goes.
If you see someone selling a great deal, but you don't quite get what they're selling, how it works, or even why it's such a great deal, DON'T BUY IT.
We could even impose this on industry, maybe make it a legal/ethical requirement that people moving around large sums of money act with due diligence or something.
If people actually stuck to this, and only bought things that they understood and made sense to them, the companies making these confusing products that nobody understands would have to make simpler more straightforward products.
These guys need to step back, and make products that THEY understand. If the designer of the product can't figure it out, it's too confusing. If none of the potential customers can understand it, it's too confusing.
Really if they currently can't implement the description, how does documenting it in python make it any better?
Oooh great, let's use an academic programming language for a desktop application intended to provide clarity to financial transactions.
A typical user's experience...
cd c:\Documents\ and\ Settings\AJ34320\Desktop\ Mess\Desktop\Old\ Desktop\Fucking\ SEC\
"not a directory or invalid folder"
c:
cd \Documents\ and\ Settings\AJ34320\Desktop\ Mess\Desktop\Old\ Desktop\Fucking\ SEC\
C:\Programs Files\Python\bin\python.exe c:\Documents\ and\ Settings\AJ34320\Desktop\ Mess\Desktop\Old\ Desktop\Fucking\ SEC\bonehead.py
Usage: bonehead.py [options] argument1 argument2
Options:
-h, --help show this help message and exit
-v, --verbose Set mode to verbose.
Who are you? The new #2 Who is #1? You are #617565. I am not a number, I am a free man! Muhahaha.
Or some other other functional language like that? Usually when you are trying to formulate loads of rules, it would seem that brevity and exactness of results trumps the implementation detail of performance.
This is my sig.
> 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
>
Hey, let's forget about unfunded goverment mandates, senators busy playing blame games, clueless SEC employees, greedy intermediaries, lopsided compensation practices, and market participants that do not understand instruments that they are trading.
What we really miss is python interface to EDGAR. Some guy say so, it must be true.
Well, this is not entirely without precedent. Even the field of Physics employes this method of specifying things that are complex enough that warrant a "model" which is highly dependent on what the model chose to include or exclude. For example, in tracking satellites, you would think that you should be able to use Physics and the myriad of formulas alone to come up with the position of satellites. But because real world physics (think drag, friction, N-body G forces etc) is too hard to figure out and are often hand-waved away (thus the model), NASA had to devise a set of algorithms to communicate a way to track satellites. They then publish the telemetry at regular intervals which are then run through those algorithms to find out where any of the satellites are at any given time. Last I worked on it, I was looking at Fortran programs which was used as the spec for the algorithm. Now, think about it, how better to describe an algorithm than an actual working program?
see: SGP4 and this in particular.
Then they use a quarter of the money from the secret life insurance policy to defend themselves in court, and then finally lose the court case and pay out another quarter of the money, then they walk away with half of the money and make the next model of the car, and caste a wider net, aiming it a kids, because due to their age, they can get a higher payout on the insurance policy.
Gravity Sucks
COBOL was supposed to be about making everything clear and obvious in a business environment. But given the current business world it's time to give obfuscated-perl, brainfuck ( http://en.wikipedia.org/wiki/Brainfuck ), or whitespace ( http://en.wikipedia.org/wiki/Whitespace_(programming_language) ) a fair chance.
OK, how about if instead of providing mileage ratings that car advertisements simply had a URL to a Python program that if you entered information about your driving habits that it would come out with an MPG value for a specific car. Obviously, there would be a completely separate Python program for every single car.
Of course, 99% of the weighting would be handled by the questions "Do you drive with a lead foot?" and "Are jackrabbit starts your normal mode?" But the other 34 questions would be there as specified by the government regulation governing the production of these Python applications.
Having a model and the user gets to make up the assumptions, you are getting a traditional garbage-in, garbage-out algorithym. Any model can conform to any belief system given the "proper" inputs. Isn't this half of what the climate arguments are about? Not the code, but the assumptions being pushed into the model?
I can't imagine that this would provide the average Joe Sixpack any useful information. I would say this isn't "transparent" in any way - unless the inputs to the model were published and required to be adhered to. This would make legally binding assumptions like in 2050 there will be fewer literate people than in 2000. I'd like to see the government come up with a plan for that.
Or worse, if a fundamental assumption of the model is rising interest rates and every investor makes 100% return in five years, great. Does the ability to push out a program that says if you enter the five year interest rates as steadily rising then justify advertising that every investor will make 100% of their money?
This also reeks of the idea that if you can't read a programming language you are a second-class citizen. Richard Stallman would be proud.
At least until someone updates the gcc to recognize that you're building patch, to put in the patch that pays that changes the diff that you submit to the python base that changes the interpretation to put .001 from every transaction into your bank account.
I would have been spilling the beans if it hadn't been recognized since the 70s.
This is not the solution. Not even close.
Companies are protected from all sorts of investor inanity by the vagueness of the public's view into their business models.
Asking a company to produce a model is asking the company to allow investors to claim that any action outside the model constitutes a violation of the promises made in the prospectus that is the model.
Adding a hold-harmless clause stating that the model is innately inaccurate is the same thing as just not producing the automated model at all.
Corporate finance reporting can't talk about the future because it doesn't know the future. It knows the past, give or take an error bar, and, provided a slight lag, it knows the present. It knows the current state of plans, and the statistics of the company's past experience in executing to plans. It knows the competitive landscape, but only as well as anyone outside knows its own insides.
In the end, the best you can do is to produce a program that allows the investor to choose what elements of the business model to include in a model, and so on, all the way down. Then any errors are the investor's own.
Keep in mind people don't like computers, programs, math or finance. You have to consider that. So I've gone on Wikipedia and did a search on a computer language that produces *minimal* code.
I briefly glanced only at the first sentence from the following page (http://en.wikipedia.org/wiki/Brainfuck) and trimmed the first sentence for length: "The brainfuck programming language is ... noted for its extreme minimalism.". See, this is what people want, it keeps things simple.
A good portion of Google's code is written in that "academic" programming language. So is the Washington Post's website. And a good sized chunk of Gnome. Mercurial, probably the second most popular dvcs (after git) is written mostly 500 lines of Python. Civilization IV and Battlefield 2 both use Python for their scripting.
What makes Python an academic language and C# an applications language? Is it the pretty IDE Microsoft makes for it?
Laws should work like computer programs, calling the "operating system" of the Constitution and acting on the "devices" of the real world under legal jurisdiction.
The problem is that bugs will cost lives and livelihoods. And the code review will be based on the comments, which will still be written by lawyers.
--
make install -not war
That aside, the most reasonable thing to do is to submit price evolution process as stochastic diff eq, which is coded into some Monte Carlo framework that is agreed upon, and the regulators plug in assumptions about liquidity, interest rates and have an easy way of changing various sensitivities and correlations.
Good job regurgitaing the populist line. In fact, the rules of disclosure are pretty legit. If they sell you a car, they have to tell you what are all the pieces you're getting. If there's no brakes, they can't claim there are brakes. But it's your job as a buyer to check there are brakes. (This is for institutional/qualified investors... for retail the rules are more protective)
There's not much for "consumer protection" in finance (it's generally caveat emptor, and for good reasons, but that's beside the point), but lying/fraud is illegal.
There's lots I don't understand about this. This seems to me to be only valid for long term funds invested in bonds and Treasuries or something.
Isn't what these people do is change their decision making constantly with shifting criteria? Isn't the bulk of what brought the house of cards down either unknowable, in denial, or covered over with Enron type mark to market delusions?
I understand the theoretical aspect of codifying some set parameters around an investment fund under which returns could be computed on a range of conditions, and that it couldn't be an attempt to capture business method criteria used in trading. I just don't see how the mortgage backed funds such as derivatives fo example could be codified since these people didn't know and quite frankly didn't care what was in them, they counted on a sham ratings scam to say that they were of such and such value by paid off people up and down the chain of deceit.
How do you codify a sham such as ratings backed sliced and diced subprime mortgages? No one could know how bad it was, they could only guess, and make sure the hot potatoes got tossed before the music stopped.
rd
...the inaugural obfuscated python programming contest...
I run: Windows, OS X, Linux, FreeBSD. Just because you have a hammer, doesn't mean everything is a nail.
XBRL is a good idea - a global, industry standard extensible XML schema for financial information presentation, including financial statements (income statement and balance sheet).
However, this proposal is encoding a scenario-based financial forecasting model developed by management and making a private entity (meaning not a governmental body, although perhaps a public company) publish that model. That's a bit too detailed, insidery and strategy-exposing for me, and I'm all about good transparency and governance.
This is asking public-company management to publish, on an near-realtime basis, it's business plan, current strategy, operational moves, future M&A activity, etc. Revealing the secret plans, as it were. A well-regulated free market, being necessary to the security of a free state, the right of the people to keep private certain financial information, shall not be infringed.
Will these be held to the same standards as current financial statement SEC filings (10K)? What if the scenarios, input variables, and model frameworks don't encompass all possible situations? What is an acceptable range of economic prevision? Can inaccuracy be the basis for shareholder or securities fraud lawsuits?
What the proposal covers is what financial analysts and corporate finance personnel do inside the company, and equity analysts do outside the company. You get (good) management's general operating philosophy and grand plans in the shareholder letter and the MD&A section of the annual report. Theoretically, at least, this is what the Board of Directors should assess as the shareholders' representatives (I'll save my comments about THAT for later), and with liquid markets you can vote with your feet, er, money.
I could see a new legal requirement to require the company to publish a standardized, general, 3-5 year strategic plan as part of the annual shareholder meeting proxy materials - maybe even allow the shareholders to vote on it (advisory or controlling vote). But we sort of have that now with the MD&A section.
Financial models are useful, and more public information about public companies is good, but I can see problems with something like this proposal. Smart blog discussions needed.
#include "Fraud.h"
int main()
{
startPonziScheme();
}
The SEC will never think of it, would probably rather get their cronies to sue Microsoft, AND SHOULD BE ABOLISHED because they're incompetent.
As I read this I have one semester left for my M.B.A. I am picking my classes for my final semester this week.
With this change do you think it would be worthwhile to take a class in Python during my final semester (this assumes that my University even offers such a class)?
Funny example. With a proper installation, I've never had to type more than "python someapp.py". Hell, if you setup the file associations, you just type "someapp.py".
In fact one can't codify the derivative sham. One holds a bucket under a male bovines rectum, until one has a large enough sample of said business process, for direct analysis.
Perhaps they could figure a way to display the actual and implied lies and deceits involved in these contracts... of course that would probably end investment as we know it anyway...
It's deeply shameful that the SEC would use such twisted language in a proposed requirement after they wrote this http://www.sec.gov/pdf/handbook.pdf handbook on how to use Plain English for disclosure documents.
It's more than a shame that there are no "right or benefit enforceable by law against the" SEC idiots who published this proposed rule with language that violates this http://govinfo.library.unt.edu/npr/library/direct/memos/memoeng.html Presidential Memorandum.
I've done contract for wall street investment banks, hedge funds, sovereign funds, and offshore currency traders. Not once have I used python or seen it in use. Finance is a KAPE world -- K, APL, Prolog, and (ugh) Excel.
Everywhere *EXCEPT* on Wall Street, "Establishing the principle of insurable interest as a requirement for purchasing insurance distanced the insurance from gambling" http://en.wikipedia.org/wiki/Insurable_interest.
"The ability of a person to buy insurance on [something for which loss-of or damage-to that thing would not cause the person to suffer a financial loss or other kind of loss] would create a moral hazard wherein the person owning the insurance policy stands to profit from the death of the insured [thing]."
Yeah, there was a lot of hand-wringing by Geithner, et.al. about how to avoid "moral hazard" in the future with respect to credit default swaps (i.e. insurance) that AIG had to pay to the Big Banks on CDOs that the Big Banks did not actually own (or owned an amount less than the insured value and, therefore, less than what they should have had an insurable interest in) but I promise you won't hear any of the captured regulators ever speak the phrase "insurable interest".
Not the same thing, but they are starting to move in this direction. XBRL is already being phased in by the SEC.
Why stop there? Let's require all financial software to be written in Python. It won't prevent another economic collapse, but it'll make damn sure that the next collapse happens much more slowly.
Proud member of the Weirdo-American community.
Code obfustication will become a profession instead of a silly contest goal!
"Bad" programmers rejoice! You can be the next generation of financial legal scholars!
That is, assuming no meaningful regulation happens that simplifies the system so that it can actually be monitored. Say, CS academics rejoice! You can invent new systems and proofs to analyze this overly complex code!
Job security here we come!
Democracy Now! - uncensored, anti-establishment news
See here for a domain specific language for financial contracts embedded in Haskell. A DSL is certainly the way to go over a "black box" or arbitrary Python code.
This seems to me to be only valid for long term funds invested in bonds and Treasuries or something.
It applies to CDOs, and perhaps to the broader class of structured investment vehicles. Nothing an individual investor is likely to meet face-to-face. (But your mutual fund manager most likely is wrangling with these beasts...)
Isn't the bulk of what brought the house of cards down either unknowable, in denial, or covered over with Enron type mark to market delusions?
Yes. But denial and deception are made much easier when no one really understands the investments they are making.
I understand the theoretical aspect of codifying some set parameters around an investment fund under which returns could be computed on a range of conditions, and that it couldn't be an attempt to capture business method criteria used in trading.
The purpose here is not just to publish a predictive model. Rather, it's to publish an algorithm that can over time be populated with the actual data on the return of underlying assets (e.g. mortgages), and based on that data give a definitive answer as to which tranche of the investment will receive what payments. The point seems to be twofold: (1) There is presumably less opportunity for litigation when the formula for payout on the investment is precisely specified in code; and (2) By providing an algorithm that exactly describes the investment, it is at least in theory possible for potential investors to understand what they are buying.
I just don't see how the mortgage backed funds such as derivatives fo example could be codified since these people didn't know and quite frankly didn't care what was in them,
Someone (e.g. Paulson & Co) knew and cared what was in those derivatives. Problem is, not everyone had the same level of knowledge. Transparency helps any market.
they counted on a sham ratings scam to say that they were of such and such value
The ratings agencies were often tasked with writing models to describe the investments they were rating. These models were proprietary information, available to investors at the rating firm's discretion, if at all. At least here, the models will be out in the bright light of day, for anyone who wants to examine and try to understand.
1) There are good reasons you have Judges. Spirit of the law, reasonable man, etc and from time to time fairness and justice.
;).
2) Badly written laws can just as easily be written in Python as they can be in some human language. Judges etc are normally far more familiar with the official language of the courts.
3) Legalese is already something like a programming language, and yes the fuzziness often is a feature not a bug, see 1).
4) When did they solve the halting problem?
The reason you have poor regulation isn't because you are using the wrong language. The problem is elsewhere, and if the regulators are the ones who thought of this idea they just providing yet more evidence that they are the problem
Ours is a common-law system - ambiguities are features. We want it vague so that human judgments filter in.
But I think we've gone down the wrong route. We go on about "rule of law" but we made it into nonsense. What does "rule of law" mean when we can't figure out what the law means without expensive lawyer service, and even then, if it goes trial, it's all up in the air?!
Commerce laws should be reformed to be much more the compilable sort with minimal ambiguities, including tort laws. Criminal and family matters, I would like to keep common-law tradition with the accompanying ambiguities.
Fuck systemd. Fuck Redhat. Fuck Soylent, too. Wait, scratch the last one.
Reason to choose a specific language: Otherwise, they could deliberately choose a language that's more obfuscated -- say, machine language -- or a proprietary language. Even if they provide the compiler for said language, it would be about as much an exercise in confusion.
Reason I'd prefer Ruby to Python: This isn't a case where performance is important, significant indentation (as much as I like it) may be a problem when people inevitably print it out, and most importantly, Ruby's internal DSLs look damned good. I think this does need to be a DSL of some sort, and I'd rather it be an internal DSL than an external one -- but I'd rather it be a DSL than a Python library.
Don't thank God, thank a doctor!
After a few rounds by Microsoft lobbyists, the required language switches from Python to Visual Basic
real regulation bans gambling. investments only benefit everyone and expand economies, move ideas forward, and improve lives when the investments are in the physical economy. the way out is to ban the speculation and return to glass-steagall standards. this proposed regulation is not regulation at all... it's more of the same casino style gambling that will continue the hyperinflation and continue the collapse. wake the hell up.
Is it desirable to have an exclusive stock exchange for Individual Investors aka http://en.wikipedia.org/wiki/Value_investing because they cannot compete with Institutional Investors aka http://en.wikipedia.org/wiki/Algorithmic_trading
I'd like to buy homeland for our 10 million people. http://twitter.com/mahadiga
Analogy is a good one and it is quoted from MSNBC to explain how shorting a stock works and how AIG got involved in the scam.
They bought insurance from AIG and asked the Bush white house to make sure AIG had bailout money.
It tanked and Goldman Sachs shorted the stock. Then Paulson Co asked AIG for insurance for the lost value. Paulson split the money with Goldman and they double dipped with stolen tax payer money. Goldman and Paulson Co knew it was about to be worth toilet paper so they shorted it and funneled tax payer money from AIG to make it look like a loss. They both collaberated and this is similar to selling a car that would fail and taking out an insurance policy on it.
Insurance fraud at its finest. There is no disclosure. Its really a secret but hey housing is very very safe get in fast! .. etc
http://saveie6.com/
Python is huge in Ubuntu. Its part of gnome and used in hundreds of applications.
Its been around for 10 years now and I see articles everywhere at tech sites and magazines promoting its usage. In fact, its the only language supported for Google's cloud services. Its the only language that can run in .Net, Java, MacOSX, Windows, and Linux. Its gaining popularity and is used for PostGreSQL admin tools and many other mission critical things that you are probably not even aware of.
You can run Jython on googles phone with JavaME without modification and this makes it very powerful in the cell phone market.
http://saveie6.com/
I've been browsing quite a lot of business news sites lately and am constantly bombarded with ads from various tiny, never-heard-of brokerage firms whose software you can download for free and use both for making your own analyses and buying shares (resulting in brokerage fees, which most claim are "the lowest of all", going to them). Now, I'm very skeptic of such applications since the firms offering such software have an incentive to give you an overly optimistic prognosis and also to encourage you to trade frequently, which is usually the worst you can do - especially if you're a small investor. IIRC Warren Buffet has said that "buy and keep" is the winning strategy...
Now, I'm much less skeptical of the tools that at least one Finnish business newspaper offers their subscribers on-line for creating and analyzing portfolios in various scenarios and since the newspaper's source of income is subscriptions, they have an incentive to offer the best tools possible. And occasionally they have had "trading games" (with pretty good prizes too, e.g. laptops) where you get virtual money to "buy" a portfolio of shares and maximize its value in three months or so. The virtual shares have the same value as in the real world so you can use any source you can think of for information to make your trading decisions - corporate home pages, any business news, your magic eightball etc. And in the games they also have "brokerage fees" that are typical of known brokerage firms. When I've played myself, I've really enjoyed it even though I haven't done very well but since it's as real as can be, it's good practice, in case I want to try it with real money at some point.
I think a lot of government, contractual, and patent issues could be helped if people were required to provide executable code that illustrates some function and computes some binding result.
However, Python is probably the wrong language for that: it doesn't have an official standard, it doesn't have a compatibility test suite or fully compatible third party implementations, it has some implementation dependencies, and it has standard libraries with huge and complex third party dependencies.
A language for legal contexts should be small, standardized, safe, self-contained, have multiple implementations, and be fairly stable. It doesn't need to be nice or convenient to program it. Scheme and JavaScript might fit the bill. Ada, Fortran, and C share some of the necessary attributes.
This proposal has one major benefit - lots and lots of lawyer cash becoming programmer cash instead.
This is an interesting proposal. We are using something similar at my company, which offers one of the most detailed databases for retail structured products.
What some people posting here misunderstand is that the proposal isn't about making available magic formulas or explaining, why a call option retails at $12,34 at a given moment. It is simply about calculating the resulting cash flow that the buyer receives from a product in a given scenario. So it let's you try out, what you receive when you assume that at maturity the underlying stock is at $15.
It does not automatically tell you if the option should be worth $12,34 or $2,34 right now. The current fair value is part of the magic sauce: It can only be calculated with the right assumptions, eg. the assumed volatility, the current interest rate structure, ... Different market participants will usually make different assumptions here, but with these assumptions plus a numerical pricing model plus the program supplied to you under this scheme you can also calculate your fair value for the product.
In my opinion a general purpose language like Python is not a good fit for this use. In any case, very strict interfaces would need to be defined. If there were multiple ways to input the assumed stock price (which is just one of a very large number of parameters), then this would not be much more useful, than the current written documentation of the products. With a general purpose language there might also be hundreds of possibilities to program even simple structured products, which makes reading/debugging these programs needlessly hard.
We have developed a special purpose language internally, that can be used to easily program variable cash flows that depend on other market data. The good thing about such a special purpose language is that most standard product have a generic representation, that is short enough to be easily read, understand and (if needed) debugged. We supply "code" for the more than 400.000 active retail structured products in our database to our customers and they can for example try out, which product works best for then in a given investment scenario.
You might have a similar effect by using a generic language + strict interface definition + enforced use of a standard library. But a compiler/interpreter for a simple special purpose language can easily be implemented in most environments while many possible users of this project might not like adding a full python-interpreter to their system.
bye, Paul.
It's pity that they used Python while Haskell has more formal semantics and an implementation that already used in financial sphere.
There is a free implementation of Composing Contracts code.
BF
http://en.wikipedia.org/wiki/Brainfuck
Jesus told him, "I am the way, the truth, and the life. No one can come to the Father except through me. - John 14:6 NLT
I understand the goal of being able to fill in your own predictions, but this sounds like a *very* poor excuse for transparency. Why not mandate a clear explanation, in plain English (if there is such a thing in the financial world).
Furthermore, do you realize what "Python" means to 98% of American public? My dad has been an engineer who programs process control systems for darn near forty years and I certainly can't talk to him about programming languages! Do you really think investors have the knowledge required to install Python, modify a program, run it, and extract meaningful information from the result? Yeah, I know exactly how simple it is. That's why you're reading /.
If you want to go this route, you would basically need a scriptable calculator with a few basic financial functions. No frills, no black boxes that can be imported, all packaged in a simple Windows point-and-click program. Maybe a web interface. But that's still not to be confused with transparency.
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.
Do You work for Magnetar? That's confidential information you're handing out there. Bad dog, no bonus for you this year.
TCAP-Abort
Example of Normalized English Input to NLESB
Normalized English has been developed by Layman E. Allen and his colleagues; see for example, Layman E. Allen, ``Language, Law and Logic: Plain Legal Drafting for the Electronic Age,'' Computer Science and Law (Bryan Niblett ed.), 1980, pp. 75-100. Normalized language has been used in the Tennessee statutes (Tenn. Code Ann. sect. 33-6-104(a) (1991)).
An example of the form of Normalized English used as input to the NLESB system follows. Note that the formatting is for the sake of readability, and is not necessary for NLESB.
Subsection (a). IF AND ONLY IF
(1)(A) A person has threatened or attempted suicide or to inflict serious
bodily harm on himself, OR
(B) The person has threatened or attempted homicide or other violent
behavior, OR
(C) The person has placed others in reasonable fear of violent behavior
and serious physical harm to them, OR
(D) The person is unable to avoid severe impairment or injury from
specific risks, AND
(2) There is a substantial likelihood that such harm will occur,
THEN
(3) The person poses a "substantial likelihood of serious harm" for
purposes of subsection (b).
Subsection (b). IF AND ONLY IF
(1) A person is mentally ill, AND
(2) The person poses a substantial likelihood of serious harm because of
the mental illness, AND
(3) The person needs care, training, or treatment because of the mental
illness, AND
(4) All available less drastic alternatives to placement in a hospital or
treatment resource are unsuitable to meet the needs of the person,
THEN
(5) The person may be judicially committed to involuntary care and
treatment in a hospital or treatment resource.
http://www.cs.utk.edu/~mclennan/NLESB-normal.html
Natural-Language Legal Expert System Builder (NLESB)
NLESB enables a lawyer to build a useful legal expert system in ordinary English without being a computer expert. It accepts rules in ordinary English, though in normalized form, and parses them into propositional data structures that it can use to draw inferences. NLESB has some features, particularly in its logic, that are peculiar to the needs of legal expert systems.
Send me mail for reprints or if you are interested in using our prototype implementation.
Publications (reverse chronological order):
A Logic for Statutory Law, by John Nolt, Grayfred B. Gray, Bruce J. MacLennan, and Donald J. Ploch, Jurimetics 35, 2 (Winter 1995), pp. 121–151. Winner of Loevinger Prize.
Legal Expert System Building: A Semi-Intelligent Computer Program Makes It Easier, by Grayfred B. Gray, Bruce J. MacLennan, John E. Nolt & Donald R. Ploch, John Marshall Journal of Computer and Information Law, 12 (1994), pp. 555–583.
Readability of the Law: Forms of Law for Building Legal Expert Systems, by Donald R. Ploch, Bethany K. Dumas, Grayfred B. Grey, Bruce J. MacLennan, and John E. Nolt, Jurimetrics 33, 2 (Winter 1993), pp. 189–221.
Law Reading Experiment, by Donald R. Ploch, Bethany K. Dumas, Grayfred H. Gray, Bruce MacLennan, & John Nolt, Pre-Proceedings of the III International Conference, Logica Informatica Diritto: Legal Expert Systems, A. A. Martino (ed.), Consiglio Nazionale delle Ricerche, Istituto per la documentazione giuridica, Florence, Italy, November 2-5, 1989, Vol. 2, pp. 681–704.
Seastead this.
... the filed source code, when downloaded and run by a taxpayer, must provide the user with the ability to calculate their taxes, describe where the money is being spent, which congressmen created each behavior, ...
This very much reminds me of:
Composing contracts: an adventure in financial engineering
http://research.microsoft.com/en-us/um/people/simonpj/papers/financial-contracts/contracts-icfp.htm
by Simon Peyton Jones.
It also reminds me of machine executable contracts in the form of computer programs being traded around in some sci-fi I have read recently...either Vinge ("Deepness in the sky", "A Fire Upon The Deep") or it may have been Stross ("Accelerando"), I don't recall which. They are both same genre and fascinating to me.
Just to counter the idea that this is something new - these cashflow models are always expressed as code somewhere. The difference in this proposal is about standardization (on Python/XML) and transparency. The people who this is aimed at are not the public, but sophisticated investors - if they don't have their own models, they should have access to someone else's models.
Ratings agencies and most banks have sophisticated (usu. web based) tools to run both credit and cashflow models on securitizations. These are usually scripting based, and with the right permissions users can see/vary all historical data, assumptions, inputs and cashflow scripts.
These would provide the user with a full suite of sophisticated tools “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 (page 210 of SEC proposal)” as mentioned above.
I think the SEC should mandate that these should be freely available to all investors, rather than forcing everybody down a limited functionality Python / XML route that may not be the best solution.
Thanks for mentioning this work!
LexiFi (the company I'm working for) has been founded by one of the authors of this academic paper and our core technology is based on the same principles. We use OCaml as our implementation language, but the approach is really language agnostic. The basic idea is to represent complex derivatives as terms of a small DSL, with a few well-understood basic blocks and combinators. Contracts are just simple pieces of data, that can be exchanged and manipulated by independent systems, and there is a clear semantics for the language.
Based on this approach, LexiFi has developed an implementation of the DSL, with many "universal" operations that works on arbitrary contracts described in the DSL: pricing, life-cycle management, risk-analysis, reporting tools. We expose these operations in GUI applications targeted to specific kinds of end-users, and the uniform representation of financial instruments gives us a lot of productivity to add new kinds of contracts.
Clearly, another great use of the representation language is to have "electronic term sheets", that is, executable descriptions of contracts that can be understood both by humans and by computers (due to the controlled expressivity of the DSL). This is very much in line with what the SEC proposes.
Trading != Investing
I'd like to buy homeland for our 10 million people. http://twitter.com/mahadiga
you really are a sucker.
My analogy is EXACTLY what Goldman and other investment banks did.
I believe 99% of flaws in stock exchanges can be prevented if every trade is scrutinized as per Insider Trading rules. http://www.sec.gov/answers/insider.htm laws.
I'd like to buy homeland for our 10 million people. http://twitter.com/mahadiga