For me, that time is now, that library is ConfigParser, and the replacement is included below the fold. It’s called conf, and it means that the only interaction you as a programmer are required to have with your config file is to assign and/or read values to/from it. Assigning and reading look exactly like normal attribute assignment/reading.

Subversion/TRAC string: https://svn.coriolinus.net/OOconf
distutils packaged version: conf-0.2.0

As always, I’m too cheap to pay a thousand dollars for a site certificate, so please ignore any certificate mismatch errors you encounter when viewing the https side of the site. If you don’t trust me enough to click through, you’ll still find the current version under the fold.

import os
import codecs
import json
from ConfigParser import SafeConfigParser

def internal(func):
	def tf(self, *args, **kwargs):
		self.__dict__['__conf__'].__dict__['__internal__'] += 1
		try:
			return func(self, *args, **kwargs)
		finally:
			self.__dict__['__conf__'].__dict__['__internal__'] -= 1
	return tf

class Section(object):
	def __init__(self, conf, name, fullname=None):
		if fullname is None:
			fullname = name

		self.__dict__['__conf__'] = conf
		self.__name__ = name
		self.__fullname__ = fullname

		self.__dict__['subsections'] = set()
		self.__dict__['attributes'] = set()

		#this lines MUST be the last in __init__
		self.__restrictedvars__ = set((i for i in dir(self) if '__' not in i))

	@internal
	def __setattr__(self, name, value):
		if self.restricted(name):
			if (not self.__conf__.__restrict__) or self.__conf__.__internal__ > 0:
				self.__dict__[name] = value
			else:
				raise AttributeError("Namespace conflict: %s restricted for Conf use." % name)
		else:
			self.__conf__.__new_data__ = True
			self.attributes.add(name)
			self.__conf__.__cp__.set(self.__fullname__, name, json.dumps(value))

	@internal
	def __getattr__(self, name):
		if self.restricted(name):
			return self.__dict__[name]
		else:
			return json.loads(self.__conf__.__cp__.get(self.__fullname__, name))

	@internal
	def __delattr__(self, name):
		if self.restricted(name):
			if (not self.__conf__.__restrict__) or self.__conf__.__internal__ > 0:
				del self.__dict__[name]
			else:
				raise AttributeError("Namespace conflict: %s restricted for Conf use." % name)
		else:
			self.__conf__.__new_data__ = True
			self.attributes.remove(name)
			self.__conf__.__cp__.remove_option(self.__name__, name)

	@internal
	def restricted(self, name):
		"""
		This function returns true for all attributes which should be stored locally, not in the
		configuration file proper.
		"""
		if name.startswith('__') or name.endswith('__'):
			return True
		if name in self.__restrictedvars__:
			return True

		return False

	@internal
	def add_section(self, name):
		fullname = ''.join((self.__fullname__, '.', name))

		if hasattr(self, name):
			raise ValueError("Namespace conflict: %s already in use" % fullname)

		if not self.__conf__.__cp__.has_section(fullname):
			self.__conf__.__cp__.add_section(fullname)
		self.subsections.add(name)
		self.__dict__[name] = Section(self.__conf__, name, fullname)
		self.__restrictedvars__.add(name)
		self.__new_data__ = True

	@internal
	def remove_section(self, name):
		fullname = ''.join((self.__fullname__, '.', name))

		if not hasattr(self, name):
			raise ValueError("Can't remove section %s, as it doesn't exist" % fullname)

		sub = getattr(self, name)
		for subsub in list(sub.subsections):
			sub.remove_section(subsub)

		self.__conf__.__cp__.remove_section(fullname)
		self.subsections.remove(name)
		self.__restrictedvars__.remove(name)
		del self.__dict__[name]
		self.__new_data__ = True

