Åbent og demokratisk samfund? Ikke her.

I forbindelse med forhandlingerne af ACTA, har Danmark endnu engang vist en grim side af sig selv.

I flg. et lækket memo12 så er Danmark et af de lande som er mest imod gennemsigtighed omkring ACTA, dvs. at regeringen ikke ønsker at befolkningen skal vide hvad der sker før det er forsent, at gøre noget ved resultatet af ACTA.

Jeg grimmes over denne samling udemokratiske mennesker, vi har til at lede os. Som om det ikke var slemt nok, at de snød os for vores folkeafstemning om EU-traktaten.

  1. http://www.michaelgeist.ca/content/view/4819/125/ []
  2. Engelsk oversættelse []

DR og censur

Forord

Jeg tror, at jeg indledningsvis bliver nødtil kort at forklare mit forhold til licensen, da denne post er relateret til dette. Jeg mener, at licensen både i dens nye form og dens gamle form er forkert på alle tænkelige måde, og derfor er jeg imod licens modellen. Jeg er ikke imod public service iform af information, nyheder og generel oplysning af folket, men jeg er imod at public service omfatter ligegyldigheder som X-Faktor og anden underholdning.

DR og censur af modstandere

Jeg er medlem af et par facebook grupper i kampen mod licensen, bl.a. fulgte jeg gruppen "Støt Lars’ kamp mod DR Licens" og det er hvad denne post handler om.

For DR har i starten af 2010, gjort noget som jeg mener går direkte imod en af begrundelserne for licensen, nemlig at det skal sikre uafhængig information fordi det er nødvendigt for et demokratisk samfund. DR har med hjælp af facebook fået lukket gruppen "Støt Lars’ kamp mod DR Licens" og det er svært for mig at se det som andet end DR har ønsket at lukke munden på en der kæmper mod deres faste indtjening, nemlig licensen. Dette er en form for censur og det kan vi ikke leve med i et demokratisk samfund, og DR der fremstiller sig selv om demokratiets vogter burde vide dette.

Plummer har siden udtalt til 180grader at Lars har truet DRs medarbejdere, men han har ikke ville præcisere, hvad han mener Lars har gjort og det er ikke blevet meldt til politiet. Dette virker for mig som en enorm dårlig undskyldning efter Plummer har opdaget at censur er en upopulær løsning. Hvis han virkelig mener at Lars har virket truende, hvorfor er Lars så ikke meldt til politiet? Lars er iøvrigt politimand, så man må jo gå ud fra at han kender loven.

Endnu engang lykkedes det DR at give mig en dårlig smag i munden over at jeg overholder loven, og rent faktisk betaler 2200 kr. om året selvom jeg helst var fri, da jeg ingen interesse har i deres produkter.

Links

http://www.facebook.com/group.php?gid=288615379362 – Facebook gruppen: "Støt Lars’ kamp mod DR Licens – v. 2.0 efter DR lukkede siden"

http://www.180grader.dk/Krimi/dr-advokat-jeg-bad-om-at-faa-facebook-side-lukket – 180grader: "DR-advokat: Jeg bad om at få Facebook-side lukket"

http://www.180grader.dk/Politik/dr-sender-redegoerelse-for-facebook-sag-til-politikere – 180grader: "DR sender redegørelse for Facebook-sag til politikere"

http://www.180grader.dk/Politik/plummer-facebook-lars-truer-vores-medarbejdere – 180grader: "Plummer: Facebook-Lars truer vores medarbejdere"

http://www.180grader.dk/Krimi/mulig-injuriesag-mod-generaldirektoer-kenneth-plummer – 180grader: "Mulig injuriesag mod Generaldirektør Kenneth Plummer"

http://ekstrabladet.dk/minsag/article1287819.ece – "Min sag" på Ekstrabladet, skrevet af Lars

PS.: Dette er min første post med blogilo, KDEs nye blog-editor.

Orango.dk – Domæne indehaver mister domæne efter 9 år til 11 måneder gammelt firma

Jeg læste fredag til min store forargelse om endnu en absurd sag om domæner, denne gang Orango.dk.

Orango.dk har været ejet af Peter Veileborg i 9 år og har været brugt til bl.a. emails. I januar startede der et nyt web-profilerings virksomhed med navnet Orango ApS og de vil gerne have domænet Orango.dk, så de tilbyder en meget lav pris for domænet 500,- som Peter afviser som værende alt for lavt.

Domæneklagenævnet giver Orango ApS medhold i at Peter forbryder sig mod god domænenavnsskik, fordi de mener at Orango ApS har større værdi af domænet end Peter og i deres afgørelse ignorere de totalt vigtigheden af emails som Peter har brugt domænet til.

Jeg er selv indehaver at et domæne (mabs.dk),

