Getting Gnus to read mail over IMAP
I have struggled, off and on, to get Gnus, the Emacs mail reader, set up to read my email. Since I’m mostly coming from the world of GUI email clients, without any experience using a newsreader (not that I wouldn’t like to — I’ve just never had access to a news server), Gnus presented some conceptual hurdles.
Gnus treats mail like news, meaning you “subscribe” to various mailboxes, and once read, email is simply hidden unless you explicitly ask to see it. The idea is that the activities of reading mail and news are very similar — you want to see what’s new without having the old stuff around, sort or filter incoming messages, write responses, then get on with your day — so the protocol used to access them (NNTP vs. POP, for example) shouldn’t make a difference in how you do them. Gnus therefore unifies these activities in a common interface, and deals with different protocols and storage methods with different “virtual servers,” i.e., back-ends which find mail or news wherever they may be. To use Gnus, you must learn how to tell it the details of how to access your messages via one or more back-ends.
So, I went to try to find the right back-end for an IMAP mail account. This raises a further complication: unlike most of the mail back-ends, which assume mail is stored locally, IMAP stores messages on the server. This makes the IMAP back-end more like a news server back-end than a mail spool back-end.
After reading the manual section on IMAP, I had tried a variety of settings that didn’t quite seem to work: although I could connect to the server, and read my mail from the Server Buffer, I couldn’t seem to “subscribe” to any “groups”, or split my IMAP mail into these groups. Fortunately, this excellent article provided a complete, working IMAP example. I’m hoping to be a Gnus addict by the end of the summer.
Software is Not Just a Tool
One of the most frustrating things I do in my daily work is wrangle with CSS. Trying to get a particular website to display correctly on multiple browsers and screen resolutions without ruining my HTML semantics can be an extremely painful process. Anyone who’s ever had to do this knows the reason: browsers implement CSS differently, and sometimes (in the case of Internet Explorer) incorrectly and without any sort of sanity. The causes behind these different implementations are various, but they include varying interpretations of the standard, disregard for the standard, and the fact that users cannot submit patches to improve CSS support in proprietary browsers.
Groaning about CSS bugs in Internet Explorer is a favorite topic on forums across the Web, but most people seem resigned to their existence and (begrudgingly) implement their own hacks and fixes, including reverting to table-based layouts. I have never seen or heard a cogent discussion of the reasons why Internet Explorer is the way that it is, or what can be done about it.
This problem is not unique to web browsers and web design. It is an inherent tension present whenever proprietary software is used to read and write data that’s supposed to adhere to an open standard. Open standards tends to evolve; proprietary software does not tend to evolve to meet them. This is partly due, I assume, to a resource allocation problem: it’s possible that even huge proprietary software companies like Microsoft can lack the resources (or willpower) to stay abreast of changes in standards over which they have little control. A bigger contributor is psychology: a culture of software ownership does not tend to foster the values of deferring to standards for the good of a group, sharing code and patches, or contributing in any other way to a community which does not recognize software property “rights.”
Ignoring standards is evil?
Contrary to popular belief, I tend not to think that Microsoft and other proprietary software outfits ignore or imperfectly implement data standards because they’re “just evil” or anything of the sort. Believing that might bring you some emotional comfort, but it’s an uncritical and shallow explanation that does little to remedy the problem. Instead, I think this behavior is rooted in a variety of cultural attitudes historical events, and conventional wisdom and platitudes. In the rest of this post, I want to focus on one such bit of conventional wisdom, which I think is a major contributor to the way that both proprietary software companies view open data standards, and users’ acceptance of those views: the belief that software is “just a tool.”
This is a belief that Microsoft in particular has promoted for some time. Microsoft makes most of its money from fairly boring, functional products: Windows and Office. The software in these products is basically designed to facilitate users’ accomplishing a series of well-defined tasks: writing a document, calculating a budget, sending an email, starting up and shutting down. Microsoft has a concerted interest in making sure that their users don’t think of software as anything other than a means to these pre-defined ends, because if users did think that, they might start to want things like well-designed graphical interfaces, open APIs and data formats that would allow them to extend the software for other purposes, and a general hackability that would make defining and accomplishing one’s own tasks easier.
Tools
There’s no doubt that computer programs — at least some computer programs — are tools for accomplishing tasks. On the most basic level, programs are a series of instructions that turn inputs into outputs. Inputs come from users, and outputs are meaningful to users. We design and run programs with the express intention of getting from one end of this chain to the other, but what happens in between may or may not matter to us. When you think of software as just a tool, you’re taking the latter perspective: you don’t care how it does the job, as long as the job gets done.
The problem is that, in reality, we all care at least a little bit about how a program does its job. Programs don’t generally run in an isolated environment, and can have side effects that make the system less usable as a whole. If a word processor erased all the documents you had previously written in order to create space in which to save the one you were currently writing, you wouldn’t likely be very happy. The program is still acting as a tool (it helps you write and save documents), but it has a nasty side effect (erasing other files) which prevents you from doing other things, like revising work you’ve already done. This might seem like an extreme example, but it isn’t so far off from what some of the other “applications” out there will do to a system in the name of just getting a job done. For example, resource-intensive programs, like anti-virus software or Windows Vista’s content protection pipeline, can use up so much memory, processor time, and I/O that the system as a whole slows to a crawl, even though its processing power and storage are thousands or millions of times faster and larger than systems available 20 years ago. Yes, these programs are tools for accomplishing specific ends, which they attain (with varying degrees of success). But they impose such significant constraints on what other programs, and thus users, can do that they fail to be useful in an more global sense.
In the tool analogy, these programs are like a hammer that automatically pulls out a nail for every one you put in. You could argue that the defect in the hammer isn’t really the hammer designer’s responsibility, since the hammer is just a tool to aid in the task of pounding nails into a board, and it still does that very well. This would plainly be ridiculous. For a tool to be useful, it can’t just “blindly” aid its user in completing one task. Rather, part of what it means for something to be a tool is that it helps its user accomplish a variety of goals, often in tandem or as means to some greater end — say, building a house. (This is one reason we often speak of tool kits.) It doesn’t make sense to refer to software as “just a tool” if all you mean by that is that it makes one kind of task easier, perhaps at the expense of doing other kinds of work.
The UNIX world is much more sensitive to this broader concept of tool-as-part-of-a-kit. Many UNIX programs are designed to do exactly one thing, and to do it very well, without trying to be all things to all people. A huge part of what makes these programs so useful, though, is not their specialization to one task, but their ability to be combined with other programs. By combining the tools of the UNIX environment, users can easily complete new tasks that the system designers could never have dreamed of. It is the UNIX philosophy of providing both a set of useful, efficient, task-specific tools and an environment that facilitates combining those tools that makes UNIX the system of choice for a wide variety of computing tasks.
This brings me to another point where the “just a tool” mindset breaks down. Software is a very unique sort of tool: one that can produce other tools whose power are limited only by the user’s imagination. People who think software is only good for doing one pre-defined task at a time have had the wool pulled over their eyes. What makes computers so great for doing so many things is that they are programmable. You can balance your checkbook with a pocket calculator, but if you use a spreadsheet instead, you’ll be able to write programs that can answer new questions when you think of them (e.g., “how much did I spend on groceries between December and February?”) without too much more effort. If you write your notes using a text editor instead of a pen and paper, you will be able to search them, reorganize them, and reformat and print them in ways that pen and paper will never allow. Information-processing tasks in general are easier to do with a computer because, once you have the input data in a well-defined format, writing programs to manipulate that data in new and interesting ways is much simpler than performing those manipulations by hand. For this reason, software at its best is less like a tool and more like a whole machine shop: not only does it allow you to do certain kinds of things to start with; it enables you to build your own custom tools when the need arises.
In the end, it may be the case that some people prefer to operate their computers like drones, working through one pre-defined task after another, never stopping to think if they could do them better or more easily by thinking of their software in a new way. For such people, software truly is just a tool, and a rather blunt one at that. But the rest of us need not suffer this fate.
Mnemonic
I have started my first “official” free software project! It’s called Mnemonic and it is available from launchpad.net. Here’s how I have described it:
Mnemonic is a Python library for analyzing experimental data about human memory. It contains functions for performing several specialized analyses and a library which allows users to readily build their own analyses.
If you want to check it out, and you have the Bazaar version control system, you can get it this way:
$ bzr branch lp:mnemonic
Mnemonic is in the earliest stages of development, but I would welcome contributions from anyone who finds it useful. My hope is that it will one day replace the MATLAB codebase at the Computational Memory Lab, where I work as a Research Coordinator. Please let me know if you use it!
Getting gNewSense running on a MacBook
I have a second-generation MacBook (bought in spring of 2007), and due to a bunch of recent issues which have turned me off from OS X (e.g., the machine randomly will fail to wake up from sleep, compiling software is a huge pain, etc.), I have been aroused from my complacency and have decided to try my hand at getting gNewSense, an all-free software derivative of Ubuntu, running. I didn’t expect this to be an entirely painless or automatic process — I had tried Ubuntu on the same hardware a little over a year ago, and found it to be lacking — but I needed a distraction from studying for the GRE, and so I dove in last weekend and burned a LiveCD.
I am currently running gNewSense DeltaH, which is based on Ubuntu’s Hardy Heron release. I have found the out-of-the-box hardware support to be surprisingly good: I didn’t need to install any special packages to get the screen resolution right, to get the mouse working, or to get the keyboard working before boot (all of which were issues with Ubuntu when I tried it a year ago). The gNewSense installer worked perfectly fine, and gave me a happily-booting system without any additional configuration on my part.
The rest of this post will be dedicated to the things I had to do to get the system working to my satisfaction after the initial installation. Even though the hardware support is impressive, especially for a distribution which makes a point of removing any and all binary-only “blobs” from the kernel, there are a few things which I have found necessary to get a system which will eventually allow me to fully replace OS X. I’m documenting them here for my own benefit, and for the sake of anyone else who might be considering running gNewSense or Ubuntu on a MacBook.
1. Getting the wireless card working. Prior to doing any system updates or installing any packages I might want, I had to get a working Internet connection. We share a wireless connection here, so plugging in direct was not really an option for any length of time. I used the madwifi drivers, which are not available as a gNewSense package (though they are now available in Ubuntu’s linux-restricted-modules package, according to the madwifi wiki). I don’t understand the licensing issues involved, because the COPYRIGHT file in the madwifi distribution says its source code is dual-licensed under the BSD and GPL licenses, which is good enough for me.
There was one snag trying to get the wireless drivers to compile. gNewSense DeltaH installs both the linux-image-2.6.24 and linux-image-2.6.24-generic kernels, but only the generic version properly uses both CPU cores, so that is naturally the one I was using. However, the default installation does not install the kernel headers for the generic kernel build, so madwifi would not compile against it. Therefore, it was necessary for me to plug into the wired connection and run
$ sudo apt-get install linux-headers-2.6.24-generic
before I could compile madwifi. Once the Linux headers were installed, though, running
$ make
$ sudo make install
in the madwifi directory worked flawlessly, and the kernel loads the driver at boot.
Update: after installing the linux-libre kernel, version 2.6.29-1, from Uncle Gnufs’ World Famous Home Baked Free Kernel Shoppe, wireless works without the Madwifi drivers. The built-in ath9k driver is used instead, and I have experienced no problems with it so far.
2. Getting the mouse working. The MacBook touchpad mostly works after a default installation, but a couple of features are missing that I really need and enjoy:
- right-clicking
- two-finger scrolling
Right-clicking is a must-have in any modern desktop environment, and it was actually the more difficult problem to solve. I am still not sure if I like the solution, but for what it’s worth, this will work:
- Install the
xkbsetpackage:
$ sudo apt-get install xkbset
- Create a file ~/.Xmodmap, and add the line:
keycode 115 = Pointer_Button3
Key code 115 is for the left Apple key. You can use a different key if you wish; use the “xev” program to determine what the key codes for different control keys are. - On the System menu, go to Preferences -> Keyboard. On the “Mouse Keys” tab, check “Allow to control the pointer using the keyboard.”
- On the System menu, go to Preferences -> Sessions. On the “Startup Programs” tab, click “Add.” Enter what you like for the name and comments; the command should be:
xmodmap /home/username/.Xmodmap && xkbset m
(replacing “username” with your actual username). - Restart X with Ctrl-Alt-Backspace.
- The LEFT Apple (Command) key will now simulate a right-click wherever the mouse pointer is.
At the moment, this solution is only working for me some of the time, and it doesn’t have the “native” feel of OS X’s Control-click for rightclick. (Indeed, you don’t have to click the mouse button at all to get a right click.) This feels uncoordinated to me, because the key is not a modifier for a normal mouse click (the way it is normally a modifier for a keypress); instead, it is a mouse click. This means that whatever key you choose must be solely dedicated to right-clicking. If anyone comes up with a better way to make a key/mouse-click combination function as a right click while still preserving the normal function of that key elsewhere, I would love to hear about it.
Two finger scrolling is easier to set up, though I don’t have it working as smoothly as in OS X yet either. Simply add these lines to your /etc/X11/xorg.conf file in the section which has the “Synaptics Touchpad” identifier:
Option "VertTwoFingerScroll" "1"
Option "HorizTwoFingerScroll" "1"
Option "TapButton1" "0"
(If you don’t want horizontal two finger scrolling, set that to “0″ instead of “1″. The third line turns off tapping on the touchpad as a click; leave it out if you like being able to click with a tap.) There are a couple of issues with this so far. First of all, the touchpad seems too sensitive to me: two-finger scrolling goes very fast, and accidental brushes of my palm or thumbs on the touchpad can have drastic effects on whatever I’m doing in a way they never did in OS X. Second, the right side of the touchpad also appears set up to be a scroll zone, which is redundant and unhelpful for me; I fixed this via the GUI (System -> Preferences -> Mouse -> Touchpad -> uncheck “Enable vertical scrolling”) but I don’t know how to set this permanently in the Xorg configuration, which I would like to do. Again, suggestions are welcome.
3. Installing GNU IceCat. IceCat is the GNU Project’s version of the Firefox browser. I much prefer it to Epiphany (which was mysteriously eating my downloads), and it adds some nice security features that Firefox doesn’t have. Downloading the .deb from ftp://ftp.gnu.org/gnu/gnuzilla/3.0.1-g1/ and installing it with dpkg worked fine.
Update: I’m having some difficulties getting Gnash, the GNU Flash player, to work with IceCat. I tried installing mozilla-plugin-gnash via apt-get and creating a link to the installed flashplugin-alternative.so from the IceCat plugins directory…and IceCat promptly crashed when I tried to open a Flashy site. I am going to assume that this is due to some kind of version conflict between the mozilla-plugin-gnash package and IceCat, and try compiling from source next.
Update 2: I compiled Gnash from source, and it works at last! I still can’t play videos on Hulu or YouTube, because they use Flash 9, and Gnash doesn’t have support for them yet, but oh well. Here are the steps to compile Gnash and the plugin for IceWeasel:
- Install dependencies:
$ sudo apt-get install libboost-dev libboost-thread-dev libagg-dev libsdl1.2-dev libgstreamer0.10-dev libatk1.0-dev libatk1.0-dev libglib2.0-dev libgtk2.0-dev libungif-dev libjpeg-dev libboost-dev libboost-thread-dev libagg-dev libsdl1.2-dev libgstreamer0.10-dev libatk1.0-dev libatk1.0-dev libglib2.0-dev libgtk2.0-dev libgif-dev libjpeg-dev libxml2-dev libcurl3-dev libboost-date-time-dev libboost-serialization-dev
- Obtain the Gnash 0.8.4 source .tar.bz2 from ftp://ftp.gnu.org/pub/gnu/gnash/.
- Unzip the sources:
$ tar xjvf gnash-0.8.4.tar.bz2
$ cd gnash-0.8.4
- Configure the build for GTK (not KDE) and to install the IceCat plugin:
$ ./configure --with-plugindir=/usr/local/lib/icecat-3.0.1-g1/plugins --enable-gui=gtk
- Make and install:
$ make
$ sudo make install
$ sudo make install-plugins
4. Fixing font rendering. This solution comes from Deep Thought. Add this XML to ~/.fonts.conf:
<?xml version="1.0"?>
<!DOCTYPE fontconfig SYSTEM "fonts.dtd">
<fontconfig>
<match target="font">
<edit name="autohint" mode="assign">
<bool>true</bool>
</edit>
</match>
</fontconfig>
Other outstanding issues:
- Sound
- Sleeping/hibernating: the system does sleep (suspend to RAM) and resume, but after doing so, I can’t switch from GNOME to one of the text-based virtual terminals (e.g., via Ctrl+Alt+F2) — they’re all black.
That’s all for now. I will update this post as I discover solutions for other issues.
I have no options for using PowerPrep
Dear GRE PowerPrep Tech Support:
I want to inform you that, because your software is proprietary and because it is only made for the Microsoft Windows operating system, I am completely unable to use it. I hope that you will take the technical steps necessary to make the software available on other platforms, and release the source code under a free software license, such as the GNU GPL.
I have tried to run the software in a variety of ways: I first tried to use it at home, using the WINE Windows compatibility layer for POSIX systems, without success. I also tried to use a Windows machine at my library, but I cannot use it on that computer either, because I do not have the administrative privileges required to install the software. I do not have access to another machine which runs Microsoft Windows. The PowerPrep software is therefore completely unusable to me.
I feel that this puts me at an unfair disadvantage as I prepare to take the GRE, and I am sure there are others who are similarly disenfranchised. I hope that ETS views this as a problem and will take steps to remedy it. The best way to make sure that everyone has an equal opportunity to use your software to prepare for the GRE is to release the source code and compiled packages for a variety of platforms. You won’t lose any money, since no one is paying for the software except by paying to register for the test, which they will continue to do; and you’ll be ensuring fair access to your software and services to everyone, regardless of their choice of computing platform.
I hope you will consider this issue as you make revisions and prepare future releases of the PowerPrep software.
FCC accepting comments about MPAA proposal
This Slashdot story details a proposal the Motion Picture Association of America has submitted to the FCC. The proposal would allow the MPAA to use Selectable Output Control (SOC) on the distribution of high-definition films, which would prevent consumers from saving them to (e.g.) a DVR. The MPAA claims their proposal would benefit consumers because it would allow them to distribute these films on cable and satellite networks before they are released on DVD, and because it would provide consumers an “incentive” to buy and HDTV before the digital transition.
Here are the comments I sent the FCC:
I am strongly opposed to the measure proposed by the MPAA to allow
Selectable Output Control to be used on the distribution of
high-definition films to consumer devices.I do not believe that there is an argument to be made for “consumer
benefit” from the use of Selectable Output Control. As a consumer,
the most important reason I prefer watching a film at home is the
freedom it affords me to watch it under whatever circumstances I
choose. I exchange the quality of seeing a film in theaters for the
ability to pause it when I get up, or to move it from my living room
player to my bedroom player, or to stop the film from playing entirely
and resume it on another date. As a consumer, I am not alone in my
willingness to wait to see a film until it is available on DVD because
it affords me these freedoms, so seeing a film earlier in its release
cycle is of no benefit to me if I am prevented from viewing it under
the circumstances I choose. Films distributed to me using SOC
therefore do not benefit me in any way.Furthermore, the MPAA’s suggestion that their proposal benefits
consumers by providing them with an “incentive” to purchase an HDTV is
insulting at best. I fail to see how having an additional reason to
purchase an expensive device is of benefit to me, particularly if I
have already chosen not to purchase one. Perhaps the MPAA could argue
they were benefiting consumers if they decided to give each of us a
free HDTV in exchange for their use of SOC — perhaps. But they
aren’t. Instead, they are claiming that their attempt to change my
personal habits in a way that will increase their profits is of
benefit to me. Incentives are not benefits, and the MPAA’s proposal
offers neither.I would regard the enactment of this proposal as another in a long
series of regulations which in fact benefit the companies the
FCC is supposed to be regulating at the expense of consumers. Please
do not allow the MPAA yet another foothold for controlling our
behavior inside our own homes!
You can submit your own comments here. The Proceeding number (for the first field on the form) is 08-82.
Split Experiments in NetLogo XML
I was recently approached by Michael Weisberg about a problem he was having using NetLogo. He has designed a NetLogo model and is running many repetitions of it to collect a broad dataset. This process is getting computationally expensive, and he wanted to farm out the experiment runs to different threads to speed up processing time.
I don’t know all the details, but it turns out that NetLogo, despite being Java-based, is not multithreaded, so Professor Weisberg is running these jobs on separate NetLogo instances running on separate machines, linked up by Apple’s Xgrid. He needed a way to take an experiment definition and split up the runs, so that the work could be spread to different nodes in the grid.
NetLogo provides a way to define an experiment using XML. Here’s an example Michael sent me:
<?xml version="1.0" encoding="us-ascii"?> <!DOCTYPE experiments SYSTEM "behaviorspace.dtd"> <experiments> <experiment name="Radius" repetitions="25" runMetricsEveryStep="false"> <setup>setup</setup> <go>go</go> <timeLimitsteps="500"/> <metric>countpatcheswith[item0visited>0]</metric> <metric>countpatcheswith[item1visited>0]</metric> <metric>countpatcheswith[item0visited>0andfirstsignificance>0]</metric> <metric>countpatcheswith[item1visited>0andfirstsignificance>0]</metric> <metric>countpatcheswith[firstsignificance>0]</metric> <metric>countfollowerswith[previous_significance>0]</metric> <metric>countmaverickswith[previous_significance>0]</metric> <metric>countfollowerswith[intxcor=25andintycor=25]+countfollowerswith[intxcor=-5andintycor=-5]</metric> <metric>countmaverickswith[intxcor=25andintycor=25]+countmaverickswith[intxcor=-5andintycor=-5]</metric> <enumeratedValueSet variable="number_of_mavericks"> <value value="200"/> </enumeratedValueSet> <enumeratedValueSet variable="number_of_control"> <value value="0"/> </enumeratedValueSet> <enumeratedValueSet variable="number_of_followers"> <value value="0"/> </enumeratedValueSet> <steppedValueSet variable="community_size" first="1" step="0.5" last="20"/> </experiment> </experiments>
The key node to notice is the <steppedValueSet> node, which defines the way a variable should change across runs of the experiment. He wanted to be able to “chunk” this range of values into multiple experiments. For example, the community_size variable defined above runs from 1 to 20 with a step of 0.5, totalling 40 (or, I guess, 39) runs. He wanted to define a chunk size of 10, and end up with two experiment nodes that look as follows:
<?xml version="1.0" encoding="us-ascii"?> <!DOCTYPE experiments SYSTEM "behaviorspace.dtd"> <experiments> <experiment name="Radius-1" repetitions="25" runMetricsEveryStep="false"> <!-- ... --> <steppedValueSet variable="community_size" first="1" step="0.5" last="10"/> </experiment> <experiment name="Radius-2" repetitions="25" runMetricsEveryStep="false"> <!-- ... --> <steppedValueSet variable="community_size" first="10" step="0.5" last="20"/> </experiment> </experiments>
This is a simple enough manipulation when you only have one stepped variable: all you have to do is read the steppedValueSet node, make a copy of its container experiment node, and adjust the attribute values on each steppedValueSet to reflect the endpoints of the chunks. But in the case where there is more than one steppedValueSet node per experiment, it gets a little trickier: now you need an experiment node for each tuple in the Cartesian product of the variable range chunks. If you have two variables with two chunks each, you need 2*2 = 4 experiment nodes; if you have three variables with four chunks each, you need 4*4*4 = 64 experiment nodes.
I wrote some Python code to perform this manipulation; you can get it here. For every experiment node in an input XML document, it reads the steppedValueSet nodes, chunks them according to sizes you define for each variable, and creates a new steppedValueSet node for each chunk. It then creates an experiment node for every ordered tuple in the Cartesian product of the sets of steppedValueSet nodes, and adds those experiments to a new XML document.
Here’s how you use the code:
# import the split_experiments function
>>> from nlogoxml import split_experiments
>>> from xml.dom import minidom
# open the input file and parse it into a DOM Document object
>>> f = open("experiment.xml")
>>> doc = minidom.parse(f)
# define chunk sizes for each variable:
# keys should be variable names exactly as they appear in the original XML
# variables with no defined chunk size will not be chunked
>>> chunk_sizes = {
... 'var_1' : 10,
... 'var_2' : 2,
... 'var_3' : 34,
... # ...
... }
# use split_experiments to obtain a new DOM Document instance
>>> new_doc = split_experiments(doc, chunk_sizes)
# do whatever post-processing on new_doc you want; here we just write it out
>>> f2 = open("output_file.xml", "w")
>>> f2.write(new_doc.toxml())
>>> f2.close()
A few warnings: first of all, this code is NOT extensively tested. I tried it on the sample XML file Michael Weisberg sent me, and it works for that, but I have not tried it with more complex experiment definitions. Second, the code for the split_experiments function is not very modular, and doesn’t contain much error-handling, so please let me know if you find it breaking down in particular places, or if you see certain functions that would be useful to abstract out. Third, all of the XML processing is DOM-based, so it has the potential to use quite a lot of memory, especially since the number of experiment nodes grows exponentially with the number of steppedValueSet variables and the number of chunks for each variable. This is probably not a problem if you’re in a situation where you have dedicated machines for running NetLogo experiments, but keep it in mind.
Please let me know if you find this program useful!
Government and Meta-Government
I want to draw attention to two sites that I’ve recently discovered, and which deserve the attention of democratically (small “d”)-minded folk: Change-Congress.org and Metagovernment.org. The first is about the United States government. The second is a “meta” government, an open document that aims to (eventually) govern governments.
Change Congress is Lawrence Lessig’s latest project. It is:
…a movement to build support for basic reform in how our [U.S.] government functions. Using our tools, both candidates and citizens can pledge their support for basic changes to reduce the distorting influence of money in Washington. Our community will link candidates committed to a reform with volunteers and contributors who support it.
Here’s a blip.tv channel with Professor Lessig’s video presentation of the concept.
The Metagovernment is a project with a much wider ambition: to be
the system which will run a series of governments using a scored, versioned website as the medium for legislation and bureaucracy under the principle of open source governance. This implementation is similar to the concept of wiki government, but with a sophisticated scoring system to avoid potential downfalls of a completely open editable system.
Both sites are working toward an important goal: greater transparency in government, leading to greater accountability of representatives to the people governed, and thus to greater democracy. Rather than just focusing on fixing the symptoms of a broken governmental system (e.g., health care laws which benefit powerful private interests at the expense of the public), they recognize a common cause of these symptoms: the hoarding of information. In different ways, they seek to make it easier for citizens and representatives to exchange information, and to build trust for each other on the basis of that information. Change Congress, for example, allows candidates to pledge not to take money from PACs (political action committees) — and then verifies that they don’t. The Metagovernment provides the infrastructure for citizens to directly create, revise and enact their own legislation.
Sharing information is important for a very simple reason. A democracy is founded on the idea that people are best off as individuals and as a group when they are able to make decisions for themselves; and it’s impossible to make good decisions in the absence of good information about the consequences of choosing one option versus another. (If someone asked you to pick a number between one and ten, you might naturally respond: “What for?” You can’t produce anything other than a random response unless you know something about the consequences of your choice.) Good information leads to good individual decisions, expectations about how individuals will behave in the future, and reasonable consequences for people who break established expectations. It is the foundation of trust, social norms, and law. Any organization seeking to improve the way we exchange information about how we govern society therefore deserves our praise and attention. I hope you’ll visit these sites.
Letter to Vermont Legislators
A couple of days ago I completed and sent out a letter to the members of the Vermont Legislature’s Committees on Education. The letter was designed to make legislators aware of the benefits of using free software in schools, and to give them some ideas about how to promote its adoption at a time when school budgets are inflating around the state and the governor is introducing cost containment legislation.
The letter makes several essential points:
- When used in schools, free (as in “freedom”) software can significantly reduce education spending because:
- it generally costs nothing to obtain and copy; there are no license fees to pay, and no restrictions on its use
- it is more stable and more secure than proprietary software, so it costs less to maintain
- it allows school districts and the state to pool their financial resources to purchase software services needed by all
- Free software has other benefits for students and educators, such as:
- giving teachers more control over how they use technology in the classroom
- encouraging student curiosity about how computers and software
work, instead of forbidding it - exposing students to the social values of cooperation and
helping their neighbors - giving parents and community members more freedom over the
software they use outside of schools
- The Vermont Legislature can promote the adoption of free software
in schools by:- providing short-term grants to re-train staff in districts that pledge to use free software
- granting districts which pledge to use free software full or partial exemption from cost containment laws
- supporting future laws which facilitate free software
distribution between districts, and which provide state funds for free
software development
The letter was cosigned by members of the Vermont Area Group of Unix Enthusiasts, and is available on their wiki here. You can also download a PDF version.
As with my earlier letter to the Vermont NEA, you are free to copy and modify this letter under the terms of the Creative Commons Attribution 3.0 United States License. Please do not attribute any changes you make to me; but please do make changes, and send it to your own legislative representatives!
This letter is licensed under a Creative Commons Attribution 3.0 United States License.
Evangelicalism and the History of Economics
I don’t usually write posts simply to refer to other content, but I have just finished reading an article that I found so interesting I will make an exception. It’s titled Let there be Markets: the Evangelical Roots of Economics, and while the title might warn of a debate along the same old “liberal” and “conservative” party lines, I found it to be much more than that.