class Conf(Section):
	"""
	Automatic storage and retrieval of arbitrary values into a config file. 

	Uses type information and automatic reconversions to store a variety of primitive types in a
	perfectly human-readable format. Primitive types are those encodable by the json module.

	Usage:
	>>> from conf import Conf
	>>> conf = Conf() #or Conf(filename, defaultsectionname)
	>>> conf.foo = 'hello world'
	>>> conf.bar = 723
	>>> conf.baz = False
	>>> conf.flush()

	[exit, start a new session here]

	>>> conf = Conf()
	>>> conf.foo
	'hello world'
	>>> conf.bar
	723
	>>> conf.baz
	False

	If you want implicit file creation, you need to use a with statement:
	>>> with Conf() as conf:
	...      conf.foo = 2783.1
	...
	>>> del conf
	>>> with Conf() as otherConf:
	...      otherConf.foo
	...
	2783.1
	"""
	def __init__(self, filename ='.conf', sectionName=None):
		"""
		Initialize a new Conf object.
		"""
		self.__dict__['__internal__'] = 0
		self.__dict__['__restrict__'] = False
		#the above is magic; it must come first

		#sanity check
		if sectionName is not None and '.' in sectionName:
			raise ValueError("Namespace: '.' cannot be part of a section name")

		#initialize the superclass
		Section.__init__(self, self, sectionName if sectionName is not None else 'config')

		self.__filename__ = filename
		self.__cp__ = SafeConfigParser()

		#load and initialize the configparser
		if os.path.exists(filename):
			with codecs.open(filename, 'rb', 'utf8') as cf:
				self.__cp__.readfp(cf, filename)

		if sectionName is None:
			topLevelSections = [s for s in self.__cp__.sections() if s.count('.') == 0]
			if len(topLevelSections) == 1:
				sectionName = topLevelSections[0]
				self.__name__ = sectionName
				self.__fullname__ = sectionName
			else:
				sectionName = 'config'

		#create the default section
		if not self.__cp__.has_section(sectionName):
			self.__cp__.add_section(sectionName)

		#load default section attributes
		self.attributes = set(self.__cp__.options(sectionName))

		#load the various sections
		#first, sort them by the number of dots they contain
		secs = [(s.count('.'), s) for s in self.__cp__.sections() if s != sectionName]
		secs.sort()
		for name in [sec for count, sec in secs]:
			if '.' not in name:
				self.subsections.add(name)
				self.__dict__[name] = Section(self, name)
				self.__dict__[name].attributes = set(self.__cp__.options(name))
				self.__restrictedvars__.add(name)
			else:
				fullname = name
				rest, name = name.rsplit('.', 1)
				sec = self
				for part in rest.split('.'):
					sec = getattr(sec, part)
				sec.subsections.add(name)
				sec.__dict__[name] = Section(self, name, fullname)
				sec.__dict__[name].attributes = set(self.__cp__.options(fullname))
				sec.__restrictedvars__.add(name)

		self.__new_data__ = False

		#this must come last:
		self.__internal__ = 0
		self.__restrict__ = True
		#This is used in combination with the @internal decorator. Each method so decorated
		# increments this variable on entry, and decrements it on exit. They can then check: is
		# __internal__ > 0? If yes, they were called from within this Conf object, and can adjust
		# their behavior accordingly.
		#
		#Note that we initialize it here to 0. When this __init__ exits, it decrements to -1. This
		# is intentional. Since each internal function starts by incrementing it, this means that
		# only if the variable is > 0 was its caller also internal.

	@internal
	def __enter__(self):
		return self

	@internal
	def __exit__(self, exc_type, exc_value, traceback):
		if self.__new_data__:
			self.flush()

	@internal
	def flush(self):
		with codecs.open(self.__filename__, 'wb', 'utf8') as cf:
			self.__cp__.write(cf)
		self.__new_data__ = False

	@internal
	def add_section(self, name):
		"""
		Create a new section in the conf file. This will become a dotted extension of the conf object.

		For example:
		>>> c = Conf()
		>>> c.foo = 'hello world'
		>>> c.add_section('bar')
		>>> c.bar.baz = 'world says hello'

		The above turns into a config file which looks like this:
		[config]
		foo = hello world

		[bar]
		baz = world says hello
		"""
		if hasattr(self, name):
			raise ValueError("Namespace conflict: %s already in use" % name)
		if '.' in name:
			raise ValueError("Namespace: '.' cannot be part of a section name")

		if not self.__conf__.__cp__.has_section(name):
			self.__conf__.__cp__.add_section(name)
		self.subsections.add(name)
		self.__dict__[name] = Section(self, name)
		self.__restrictedvars__.add(name)
		self.__new_data__ = True

	@internal
	def remove_section(self, name):
		"""
		Remove a section and all included data.
		"""
		if not hasattr(self, name):
			raise ValueError("Can't remove section %s, as it doesn't exist" % name)

		sub = getattr(self, name)
		for subsub in sub.subsections:
			sub.remove_section(subsub)

		self.__cp__.remove_section(name)
		self.subsections.remove(name)
		self.__restrictedvars__.remove(name)
		del self.__dict__[name]
		self.__new_data__ = True

