|
|
Under their current political system, the American chattel have a “civic duty” to voice their opinion about who they want as a representative. Every 4 years potential presidents spend billions on campaigns to excite the plebeians to “get out and vote!” to “make their voice heard!”. That money would certainly have more impact if spent on the actual causes that Team Red and Team Blue claim to care about. Rather than offer direct assistance, both parties choose instead to promulgate the most basic falsehood of possible: that your vote counts in the national election for president. Nothing excites people more than sports that matter least.
Let’s count the ways that the system ensures your vote does not count.
First, gerrymandered districts ensure predictable voting outcomes. Politicians regularly carve up their constituency in ways designed to support the current power balance, usually to protect the incumbent. From the national perspective, these districts make predictable state outcomes, whether Red or Blue.
Second, either others outnumber your vote when you hold the minority opinion or you vote with the tide. “In either case, your vote does not decide the outcome. In all of American history, a single vote has never determined the outcome of a presidential election”[Reason, 2012].
Third, the Electoral College can ignore the popular vote. “There is no national election for president, only separate state elections. For a candidate to become president, he or she must win enough state elections to garner a majority of electoral votes.”[Walbert, 2004]. Electoral delegates have no obligation to vote the same way as the popular vote of the state they represent, but they usually remain faithful.
Fourth, in the event that a state doesn’t have a clear position, the Supreme Court might decide. In 2000, the state of Florida did not have a clear preference, even after multiple recounts. When hearing the lawsuit over whether the recounts should continue, the Supreme Court accepted the de-facto power to decide the outcome of the election.
Fifth, Congress can decide. According to the rules of the Electoral College, “If no candidate wins a majority of the electoral votes or if the top two candidates are tied, the House of Representatives selects a president from among the five candidates with the most votes.”[Walbert, 2004]. According to this rule, Libertarian Gary Johnson has a chance in 2016 if he can win his home state of New Mexico [Wilson, 2016].
Now I’ve given reasons why your vote doesn’t count, let me address why it does matter.
South Africa endured many years of violence under the Apartheid regime. Many people and countries worldwide boycotted Apartheid, but the US government insisted on supporting the Apartheid regime, saying that while the US abhorred Apartheid, the regime was the legitimate government of South Africa. Then the Apartheid regime held another election. No more than 7% of South Africans voted. Suddenly everything changed. No longer could the US or anyone else say that the Apartheid regime had the consent of the governed. That was when the regime began to make concessions. Suddenly the ANC, formerly considered to be a terrorist group trying to overthrow a legitimate government, became freedom fighters against an illegitimate government. It made all the difference in the world, something that decades more of violence could never have done.
In Cuba, when Fidel Castro’s small, ragged, tired band were in the mountains, the dictator Batista held an election (at the suggestion of the US, by the way). Only 10% of the population voted. Realizing that he had lost the support of 90% of the country, Batista fled. Castro then, knowing that he had the support of 90% of the country, proceeded to bring about a true revolution.
In Haiti, when the US and US-sponsored regimes removed the most popular party from the ballot, in many places only 3% voted. The US had to intervene militarily, kidnap Aristide, and withhold aid after the earthquake to continue to control Haiti, but nobody familiar with the situation thought that the US-backed Haitian government had the consent of the governed or was legitimate.
You’ve Got to Stop Voting by Mark E. Smith
Whether your candidate has a chance or not, your participation in the vote directly demonstrates your “consent to be governed”. The politicians have a system of elaborate and arcane rules, which they deliberately devised to disenfranchise your voice. The political class cares far more about you checking a box than they do about which box you check.
“Boycotting elections alone will not oust the oligarchy, but it is the only proven non-violent way to delegitimize a government.”[Smith, 2012].
I just attended the Young American’s for Liberty state convention yesterday in order to hear the venerable David Friedman speak. Below are my notes highlighting the main points of the talk. You may recognize some examples and positions if you’ve been following his work.
Economists studying market failure make legitimate arguments against laisse-faire, but those arguments make a stronger case against government. Let’s define market failure as those circumstances in which individual rationality doesn’t lead to global rationality. For example, suppose we were part of an army standing on the battle field. I think, there’s only a minuscule chance that it affects the battle if I defect, and I will almost surely live as the others delay the opposition by fighting. All of us execute that logic, we all run, and the opposition kills us. To take another example, I am warmed greatly by burning coal and only make a minuscule contribution to the London fog. But, it’s possible (though not always), to engineer around the failure with a change of the rules. For example, the arab’s deadlocked in the open desert making no progress to the nearby oasis as they insist on winning the “who’s got the slowest camel” competition. Economists largely assume that people act in their own rational self-interest and that’s generally the case.
But what about Public Goods? (aside: The government often produces private goods, such as the post, while many public goods are produced privately, such as education and libraries.) Let’s define a public good as one that’s open to consumption, where the producer cannot capture payment from the consumer. For example, the beauty of the Sears Tower, listening to an unencrytped radio broadcast, or watching a TV program. For some cases, the market arrived at a clever solution: couple the public good (radio program) with a public bad (advertisement) and let the baddies subsidize the good for the enjoyment of all.
There are often externalities, in both directions. Some the costs outweigh the benefit and others where the cost is less than the benefit but the producer can’t collect enough to make it worth the effort. For example, take a resturant, a movie theater, and a store. It might not be worth running any individual enterprise, as they impose foot traffic on neighbors (negative externality). But if they occur together, say in a mall, then the traffic is mutually beneficial to all stores (externality becomes positive) and the rent for a shopwindow captures some of that.
Not all problems are solveable with laisse-faire and the market result is often less than ideal (comparison to the ideal is how the market ‘failed’ even when the outcome was considered ‘good enough’ by the people). With perfect information, you might be able to obtain the ideal, but we are in very short supply of good dictators.
Democracy also has its failure modes. For example, voters should be knowledgeable and informed when they cast their ballots. But proposals are seldom transparent. For example, the Farm Bill is never advertised as a money transfer program. Plus, in a representative system, the voter has a double-indirection problem. First they must know how good/bad each bill is and then they have to know how the candidates voted. Often that’s unknown, because the candidate is new (actually, all upcoming bills are unknown). Given that the chances of changing the election are slim, how much should a voter invest in becoming informed? Not much, they should be rationally ignorant, with two exceptions. One, the think politics is fun and do it out of intrinsic interest and two, they have influence or represent a special interest and have a high stake in the result. In this market, we see concentrated special interests winning benefits over dispersed victims.
What about long term planning? In the market, why should I plant black walnut trees which won’t bear nuts until I’m long dead? Well, ten years from now I can sell them! to a person that doesn’t want to wait as long. In turn, they could sell years later to a still more impatient person. But the transfer needs strong and secure property right. I must expect that the field is still mine to sell after ten years. Politicians, in contrast, have very insecure property rights. They will often be out of office before the benefits of a bill become evident, and it might be the other party is in office at that time and claims all credit! So they have a strong aversion to paying large amounts now when the benefits are far away in the future. You can see that their rhetoric does not reflect their actual behavior, because they often promise without making delivery in that uncertain future.
So politicians tend to 1. Promote policies that sound good on the surface (easy to advertise), 2. enact bills that benefit special, concentrated interests at the expense of dispersed victims, and 3. take short-term actions. Finally, and what’s worse, they make decisions that have very widespread effects (externalities) without knowing the outcome. For example, a panel of judges making a decision about a vaccination program (for polio?) treated an annual recurring cost as a one-time payment, mis-pricing the program by a factor of 40, negatively affecting thousands of people.
We must conclude then, that Market Failure is structurally endemic to Politics and the theory of market failure is a better predictor of government behavior than it is of free market behavior.
The conclusion generalizes to everyday life. For example, for those with a spouse, who does dishes after dinner? There are two options: 1. one cooks, the other cleans, and 2. the same person cooks and cleans. Everyone chooses option 2, because then the cooker controls how much cleaning takes place (makes a meal with fewer dishes). Also, this is why we tell children to clean up their own mess, rather than the messes of others.
There’s also the silent student problem. When the instructor asks “does every one get it?” they never get a response. Mostly, because the cost of asking is to look dumb in front of everyone (but, rationally, in a large classroom, there must be others who didn’t understand), but also because the benefits of asking will be dispersed to everyone present (they might do better on the exam). One solution is to use a button on the floor, which can be inconspicuously pressed, activating a signal at the back of the class visible to the teacher, but not the students.
Or economics and law. Suppose a proposal that makes armed robbery a capital crime, assuming murder is already a capital crime. Many people might be for it, as “being tough” and providing a strong dis-incentive for armed robbery. But the economist will ask: Do you really want all armed robbers to murder their victims? Because if the cost of robbery is the same as robbery + murder, then I, as a robber, will surely kill my victims for the punishment (cost) is no different and there is a benefit that the dead won’t identify me to the police.
Questions.
What should we do? Given that rationally ignorant voters make decisions on freely available information, politicians complicate the issue by advertising bills with plausible deniability. For example, the auto tariff is about protecting jobs and hurting foreigners. The auto-workers union doesn’t ask for a bill that’s a direct transfer payment. How should we respond? One: change the body of free information. Spread more accurate information and ideas. Two: create alternatives. Run a business that competes, showing that the government-provided solution isn’t any good (quality or quantity).
What about replacing the government entirely? Dealt with this in 3rd part of Machinery of Freedom, discussing private security insurance firms that operate under the discipline of repeated interaction. Customers have their choice of firm.
With increasing productivity, what about ensuring work/jobs? First, we should think of jobs and workers as two distinct numbers, and then notice they are always very close to each other. Sometimes apart (depression era) sometimes close, but very strongly correlated (both increased over the last century). This implies they are in an equilibrium situation, so we should not worry too much. Also, look at the fixes: the racism inherent in the minimum wage (historical union). And be careful: if you give the government power to do XYZ, how will they *actually* use that power?
What about education? School voucher program implies that most schools would be comparable in quality. That’s not really different from being centrally managed. Instead, if we value diversity, we should remove single organizational administration and control, we should decentralize.
What about Rothbard and 100% reserves? It’s actually not desirable for a bank to have 100% backing, especially if it has other liquidate-able reserves. It could then, when faced with a run, sell the other assets in exchange for the backing material (e.g. gold or silver) and make good on the original agreement. Personally, would prefer some electronic, anonymous, cash-like system.
What about the incentives to incarcerate faced by private prison operators? Well, those same incentives are faced by state-run prisons. It sounds good to be “tough on crime” and the taxpayers foot the bill. Refer to David Skarbek’s book, The Social Order of the Underworld: How Prison Gangs Govern the American Penal System, to see how even outlaws have created an ordered society. Also, read Poul Anderson The Margin of Profit for an answer on “how to get people to stop doing bad things” (answ: make it unprofitable), and my book Law’s Order: What Economics Has To Do With Law and Why It Matters for an examination on the costs and benefits of a property system.
David Friedman gave a talk Problems with Libertarianism: Hard Problems (and how to avoid them).
- What rights do you have against a criminal?
If your only right is to re-claim the stolen property, then at-worst the thief breaks even.
To what extent can we meter out determent punishment.
What’s the factor of retribution, why 2x? not 3x or 1.5x?
What if you only catch 1/10th of the thieves? Then 10x?
But that pushing the guy caught for the crimes of those not caught.
Also, the number of people caught is a function of how much spent to try to catch.
What if a mistake is made? How much trouble to avoid making them?
- What are you entitled to do to defend your rights?
Capital punishment for petty theft?
- Human shield problem.
Can you shoot back, and risk killing the innocent shield?
Can the voluntary defense fund aim nuclear weapons at Moscow?
Possibly killing innocent victims (more so than you) of the Soviet Union?
Bad guys aren’t libertarian, and don’t care about trespassing when advancing their troops.
If it’s acceptable to place run roughshod over innocents in attacking the aggressor, then it’s acceptable to draft.
- Absolute property rights.
Trespassing photons across absentee-held land.
You think they don’t damage, but I, the owner, gets to decide that.
Allow you to breath in, but not out, because I don’t like the CO2.
- Distribute the risk of injury should I crash my airplane?
I get the benefit of flight, at cost to you without your permission.
- Property in land, not derived from owning self+labor.
I could walk across before you build up the house and path, so my use is not in conflict with your labor.
- Very large part of land in the world is stolen.
- Public good problem.
If something is desirable, then market will provide. Can only say Maybe.
def: good that producer cannot control who gets it, ex: radio broadcast
Combine the good (pos value to customer + pos cost of production) with another public good (neg value to customer + neg cost of production), ex: adverts
What about national defense? (defense against nations) Hard to stop missile in flight by determining if target has paid for defense.
Is answer to aggress the funds, or to surrender?
soln: Assuming problem doesn’t exist.
Soviets have no interest in attacking, only have tanks to prevent us from doing so.
soln: Somewhere there’s a proof that market will provide.
Nobody’s found it.
soln: It’s a lifeboat problem.
Still have to find the answer, we do live on a spaceship after all.
soln: The is-ought dichotomy.
But then in some way you’re defending the ability to do whatever is necessary.
soln: Pooling money.
The good is worth X but whether I spend is only a fraction of the funds and I receive the benefits regardless.
- Privatizing the government property.
soln: sell it. But if government doesn’t own it, what right have they to sell it?
You can also avoid the problems by changing the subject.
As a preliminary, I feel obligated to mention that writing a contract only protects yourself on paper. The real world has such complexity, and with innumerate contingencies, that any contract will fail to enumerate them all. Establishing an explicit contract often also cements distrust between parties, due to its impersonal nature. The contract just gives a written record of what the parties agreed to, so that, should the end up in arbitration, others can more readily see the terms of the agreement. Because of these factors, writing a contract is a costly affair.. So, what should go into it?
Suppose two parties, even after recognizing the costs, still wish two write a contract. They agree on many standard items and write them down (or borrow them from a template), but the parties still have some remaining details about which they disagree. Each has an interest in investing a some time to sort out these details in order to avoid unpredictable future conflict. But how shall they obtain an agreement on what actually gets written down?
I thought of one approach: holding a silent auction. For every issue on which they have a disagreement, they can write down all the mutually-exclusive options and hold a silent Vickrey auction.
The Problem and Its Solutions
If we were living in a perfect world, the business logic would be separated from the presentation layer. Since Rave sits atop a rich GUI, where event handlers can execute arbitrary code, there exists a strong temptation to put business logic in the presentation layer. The fact that we code both parts using the same language (C++) makes this temptation doubly hard to resist. Indeed, sometimes a clear cut separation doesn’t exist. So we shouldn’t find it at all surprising that our founding coders may not have kept up a wall of separation between GUI and Business Logic.
Let’s walk through an example that I have adapted from Martin Fowler’s post on GUI Architectures.
Suppose we have a system requirement that the GUI must display a red box when a seat is disconnected, a green box when connected, and a yellow box for a slow connection. Suppose further that the application already uses an integer to represent the connection state, and presents it through the function linkRate(). It ranges from 0Mbs (disconnected) to 1000Mbs (full connection), taking various intermediate values depending on a measured traffic rate (not just the OS ethernet link state). The green box represents any measured rate above 700Mbs, while the red box represents any rate below 5Mbs.
Where should the logic for choosing the box color reside?
Where should the listing of boundary values for each category reside?
Where should the listing of colors reside?
If you had to write tests to prove your solution worked, would you change your mind on where to place that code?
| Logic Placement |
Description |
| GUI |
The GUI contains all the smarts. It reads the value of linkRate() from the application and then performs its own calculation to determine the color. |
| Shared |
The GUI and application share responsibility. The application provides a linkRateState() that presents an enum which the GUI then maps to a color. |
| Application |
The application contains all the smarts. It does the heavy lifting and provides a linkRateColor() method that tells a really dumb GUI what color to show. |
For some variation of value preferences, all of the above can be reasonable decisions. I have a bias towards testing making the GUI as easy to test as possible. You might think that idealism would incline me to favor the dumbest GUI possible, and you’d be right in most cases, but I want to draw out some reasons to make an exception for this example.
The Case for the Dumb GUI
Mostly I want a dumb GUI because testing it is very hard. To test the GUI, I must launch it within a harness that intermediates all the events, introducing programmability to events like clicks, drags, and keyboard presses. The harness requires a full simulation of the application, including connections to external services (database, file system, SCUs, etc). Finally, at least with squish and RAVE, the test scripts execute at glacially slow human speeds, sleeping for entire seconds to allow for menu animations and other GUI renderings.
Having the dumbest possible GUI would mean having a presentation that so incredibly lightweight that it would be very improbable to get wrong. When the application tells it what color to show, the GUI has very little opportunity to do wrong. The mapping logic of linkRateColor() would have a unit test in the application, ensuring conformance to system requirements. With a thin enough GUI, I wouldn’t care that it didn’t have automated tests.
But placing linkRateColor() in the application muddies the purity of the application. For now it must always and forever include a link to whatever library provides QColor. I can no longer build the application without some GUI library. If I want to re-use that component, I drag the dependency along with it. And, finally, no part of the application actually uses linkRateColor(), it only exists to support the GUI.
The Case for the Shared Responsibility
I have nothing to say here but “eeewww gross”. Unless there is an application-side consumer for the linkRateState() it’s not worth coupling the GUI and application with such a specific API. Should the specification change the details about the boundary values between colors, then both the GUI and the application will need updating. We shouldn’t use designs that increase our maintenance overhead.
The Case for the Smarter GUI
If the application never has a need to know the boundary values for the different link rates, then we can assume that those values represent a specific presentation requirement. Given that circumstance, I favor placing the logic into the presentation layer.
Yes, this solution increases the GUI’s responsibilities, making it more complicated to test. Counter-intuitively, the increased testing difficulty of a more complex GUI has pushed me to advocate for making the GUI a stand-alone piece. The situation just serves to make my next point, about a stricter separation between presentation and application logic stronger.
The Wall of Separation (between GUI and Application Logic)
In an ideal world, the business logic carried out by the application and the presentation logic carried out by the GUI remain strictly separated. So separated, that we can pull apart the two pieces and test them separately. We can even build a second GUI (for a new customer) without impacting the underlying application. With this separation, the application acts as a data Model while the GUI(s) merely present a View of that data.
For testability purposes, let’s pull apart the two pieces an envision a wall between them. The only communication link through that wall is an API, depicted as a network socket. The application (network server/data model) responds only to specific messages (requests for and updates to data) sent over the socket. It keeps the GUI informed about changes by emitting other messages (events).
The clear separation between application and GUI serves dual purposes:
- It makes us think harder about which piece (GUI or app) should receive new logic
- It allows tests for each piece to remain laser-focused on that piece without getting distracted by the other parts of the system.
Testing the Application
To test the application, we simply fake the GUI. Because of the separation I’ve made here, it amounts to just implementing a network client that generates a sequence of data updates or requests, and asserts that it receives expected data-update events and delivery of requested data. In a different world (the real one), where the API exits as method calls instead of a network socket, we create a headless driver, that makes the calls and receives the events. Even more granularity can be achieved by single-stepping the event loop (when that makes sense), to assert that certain events do NOT occur.
In our example, we have the fake GUI assert that it receives a linkRateChanged() event, after the test, using an internal update function, modifies the linkRate variable. If the GUI can set the linkRate, then we can also test round-trip in 3 steps:
- Have the GUI send the update data request
- Step the application event loop
- Assert that the fake GUI receives the expected data changed event.
In both circumstances, we assert that the application generates events according to a specified protocol. With a large enough suite of individualized tests, we cover the application’s behavior for all the actions the GUI can take. When we miss an action, we simply record it in a new test as an expected event/response sequence.
Testing the GUI
To test the GUI, we simply fake the application. A test harness drives the GUI from one end, clicking and dragging on widgets and buttons, while the application that it links to provides a pre-programmed series of responses. If we generate the GUI events directly, e.g. by calling on the event handlers for specific widgets, we can even drive the GUI in a headless environment (by virtualizing X11). The tests remain focused on accuracy of presentation.
In our example, we have the fake application emit a linkRatechanged() changed event, and assert that the GUI updates the color according to presentation requirements. If the GUI can set the linkRate, then we can also test round-trip, using a similar 3 steps:
- Drive the GUI to go through the update link rate dialogs/widgets.
- Assert that the updateLinkRate() event is received by the fake application and respond with a pre-programmed linkRateChanged() event
- Assert that the real GUI updates the rendered color.
In both circumstances, we assert that the GUI performs renderings according to the events it receives from the fake application. Again, a large enough suite of individualized test covers the presentation layer for all data states the application can take. We still record any missed behaviors into a new test taking the form of an expected event/render sequence.
What the Wall of Separation Achieves
Separating the GUI from the application, and treating it as a View or presentation layer only (with the application taking the role of a data model) gives use the ability to separately each pieces. The wall itself represents an expected set of behaviors to command/response stimuli. In ordinary implementation we have direct C++ API calls, but that just muddies the idealized separation, and motivated me to start out with a network messaging description. Conceptually, testing the GUI can be approached with the same techniques as testing a client/server implementing a network protocol. If we clearly state the expected behavior, then each side of the fence merely has to uphold it’s end of the protocol.
Yes, the separation probably means more tests. But, those tests will be smaller, faster to execute, and easier to write and maintain. When we do perform whole-system testing (which is always rarely relative to the automated protocol testing, because of the costs involved), it will catch use-cases of the interaction not already covered by the piece-wise tests. However, a record of the command/response sequence in each failing whole-system use-case, can be rolled backing into separate piece-wise automated tests, one for each side.
Ultimately, our goal is to catch bugs earlier by exercising the behavior protocol of each side separately. By working toward that goal in this way, we can also ensure that we meet our system requirements by encoding them into automated behavior tests exercised against both sides of the wall.
Over the past couple months, I’ve busied myself with finding offers of other employment. IMS (now Zodiac Inflight Innovations) has not given me the career growth that I initially anticipated. I find that, though they are getting better, management has been fairly schizophrenic. All the time chasing to put out fires and very little of the time investing in software quality practices that prevent such emergencies.
I interviewed with Google twice. Once last month at the Irvine Office for a position as Sr. Software Engineer. They decided not to hire at that time, because my performance during the interview was “on the edge.” However, their recruiters reached out later to have me interview for a Software Engineer in Test position. I subsequently read the book “How Google Tests Software” and was quite impressed with the specialist role. It’s more of a framework and tools builder for the other engineers, all with the goal of improving quality.
During the time between interviews, the kind fellows at JobSpring Partners, who helped me get hired by IMS (now Zodiac Inflight Innovations), followed up to discover that I was indeed unsatisfied with the career growth opportunities in my current position. They connected me with Fisker Automotive, which is rebuilding a team of software engineers so that they can rewrite the infotainment software that controls the Karma.
So, I stand at a cross-roads in my career. Do I choose a smaller company and pursue technical leadership, or choose the well-established and pursue technical skills growth? I did an analysis, to help myself decide. I would be comfortable with either choice in everything but the “Daily Work” category.
Daily work
– google: code monkey
– fisker: system designer, software architecture
Skills improvement
– google: software engineering, how to program “at scale”
– fisker: technical leadership
Personal Interactions
– google: smart, competent programmers
– fisker: upper management
Social Capital
– google: larger number of co-workers, can jump to other projects
– fisker: customer interaction
Technical Capital
– google: lots already in place, but must find a project to exploit it
– fisker: little, have to organize it all myself
Industry
– google: has wide variety of projects (incl. computational finance)
– fisker: automotive, embedded, gui design
On Paper:
– google: I have google on my resume, with crazy job title (they let you make one up)
– fisker: I put “declined an offer from google to work for fisker” on my resume
The Exit
– google: find a startup that wants a googler
– fisker: an associated business, competitor or customer, recruits me for tech leadership skills
Likely Outcomes
– google: I work maintaining someone else’s system. Learn big system design.
Fail to grow my social network because I focus on little problems for my immediate boss.
Could reach out to work on computational finance or bitcoin-inspired distributed systems.
Google will use internally whatever I make. (I don’t keep anything when leaving)
– fisker: I develop/design a system, learn and teach others about system design, continuous delivery.
Grow my technical leadership skills by promoting design techniques to a smaller team.
People outside the company will value the final product.
Can have some influence on the direction of the business.
I once participated in a debate about copyright issues, taking the position that copyright is an illegitimate concept. I prepared the following notes prior to the debate.
Opening Points
- Historically founded on governmental systems of control
- Enforcement requires the interference in an otherwise free market
- Utilitarian arguments supporting copyright need to meet a burden of proof
- People have been creating works of art since forever, no reason to think that they will suddenly stop now
- Incentives of copyright don’t work, because money doesn’t guarantee creative quality
- The enforcement in protecting an intangible causes tangible harm (jail, extradition, home invasion, confiscation, restricted freedoms)
- Copying and duplication are not equivalent to theft, stealing, piracy (sinking of ships), or infringement (derivative knock-offs and rip-offs)
- English language has no word for “theft through the act of duplication/copying”, but does have a word for things that don’t replicate — “dead”.
- Obscurity is a bigger threat to most artists than unrestricted copying
Fundamentals
- def copyright: the right of an artist/creator to prevent other people from using their own (physical) property to duplicate the artist’s work. Is a right of monopoly, not of property.
- No need for property rights in information, because knowledge is non-rivalrous
- Influences
- Moral rights of the author who created the work
- Economic rights of the benefactor who paid for a copy to be made
- Physical property rights of the individual owning a copy
- Soverign’s right to censor and regulate the distribution/printing industry
History
- Manual copying. System of control over scribes
- Stationer’s Company in 1557. (censorship: prevent heretical publications)
- Statute of Anne 1710. (broader focus: protect the reading public, continued production of literature, advancement and spread of education, pragmatic right to (re-)print, balance between authors, booksellers, and public)
Alternatives
Counter-examples, The world without
- (from Boldin and Levine) fashion, food recipe and appearance, automobile sculptural design, furniture, magic tricks, hairdos, open source software, database, tattoos, jokes, fireworks, game rules, perfume scents, mutual fund composition
Resources
Countering Pro-IP arguments
- Argument by Creation. Creation is not a source of ownership, only a source of wealth. You own the work, because you already owned the inputs. Creation involves the re-arrangement of physical property. In contrast, homesteading (appropriation) is about first one to emborder and use.
- Argument by Scarcity. Good ideas may be scarce (rare) but they are not rivalrous (exclusivity of use).
- Argument by Ability. We can treat works as property, but so what? We could also treat humans as property and choose not to. Also, treating intangible patterns as property contaminates physical property law, it opens the temptation to move from “fair use” to “fair trespass”.
- Argument by Limitation. All property rights get limited anyway (I can’t shoot my bullet at your body). But the limitation on the shooter is based on sanctity of the target’s property. It’s the action (trigger pull) that’s limited, not the property (gun could be borrowed). Actions employ scarce means (property), actions are limited because of property rights.
- Argument by Balance. We should balance innovation and IP vs. free speech. YouTube has 29hrs of video each minute, I’m not willing to give that up for 20 hrs of big budget film each year. Should we have to find just the right amount of stifling that will promote production!! Intervention in the market (short term monopoly grant) is clearly non-libertarian. The public benefits are unproven, so the burden of proof lies with the proponent of IP.
- Argument by Authority. The Constitution authorizes it, but doesn’t obligate it (wasn’t actually enacted until a year after ratification). Stated purpose “to promote progress of science and the arts” still without evidence. I also don’t care about the back-room deals of politicians 200 years ago. Even the Founders knew it wasn’t a natural right, but a government grant. Other things authorized by the constitution are terrible (slavery, taxes, eminent domain, etc).
- Argument by Moderation of Liberty. Liberty is not our only value. rephrase: we need rights not only in scarce resources, but also others. But the enforcement requires physical force against physical property, causing real, measurable harm. What if we were to restrict intellectual property enforcement to the ‘intangible realm’.
- Argument by Contract. Yes people can enter into copyright restrictions via contract, but that wouldn’t be adopted at large, it wouldn’t bind 3rd parties, it only follows on first sale, existing version would set damages too high (millions) driving customers away (preferencing them toward pirate goods, setting damages too low and customers would ignore it or collection would be too expensive, the hassle of tracking infringement is cost prohibitive and invasive of customer privacy, there is no low cost mechanism of tracking/propagating ownership.
- Argument by Due Income. The labor theory of value is bunk, and profit is an unnatural temporary aberration in the free market, it attracts competition. You don’t own the value of what you produce, only it’s physical integrity. The value is market-based and exists only in the minds of others.
- Argument by Utilitarian Maximization.
- Methodological problem: value is ordinal, not cardinal. (von Mises) Value is not a substance, thing, or measurable quantity, it appears only in choice among ends. Utilitarianism mistakenly wants to add up all values and shift them around. Moral Problem
- Moral problem: It is unethical to take from the rich and give to the poor, even if the total valuation indicates global good.
- Evidence problem: proposal for government intervention requires proof of global benefit
- Argument by Misplaced Question. How would artists get paid? Counter-ask, who would pick the cotton? The question is not an argument, and the artist’s lack of a business model/plan is not my problem. The customer owns his money until parting with it, the creator/artist has no ownership claim over future uncertain revenue.
- Argument by Accusation. You’re a freeloader that wants everything for free. First, that’s not necessarily true (c.f. benefactor model). Second, the benefit of a free market is abundance at low prices.
- Argument by Complicity. But you’ve benefited from copyright! First, I benefited against my will. Second, my status as a forced hypocrite doesn’t invalidate stance against IP. Copyright lawyers (and cancer doctors) exist because of bad things.
- Argument by Plagiarism. What if I published your work under my name? That’s a case of fraud or plagiarism, not an infringement on copyright.
- Argument by Language. It’s my idea, I own it. She’s my wife, I own her.
- Argument by Industrial Need. Industries that use IP are profitable and it’s essential for their business. So also is crime essential for the profit of the mafia. The correlation of profit with copyright is not necessarily causative, many industries are profitable without IP law (c.f. Bolrin and Levine). Perhaps they need IP to survive, because they are at a competitive disadvantage (skewed market protects big players).
Questions
- What natural rights have an expiration date?
- Through what mechanism do we establish the cutoff time?
- Should we treat non-rivalrous as we treat rivalrous ones?
- How does my act of making a copy/duplicate destroy/infringe/trespass your use of your copy/property?
- What am I stealing when I make a copy/duplicate?
- Is it possible for a society without government to have copyright law? How would it originate?
- Can you cite one study that demonstrates a net benefit to copyright. (costs clear: administration, legal fees, liberty) Papers showing an increase in the applications/use are not convincing, as many would apply for a license to steal.
- The same government that outlaws monopoly (antitrust law) also authorizes them? How to resolve the inconsistency?
- Can you enforce copyright without committing aggression against physical beings/goods?
- Physical property employs boundaries (locks, fences) to indicate theft, what about stories+songs?
- Supposing that I wanted to divest my work of copyright, how would that happen? Currently no way to do it, the Berne Convention prohibits the US from revising copyright to permit it.
I’m writing this post using my new Ergodox keyboard, and having a hell of a time adapting to the lack of a slant between the rows of the keys! For example, I continue to hit the “x” key when I intend to hit “k”. I have also re-positioned some of the control keys, such as backspace (which now gets hit by either pinky knuckle), control (which used to be mapped to caps-lock on a conventional keyboard), and enter. I also noticed that my thumb naturally rests between the [space] and F1 keys. Overall, my hands feel vey splayed-out. Not just as a result of resting my thumb on a far-away [space] key, but also because the distance to keys has changed. The change in slant between rows has altered the positions of keys further away, such as the numbers and symbols.
Anyway, here are some pictures of the assembly process, which took all day, the final result, and the layout that I’ve programmed. Typing will definitely take some getting-used to, and the cherry mx-blue make very loud clicky sounds.
Assembled Ergodox
Layer 0
Layer 1
Three weeks ago I started a new project that uses nodejs and which forced me to learn some asynchronous programming. I couldn’t quite manage to adapt.
Because this was server code that ties together other web services and my own database, many of the helper functions ended up having multiple asychronous steps. The lack of return values strongly pressured me to nest long chains of anonymous functions. As if that wasn’t bad enough, they style also encouraged inlining the details of each step, which made identifying and factoring out common code, all the more difficult. Because of the nesting it was far easier to factor out steps near the end of the chain instead of those in the middle. Compared to conventional synchronous programming, this callback model felt like programming inside out. So I went looking for other options. I watched a video on promises, by the implementors of the Promises/A+ spec and q module.
They pointed out 3 important deficiencies of the async callback model, all of which were contributing to my difficulties:
- Syntactical nesting pyramid of doom.
- Lack of a callstack when reporting errors.
- Lack of return values, who would receive them without a callstack?
The convention synchronous programming model has three ways of returning results (return value, throw error, and side-effects), and the async callback model abandons the two most important ones! Thankfully, promises gave them back to me. I spent a day rewriting all the broken async callback code that I had written, and it’s taken about a week to really grow comfortable with the new style.
Yet, some conveniences are still lacking. The promise chain does not hold temporary values such analogous to having stack-local variables in a multi-step function. We currently achieve the same effect through closures in anonymous functions, as shown in an example at q’s github repo.
function authenticate() {
return getUsername()
.then(function (username) {
return getUser(username);
})
// chained because we will not need the user name in the next event
.then(function (user) {
return getPassword(user)
// nested because we need both user and password next
.then(function (password) {
if (user.passwordHash !== hash(password)) {
throw new Error("Can't authenticate");
}
});
});
} |
function authenticate() {
return getUsername()
.then(function (username) {
return getUser(username);
})
// chained because we will not need the user name in the next event
.then(function (user) {
return getPassword(user)
// nested because we need both user and password next
.then(function (password) {
if (user.passwordHash !== hash(password)) {
throw new Error("Can't authenticate");
}
});
});
} But if promises promote code flattening as an strong benefit, then we ought to support something like stack storage. I propose the addition of two functions:
- pput(name)
- Take the return value of the current promise as a property with the given name on the current promise and return the current promise.
- pget(name1, name2, …)
- Retrieve the properties with the given names on the current promise and return them as an array-fulfilled promise, or a single value-fulfilled promise when only one name is given.
All the other promise functions (e.g. then) shall copy the defined properties along the chain. Using promise properties, we can flatten that example code.
function authenticate() {
return getUsername()
.then(getUser)
.pput('user')
.then(getPassword)
.then(function (password) {
// grab the user property from the promise
if (this.user.passwordHash != hash(password)) {
throw new Error("Can't authenticate");
}
});
} |
function authenticate() {
return getUsername()
.then(getUser)
.pput('user')
.then(getPassword)
.then(function (password) {
// grab the user property from the promise
if (this.user.passwordHash != hash(password)) {
throw new Error("Can't authenticate");
}
});
} Notice that inorder to provide both the attribute that was pput on the promise, I also had to change the target reference of the this pointer, so that it points to the promise rather than the global object. I am not sure whether others shall find making that change acceptable or not. If not we can modify the existing chain operations so that they pass the promise in explicitly. So the then function would become pthen. In that case the example would read something like the following.
function authenticate() {
return getUsername()
.then(getUser)
.pput('user')
.then(getPassword)
.pthen(function (promise, password) {
// grab the user property from the promise
if (promise.user.passwordHash != hash(password)) {
throw new Error("Can't authenticate");
}
});
} |
function authenticate() {
return getUsername()
.then(getUser)
.pput('user')
.then(getPassword)
.pthen(function (promise, password) {
// grab the user property from the promise
if (promise.user.passwordHash != hash(password)) {
throw new Error("Can't authenticate");
}
});
} If we want to keep ourselves restricted to only the proposed pput and pget, we’ll just have to do a little extra storage and retrieval work.
function authenticate() {
return getUsername()
.then(getUser)
.pput('user')
.then(getPassword)
.pput('password')
.pget('user', 'password')
.spread(function (user, password) {
// grab the user property from the promise
if (obj.user.passwordHash != hash(obj.password)) {
throw new Error("Can't authenticate");
}
});
} |
function authenticate() {
return getUsername()
.then(getUser)
.pput('user')
.then(getPassword)
.pput('password')
.pget('user', 'password')
.spread(function (user, password) {
// grab the user property from the promise
if (obj.user.passwordHash != hash(obj.password)) {
throw new Error("Can't authenticate");
}
});
}
Looks like some individuals have had nearly the same thoughts as I have on the state of keyboards. The progress looks good.
Key64 has some good prototype hardware. The keyboard is short on keys and compensates by having layers bound to modifier keys, which appear mostly on the thumbs! Recall that I wanted to make the thumbs work harder in my post on the configurable keybord.
Another fellow has taken inspiration from Key64 to create Ergodox. His site contains PCB and 3D printing files so I could theoretically create a keyboard myself.
Finally, KeMice has an indiegogo campaign to create a lightweight, portable split keyboard with the right side acting as the mouse. If only they’d gotten the layer feature via meta-keys, I’d be contributing.
|
|
