
Petition: Public Money Should Produce Public Code - kiyanwang
https://creativecommons.org/2017/09/18/sign-petition-public-money-produce-public-code/
======
shanear
Wholeheartedly agree. There is a big push do this inside the US federal
government right now. I work for the United States Digital Service, and at the
Department of Veterans' Affairs, almost all application code we write is open
source:

[https://github.com/department-of-veterans-
affairs](https://github.com/department-of-veterans-affairs)

This push is happening in other agencies as well. Check out
[https://code.gov/](https://code.gov/) for other shared projects from agencies
around the federal government.

~~~
criddell
How has your experience with the USDS been? From a selfish point of view, it
seems like a great way to make contacts in the industry while serving your
country.

~~~
shanear
I'm coming up on having been here for two years, and both of those things have
been true. It's been a great experience to work alongside top-notch folks from
all over the tech industry on problems that deeply impact so many lives.

It's also the best civics lesson you'll ever have. You get to see up close how
the federal government runs, good and bad. There's a lot of nuance on how
policy, legislation, and technology all interact that I didn't appreciate
before I worked for the USDS.

~~~
CryptoPunk
>>There's a lot of nuance on how policy, legislation, and technology all
interact that I didn't appreciate before I worked for the USDS.

Would you mind sharing some of your insights?

------
rvanmil
I've seen quite some code which was paid for by public money. If this would
actually happen it would mostly just expose a tremendous shitheap of
"enterprise" code created by consulting firms whose entire business model is
based on delivering and "maintaining" overengineered crap with huge
maintenance costs.

~~~
daenney
> If this would actually happen it would mostly just expose a tremendous
> shitheap of "enterprise" code created by consulting firms whose entire
> business model is based on delivering and "maintaining" overengineered crap
> with huge maintenance costs.

But that's a good thing to expose too. Might even provide a deterrent to those
that are in the habit of producing bad and over-engineered work as it'll be
public and potentially affect their reputation. And even then, we can probably
still use that code and learn from it. Just because bad code is written with
public money doesn't mean it should be kept private.

~~~
rvanmil
Agreed, however I think it is unavoidable simply because demand for cheap code
is many times higher than demand for good code. And even if it was the other
way around, I don't think the market would be able to provide it.

------
dmos62
I hope this campaign gets some traction. Closed source is wasteful, and even
more so to fund it with public money.

Software development today is quite inefficient. It mainly suffers from two
problems: duplicated effort, when a solution already exists, but it is
inaccessible, and misdirected effort, when a problem is solved in a way that
doesn't facilitate preparing other, possibly hardly-related, solutions in the
future.

The cause of duplicated effort is that closed source carries no social stigma;
in other words greed is not penalized. The cause of misdirected effort is lack
of understanding of how to ergonomically assemble sub-systems into systems,
which is simple enough and is described in the Unix philosophy [0], but
nonetheless is very rare.

[0]
[https://en.wikipedia.org/wiki/Unix_philosophy](https://en.wikipedia.org/wiki/Unix_philosophy)

~~~
jsty
> misdirected effort, when a problem is solved in a way that doesn't
> facilitate preparing other, possibly hardly-related, solutions in the future

Would you be able to clarify what you mean by this? In my experience, trying
to write all-encompassing software quickly leads to issues with actually ever
getting anything out the door in a working state - better to solve your
particular problem and generalise later as needed.

~~~
corobo
In my experience misdirected effort comes more from a lack of planning or
full-fat spec being produced before the work begins rather than an attempt to
cram in every feature under the sun.

Instead of knowing exactly what features to put in you get a request along the
line of "We need something that does x" and no time to plan how to do x, so
you end up with something that does it then the feature creep starts, making
the original x look like a code version of Seth Brundle after his
teleportation mishap in The Fly.

The age old "Weeks of programming can save hours of planning"

~~~
jsty
Totally agree. A few pages of good spec / design docs can save so much wasted
effort. Indeed I'd struggle to think of many non-trivial past projects where
committing the design to paper hasn't revealed some hidden flaw that would've
bitten hard later on.

> Seth Brundle after his teleportation mishap in The Fly

For anyone who didn't get this reference like me ...
[http://i43.tinypic.com/2ngr969.jpg](http://i43.tinypic.com/2ngr969.jpg)

------
ptero
The intent is good and I hope we find a good way to implement this.

I do see pitfalls though: I would separate ownership (i.e., one cannot patent
the code developed with public money -- IMO a good idea) and visibility
(showing the code on request -- IMO a very dangerous one).

My big concern is formalizing things that should be left informal. For
example, in applied research, we usually build a number of throwaway
prototypes before the real system. Those quick prototypes and proofs of
concept are often ugly in many ways. If I have to expose those to the world I
have to smooth sharp edges (HR -- "we cannot get _this_ outside"), which means
instead of building 10 throwaways I can only build 2-3.

~~~
jack9
> in applied research, we usually build a number of throwaway prototypes
> before the real system. Those quick prototypes and proofs of concept are
> often ugly in many ways.

So basically you just do normal development? In the commercial world, one of
those prototypes usually becomes the production code.

~~~
ptero
Yes; but I am just saying that putting a bright spotlight on intermediate
steps might stifle quick prototyping.

~~~
chii
i don't think public code means community driven, or public development.

Just uploading a zip of the final source code is enough to count as public
code imho.

------
fmsf
This would specially be interesting to enable easy external auditing.
Specially since governments rely a lot in large consulting companies, and
these often deliver software of questionable quality. Also easier to evaluate
would be the high costs usually associated with contracts to develop software
sponsored by tax money.

~~~
giancarlostoro
Also those who review the open sourced code could find themselves getting job
offers potentially, or find it easier to apply for jobs with those systems.
The only exception I see to the whole "Public Money should produce Public
Code" is in the defense sector depending on the project components. We
wouldn't want to share code that is used in war with the entire world I don't
think?

------
caxistic
I'd love to see this be adopted in the US, but I'm not holding my breath.

There's an example of this in my field that upsets me quite a bit. A set of
tools were developed using public funds through federal research grants and
other similar mechanisms, with the express purpose of making free alternatives
to private tools available. After the project was successfully completed, the
leaders of the project decided to start charging hundreds of dollars for
"maintenance" of the toolset, which would only run on Apple devices no less.
(For some tools, the cost is substantially less than private alternatives; for
others it's more expensive or about the same.)

My concern about this isn't so much that they started charging money to
maintain the project per se, after federal grants ran dry. My concern is that
the product development costs were already paid for using taxpayer dollars,
and that if it were open-sourced, it would be almost as usable, if not more
usable (if it were ported to other non-Apple platforms), and free.

The other area of this that I find upsetting are these "small business grants"
that basically use taxpayer funds for VC software development, with no public
return. Government pays for software development, and then the developer gets
to charge for it later.

~~~
mmaurizi
The public return comes in the form of the company that receives the grant
paying federal income taxes on their profits.

Commercial profitability is usually a desired goal for these business grants,
_because_ the government wants their money back (via taxes).

------
sabujp
Unfortunately this doesn't work in public education where it is most needed.
All the companies pushing content to the kids, e.g. i-ready, st-math, while
they may be "non-profit" do not share their code or source materials. What's
worse is often their licenses only last for 1 year and have to be renewed
again.

------
gregman1
Example: Public of Andorra gives money to Andorra Programmers to make some
cool program that all people need.

Why US Public is allowed to use that code? Andorra's budget is not that big so
why people of Andorra should pay for people in States? That's a very good way
to not produce Public Code at all.

~~~
mattnewton
There are other benefits, like US public submitting bug fixes, Andorra's code
becoming a de-facto standard making it easier for them to hire contractors and
support, and the fact that Andorra can use lots of open source from the US
already. It's not a zero sum game.

------
jbreckmckye
One counter argument: national taxes shouldn't be used to produce code that
could benefit other countries, unless that is recognised as a kind of
international aid.

(Not my opinion, but one I can imagine from certain political quarters)

~~~
dec0dedab0de
Has anyone ever made the argument that NASA images are international aid,
because they help astronomers in other countries?

~~~
cmurf
Well what matters is whether it is, or can even be, a convincing argument.
Just saying things doesn't make them true.

~~~
tadufre
it makes them true for some people

------
thomastjeffery
The obvious problem with proprietary code is the questionable quality of
consulting companies, etc., but I think the biggest advantage to free software
is _interoperability_.

Right now, there are thousands of _data entry_ jobs, whose sole purpose is to
translate data from one system to another, often _within the same
organization_.

A friend of mine who has recently learned simple Visual Basic has told me
about what he calls "huge" savings simply from writing scripts to copy and
transform data rather than pay people to read and type it.

------
d4rti
Much of gov.uk is open source [https://www.gov.uk/service-manual/service-
standard/make-all-...](https://www.gov.uk/service-manual/service-
standard/make-all-new-source-code-open)

~~~
_joel
It's unfortunate that large public sector orgs in the UK are going more in for
AWS and their proprietry pieces such as DynamoDB though. Also more crazy when
they (AWS) pay very little corporation tax and one of the orgs is in charge of
collecting tax </rant>

------
otakucode
At the US federal level this already occurs. Any code written by government
employees exclusively gets released to the public. Just the other day I came
across the NIST biometrics matching stuff which was made open for exactly this
reason.

------
yostrovs
Shouldn't then transportation funded with public money be freely accessible?
What about public parks that now we have to pay for to get in?

------
tobeportable
I like how this video also calls for open architectural plans, aka the source
code of our buildings.