conf.py by coriolinus is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.
Permissions beyond the scope of this license may be available at http://www.coriolinus.net/contact/.

1. Lexer / Phoneme Analyzer: This just tokenizes the input stream, whether it be audio or text. These are actually separate branches for the different types of input, but functionally do the same thing. Operates at the character/raw sound level.
2. Parser: Checks grammar and syntax of input tokens. Generates all possible interpretations of homonym/homophone possibilities. Operates at the word level. Generates sentences.
3. Local Contextual Integrator: Considers local details: formatting of text, source and quality of audio, etc. Gives a small, local “big picture” to frame the input in question. Operates at the word level, but by nature considers a variety of external cues.
4. Literal Semantic Analyzer: Given the tokens and their context, decides what the literal meaning of a given sentence is. Operates at the sentence level.
5. Source Knowledge Integrator: The source of a given communication is important. A message from a family member might be more trusted than a random internet article. A sentence from a very literal, precise person is more likely to mean exactly what it says than one from an excitable teenager. Operates at the sentence level.
6. Conceptual Accumulator: Collects a bunch of related sentences into a paragraph-level concept. Decides what sentences are related and how they fit together.
7. General Semantic Analyzer: Decides what the author probably meant in a particular paragraph. Resolves logical contradictions and paradox. Operates at the paragraph/concept level.
8. General Contextual Integrator: Integrates a concept with a worldview. This is the level which decides if someone is lying, wrong, or otherwise speaking falsehoods. Operates at the concept level, though by nature includes a wide variety and broad scope of external information.
9. Cognition: normal thought about ideas. Operates at the conceptual level. Can modify the rules of lower levels, for example when learning a new language or updating the current model of the current language.

Humans accomplish layers 1-5 automatically and unconsciously. Layers 6-8 are like breathing: generally subconscious, but can be consciously overridden. Layer 9 is when we start getting into id, ego, superego stuff: possibly subconscious but generally sentient behavior. Computers right now are quite good at steps 1 and 2 using artificial languages, and rubbish at them for natural languages. Layers 3 and above may exist as research projects, but are above the current state of the art.

When I go back to school, there is a high probability that this is the stuff I will focus on, trying to push the state of the art in computer thought up, level by level. It is fascinating!

It's longhand addition: the sum with carries ignored, plus the carries. Why not just use a normal adder? This equation still has an addition operation. However, this reduces the probability of a carry operation by about half (assuming binary numbers with each bit independently equally likely to be either 0 or 1).

It's not useful, but it's cool. This whole book is 300 pages of such tricks, few of which I expect ever to use, but all of which trigger little explosions of happiness when I figure out how they work. If you've ever considered bit-twiddling without immediately assuming it's a euphemism, you'll like this book.

Hacker’s Delight, Henry S. Warren, Jr. (Amazon)

You invent the world’s tiniest (and most sideways) centrifuge, and accelerate someone to near lightspeed along one of these dimensions. Does this brave experimentee experience relativistic weirdness?

