1. nano /etc/rc.conf

2. Append these contents at the end: https://gist.github.com/949987

3. /etc/rc.d/network restart

4. Done! You should have proper network connectivity now.

Notes notes notes. Moar Notes!

I never really understand why public mailing lists never implement the reply-to munging feature to always overwrite the Reply-To fields back to the mailing list address instead of the user address. Erlang’s questions list is one such example.

The mailman software’s doc page on the topic of munging “reply-to” mentions that this is a pretty sensitive issue but I fail to see why. When I get onto a mailing list with a question, I would like to have the best responses – even if that meant it had to come from multiple people. If everyone posted to the list itself, the ensuing email “conversation” can be more effective than if everyone were to reply to only the author. In the former case, people who’ve offered solutions or suggestions can still have their answers improved upon by other people who’ve read it – thereby proving more helpful than the latter case.

There is this page which asserts the RFC’s statements on what the Reply-To really stands for, and I disagree to its views since a user getting on a mailing list does not know what they want their Reply-To to be. They are posting to a public mailing list and it would be very disappointing if the mailing list does not serve the public’s interest in sharing and improving knowledge. Following standards is a good thing when it is constructive, not destructive.

Let us get a little off-track here. Have a look at Stack Overflow, or even the newer Quora – They never hide any answers from the public when a question is replied to. The answers do not privately go to the author, nor do the comments upon it. Everything is pretty much public. As a result, people have enjoyed very good answers with edits and comments; and using web search has proven to be more effective in problem-solving at work or else ever since these sites got popular. Why can’t the same ideals, then, be applied to the archaic-yet-effective mailing lists?

I’d like to state my opinions only here (in personal spaces). I do not wish to engage in “flame wars”, which is claimed to happen in discussions on these topics and thereby refuse to bring up this topic on the mailing lists that follow no reply-to overriding.

in:sent from:me term -Re

Now am wondering why it didn’t strike me immediately to look for the “Re” keyword that makes a mail a reply de-facto. Of course, there’s a much more neater, more RFC-5322 compliant way of searching such mails, but I’m unsure if GMail supports such querying.

Spider-Man: Shattered Dimensions Box Cover showing all four playable Spider-Men -- 2099, Amazing, Noir and Ultimate (The Ultimate character comes with a Venom suit)

After playing Batman: Arkham Asylum, my bar that sets the definition of a good RPG action game just took a shot towards the sky. The game-play in it was the most involving for a comic character based RPG, based on a comic character who’s at human heights. The fights were great, the moving around the area fluid and just like how the character would do, etc.. I’m sure you’ll appreciate the game if you play it, cause the story doesn’t disappoint you either.

Along came the Spider-Man game, and brought in perhaps for the first time ever, the Spider-Man 2099 and the Spider-Man Noir characters into video games! I think they’re great characterizations. The former imposing the role upon himself to get rid of a drug addiction, and the latter just facing a twisted history with his timeless humor. Their comics are great too.

Spider-Man Noir -- Incapacitating a henchman. All in total silence. Way cool.

Now case-in-point: Spider-Man Noir. The Noir Spider-Man levels in Shattered Dimensions is very similar to what much of Arkham Asylum had to offer. Only, it has much more pace. Any Spider-Man game worth its salt would offer deadly combos and faster-than-eye-can-follow agility during battles, and Shattered Dimensions doesn’t disappoint. The way you could incapacitate a henchman in Arkham Asylum, you can do it with Spider-Man Noir using webbing. Sneak up on them in the darkness, and web yank them to blackouts. Its Arkham Asylum all over, but with webs and sticking on walls! I’m not getting enough of this, so am going and playing more of it now. What’s more is that it offers a great bunch of classic rogues from Spider-Man gallery, across different timelines; yet you don’t get lost!

You should try this game out, its good fun with not too repetitive themes. For Spider-Man fans, it is an imperative. Stan Lee has himself voiced over a few narrations. This one is surely a timeless classic.

For those who don’t know yet, you can start a fresh chrome window with a custom UA using the –user-agent command-line parameter while launching it:

# Using chrome, or chromium -- as you like it.
chrome --user-agent="My User Agent String. Bow to it, statisticians. Kidding."

You can then visit http://whatsmyuseragent.com/ to verify the results of the user-agent property change in Chrome/Chromium.

The command-line parameter, –user-agent, is (not very) surprisingly not documented under the supplied manual page.

wget https://beta.swype.com/android/get/?download_NOW=androidBeta -U "Mozilla/5.0 (Linux; U; Android 2.2; en-us; Nexus One Build/FRF91) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1" -O Swype.apk

