Archive for open source

More on open source

Posted in Uncategorized with tags on June 28, 2009 by spinoza1111

In open source, providing computer users with assets is basically overemphasized. However, I hear of no concern with compensating older and retired programmers for the true value of their labor.

Companies (such as Bell-Northern Research) destroyed by the greed of their managers are paying pennies on the dollar in pensions to former employees who created the fortunes of the top managers. Diligent research could find the authors of resources that made these fortunes but there is of course no interest in such research.

Instead, a culture of macho self-hatred in programming enforces power relations in Foucault’s sense.

In many cases, code from afar, written by a programmer remote from the code reader, is treated with greater respect; this is part of the reason for the preference for the offshore coder.

Whereas in real programming culture, code written by the clown in the next cubicle is greeted with resentment and a search for errors, because in a situation of forced competition, people resent bodies and their tics, and form an association between bodies and tics, and code.

Psychological transference plays a role; many people regard programming as dead-end, or came to it after failing at other careers (often, academic careers) and transfer their self-hatred onto caricatured “typical nerd” programmers who represent what they don’t want to be (feminized and without power) and fear they are after all.

The code generated by coworkers is resented as dead labor and considered a cost center, so, after layoffs, the issue of the value of the intellectual production of the laid-off is a non-starter.

No canons of good practice ever emerged from programming and after fifty years, the field is still dominated by childish fads and feverish paradigm shifts. That’s because people don’t care about code to the extent they care about bodies, and their embodied position in a general doom, in an economy which has been making the rich richer and the poor, poorer, for fifty years.

So, far from getting fairly compensated for the value of their production, people are now encouraged to work for free, and to wait in a subservient fashion for recognition which for most contributors never comes. In fact, there’s a law of organizations: recognition almost never goes to real contributors. We know, for example, that the Academy Awards never go to truly great movies: but in an ape reflex people who know this still stay up to watch the Academy Awards.

As I indicated in the previous post, we were creating open source in the mainframe era in the sense that we were working extra hours to make computers with serious designed-in flaws (such as the flawed mechanism of subroutine call on the IBM 1620 as pointed out by Dijkstra and the absence of stacks on IBM 360 and 370 computers) minimally useful. In my case these extra hours were worked willingly: but in many cases I saw, programmers were being bullied to work extra hours.

Nor does new technology, closed or open, seem to change this. Management as a class still seems to have a knack for adding, as a “requirement”, standards and practices which make the job harder, and their continues to be a conspiracy between managers and the least skilled programmer, even on contemporary platforms, to replace ingenuity and elegance with long hours of cut and paste…the only difference in Open Source being that you can walk away from cut and paste-o-rama, since you’re usually not getting paid either way.

The basic problem? We take better care of computers than people. Our computers are treated with awe and reverence while children scream under the stairways, boys sob in armies, and old men weep in parks (to paraphrase Allen Ginsberg). I’ve participated in open content (wikipedia) and the experience sucked. I’ve done volunteer work for the homeless and it was great.

Computers don’t need our volunteer work. Since programming is a paraprofession and not a profession by definition, which cannot set its own rules, programmers need health insurance including a government-paid single payer option, payment or forgiveness of student loans, day care, and pensions banked with the government and not companies who walk away from their obligations in bankruptcy.

Wall Street’s ignorant perceptions aren’t rational and shouldn’t control. There is no reason why Microsoft can’t produce software of high quality apart from the fact that its rational process of development is continually under an irrational level of pressure from the outside to show that it is “up-to-date”…to people ignorant of technology and computer science in financial markets.

In a form of Platonism, financial markets act as if existing computer systems are all criminally deficient vis a vis some new vaporware produced by willing slaves in a fashionable area such as Estonia. This is a racist and Orientalist dream, not rationality. It seeks to take advantage of a market failure because in a market under Say’s law, the producer is paid. It is deeply hypocritical since it doesn’t question the free market despite the fact that the free market in software now depends on injections of free code from outside the market.

In many articles about Open Source, the author, lauding O.S., says it’s a “myth” that O.S. producers aren’t paid, and promise to address the problem…later. At the end of the article one discovers that the problem hasn’t been addressed.