My prediction: yes, but not in the traditional sense. The necessary caveat here is that I do not have the necessary math to back any of this up; this is just intuition based on my understanding of physics.

Let’s list the traditional effects of near-lightspeed travel. There’s an increase in mass, compression along the direction of travel, a reduction of rate of perceived time. These effects can only be perceived by an observer whose velocity relative to the experimentee is large.

The salient feature of the seven bonus dimensions is that they are very, very tiny and extremely tightly curled: any motion along any of them will quickly return an object to the starting point. (This is both why the experiment features a centrifuge instead of a traditional accelerator and why they play a negligible role in human-scale life.) Also, they are orthogonal to each other and to the traditional four dimensions of everyday life.

The centrifuge’s overall effect, then, will be to vibrate the experimentee; whether it’s a sine wave or a sawtooth depends on details of the wrapping that I don’t know, but that ultimately don’t matter. Either way, vibration can be averaged out to a single position.

We wouldn’t notice the spatial compression: that only applies in the direction of travel, and in this case that direction is orthogonal to any direction humans can sense. However, we would notice the other two effects: time dilation and mass increase. Even though the experimentee is at rest in the primary three dimensions and is effectively only vibrating in the fourth, that vibration is still at near-lightspeed. I can’t come up with any reason why those effects should be masked.

Holy crap. I think I just simultaneously invented both stasis fields and gravity generators.

It sounds like a disease, doesn’t it?

I also learned some things:

1. I am very, very out of practice. More than four hours into the exercise, I was still debugging. The bugs were things like MSSQL Optional Feature Not Implemented, not actual logic errors, but still. That’s too long given the complexity of the task.
2. I have a lot of fun coding. In a basically unprecedented move, I was delaying leaving work until the guy whose office I was borrowing made me leave so he could lock up. Especially given that I’d had an 11 hour day at that point, this is a significant development.
3. For all that I rag on MS products, the MSSQL query designer really does take a lot of work out of the process of writing complex queries.

Actually, 90 minutes into the exercise, a civilian contractor came by and worked magic and solved the problem for which I was writing code in the first place. I kept working, using the excuse that my version will be more featureful than the Army’s, and that by having the source to it the Army will benefit. The real reason is much simpler: I’m having way too much fun to just give this project up. I am perpetually at the 50% mark and working rapidly towards completion; I’m not going to let this just escape me.

More images here, at the flickr set.

KIETH: Hi, my name is KIETH. How may I help you? [06:05:08 PM]
coriolinus: hello keith [06:06:14 PM]
KIETH: hello, [06:07:05 PM]
coriolinus: I’ve got Bad Company 2 installed via Steam [06:06:35 PM]
coriolinus: I played it a bit a few weeks ago, put it down, and tried it again today [06:06:48 PM]
KIETH: Okay. [06:07:55 PM]
coriolinus: The problem was that after loading the game, pressing the “Resume” button, and loading the maps, it dumped me back down to the desktop with no error at all [06:07:18 PM]
KIETH: Carry on. [06:08:02 PM]
coriolinus: it happened when I was logged into the servers and when I wasn’t [06:07:37 PM]
coriolinus: All I’m trying to do is continue playing where I left off, but this game keeps crashing seemingly immediately as it finishes loading the level [06:08:10 PM]
KIETH: Please provide me the dxdiag of your PC. [06:09:21 PM]

[cut for length]

KIETH: Okay. [06:10:37 PM]
KIETH: Sorry. [06:12:31 PM]
KIETH: The game is not tested on windows 7, 64 bit. [06:12:57 PM]
KIETH: Please run the game on compatibility mode. [06:13:14 PM]
coriolinus: i see [06:12:41 PM]
KIETH: Is there anything else I can do for you ? [06:13:37 PM]
coriolinus: when does EA expect to extend compatibility testing to modern hardware/software combinations? [06:13:15 PM]
KIETH: No. [06:14:33 PM]
‘coriolinus’ disconnected (‘Concluded by End-user’). [06:14:59 PM]

In other news, don’t bother buying Bad Company 2.