TITLE: Debugging the Law
AUTHOR: Eugene Wallingford
DATE: November 19, 2010 4:45 PM
DESC:
-----
BODY:
Debugging the Law
Recently, Kevin Carey's
Decoding the Value of Computer Science
got a lot of play among CS faculty I know. Carey talks
about how taking a couple of computer programming
courses way back at the beginning of his academic
career has served him well all these years, though he
ended up majoring in the humanities and working in the
public affairs sector. Some of my colleagues suggested
that this article gives great testimony about the value
of
computational thinking.
But note that Carey didn't study abstractions about
computation or theory or design or abstraction. He
studied BASIC and Pascal. He learned computer
programming.
Indeed, programming plays a central role in the key
story within the story. In his first job out of grad
school, Carey encountered a convoluted school financing
law in my home state of Indiana. He wrote code to
simulate the law in SAS and, between improving his
program and studying the law, he came to understand the
convolution so well that he felt confident writing a
simpler formula "from first principles". His formula
became the basis of an improved state law.
That's right. His code was so complicated and hard to
maintain, he through the system away and wrote a new
one. Every programmer has lived this experience with
computer code. Carey tried to debug a legal code and
found its architecture to be so bad that he was better
off creating a new one.
CS professors should use this story every time they try
to sell the idea of universal computer programming
experience to the rest of the university!
The idea of refactoring legal code via a program that
implements it is not really new. When I studied logic
programming and Prolog in grad school, I read about the
idea of expressing law as a Prolog programming and
using the program to explore its implications. Later,
I read examples where Prolog was used to do just that.
The
AI and law community
still works on problems of this sort. I should dig
into some of the recent work to see what progress, if
any, has been made since I moved away from that kind
of work.
My doctoral work involved modeling and reasoning about
legal arguments, which are very much like computer
programs. I managed to think in terms of argumentation
patterns, based on the work of Stephen Toulmin (whose
work I have
mentioned here before).
I wish I had been smart or insightful enough to make
the deeper connection from argumentation to software
development ideas such as architecture and refactoring.
It seems like there is room for some interesting
cross-fertilization.
(As always, if you know about work in this domain,
please
let me know!)
-----