A lot of Open Source is great because if you’re enthusiastic you produce great stuff. But what’s hidden is the effect on families and lives of constant unpaid labor.

Is Open Source theft of intellectual production and virtual slavery?

Posted in Uncategorized with tags , , , , on June 27, 2009 by spinoza1111

Is “open source” theft of intellectual production and virtual slavery?

“Open source” is the making-available of software source code and other media freely with permission to modify source code and original media. Examples include the Linux and Ubuntu operating systems and the content of wikipedia. A related term from Richard Stallman of the Free Software Foundation is “freeware” which is software provided free of charge in source form. In effect and according to Stallman, most Open Source is freeware and most freeware is O.S.

Open Source is “intellectual production” and not “intellectual product”. However, it appears to me that the concept, together with the architecture of the Web, obscures who writes it and in significant cases enables a virtualized, but not victimless, theft.

It did allow developers to escape the harsh corporate discipline of software shops, one manifestation of which was the constant necessity for overfocus on overdefined goals. That is: designing an effective software system for either a large or basically hard problem is designing a language and Wittgensteinian “form of life” for solving problems in an environment subject to rapid change, but it’s been a common experience that managers would prefer programmers not to do so, but instead deliver, at a quick pace, specific hard-coded modules that would appear to work, and “satisfy” an “end user”.

Whereas because much of Open Source and “open content” is written, modified and debugged by unpaid volunteers/interns, it can be more generally and reliably developed as seen in the case of Linux, which is of higher quality than the closed source monster, Windows.

Open Source was prefigured, in my experience, in the closed shops of the mainframe. Basically, early programmers (of which I was, in a sense, one) lavished time on what seemed at first to be silly goals, often their own personal time, only for the software they created to be key/strategic. For example, noticing that I was maintaining fifty small assembler programs to handle requests for selecting alumni of Roosevelt University, I, working on my own time, designed a language for specifying these requests and laying out the output report, from envelopes to (ta da) mailing labels.

Working happily, and oblivious to the hours or the complaints of my girlfriend, I produced a replacement for the previous programs which appears to have saved a lot of time, even after I left the university’s employ. I encountered the same type of program buried in libraries on Princeton’s mainframe years later, written in assembler as well.

The fraction of time I spent after hours was “open source” in a sense.

This continued, and I was never loth to work extra time to be able to solve a genuine, and genuinely interesting, problem, and I found that many such problems, falsely renarrated as specific “business” problems, lurked behind many vanilla applications. Reinsurance turned out to be a recursive application which needed a stack. Billing for pbx calls of any complexity turned out to be the need to simulate the operations of the pbx based on the only records available, which were of atomic telephony events.

A rational internal compiler for use of field engineers to control PBXs turned out to need a rational installation process itself controlled by software. And in many cases, the users either needed or wanted to enter logic (criteria) as data, and I either needed to write small compilers or, when I was more fortunate in the chosen language, to present the user’s logic to the language for runtime compile and execution…this was duck soup in Rexx and Quick Basic, not so easy in compiled languages.

Software turned out to be, as the creation not of code but of Wittgenstein’s forms of life, an activity that in capitalist relations always had a large “margin”, a “margin” that could not be spoken of for fear of the suits.

Consider a “real” square, drawn “perfectly” either with Microsoft Paint or a compass and straightedge. In all cases it isn’t a square, just a picture of a square whose “edge” is never Euclidean because its edge always has some thickness > 0. In computer graphics and presentation, the programmer has to learn the difference between what is called the “size”, say of a Windows “form” (box on the screen) and its “client size” for this reason. Only in special cases (a borderless box colored differently from its background) is client size == size.

