

ACM weighs in on SEC proposed Python requirement - tzs
http://www.sec.gov/comments/s7-08-10/s70810-89.pdf

======
tom_b
Link to the proposed SEC rule:

<http://www.sec.gov/rules/proposed.shtml>

Look for 33-9117.pdf

Interesting questions based on my reading from the pdf (see excerpt below,
italics by me): If it's not currently practical to evaluate an investment
before making an investment decision, why would you make the decision to
invest? <cough,cough, index fund, cough>

Next, who wants to do a constraint-programming back-end web app that takes a
prospectus and generates this functional code? How much would institutions pay
us for this?

From the pdf:

"The ABS issuer or the underwriter generally will have a computer model of the
waterfall. However, the issuer or underwriter currently has no obligation to
share the computer model with actual or potential ABS investors. Because
prospective investors in ABS typically do not have access to the ABS issuer’s
computer models, under current conditions, an investor must create its own
computer program. It does this by taking the priority of payment rules stated
in the trust agreement, pooling and servicing agreement, indenture, or other
operative document for the ABS and described in the prospectus, converting the
English language statement of those provisions into one or more algorithms,
and then expressing the algorithms as computer code in a programming language.
_As a practical matter, it is often not possible to complete these steps
before making an investment decision._ This is particularly onerous for
smaller institutional investors, for whom it may not be feasible to acquire
the financial and technological expertise necessary to develop a computer
program of the waterfall. Thus, investment decisions with respect to ABS may
be made without the benefit of the investor performing its own quantitative
valuation analysis. This may encourage undue reliance on the determinations of
credit rating agencies. Further, there is the possibility that some investors
will program the waterfall erroneously, leading to inaccurate ABS valuations."

------
agentultra
I don't understand why the ACM is so perturbed by Python. Why did the SEC
choose Python to begin with? I'm sure that they weren't concerned with the few
milliseconds you might lose on Monte Carlo simulations vs a compiled language
implementation. While all valid points in one way or another, their criticisms
of Python appear to lack context. Did the SEC choose Python for its speed and
security?

~~~
btilly
The SEC probably chose Python because it has a reputation of being easy to
read and write.

For me the deal killer about Python in particular is that it uses native
arithmetic, which means that going from machine to machine, and operating
system to operating system any program that uses floating point will have
unspecified behavior.

I've worked in finance and dealt with programs that use floating point. I've
encountered the fact that behavior changes on different machines. Now a 1 or 2
penny difference on a several million bond flow may seem unimportant, but it
is unfortunately very important because the first thing anyone in finance does
to verify that two numbers match is look at the first digits, the length of
the number, and the pennies. If those agree, you move on.

So those insignificant penny differences are unfortunately the first thing
that gets noticed. Been there, done that, not fun.

~~~
parfe
Floating point cannot represent money.

~~~
tzs
What would you use to represent money?

~~~
binarysoul
whole numbers, ie cents

100 cents instead of 1.00 dollars

~~~
tzs
So basically integers. Floating point can represent integers, and floating
point add, subtract, and multiply on integers is exact, so why not use
floating point to represent cents?

On a 32-bit machine, using native integers limits you to $40 million dollars
or less ($20 million or less if you have to use signed integers). Double
precision floating point gives you something like 52-bit integers.

When dividing, you would have to explicitly use floor, round, or ceil to make
the result be an integer.

------
mustpax
For more background see: <http://news.ycombinator.com/item?id=1272541>

SEC is proposing that prospectuses (prospecti?) for asset backed securities
include a simulator written in Python. The investor can use this simulator to
test out the behavior of their investment under various conditions.

Fascinating idea, I wonder, though, what is going to happen when the simulator
and the prospectus disagree. I would assume the text of the prospectus would
override the source code. It is going to be quite a challenging task trying to
align legalese and Python, or any other programming language for that matter.

~~~
btilly
Unless the simulator carries more legal force than the prospectus, the entire
exercise seems to be useless.

~~~
yummyfajitas
Presumably if the simulator and the prospectus differ in a material manner,
the bond packager/issuer would be subject to some legal liability.

~~~
btilly
The problem is that the prospectus is a legal document. When you run legal
documents through the legal process, you often get indeterminate answers. How
much liability should the bond packager/issuer have if their simulation
accurately reflects their understanding of the agreement, but a court decides
that their understanding was incorrect?

~~~
yummyfajitas
I think that amount would vary based on whatever the standards are for due
diligence and the indeterminate nature of the legal answers.

However, as I understand the proposal, most such legal problems would be
irrelevant as far as the python program is concerned. The python program would
only answer questions like "what happens if party XXX becomes insolvent" or
"what if 84% of mortgages are repaid, 10% are prepaid and 6% are in default".
Most legal disputes would center on issues like "were material factors
relating to mortgage repayment rates properly disclosed" or "are former home
borrowers currently squatting 'in default' or merely 'delinquent' if the
mortgage servicer has failed to evict them". The answer to questions like
these is simply the _input_ to the python program.

~~~
btilly
Absolutely, the Python program cannot replace the prospectus for the reasons
you describe.

However current practice is that the prospectus also describes, in legalese,
the rules by which you determine what happens if party XXX becomes insolvent,
or what happens if 84% of mortgages are repaid, 10% are prepaid and 6% are in
default. And then there are multiple scenarios supplied to clarify people's
understanding of how those rules work.

There is a cottage industry that basically consists of taking these
prospectuses and creating computer versions of them. This is called reversing
a deal. I've seen these models take anywhere from a day to a week for simple
models, and for complicated ones outside specialists may need to be used.
These models are considered valuable property, and so a given deal may wind up
being reversed by multiple people. These created models often do not agree
with each other or the servicer.

If the prospectus continues to contain the authoritative explanation, then
this activity is still a necessary sanity check. If the script is definitive,
then this error-prone step can be greatly streamlined and automated. Getting
rid of this expensive activity strikes me as a very good thing.

Disclaimer, I used to work for a company whose main job was reversing deals,
and then keeping models up to date as the cash flows came in. I did not work
on that side of the business, but I've seen how important it is.

------
tom_b
um.

Users (non institutional investors?) will download a program with the asset
backed security information in a separate XML file, use that file to perform
their own analysis of the possible performance and cash flow (called the
waterfall in the proposal) to make an individual determination of the actual
value of an ABS pile of investments.

You've got to be kidding me, right? _This_ is how we are to increase
transparency in pooled ABS investments?

Forget the fact that the ACM is weighing in on the appropriateness of Python
as the program's implementation language here - say there is a bug in the
implementation of the program that allows you to model this waterflow cash
flow. Who can I sue, if as an individual investor, I relied on this
implementation (along with my subtle tweaking of simulation variables) to make
an investment decision?

Forgive my naivete, maybe I've made a bad assumption about what the program is
supposed to actually reflect. Does it represent a firm contract or rule set
about how cash flow in the ABS pool will work given certain inputs?

~~~
nkassis
I think if there is a bug, it's your job as an investor to find it and report
it (if it's unintentional of course). The program is provided to you in source
form to allow you to verify and modify it.

------
bhiggins
Someone at SIGPLAN must really like F#.

~~~
kd0amg
Well, it is a group for languages enthusiasts, a demographic which seems to
like functional programming more than others do.