som jeg bl.a. bruger til email og blog. Jeg ville da nødigt stå i samme situation som Peter Veileborg, at miste mit domæne på den måde. For mig er dette en vigtig
sag, for det ser ikke ud til at os private domæne ejere er sikret i sager som denne og mit domæne, mit påtaget navn mabs, er ligeså vigtigt for mig som mit folkeregisternavn som mabs i øvrigt er baseret på.

Udover at jeg synes afgørelsen er helt uden for al rimelighed, så finder jeg også Orango ApS forretningsmoral som værende meget dårlig. Alene det at de kommer med et utrolig lavt tilbud for domænet, 500 kr., for så at bruge det som argument med ejeren. Men også at det ser ud til det har været en bevidst strategi for dem, at ville kapre domænet fra Peter.

Jeg er fuld forstående over for at man skal bekæmpe domænepirater, men det kan man på ingen måde kalde Peter Veileborg i denne sag, da han har haft navnet længere end Orango ApS har eksisteret.

Jeg savner en klar beskyttelse af private danskere i sager som denne, da det ikke kan være rigtigt at vi står så dårligt i sager som denne.

Det er mit håb at Peter Veileborg går videre med sagen og jeg har tilbudt ham et mindre beløb som støtte til sagen, da princippet i denne sag er meget vigtigt for mig.

Jeg har desuden skrevet en mail til videnskabsministeren, Helge Sander, for at få nogle svar og jeg har sendt et debat oplæg til IT-politiskforenings mailingsliste.

Links:

http://www.comon.dk/nyheder/Domaene-ejer-mister-navnet-efter-ni-ar-1.247341.html
http://www.comon.dk/nyheder/Principiel-domaenesag-kan-ende-i-retten-1.243502.html
http://new.czar.dk/?p=547
http://www.dr.dk/nettv/update/?video={cc7e58df-fbcb-41ee-85ed-ea674dd41e4f}
http://www.domæneklager.dk/uploads/2009-0099orango.dk
http://myplace.dk/2009/11/21/dk-domaener-kan-tages-fra-dig/
http://peter.binderup.dk/blog/2009/11/21/ejeren-af-domnet-orangodk-skal-overdrage-det-til-orangonu.html
http://domaene-retfaerdighed-tak.skrivunder.dk/
http://www.180grader.dk/IT/wild-wild-west-ejendomsret-til-dk-domaenenavne-ringere-end-ejendomsret-i-det-kommunistiske-kina#comments

Started on Git

I’m currently learning, how to use git and plan to move my private svn-repository to git soon.

I just stumbled up on the site http://gitcasts.com that has some short video courses in using git.

Git is somewhat different from subversion(svn) and introduces some new concepts for me, namely the local index, remote-repository, rebasing, branching (never used it in svn) and automated merging.

I’ve had a hard time getting of the ground with it, but I was very motivated since many of the more important (to me) open source projects like amarok have moved to it and KDE is planing to do so.

The more I learn about Git the more I like it. Now I’m off to watch more of those videos.

Reducing memory usage with JavaScript

In this article I’ll talk about reducing memory leaks in JavaScript with focus on working with jQuery and the encapsulation I used in my work1.

This dates back to a problem I had in my previous job, our web-application used a lot of memory and it just kept growing the longer the application was running. Reloading the page only fixed the problem some of the time, often restarting the browser was the only way to free the memory.

This problem had to be fixed and fixed quickly. I found a very useful document from Microsoft about memory leak patterns in JavaScript2,

which helped a lot.

I’ll list the patterns I intend to cover by name for reference.

  1. Circular References
  2. Closures

Circular References

With circular references an object have a reference to another object, which in turn have a reference back to the other object and since the references are never removed the garbage collector will not know to free the memory.

I ran into this because I wanted to save time by not looking for DOM elements, I already had found once. Searching the DOM can be slow, especially than you have a large page with many elements.

But since it caused a lot of memory leaks, I had to find another way to do it OR live with the waste of time searching for elements. I found another way with jQuery, the function “data”3 solves the problem in a nice and clean way.

I’ll show a simple example, how this can be used. But first I’ll show a piece of code which a potential memory leak.

	// Find the elements in the DOM-tree
	var el1 = $( "#element1" );
	var el2 = $( "#element2" );

	// Creating circular reference problem
	el1[0].other_element = el2;
	el2[0].other_element = el1;
…
	// Accessing element-reference
	el1[0].other_element.css( "background-color", "black" );
	el2[0].other_element.css( "background-color", "#666000" );
…
	// Removing the reference
	el1[0].other_element = undefined;
	el2[0].other_element = undefined;

And here is a piece of code which don’t have the potential memory leak:

	// Find the elements in the DOM-tree
	var el1 = $( "#element1" );
	var el2 = $( "#element2" );

	// Add the reference with the data-function
	el1.data( "other_element", el2 );
	el2.data( "other_element", el1 );
…
	// Accessing the element with the data-function
	el1.data( "other_element" ).css( "background-color", "black" );
	el2.data( "other_element" ).css( "background-color", "#666000" );
…
	// Removing the reference
	el1.removeData( "other_element" );
	el2.removeData( "other_element" );