There, nice and easy?

Sorry Swype, to make you count a N1 download instead of an SGS.

Never has a modal dialog made you read itself to understand. It has always been about pressing the right button, to get back to whatever it was you wanted to do. As far as intentions of the developers, and to some extent the libraries go, they only want you to do whatever it is you wanted to do in the software’s right way. Press the right button, and maybe the software will do good to you. Press the wrong button and you’re probably doomed. Press the only button and you know you’re back to square one. If there are no buttons, then thank god for the display manager. If there is no display manager, you’re free of all annoyances.

There have been enough criticisms of modal dialogs that the Wikipedia page for the same has a section discussing it. But one hardly finds an application that does not throw a modal dialog on your face for whatever it is you did wrong or it did wrong (oh the horror).

Then there came the web, claiming to do away with most modal stuff as the web GUI programming model is hardly similar to the desktop model. Designers had a great chance to rid all the flaws of ancient desktop models and implement the best usability ways there could ever be, with support of some very powerful languages and associated libraries. What got popular instead, are things similar to Lightbox.

Such elegant are the looks of a lightbox implementation (an example of modal-ness), that it makes you feel all warm inside when you see it working on your own website, the feeling you get about never having to, or having your visitors to, leave the page they are on in order to see content associated to it; and to certain extent, browse horizontally across all other associated content than just one. It began okay first, click a media and it begins a modal environment that looks like Apple’s keynote events with a spinner. People could also open the link in a new tab to view the image in their browser’s image viewer (or other). Then, people couldn’t. Someone exclaimed with great delight that their JavaScript Kung-Fu was better than others.

Its one thing to pop a modal window and darken out all other content to let it have focus. It is another thing to add a spinning animation with absolutely no information, percentage wise or other, to indicate progress. Nobody cared if the spinner were enough to let the user know content’s actually loading or not because hey, they developed it in environments where the network was blazing fast and you hardly ever saw it. Progress. They just don’t get its meaning right. Space and time are measurable quantities and with content, progress is finite and must be calculated to be called as a progress animation. Fancy circular spinning darkness is anything but fancy. Even the Flash developers of the past, present and the future understood this mostly. But not the web developers, never ever.

Has no one ever noticed how a browser or image viewers worth their salt render images? Has nobody seen the progressive rendering of image data on the screen as it gets downloaded? It might make your network feel slow, but it never lets it feel non-functional.

Plague like the Lightbox (and associated beautiful modals) must be scrubbed out of the WWW. Let my clicks pass me to another page, I don’t mind. Nobody ever minded it until someone suspected they did.

Single assignment is like algebra.

When I went to school, my math teacher said, “If there’s an X in several different parts in the same equation, then all the Xs mean the same thing.” That’s how we can solve equations: if we know that X+Y=10 and X-Y=2, then X will be 6 and Y will be 4 in both equations.

But when I learned my first programming language, we were shown stuff like this:
X = X + 1

Everyone protested, saying “you can’t do that!”. But the teacher said we were wrong, and we had to unlearn what we learned in math class. X isn’t a math variable: it’s like a pigeon hole/little box…

In Erlang, variables are just like they are in math. When you associate a value with a variable, you’re making an assertion – a statement of fact. This variable has that value. And that’s that.

– Joe Armstrong, in his book Programming Erlang.

A quick way to generate primes, as many would tell you, would be to implement and use the Sieve of Eratosthenes. Its a simple sieve that works by striking off all multiples of primes thus observed in sequence. Wikipedia has an illustration on its working technique.

There is another simple sieve derived from the same idea, known as the Sieve of Euler, which uses a filtering technique based on products of an encountered prime across the remaining elements. This sort of a sieve, again explained in a good manner at Wikipedia, is shorter and easier to implement in Erlang than the traditional Eratosthenes (and I mean proper Eratosthenes, mind you).

The following is the solution I came up with, a couple of days into learning Erlang for great good:

-module(primes).
-export([generatePrimes/1]).

% Sieve of Euler %

generatePrimes (N) when is_integer(N) and (N > 1) ->
    Numbers = lists:seq(2,N),
    BeginIndex = 1,
    generatePrimes(Numbers, [], BeginIndex).

generatePrimes (Numbers, Numbers, _Index) ->
    Numbers;

generatePrimes (Numbers, _PreviousNumbers, Index) ->
    FilteredNumbers = ordsets:subtract(Numbers, multiples(lists:nth(Index, Numbers), Numbers)),
    generatePrimes(FilteredNumbers, Numbers, Index + 1).

multiples (Prime, Numbers) ->
    lists:map(fun(Num) -> Prime * Num end, Numbers).

