dmtdev

Fully iterative Ackermann function computation

dmyersturnbull — Sat, 15 Aug 2009 23:18:44 +0000

I recently heard someone insist that the Ackermann function can only be computed recursively.

Wrong! Here is a fully iterative implementation of Ackermann‐computation, written in Python:

def ackermann(m, n):
	stack = [m]
	while stack:
		m = stack.pop()
		if m == 0:
			n += 1
		elif n == 0:
			stack.append(m - 1)
			n = 1
		else:
			stack.append(m - 1)
			stack.append(m)
			n -= 1
	return n

The insistence that the Ackermann function can only be computed recursively is rampant and is often caused by a poor understanding of recursion and why it is not required for Turing‐completeness. Using Python 2.6 on my Intel Core 2 Duo, the above iterative implementation performed better than the typical recursive implementation—a fact that should not surprise anyone.

Linguistic and Typographical Conventions

dmyersturnbull — Tue, 11 Aug 2009 06:31:47 +0000

My own grammatical and typographical conventions have fascinated me for some time. When writing, from the most trivial and the most significant, I am dogmatically and painfully conscious of every sentence, every word, every thought, and every comma I ~~determine (joking, joking!)~~ choose to use. Sometimes, when I deliberately revise my conventions, I rewrite pieces of ancient, obsolete text of mine, regardless of the shame and self‐pity I feel for doing so.

Although this post’s presence indicates otherwise, I wrote this for myself: reviewing my conventions will hopefully discourage (and hopefully hinder) me from changing my conventions so often. Its presence here is of secondary concern, but hopefully it will provoke discussion among readers—at least the non‐verbal, internal kind.

When writing, I do…

Capitalization

Capitalize honorifics.
Capitalize possessives and pronouns of veneration.
Capitalize doctrines, philosophies, and Platonic ideals.
Capitalize names of genera.
Capitalize names of regions that are proper nouns.
Not capitalize directions.
Not capitalize names of species.
Not capitalize names of regions that are not proper nouns.

Acronyms and abbreviations

Not use periods or spaces to delimit letters in acronyms or initialisms.
In non-web mediums, include the acronym form in parenthesis when introducing an acronym or initialism.
In web-based text, use tags to introduce acronyms and initialisms at every occurrence.
Not use apostrophes in non-possessive plural acronyms.
Generally avoid abbreviations. When using an abbreviation, I always append a fullstop.

Quotations

Indent block quotations with one tabstop.
Not surround block quotations with quotation marks.
Introduce block quotations with colons, not horizontal bars (U+2015).
Use square brackets for editorial marks.
Use ‘[sic]’ to indicate mistakes that are reproduced verbatim.
Replace confusing text with editorial enclosed in square brackets.
Replace unintelligible speech with ellipses enclosed in square brackets.
Alter the typography where necessary to assist readability and consistency.
Alternate between double quotation marks and single quotation marks for nested quotations.
Enclose punctuation within quotation marks only if it is part of the quotation (“the British way”).

Parenthesis

Avoid nested parenthesis.
For nested parenthesis, use spaces between consecutive opening parenthesis and consecutive closing parenthesis.
Enclose punctuation within parenthesis only if it is part of the parenthesized idea.

Commas

Use commas wherever grammatically required.
Not use commas wherever stylistically appealing.
Not splice with commas.
Use serial commas except where their use would cause ambiguity. For example, I would use ‘He showed his friends, John, and Mary’ but ‘He showed his friend, John and Mary’.

Semicolons

Use semicolons to separate full sentences that continue a single thought.
Use semicolons as a lower-precedence delimiter for lists.
Avoid using multiple semicolons in a single sentence.

Colons

Use colons to introduce lists.
Use colons to explain, prove, or refine the preceding thought.
Avoid using multiple semicolons in a single sentence.

Hyphens

Use hyphens to join prefixes and suffixes with a word.
In digital mediums, always use U+2010 instead of the deprecated, ambiguous U+002D.
Use hyphens to distinguish between homographs.
Use hyphens to form compound modifiers, except where the first operand is an -ly adverb.
Use hanging hyphens on both prefixes and suffixes.
In handwritten text, use hyphens to indicate that words are continued on following lines.

En dash