[Would the only "real" square, isomorphic to the Platonic-Euclidean be either a square in a Mondrian painting or a Microsoft Paint square with no border but a different color from the background? The Mondrian-painted square always has bumps and painterly gestures that disqualifies it. This leaves the Microsoft Paint square which has no painterly "edge" as the closest to the Platonic square. But it's not perfect if space is curved, is it? There could also be micro-differences in height and width if pixels, whose size determine both, are not perfectly square.]

Mondrian and a red square

In general the problem is of the margin, and the fact that great programmers have always, in closed source and open, stayed up past their bedtimes. I know of no exception. This may be the result of the fact I identified in “Computer Software as a Philosophical Pathology“: computer memory is always finite and there’s always one more “bug” as a result.

Open source does not of course eliminate the theoretic problem, but it does free corporations from overseeing the creations of forms of life. Instead, they can legally dicker with the open source .org people to obtain commercially viable copies, and in so doing, I do not believe that the interests of the original creators are protected at all.

In fact, Open Source makes the whole process so opaque and so renders actual creators of content so anonymous as to resemble the takeover of Russia’s aging but huge industrial plant in the 1990s by gangstas and “biznezmienie” who were, in many cases, favorably situated sons of the Communist *nomenklatura*, men and women of the Stalinist bureaucracy who’d used prestige educations and inside information to essentially steal the people’s shares in industrial plant.

Programmers regard themselves as creative, professional “engineers”, but were never accorded this dignity from outside the paraprofession. Managers, lawyers, and other truly independent professionals had nothing but contempt for programmers, and as a condition of employment, the programmers had to agree to this low status, and allow their intellectual product to be underpaid and alienated in Closed Source regimes.

Open Source merely mystified and compounded this problem.

The most egregious example is wikipedia. Here, a sharpie and arbitrageur of other people’s use values, Jimmy Wales, was unable to manage people circa 2000 because of his personality problems. He therefore created a tax-exempt .org circa 2002 where “anyone” could change his encyclopedia and add content. The idea wasn’t his, it was Dr. Larry Sanger’s, but what the hell.

In 2004, the spirit of “be bold” and a certain collegiality reigned: but circa 2006, strange editors started to appear. Ignorant of actual scholarship and very rude to others while oversensitive to slights in the lower middle class register, these characters proceeded to hound and persecute contributors who did not conduct themselves with the right sort of subervience…a subservience last seen in the ante-bellum South of the USA.

Reputations were permanently ruined, and good contributors were driven out by “editors” who in many cases turn out to be convenience store clerks and religious obsessives, pre-Enlightenment characters not qualified to create a dictionary let alone an encyclopedia.

Mere thinking became “original research”, and in the manner of vile little clerks throughout history, rules were interpreted with a soul-destroying literality by people who, owing to their very lack of internal self-discipline, need rules at all time.

I quickly became a monstrum horrendum of course, having very low tolerance for this sort of thing, and the nastiness of the process became unbounded. For example, posters seeking to curry favor transformed my patronym (Nilges) into a racist slur as had my racist fellow students (including the racist, right wing rock star Ted Nugent) in high school. It was lynchin’ time, and I believe it became so because Jimbo Wales needs money.

The work of the eradicated was retained and their eradication ensures now that Wales shall be able to turn wikipedia into a profitable paper edition, which appears to be his real goal after all.

This provides Massah Wales (an American southerner) with some of the advantages of slavery (free labor product) without the ugly image of slave-driving, and I think it may generalize to Open Source.

Open Source has a “liberal” reputation because of the unreflective binary opposition in the computer field between the corporate fuddy duddy and the bearded, and therefore presumably free, hippie coder…an unreflective binary opposition which neglects the way in which IBM salesmen received a modicum of dignity and respect in the depths of the Depression by putting on white shirts and ties, and singing the IBM song, and the way in which Thomas J Watson opened up employment to people of color before EEO legislation.

Basically, the innocent American assumption is that “out there” there is a land of unstructured freedom, owning a house for no down payment, free of negative bringdown signifiers such as Hegel’s state and the corporate state, and this American dream keeps people in line, and subject to a much harsher regime than they’d otherwise accept…including the theft of their intellectual production.

“Intellectual production” is my own term of art, and it is meant to contrast with “intellectual property”. Our society has an excessive respect for the latter and none at all for the former, the work product of the forgotten man.

In 1976, Bill Gates called a spade a spade. He told the hobbyist-hippies of the Altair generation that they weren’t “free”: they were, he said, pirates and slaves because he and Paul Allen earned two dollars an hour net for producing the first useful Basic compiler for microcomputers. It had been stolen and widely disseminated by early computer thugs, some of whom bothered to claim to be “anarchists”.

But it was Microsoft which made millionaires out of secretaries and programmers from inferior universities as had the old IBM, and it did so by protecting its source code…religiously. Whereas if access to the means of production is made obscure, insiders with networks obtained at expensive universities have, whether post-Communism in Russia or in software, a built-in advantage.

Return to barbarism starts with this sort of theft. Corporate America never really figured out how to treat programmers with basic decency and respect, which destroyed a port of entry to the middle class open to talents in the 1960s. Open source, far more than offshore development, replaced paid employees with time slices of hidden slaves; in my experience, offshore creates jobs!

The result is a world of pirates and slaves, and a lack of interest in software careers.

A new Microsoft .Net tool for executing source code at run time

Posted in Uncategorized with tags , , , , , , , , on April 12, 2009 by spinoza1111

screen1

In developing a “laboratory” for messing around with Conway’s Game of Life and other cellular automata (as described elsewhere in this blog), I need to compile rules specified or changed by the user into .Net object code for reasonable efficiency. This involves using “reflection”: access to code as an object in an OO language.

In industry, one is expected to be silent about these distinct and well-defined needs, and quietly hack or copy some clown’s code, and deal with the inchoate results and the self-hatred that comes from doing a bad job. I wake up every morning singing loud Hosannahs that I am no longer in industry for this reason (I am a teacher of English after thirty years in a software industry which produced the credit crisis owing to its deliberate lack of craft and embedded anti-intellectualism).

I therefore have spent some time developing a distinct object for this purpose, codeDoer, the doer of code.

Microsoft .Net supports “reflection” in the form of access to compilers at run time: but actually using it messes up your code.

A “fully interpretive” language such as Rexx, used on IBM mainframes, is fully interpretive because “code” is a thing accessible to code. In Rexx, “code” is a Rexx string, and strings are part of Rexx’s fundamental ontology: everything is a string.

However, in many languages, vendors have long been reluctant to give the programmer access to reflection, since full reflection allows the programmer to essentially steal the vendor’s thunder by providing compilers to third parties.

In my book, “Build Your Own .Net Language and Compiler” (Apress, May 2004), I discuss how to implement a non-object-oriented reflection (in the sense of executing source code represented in strings at run time) in the interpreter.

But in .Net, accessing Reflection out of the box seemed to me to involve a lot of time-consuming and difficult to maintain clap trap, generating code using pathological practices (such as Invoke() in place of simple calls when Invoke() is not needed).

I just wanted to be able to code

CodeDoer objCodeDoer = new CodeDoer(“1 + 1″);
objCodeDoer.compile();
MessageBox.Show(objCodeDoer.run());

where a pre-edit would check the code for one of two forms:

* Expression: no terminating semicolon, no return
* Code: terminating semicolon and/or a final return

so I did.

The compiled object code is available for continual reuse after the first compile.

The codeDoer class executes simple or fancy code and returns its value, having whatever side effects are planned for in the code. Here’s a screen shot of it executing a recursive N Factorial program, which accesses a params array of objects to get the value of N: because C Sharp is strict with conversions, the code includes a characterwise conversion of an object to a string to a Long integer.

screen2

The codeDoerTester form and class tests the codeDoer class, allowing you to try C Sharp expressions and statements out.

The class uses a methodology for reliable and maintainable object oriented design which I discuss in “Build Your Own .Net Language and Compiler”, including self-inspection and the use of XML to dump its state. It also “cooks” C Sharp expressions (adding return and semicolon) and then as needed “bakes” them (adding namespace, class and method wrappers) prior to compiling them using a provider.

I believe Open Source to be a form of virtualized slavery, in which the code worker is enslaved by the theft of his intellectual property by men like Jimmy Wales…who get rich based on free labor. Therefore it is against my religion to give this code away. I ain’t gonna be altruistic to rich people, which creeps like Wales expect.

Instead, if you’re interested in it, contact me at spinoza1111@yahoo.COM to discuss a deal for the DLL and/or the source code. I’m not free but I am cheap. Hell, if you need the code for charity and social work, I’ll probably give you the whole kit and kaboodle for free after all.

Follow

Get every new post delivered to your Inbox.

Join 538 other followers