First, a proviso to what follows: I am almost certain that this is a bad idea and that you should do it. At the very least, you should make sure that your setting names don’t clash (I like to prefix them with the app name).

The goal is simple: your app should contain a settings module which defines the default values for your application’s settings. These values should be injected into Django’s settings system so that manage.py diffsettings and similar functionality all work as you’d expect.

The approach is just as simple: add some code to the top-level module of your application that loops over the values in your app.settings module and inject them into the django.conf.global_settings module and (because it’s already been initialised by the time apps are loaded) the django.conf.settings object (being careful not to stop on actual configured with your default values).

The code itself is pretty simple. From app/__init__.py:

def inject_app_defaults(application):
	"""Inject an application's default settings"""
	try:
		__import__('%s.settings' % application)
		import sys
		
		# Import our defaults, project defaults, and project settings
		_app_settings = sys.modules['%s.settings' % application]
		_def_settings = sys.modules['django.conf.global_settings']
		_settings = sys.modules['django.conf'].settings

		# Add the values from the application.settings module
		for _k in dir(_app_settings):
			if _k.isupper():
				# Add the value to the default settings module
				setattr(_def_settings, _k, getattr(_app_settings, _k))
				
				# Add the value to the settings, if not already present
				if not hasattr(_settings, _k):
					setattr(_settings, _k, getattr(_app_settings, _k))
	except ImportError:
		# Silently skip failing settings modules
		pass

inject_app_defaults(__name__)

You can see the code in a proof of concept application in my django-application-settings project on GitHub.

[gitosis]


[repo repo1]
description = This is a repository with stuff in it
owner = A User

[repo repo2]
description = Another repository with stuff in it
owner = Another User

[repo docs]
description = Documentation
owner = A Manager

[group developers]
writable = repo1 repo2 docs
members = auser anotheruser

[group managers]
writable = docs
readonly = repo1

The goal is to append a value to the writable line in the group developers section (leaving the rest of the lines alone). Any solution will need to do the following:

1. find the group developers section; then
2. find the writable line in that section, if any, and update it.

This is simple to do in AWK:

1. a rule sets a flag when you enter the group developers section;
2. another updates the writable line when the flag is set;
3. a thirds rule clears the flag when you leave the section;
4. a final rule outputs other lines unchanged (we use a flag to skip the lines modified and output above).

Here’s the code:

# Clear the flag
BEGIN {
	processing = 0;
}

# Entering the section, set the flag
/^\[group developers/ {
	processing = 1;
}
	
# Modify the line, if the flag is set
/^writable = / {
	if (processing) {
	    print $0" foo";
		skip = 1;
	}
}

# Clear the section flag (as we're in a new section)
/^\[$/ {
	processing = 0;
}

# Output a line (that we didn't output above)
/.*/ {
	if (skip)
	    skip = 0;
	else
		print $0;
}

Easy!

Haskore

A computer music system based on Haskell.

Pan (or Pan# or one of the several variations on the theme)

A functional graphical processing language similar to Haskell.

Pivotal

A document centred presentation of Haskell.

FunWorlds

An interactive 3D animation package in, you guessed it, Haskell.

1. I like functional programming, in general, and Haskell, in particular.
2. I don’t like the languages usually taught to students (Java, VisualBasic, etc.)
3. I think that a different, more fundamental, approach might help (supported, I think, by the experiences of teachers using SICP in high schools in the U.S.).

We’ll see how things pan out. If possible, I’d like to integrate some of the above packages into a single whole. Haskore and one of the portable Haskell variants of Pan, for example, might be integrated with Pivotal to give a relatively simple environment for interactive, multi-media Haskell programming. Haskore, in particular, could benefit extraordinarily from such an integration: the student be able to “code”, visualise and listen to their musical compositions from the same program.

1. functional data-structures, amortised analysis, etc.;

2. testing and specification with QuickCheck;

3. programming with folds, unfolds, etc.;

4. music programming;

5. representing financial contracts;

6. graphics programming;

7. hardware description;

8. combinators;

9. arrows; and

10. phantom types

amongst other topics. This looks to be a fascinating mixture of methods (data-structures, testing, folds, arrows, etc.) and applications (music, graphics, financial contacts, hardware description, logic programming, etc.) if a little thin for its price.

Both the software from the book and details about the symposium from which its content comes are available on the Oxford Computing Laboratory web-site.

I spent some of the 2.5 hour bus trip back from classes in Hobart today thinking about ways to present monads. As a result, I’ve decided to write my very own version of that mainstay of the Haskell community – Yet Another Monads Tutorial. The goals of this project are twofold:

1. to try to solidify my understanding of monads, their uses and theory; and

2. to present programming in a way that very few or, more likely, no students will experience before advanced undergraduate CS classes.

My current thinking is to introduce functional programming in terms of expression reduction (using Hugs or, maybe, GHCi). This will segue into a discussion of evaluation semantics (specifically, lazy evaluation) which will raise the problem of sequenced computations. Monads (as we already know) provide a solution to this problem which will be demonstrated with some work in the IO monad. To really understand how Monads work in Haskell, we’ll have to take a brief detour through type classes before we look at defining our own instances of Monad.

The main example (and the only one that I’ve thought most about) will be a Monad that allows us to compose transformation matrices for 3D work in monadic style. In this Monad, we’ll be able to create a transformation matrix by doing something like:

myTransform = do
    identityMatrix;
    rotateAbout Z 90;
    scale X 1.5;
    translate Y 20

rather than explicitly creating the matrix for each transformation and multiplying them together or, worse, poking at the individual members of the transformation matrix. Furthermore, this example lends itself quite well to extension. Instead of calculating a matrix which performs the appropriate transformations, we might instead create an data-structure encoding the calculation which will, when evaluated, yield such a matrix. This data-structure could then be evaluated (like, if I understand correctly runST does for the ST monad) or it could be subjected to symbolic manipulation (perhaps allowing the students to implement a simple optimiser).

This will probably turn into my major project for next semester (developing plans and materials for an entire unit). If it does, I’ll probably make it available online somewhere.

This paper appears to have as its object a solution to similar problems as those addressed by software transactional memory, i.e. maintaining memory consistency. Where STM provides transactions that can be used to implement multi-threaded programmes much more simply that traditional explicit locking approaches, this paper uses a similar mechanism to handle unexpected failures (uncaught exceptions) and roll-back the effects of the failed code.

The authors describe their implementation of an undo mechanism in Bartok, an experimental optimising C# compiler and CIL runtime. Their system extends C# with a try_all block which acts as a catch-all exception handler. If an exception propagates is raised within a try_all block and is not handled before it reaches the scope of the block, then the roll-back mechanism is engaged.

The main difference between Haskell’s STM is the goal: where STM is concerned with maintaining memory consistency in the face of concurrently executing threads, this system is concerned with simplifying error handling and recovery.

Google | CiteULike | LtU