Use non‐spaced en dashes to indicate (closed) ranges.
Use non‐spaced en dashes to indicate relationships between two things.
Use en dashes with single appended spaces as a replacement for hyphens when one operand includes a space. For example, I would use “pro– San Diego doctrine”. Does anyone have a better alternative?
Avoid using en dashes in compound modifiers when a comma would suffice.

Em dashes

Use non‐spaced em dashes to enclose parenthetical but equally important information.
Use non‐spaced em dashes to provide stylistic and tone-providing sharp breaks in flow.

Slashes

Prefer other punctuation over slashes.

In informal writing, use ‘and/or’ where applicable to remove ambiguity.

Punctuation

In informal writing, use exclamation marks, question marks, and interrobangs.
In informal writing, Use parenthesized exclamation marks and question marks in the middle of sentences.

Figures

Present numbers as words only when they can be pronounced in fewer than four syllables and written in less than one word.
Not provide information to distinguish between the long and short systems.
Prefer using ‘USD’ or other unambiguous symbols of currency units over the generic ‘$’ and ‘¤’ except when previous text makes the meaning of ‘$’ or ‘¤’ obvious.
Always prefer SI and other prescribed standards over other systems.
Use scientific notation (using superscript forms) for large numbers and Kunth’s up-arrow notation for extremely large, known numbers when precision is required.
Abbreviate units in scientific and informal writing.
Generally use SI prefixes but may present figure forms in scientific notation as alternatives to extremely high and uncommon prefixes.
Use ISO 8601 for dates.
In digital mediums, use digit dashes (U+2102) instead of hyphens in text that contains numbers.

Formatting

In digital mediums, italicize programming keywords, computer commands, hash sums, foreign text, and other non-English text. When referring to the text as text, I do not use single quotes (I normally would).
In digital mediums, use italicized text for emphasis.
In informal text in digital mediums, use bold text for serious emphasis.
In digital mediums, not underline text.
In hand-written text, underline titles of creative works.

Other grammar

Start sentences with ‘But’ and ‘And’ when doing so enhances readability.
Not confuse ‘which’ and ‘that’.
Always use commas for non-essential clauses and never use commas for essential clauses.
Use who and whom correctly.
Use data as plural and datum as singular, radius and singular and radii as plural, cactus as singular and cacti as plural, and so on.
Choose not to split infinitives except in some circumstances.
End sentences with prepositions where doing so is clearer.
Not use ‘they’ as a replacement for ‘he or she’.
Prefer comparative and superlative adverbs and adjectives over ‘more’ and ‘most’.
When using comparative adverbs and adjectives, include both operands of the comparison.

Spelling

Use -ize over -ise, -yze over -yse, -er over -re, and -xion over -ction (“the American way” ¹).
Now use -or over -our.
Prefer standard -ed endings for irregular verbs (“the American way”).

Miscellaneous

Enclose words and other characters in single quotes to refer to the word itself or characters themselves.
In digital mediums, always use correct Unicode character identities if possible, including for en dashes (U+2013), em dashes (U+2014), figure dashes (U+2012), swung dashes (U+2053), soldi (U+2044 ²), ellipsis (U+2026), single quotation marks (U+2018 and U+2019), double quotation marks (U+201C and U+201D), prime marks (U+2032, U+2033, U+2034, and U+2057), and minus signs (U+2212).
When referring to the plurality of a single character (as text), italicize the character and append ‘-s’. For example, I would write “multiple a-s”.
Use contractions only in some informal text.
Use IPA where helpful.
Not invent words and other dittononsensibilities.
Not use second-person in cases where third-person is more clear.
Use Harvard‐style citation.
Use footnotes as supplemental notes for non‐normative information.

¹ With regard to ‐ize and ‐ise and ‐yze and ‐yse and with note to common ignorance, the “American way” predates the “British way”, and the “British way” only became the “British way” during the last century. French influence and disdain for American conventions are two potential explanations for the switch.
² Unicode incorrectly assigned the solidus to be “FRACTION SLASH U+2044” and the slash to be “SOLIDUS U+002F”.

User‐agent detection using regular expressions and relational databases

dmyersturnbull — Tue, 09 Jun 2009 22:46:39 +0000

Detecting clients is trivial yet extremely difficult to do well. Developing a mechanism that properly and reliably detects operating systems and architectures in order to provide specifically‐targeted downloads requires patience. Because I remain infatuated with dynamic solutions, the solution I used is atypical.

I have a database table (inappropriately called archs) with six columns:

id [unsigned int (10)] {primary key, auto_increment}
An integer identification.
name [varchar (80)] {unique}
A short, unique name, which is displayed to the user.
regex_match [varchar (250)]
A Perl‐compatible regular expression that matches any HTTP 1.1 User-agent header string that user agents running on this row’s operating system could reasonably supply. Needs not uniquely match, not even within the same group; overlap of matches between rows that share a group is permissible.
{default=null} stamp [timestamp] {default=current_timestamp}
The time at which the row was inserted.
precedence [unsigned tinyint (3)]
Indicates the order in which the regular expression should be processed. For example, a row for Unix‐like might have a precedence of 1 and rows for GNU‐Linux and FreeBSD might have a precedence of 2. The PHP code processes expressions with lower precedence first (the motiviations for this are strong and are explained in the code’s documentation).
group [unsigned smallint (5)] {default=null}
A group of related rows under which this row falls. Corresponds to the id of another (parent) row, which has a precedence of this row’s − 1, resulting in a many‐to‐one multiplicity. For example, the GNU‐Linux and FreeBSD rows might share the group equal to the Unix‐like row’s id, and they would have a precedence of one higher than the Unix‐like row’s precedence.
After the PHP code matches the User‐agent string against rows of a given precedence, it attempts to match it against rows of a precedence one higher.

Here are the rows I have:

Id	Name	Regular expression	P	G
1	platform‐independent	.*	1	NULL
2	Windows	.\(.([wW]indows).*	2	1
3	Unix‐like	.\(.([uU]nix\|[sS]olaris\|[fF]ree\|[oO]pen\|[nN]et)[bB][sS][dD]\|[sS]un[oO][sS]\|[lL]inux\|cygwin).*	2	1
4	Mac OS	.\(.([mM]acintosh\|[pP]ower[pP][cC]\|[aA]pple\|(ppc\|PPC) [mM]ac).*	2	1
5	GNU–Linux	.\(.([lL]inux\|cygwin).*	3	3
6	Unix	.\(.([uU]nix).*	3	3
7	BSD	.\(.(([fF]ree\|[oO]pen\|[nN]et)[bB][sS][dD]\|[sS]un[oO][sS]).*	3	3
8	Solaris	.\(.([sS]olaris).*	3	3
9	OS/2	.\(.(OS/2).*	3	3
10	Windows Vista	.\(.([wW]indows [nN][tT] 6.0\|[wW]indows [vV]ista).*	3	4
11	Windows NT 5.2	.\(.([wW]indows [nN][tT] 5.2\|[wW]indows [sS]erver 2003\|[wW]indows [xX][pP] x64 [eE]dition).*	3	4
12	Windows XP	.\(.([wW]indows [nN][tT] 5.1\|[wW]indows [xX][pP]).*	3	4
13	Windows 2000, SP1	.\(.([wW]indows [nN][tT] 5.01\|[wW]indows 2000).*	3	4
14	Windows 2000	.\(.([wW]indows [nN][tT] 5.01\|[wW]indows 2000).*	3	4
15	Windows ME	.\(.[wW]in( 9x 4.90\|dows 98).*	3	4
16	Windows 95	.\(.[wW]indows 95).*	3	4
17	Mac OS PPC	.\(.([pP]ower[pP][cC]\|(ppc\|PPC) [mM]ac)).*	3	5

I tested these expressions using Regexxer 0.9 and this list of user‐agent strings.
This table is available in .sql format. I will provide the PHP source code soon.

Good Programming Language Features

dmyersturnbull — Fri, 03 Apr 2009 23:27:35 +0000

This post presents a list of programming language features I have had good experiences with. It is neither absolute nor complete, but it accurately—albeit not conclusively—outlines my preferences in programming languages. Each preference is my opinion, and I remain open to discussion. I deliberately kept these items specific rather than abstract (for example, “concision” is not included). With that said, I prefer languages that are open source, fiscally inexpensive, standardized, high-performance, and concise in syntax.

I present this list partially in response to something I dislike: programming language advocacy and “us-versus-them” philosophy. Let’s be clear: it is possible for a language to have zero strengths, but it is hardly likely. Different languages are more suited for different purposes, some languages have overall weaknesses or overall strengths as a result of failed or successful experiments, and some languages are no longer widely used—some for good reasons. In every case, a combination of arrogance and conviction does not benefit. “Your” language may be superior—or inferior—to some other, but I encourage everyone to maintain a broader and more logical approach: examine languages’ strengths and weaknesses without arrogance or religious zeal. Thank you.

Here is the list, sorted by relative importance (most important first) constrained by implementations of the notion with which I am familiar (for example, constructors is ranked lowly, but implementations could exist so extreme that they would be more important. Some of these points only apply to certain types of languages. Languages whose implementations exemplify each point are placed in parenthesis.

Strong, static typing (Java):
Types must be declared. Five does not equal true.
```
if (5 == true) {} // Error
```
Object orientation and namespaces (Java):
Everything is or is contained within a class. No global namespace exists.
Imports are controlled explicitly with a directive. Package definitions are hierarchical and are coupled to class locations. Members must be defined in their corresponding class.

Implicit accessors (C#):
Getters and setters are called implicitly.

public int halfLife {
	get {
		return halfLife;
	}
	set {
		halfLife = value;
	}
}
void foo() {
	int bar = halfLife; // Calls the getter
	halfLife = 5; // Calls the setter
}

Encapsulation (C#):
Encapsulation is handled explicitly. Access can differ between accessors and mutators.
```
private int halfLife {
	public get {
		return halfLife;
	}
	private set {
		halfLife = value;
	}
}
```

Garbage collection (Java):
Allocation and dellocation of resources is handled automatically. Java-style destructors are permitted. Garbage collection can be invoked explicitly.

class Foo {
	void openConnection() {}
	void closeConnection() {}
	void doEverything() {}
	void run() {
		Runtime.getRuntime().gc(); // Runs the garbage collector
	}
	protected void finalize() {
		closeConnection();
	}
}

Information hiding (C#):
Encapsulation is supported at language-level with access-modification keywords.
The access modification can be private, public, protected, internal, and protected internal; allowing full control in specifying access of subclasses, internal classes, and external classes.

public class Fruit {
	static fruitOnTree = 100;
	protected static Fruit pick() {
		fruitOnTree--;
		return new Fruit();
	}
	protected internal static Fruit purchase() {
		return new Fruit();
	}
}
public class Apple : Fruit {
	public Apple() {
        	Fruit.pick();         // Cannot
		Fruit.purchase(); // Can
	}
}

Pointcut–Join-Point–Advice Model (AspectJ):

aspect ColorControl {
	pointcut CCClientCflow(ColorControllingClient client):
		cflow(call(* * (..)) &amp;amp;amp;&amp;amp;amp; target(client));
	pointcut make(): call(FigureElement Figure.make*(..));
	after (ColorControllingClient c) returning (FigureElement fe):
		make() &amp;amp;amp;&amp;amp;amp; CCClientCflow(c) {
		fe.setColor(c.colorFor(fe));
	}
}

This example was shamelessly “borrowed”.
AspectJ Programming Guide

Multiple return (Python):
Methods can return multiple values using tuples.
```
def foo():
	return 3, "hello"
my_int, my_str = foo()
```

First-class functions (Python):
Functions are first-class objects and can be interchanged easily.

def major_slice(items):
	return items[0] ** 2
def minor_slice(items):
	return math.sqrt(items[0])
def print_slices(items):
	for f in [major_slice, minor_slice]:
		print(f(t))

Pointers (Java):
Direct object access through pointers is not allowed. Actual objects are never handled; only references are used.

Car mycar = new Car(); // Creates a reference
Car mycaragain = mycar; // Creates another reference
Car hiscar = mycar.clone(); // Creates a new object

Exception handling (Python, Java):
Exceptions are handled with try, except or catch, else, and finally blocks, which act on subclasses of some Exception superclass. A single except or catch statement can catch multiple types. Exceptions are thrown with raise or throw and can be chained. Java-style checked exceptions do not exist.
```
try:
	foo()
except SizeError, WidthError:
	print('failure: size or width')
except FormatError
	print('failure: format')
else:
	print('success')
finally:
	print('finished')
```
```
try {
	read();
} catch (IOException ioe) {
	throw new BadStuffHappenedException(ioe); // Chained exception
}
```
Generics (C#):
Java- and C#-style generics. The information is retained at compile-time to enhance reflection.
```
Thing foo = Thing();
foo.GetType(); // Returns information about the generics
```
Unicode support (Java):
All strings use UTF-16.
```
String status = "?!";
```
Constants (D):
Declaring an object as immutable forbids changes to any of its fields.
```
immutable Car car = Car();
car.brand = "Ford" // Error
```
Declaring an object as immutable forbids changes to any of its fields only through that reference.
```
Car car1 = new Car();
car.brand = "Ford" // Fine
const Car car2 = car1
car.brand = "Ford" // Error
```
Closures (Scheme):
Closures are fully supported.
```
(define (derivative f dx)
  (lambda (x) (/ (- (f (+ x dx)) (f x)) dx)))
```
Shamelessly “borrowed” from Wikipedia.
Interfaces (Java):
Interfaces are distinct concepts from inheritance used to bind class implementations to specific external handling.
```
interface Writer {
	public void write();
}
class Thing implements Writer { // Error
	doWhatever();
}
```

Inheritance (C++, Java):
Multiple inheritance is supported (as in C++). All methods are virtual by default (as in Java). Inheritance can be forbidden by using final (as in Java).

class Fruit {}
class Juice {}
class AppleJuice : Fruit, Juice {}

class Fruit {
	void doCoolThing() {}
}
class Apple extends Fruit {
	void doCoolThing {}
}
final class ThingHandler {
	Apple apple = new Apple();
	apple.doCoolThing(); // Always calls Apple.doCoolThing() and never Fruit.doCoolThing()
}
final class ThingHandler2 {} // Error

Contracts (D):
Contracts are handled explicitly with the keywords assert, in, out, and body.

long squareRoot(int n)
in {
	assert (n > -1)
}
out (result) {
	assert((result * result) <= n &amp;amp;amp;&amp;amp;amp; (result + 1) * (result + 1) >= n);
}
body {
	return std.math.sqrt(n);
}

Enums (Java):
Values can be assigned to enumerations. Enum definitions can contain methods and constructors.

enum Direction {
	NORTH(0, -1),
	NORTH_WEST(-1, -1),
	WEST(-1, 0),
	SOUTH_WEST(-1, 1),
	SOUTH(0, 1),
	SOUTH_EAST(1, 1),
	EAST(1, 0),
	NORTH_EAST(-1, 1);

	public int x;
	public int y;
	boolean isDiagonal() {
		if (x == 0 ^ y == 0) {
			return true;
		}
		return false;
	}
}

Overloading (C):
Method signatures consist of a name and an argument list.

String foo(int a, double b) {} // Fine
String foo(bool a) {} // Fine
int foo(int a, double b) {} // Error

Streams (Java):
Streams are handled abstractly and can be wrapped into other streams.

URLConnection connection = url.openConnection();
InputStream stream = connection.getInputStream();
GZIPInputStream gzis = new GZIPInputStream(stream); // Wrapped stream

True multidimensional arrays (C#):
Continuity of memory allocation for multidimensional arrays is ensured. Jagged arrays are easy to use.

int[,] foo = new int[10,4]; // These indexes are stored are stored continuously in one block.
foo[2][3] = 5;
int[][] myJaggedArray = new int[][]  {
	new int[] {1, 2},
	new int[] {1, 2, 3},
	new int[] {6}
};

Abstract classes (Java):
Abstract classes are purely abstract and cannot contain implementations.
```
abstract class Foo {
	public doThing() {
		doOtherThing(); // Error
	}
}
```
Constant methods (C++):
Methods can be defined that cannot change their object’s fields.
```
const getFoo() {
	x = 5; // Error
}
```
Operator overloading (C++):
Operator overloading is permitted. Overloading of the assignment operator and parenthesis is not allowed. Right-associative operator chaining is permitted and is implemented for library classes.
```
class Foo {
	Foo Foo::operator += (const Foo& rhs) {}
	Foo Foo::operator ! (const Foo& rhs) const {}
	Foo Foo::operator - (const Bar& rhs) const {} // Error
}
void bar() {
	int a, b, c, d;
	a = b = c = d = 0;
}
```
Constructors (none):
Constructors may implicitly set fields with something like:
```
class Foo {
	int x;
	string s;
	Foo(int# x, string# s) {} // This sets Foo.x and Foo.s
}
```
I have never seen this implemented, though a Java 7 JSR suggested something similar (using the this keyword).
Documentation generation (C#):
Metadata for documentation is contained within the source code, is generated easily, and is specified with XML.

/// 
/// This class perfoms complex foo.
/// 
/// 
/// Oh dear!
///

List comprehensions (Python):
List comprehensions are simple.

def get_slices(self):
	return [Math.tan(slice ** 2) for slice in pie]

Annotations (Java):
A simple annotation syntax can attach metadata to code. Custom annotation types can be defined.
```
@Deprecated
class Bar {}
@RequestForEnhancement
class Foo {
	@NotNull
	static Bar bar;
}
```
Loops (PHP, None):
Iteration over multiple data is simple.
```
foreach ($array as $index => $value) {}
```
A simple repeat keyword allows straightforward repetition:
```
repeat (5):
	do_foo()
```
Static If (D):
There are static if-s, which are evaluated at compile-time.
```
static if(n == 1) {
	// Do something
}
```
Switch statements (C#):
Switch statements break automatically; they will “fall through” only if explicitly requested. Strings are permitted in switch statements.
```
switch (message) {
	case "Hello":
		sayHello();
		message = "Goodbye"
	case "Goodbye"
		sayGoodbye(); // Will not execute
}
```

Fourmilab and Java+Hotbits+TLS

dmyersturnbull — Fri, 20 Mar 2009 01:25:02 +0000

In paranoid cryptographic applications, I use John Walker’s HotBits, a free service which generates genuine random data based on radioactive decay. It generates ½ bits per sample, using radiation generated from Cæsium-137 beta decay:

The service stores the generated data in a buffer; when it serves a request, it pops the data and transmits it.
I trust HotBits over other solutions such as random.org because their entropy seems more reliable and because they provide a TLS‐secured request page. I am also naturally less suspicious of providers of cool free services and open source software, providers of science fiction stories, and anything whose name means “ant lab” in French.
I built upon Fourmilab’s randomX Java encryption package in my class SecureRandomHotBits, which accesses the TLS‐secured HotBits for enhanced security. My code does not extend randomX’s randomHotBits but easily can; add extends randomHotBits to the class declaration to extend randomX functionality.

Gone too far

dmyersturnbull — Thu, 19 Mar 2009 17:57:43 +0000

Posted under sarcasm.

Lately I have been pondering this ridiculous notion called “gay rights”—apparently sinful atheistic Muslims want to practice the disease of homosexuality under US law. The Lord is omnipresent and will see through these Communist homosexuals and weigh their intentions, but He asked me to vote for Proposition Eight anyways because He recognizes our need to constrain their sin. Homosexuals that would have sinfully “married” without mortal law will be condemned to Hell anyways, but Proposition Eight is nonetheless needed.
Despite what William J Murray (God bless him, and may his atheistic mother burn for eternity) thinks, societies cannot have absolutes. Homosexual marriage is illegal because lines must be drawn; sooner or later some sinful heathen farmer might marry his sheep! If you open the floodgates, who knows what sinners will attempt? Recognizing this point—and with the Lord’s help, I propose new legislation:
The United States’ Framers recognized the definition of citizen only to include white, land‐owning males. Clearly, we have shifted from the Lord’s path: first those without property, then non‐whites, then women, and then His youngest children. Soon some farmer will want his sheep to vote! Lines must be drawn; hence, God and I propose that “citizen” be reverted to its proper definition.

Compiz with fglrx on Mobility Radeon 3400

dmyersturnbull — Sun, 08 Mar 2009 05:01:54 +0000

On 2009‒02‒16, I wrote:

While still in the mood for pointless Linux software, I tried Compiz Fusion again—again, with no success. I plan to wait until the RadeonHD driver is finished. I have not tried AMD’s proprietary fglrx driver thanks to horror stories of system crashes and hardware damage.

I tried fglrx anyways. I followed fedoraforum.org’s tutorial for my Dell Studio 15, Radeon Mobility, and Fedora 12, and I now have Compiz Fusion working. I encountered three issues:

Using the Animation plugin, effects are not displayed for the shade, focus, and minimize actions.
Occasionally when I switch back to Firefox, Firefox’s scroll bar will not function unless I maximize, resize, or move Firefox. This occurs even with all plugins disabled.
When opened, gnome-compiz-manager returns the error: “Type mismatch: Expected list, got string”. I cannot change the shortcut keys in any menu. (I use CCSM).

I will post any solutions here; otherwise I will file a bug report against freedesktop.org’s bug database.
Otherwise, Compiz is functioning beautifully on my Mobility Radeon HD 3400. I added compiz-fusion-icon to my Gnome startup scripts, which serves to load it automatically.
I’m off to spin my desktop. I might post screenshots later.

Fedora Plymouth Graphics and Compiz Fusion

dmyersturnbull — Mon, 16 Feb 2009 23:42:38 +0000

Here are two changes I made to my Fedora install recently—one successful, one not.

graphical Fedora Plymouth animation (success)

I will neglect my blog’s philosophy by covering a topic that has already been covered: Axel’s guide describes this process. Derek Hildereth also covered this process, citing Axel’s guide. ⟵I tried this one.

My Dell Studio 15 has an ATI Mobility Radeon HD 3400 graphics card, for which I am using x.org’s default open source driver. I had been using Plymouth’s text animation, assuming that the graphical modes would not work with my card. I followed Axel’s guide and now have an esthetic boot sequence. Briefly:

Add a VGA framebuffer resolution value to grub.conf. For example, I added the bold text in mine:

title Fedora (2.6.27.12-170.2.5.fc10.i686)
root (hd0,1)
kernel /vmlinuz-2.6.27.12-170.2.5.fc10.i686 ro root=/dev/VolGroup00/LogVol00 rhgb quiet vga=0×323
initrd /initrd-2.6.27.12-170.2.5.fc10.i686.img

vga should be specific to your display. Use the following table, which I obtained from Steven K. Baum’s reference.

Colours   640x480 800x600 1024x768 1280x1024 1600x1200
--------+---------------------------------------------
256     |  0301    0303     0305     0307      031C
32,768  |  0310    0313     0316     0319      031D
65,536  |  0311    0314     0317     031A      031E
16.8M   |  0312    0315     0318     031B      031F

You can configure Plymouth’s animation with the following two commands (as root):

plymouth-set-default-plugin pluginname {solar, fade-in, pulser, spinfinity}
/usr/libexec/plymouth/plymouth-update-initrd

Compiz Fusion on Mobility Radeon HD 3400 FOSS drivers (failure)

While still in the mood for pointless Linux software, I tried Compiz Fusion again—again, with no success. I plan to wait until the RadeonHD driver is finished. I have not tried AMD’s proprietary fglrx driver thanks to horror stories of system crashes and hardware damage. It seems that Mobility Radeon HD 3400 graphics cards do not enjoy stable drivers that enable hardware acceleration—yet.

Update: fglrx works perfectly on my Radeon HD 3400, and I have Compiz working.

If this worked or did not work for you, comment!

ABC’s Story on Abbie Schubert, Dell, and Ubuntu

dmyersturnbull — Thu, 12 Feb 2009 00:03:05 +0000

On 2009‒01‒13, ABC’s WKOWTV posted a news story and article, where Abbie Schubert, a student enrolled in online courses at Madison Area Technical College bought a Dell computer with Ubuntu and blamed Dell, Ubuntu, and GNU–Linux for having to abandon her semesters. ABC writes:

She didn’t realize until the next morning her laptop defaulted to the Ubuntu operating system.
…
Her Verizon High-Speed Internet CD won’t load, so she can’t access the internet. She also can’t install Microsoft Word, which she says is a requirement for MATC’s online classes.
As a result, with no internet and no Microsoft Word, Schubert dropped out of MATC’s fall and spring semesters.

While first reading this article, I felt sympathetic for the student. I don’t anymore.

Ordering a PC with Ubuntu requires either awareness or negligence:

On Dell’s front page, hover your cursor over the drop‐downs for Desktops or Laptops & Mini and select the option for Open‐Source PCs, despite the flashy image–links’ prominence. This brings you to Dell’s Ubuntu page.
Ignore the warnings like Not sure Open Source is for You? and The main thing to note is that when you choose open source you don’t get a Windows® operating system. If you’re here by mistake and you are looking for a Dell PC with Windows, please use the following link.
Ignore the description, with its own warnings like may not be compatible with the same software applications and hardware as Windows operating systems.
Go through the typical web‐based configuration process, explicitly clicking Ubuntu, not noticing the selection options for Operating System, which again says Ubuntu. Ignore the Review screen which again says Ubuntu and click continue anyways. Add the item to your cart and again ignore the Ubuntu.
While confirming your purchase email, ignore the information.

Is that really insufficient notice? Then, Abbie Schubert’s particular case also requires the following:

Not using alternatives, such as library computers (which her campus had).
Not requesting help from her peers or the Linux community.
Attempting to use wireless drivers in a CD explicitly for Windows.

Users accustomed to Windows find switching difficult, so I am sympathetic towards her confusion after the purchase. But I do object to her—or, more likely, only ABC’s—eagerness to blame Dell and Ubuntu.

The article itself rings of bias. For example:

[Ubuntu is] extremely popular with certain circles of computer users because it’s free.

Or perhaps because it is better? Even Dell makes buying computers with GNU–Linux difficult and more expensive; many if not most GNU–Linux users buy a PC with Windows and then install GNU–Linux.

Here is another:

But it is not Windows, and what works on Windows doesn’t always work on Ubuntu.

…and vice versa, perhaps?

At 1:35 of the Youtube movie, notice the ABC reporter: […] Ubuntu might look a lot like Windows, but it sure doesn’t act like it accompanied by a carefully‐chosen screenshot of an error in Firefox.

ABC’s implicit and explicit accusations that Dell forced her to use Ubuntu likely border on slander.

She called Dell the very next day and says the representative told her there was still time to change back to Windows.
But she says Dell discouraged her.
“The person I was talking to said Ubuntu was great, college students loved it, it was compatible with everything I needed,” said Schubert.

The question arises: what conversation preceded that quote? I highly doubt the representative said that randomly.

ABC also writes:

She also says Dell claimed it was now too late to get Windows and any changes she made herself would void her warranty.

…perhaps because that is their policy?
“Claimed” overtly suggests misinformation or fabrication. Dell certainly does not have a reputation for sincerity and integrity, but ABC has a reputation for providing information that is deliberately misleading.

Whether Abbie Schubert deliberately created Microsoft’s new‐found marketing weapon or ABC warped her story for mass‐appeal (I find the latter more probable), her issues are a direct result of her choice in purchase.
I wish her luck in her next semester.

Vincenty Ellipsoidal Geodesy and PHP Nightmares

dmyersturnbull — Thu, 22 Jan 2009 01:28:11 +0000

I address two matters here.

Earth‐distance calculator based on Thaddus Vincenty’s formula and WGS‒84

Two weeks ago, I considered running from UCR to Cal Poly Pomona to visit friends there. Questioning the run’s feasibility (and my athleticism), I wanted to know the distance (it is 49km). Quickly searching, I found several distance calculation websites, all of which used spherical models—inadequate for those afflicted by OCD. So, I wrote a web‐based program to calculate the distance between any two points (longitude and latitude) accurately using Thaddeus Vincenty’s formula for calculating ellipsoidal geodesics and an accurate coordinate frame for the Earth, WGS84. My web page’s PHP code (licensed under the GNU GPL version 3) is—necessarily discounting altitude—accurate to within ½mm. After writing about a third of the code, I discovered other websites (particularly, see Movable Type Scripts’ page and realized that Google Maps had a (in my defense, new) selection for “walking”. However… my calculator is notably user‐friendly and has flexible input requirements, so I do not regret the time I spent.
Here are the WGS84 values:

Major semiaxis:
a = 6378137
Minor semiaxis:
b = 6356752.314245
Flattening (a − b) / a
ƒ = 1/298.257223563
Negligible value (iterates until):
Δλ < 10⁻¹²

PHP is terrible—again

I refuse to use PHP ever again.

Update: That was a lie. I capitulated yet again—and regretted it yet again.

If an employer requires me to use it, I will likely quit. I repeatedly give PHP chances and am repeatedly disappointed. After writing the calculator, I spent nearly three hours searching for a bug that resulted in significant numerical error. Well—here it is:

I had this line:

$uSqr = $cosSqrAlpha * (sqr(ELLIPSOID_A) - sqr(ELLIPSOID_B)) / sqr(ELLIPSOID_B);

And then this line:

$B = $uSqrd / 1024 * (256 + $uSqr * (-128 + $uSqr * (74 - 47 * $uSqr)));

Almost any other language would have returned an error since $uSqrd is undefined. But not PHP. In its wisdom, PHP decided that since $uSqrd is undefined, it equals zero. Admittedly, PHP reports the use of undefined variables at higher “error reporting” levels, so it is arguably my fault for not setting error_reporting. But really…
I loathe weak dynamic typing.

Again, my distance calculation webpage is available to those interested. If you have feedback, comment!