As you can see there isn’t much difference in the two code examples, but there is a huge difference between in potential for memory leaks.

This works because jQuery will remove the data when the DOM-element is removed (through jQuery). You should note that if you remove el1 and not el2, el1 will still be referenced from el2 until el2 is removed.

The problem and solution for closures.

Now with jQuery, we tend to create a lot of new functions when we add events, loops through arrays and so on. We need to be careful then we do this, since it can lead to the problem described in that Microsoft document as “Closure”.
Basically the problem is that inside function (A) we create a new function (B),

if B references to an outside object we have an extra reference and reference count for the element never reaches zero, this means that the garbage collector doesn’t free the memory.

Like before I’ll give an example with the potential problem followed by an example without the problem.

function A( el ) {
	var el2 = $( "<div>Hallo</div>" ).appendTo( document.body );
	el2.css( {
		"position" : "absolute",
		"top" : 100,
		"left" : 100,
		"background-color" : "#666000"
	} ).hide( );

	el.click( function( e ) {
		el.hide( );
		el2.show( );
	} );

	el2.click( function( e ) {
		el.show( );
		el2.hide( );
	} );
}

Without the potential problem:

function B( e ) {
	var el = e.data.el;
	var el2 = e.data.el2;
	el.hide( );
	el2.show( );
}

function C( e ) {
	var el = e.data.el;
	var el2 = e.data.el2;
	el.show( );
	el2.hide( );
}

function A( el ) {
	var el2 = $( "<div>Hallo</div>" ).appendTo( document.body );
	el2.css( {
		"position" : "absolute",
		"top" : 100,
		"left" : 100,
		"background-color" : "#666000"
	} ).hide( );

	el.bind( "click",  {
		el : el,
		el2 : el2
	}, B );

	el.bind( "click",  {
		el : el,
		el2 : el2
	}, B );
}

In the first example I have two anonymous child functions in function A, every single time A is called two new enclosures are created from these two functions. Each of the child functions have references to elements from function A’s scope potential preventing the garbage collector from deleting the elements.

In the second example I’ve moved the two functions out of function A and instead just give a reference to the functions inside function A when I bind the events, but in order for the functions B and C to access to the elements I use the jquery-function “bind” insteed of “click” to bind the events, “bind” allows me to provide a data-object to the function. In the event-function I can easily access the data by accessing the parameter “data” on the event object.

The reason this works is that the two closures are no longer created and the references to the element are parsed by normal reference through the event-object. Jquery will unbind all events from an element once it’s removed, eliminating the reference created by parsing the data-object to bind.

Another way you can achieve this is with the “data”-function like this:

function B( e ) {
	var el = $( this );
	var el2 = el.data( "el2" );
	el.hide( );
	el2.show( );
}

function C( e ) {
	var el2 = $( this );
	var el = el.data( "el" );
	el.show( );
	el2.hide( );
}

function A( el ) {
	var el2 = $( "<div>Hallo</div>" ).appendTo( document.body );
	el2.css( {
		"position" : "absolute",
		"top" : 100,
		"left" : 100,
		"background-color" : "#666000"
	} ).hide( );

	el.data( "el2", el2 );
	el2.data( "el", el );

	el.click( B );
	el2.click( B );
}

The major difference here is that the data is no longer private. Every piece of code that can get a hold of either of the elements can get to the other through the data-function.

But if the data is not meant to be private this can be fine. I’ve done this in a few jQuery plugins I’ve created where is was better to just add the element references as data so that all my functions for the plugin could easily reach the elements that made up the interface.

Saving memory on events

Another way the save memory is to use the same event-function for more then one element, especially if the functionality is similar. Here I’ll show how I tend to use a single event for two buttons.

…
	<button xaction='okay'>Okay</button>
	<button xaction='cancel'>Cancel</button>
…

I add the attribution “xaction” to the elements to indicate what kind of action I want to take then the button is clicked.

Here are the JavaScript-code the handle the click event on these two buttons.

function button_clicked( e ) {
	var el = $( e.target );
	var xaction = el.attr( "xaction" );
	if ( xaction == "okay" ) {
		// TODO: Handle okay action.
	} else if ( xaction == "cancel" ) {
		// TODO: Handle cancel action.
	}
}
…
$( "button[xaction]" ).click( button_clicked );
...

It’s not that a function uses a lot of memory, but if you have a lot of functions that could become fewer by refactoring the code, it can add up to a lot of memory.

Another reason I like this is the refactoring of code it self. I don’t like to have functions that have 95% of the same functionality, then we can create a function that handles the 95% plus the last 5% percent from multiple functions.

  1. covered in http://www.mabs.dk/wordpress/index.php/2009/04/20/reintroducing-a-little-sanity-in-working-with-javascript/ []
  2. http://msdn.microsoft.com/en-us/library/bb250448.aspx []
  3. jQuery doc: http://docs.jquery.com/Core/data []