% Compile as c(primes). %

The function primes:generatePrimes(N) will generate all primes until N. On my 2.93 GHz machine it takes about 2.1s to generate all primes under a million (78498 primes).

As a bonus, you can go ahead and compute single-line inelegant solutions #3 and #10 of Project Euler as:

% Solution to problem 3 %
lists:nth(1, lists:dropwhile(fun(X) -> not(600851475143 rem X == 0) end, lists:reverse(primes:generatePrimes(trunc(math:sqrt(600851475143)))))).

% Solution to problem 10 %
lists:sum(primes:generatePrimes(2000000)).

Notes: There is some redundant multiple calculation involved but I noticed that if I perform a sublist operation to remove that it slows the generation down, so I let it be. The sieving operation also terminates when it notices that no number was filtered in one of its call, as this marks the proper end of it. For instance, to generate all primes under 100, it only sieves through the first five primes.

Update:

Kind commenter Angel (angel at uah dot es) posted a solution (and a multi-process one!) to a proper Eratosthenes’ Sieve (based on the O’Neill’s paper I referenced above), which goes below:

% "Genuine" Erathostenes sieve in erlang
% based on www.cs.hmc.edu/~oneill/papers/Sieve-JFP.pdf
% 2009 Angel Alvarez
%
% Process  1     2     3     4     5     6     7 ....
%
%         02    03    05    07    11    13    17
% P 02 -> 04
% P 03    04 -> 09
% C 04 == 04    09
% P 05    06    09 -> 25
% C 06 == 06    09    25
% P 07    08    09    25 -> 49
% C 08 == 08    09    25    49
% C 09    10 == 09    25    49
% C 10 == 10    12    25    49
% P 11    12    12    25    49 -> 121
% C 12 == 12    12    25    49    121
% P 13    14    15    25    49    121 -> 169
% C 14 == 14    15    25    49    121    169
% C 15    16 == 15    25    49    121    169
% C 16 == 16    18    25    49    121    169
% P 17    18    18    25    49    121    169 -> 289

-module(multi_erathostenes).
-author("angel at uah dot es").
-compile(export_all).

compare(X,Y) when X > Y -> greater;
compare(X,Y) when X < Y -> smaller;
compare(_,_) -> equal.

worker(Prime,UpperBound)->
	receive
		{test,Number,ParentPID} ->
			ParentPID ! ok,
			case compare(Number,UpperBound) of
				equal ->
%					io:format("[Worker of prime: ~w (~w)] Found composite: ~w~n",[Prime,UpperBound,Number]),
					worker(Prime,UpperBound + Prime);
				smaller ->
					io:format("[Worker of prime: ~w (~w)] Spawn new worker for Prime: ~w~n",[Prime,UpperBound,Number]),
					NextPID =spawn(?MODULE,worker,[Number,Number*Number]),
					worker(Prime,UpperBound,NextPID)
			end;
		stop ->
		    noop
	end.

worker(Prime,UpperBound,NextPID) ->
	receive
		{test,Number,ParentPID} ->
			ParentPID ! ok,
			case compare(Number,UpperBound) of
				equal ->
%					io:format("[Worker of prime: ~w (~w)] Found composite: ~w~n",[Prime,UpperBound,Number]),
					worker(Prime,UpperBound + Prime,NextPID);
				smaller ->
% 					io:format("[Worker of prime: ~w (~w)] passing along: ~w~n",[Prime,UpperBound,Number]),
					NextPID ! {test,Number,self()},
					receive
					    ok -> ok
					end,
					worker(Prime,UpperBound,NextPID);
				greater ->
% 					io:format("[Worker of prime: ~w (~w)] passing along: ~w~n",[Prime,UpperBound,Number]),
					NextPID ! {test,Number,self()},
					receive
					    ok -> ok
					end,
 					worker(Prime,UpperBound+Prime,NextPID)
			end;
		stop ->
		    NextPID ! stop,
		    noop
	end.

start(N) ->
    OnePID=spawn(?MODULE,worker,[2,4]),
    cicle(3,N,OnePID).

cicle(Last,Last,Worker) ->
    Worker ! stop;
cicle(Current,Last,Worker) ->
    Worker ! {test,Current,self()},
    receive
	ok -> ok
    end,
    cicle(Current+1,Last,Worker).

RSIBreak - Repetitive Strain Injury prevention software for KDE

It isn’t a full fledged timer feature but I think it will get your needs covered with its offerings easily enough. One of the amazing utilities I’ve used, built with KDE Libraries. It should be available in your Linux distribution’s software repository too.