Microsoft DevDays 2009

Vandaag was het weer zover, de Microsoft DevDays 2009.

Een bijna vertrouwd gezicht om Arie Leeuwesteijn de opening te zien verzorgen.

Dit jaar een best interessante keynote; niet alleen amusant maar ook informatief over The Azure Services Platform.

Daarna een hele goede presentatie van Ingo Rammer over Dynamic Data. Dynamic data is een te customizen ‘applicatie’ die voor een of meerdere tabellen in je Entity Framework een CRUD site genereert. Het genereren gebeurt runtime aan de hand van templates en je Model, dat grotendeels uit het EF komt maar waar je zelf ook aanpassingen aan kan doen. Je kunt bv van een attribuut aangeven dat het een waarde mag hebben tussen 0 en 100 en er wordt dan bij een refresh van je pagina direct een validator gegenereerd.
Mooi spul, zeker voor een admin tool of een klant die de afweging maakt van een minder tailor made applicatie tegen een lagere kostprijs. Na MS-Access is er eindelijk weer een eenvoudige datadriven oplossing van Microsoft.

Daarna een vrij technische verhandeling over production debugging. Leuk om te zien wat er allemaal mogelijk is aan monitoring, memory dumps, managed- en unmanaged memory e.d. Een leuk stukje: midden in het verhaal was er ineens een heap dump te zien met daarin o.a. een OutOfMemoryException. Het bleek dat je die niet serieus moest nemen in je diagnose omdat die er altijd in zit: als de CLR start dan wordt deze al op de heap geplaatst omdat als de CLR echt een out of memory tegenkomt, hij geen geheugen meer vrij heeft om een OutOfMemoryException op de heap te plaatsen.

Vervolgens een presentatie over ASP.Net Ajax 4.0 die nu in Beta was (of in CTP, ‘k weet niet zeker). Het kwam er eigenlijk in het kort op neer dat ze een hele grote Ajax library aan het bouwen zijn waarmee je in de client op dezelfde manier, dus niet met C# zoals in Silverlight, maar op een gelijke wijze dingen moet kunnen doen als op de server.

Het slot was van Sander Hoogendoorn met een mooie presentatie* over frameworks die niet alleen aan het einde wel trek had in een biertje (wat er overigens niet was zover ik kon zien) maar ook twee mooie uitspraken had:
Over een passend formaat framework: “Frameworks zijn er, net als pizza’s, in 2 formaten: te groot en te klein.“
en over de lock-in die een framework vaak met zich mee brengt: “Frameworks zijn net als vrouwen, je kunt er niet mee leven en je kunt ze niet killen“.

Al met al een amusante dag: veel gezien en gehoord, nog wat leuke boeken gescoord en oud(e) collega’s ontmoet.

* Bij Sander spreek je eigenlijk niet echt over een presentatie maar meer over een infotainment show

Asp.Net MVC – AjaxOptions

Ik had een mooie copy-paste actie, die helaas tot een niet te reproduceren fout leidde.
Het begon allemaal met een Ajax sectie in een MVC partial view:

<%
using (Ajax.BeginForm(“AddComment”, “Comment”, null, new AjaxOptions

{
OnComplete =“AddCommentOnComplete”,

LoadingElementId =“AddCommentLoading”,
OnBegin =“AddCommentonBegin”

UpdateTargetId = “DivAddCommentAnonymous”
 }
))
%>

  Toen wilde ik ergens anders een Ajax link maken. Ok, het is iets heel anders, maar ook daar wilde ik een set AjaxOptions meegeven. Dus… copy-paste.
Wel het LoadingElementId element weggehaald, maar de 2 events laten staan voor debug doeleinden met een alert erbij.
Maar toen de link werd uitgevoerd en de controller een partial view retourneerde, werd deze niet, zoals het hoort, netjes in de pagina verwerkt, maar kreeg ik alleen de partial view te zien, in plaats van de hele pagina.
Wat bleek de crux te zijn: de 2 OnXXX events horen natuurlijk helemaal niet bij een Link, en niet alleen horen ze er niet bij, maar als je ze er wel bij doet, dan krijg je genoemd gedrag.

Lambda expressions

Ik moet zeggen, toen ik 2 jaar geleden voor het eerst een boek over Linq las en daar een heel stuk stond over Lambda expressions, dat ik halverwege wel even achter m’n oren moest krabben: wat is dat voor iets?
Maar zoals met alles, als je het meer en meer ziet ga je zelf ook wat proberen en gebruik ik nu de volgende 2 lambda’s regelmatig.
De ene is voor het selecteren van objecten uit een generic List op basis van een property van dat object, de andere is voor het ophalen van een lijst met de waardes van 1 property van die objecten (deze staat verderop in de blog ook al vermeld, maar voor de compleetheid toch nog even vermeld).

De case bij de eerste is: ik heb een lijst met keyword objecten. Deze hebben allemaal een property ‘rank’. Nu wil ik een lijst met alleen die keywords die minimaal een rankwaarde van 2 hebben. Daarvoor gebruikte ik altijd een mooie anonymous delegate die ik van m’n vriend en oud-collega René had geleerd (en het stond altijd wel biek, een anonymous delegate ) :
keywords.FindAll(delegate(Keyword m) { return m.Rank >= 2; });
Met een Lambda wordt het echter dit:
keywords.FindAll(m => m.Rank >= 2)
En dat is toch ook wel mooie code vind ik.

De case bij de 2e is: ik heb nog steeds die lijst met keyword objecten. Deze hebben naast de genoemde rank ook een value. En dat is waar ik op dit moment interesse in heb: in al die values. Ik heb dus een lijst met keyword objecten, en ik wil graag een lijst met strings gevuld hebben.
De oplossing zit in de ConvertAll methode:
List<string> values = keywords.ConvertAll(z => z.Value);

ps.
ik heb nog even opgezocht wat Microsoft eigenlijk zegt over een lambda expression:
A lambda expression is an anonymous function that can contain expressions and statements, and can be used to create delegates or expression tree types.

ASP.NET MVC Routing Debugger

Als je net begint met het Asp.Net MVC heb je waarschijnlijk veel zaken waar je tegen aan loopt, maar 1 van de eerste is waarschijnlijk de routes: je definieert in je global.asax je routes, je opent de browser en…. daar is je view niet.
Vooral als je veel routes hebt gedefinieerd is het soms moeilijk in te schatten welke paden worden doorlopen en welke niet.
De oplossing is simpel gelukkig: een DLL toevoegen aan je project en 1 regel code aan je global.asax, en dan zie je dit:

Je ziet een lijst met alle routes die je hebt ingegeven, en in het groen de routes die matchen met de url die je op dat moment in hebt gegeven.
Daarnaast zie je bovenin in de kleine tabel welke controller er wordt aangesproken, wel action er wordt uitgevoerd en de waardes van de eventuele parameters.

Hear hear:  http://haacked.com/archive/2008/03/13/url-routing-debugger.aspx

Fiddler gebruik op Vista met ASP.Net site die runt op de webserver van Visual Studio (2008)

Zo, dat is een hele zin…

Maar goed: stel je wilt in je site die lekker Ajax dingen doet even luisteren naar het HTTP verkeer. Je gebruikt Fiddler (in mijn geval v.2.2.2.0) en je hoort op htpp://localhost:47867/ …. niets.
De standaard oplossing is een punt (.) tussen de localhost en de dubbele punt. Dan krijg je
htpp://localhost.:47867/
Dat werkt alleen niet echt onder Vista. Niet geprobeerd maar gelezen is oplossing 2: geen localhost gebruiken maar je machinenaam. Dan krijg je
http://mydevmachine.:47867/ maar dat schijnt het niet goed te doen bij de interne webserver van Visual Studio.
De laatste mogelijkheid, en die deed het ook bij mij, was het localhost ip adres; en dan krijg je http://127.0.0.1.:47867/

En dan ziet Fiddler alles voorbij komen!

Geblokkeerde DLL

Vandaag bij het runnen van een unittest kreeg ik de volgende melding:
Failed to queue test run ‘michel@AFFINNOLAPTOP 2009-04-22 09:31:21′: Test Run deployment issue: The location of the file or directory ‘C:\project\beurs\Beurs.Web\RouteDebug.dll’ is not trusted.
Even gegoogled, en de eerste hits wijzen naar een rechten probleem: CASPOL dus. Nou is CASPOL al niet snel mijn vriend, maar nu is het gewoon een directory op disk, en vroeg ik me af of het inderdaad een rechtenprobleem is.
Nu is RouteDebug.dll een dll die van een andere site afkomt, en een andere oplossing die ik vond was deze: Rechtsklik het bestand, in dit geval RouteDebug.dll, en kies voor ‘blokkering opheffen’. En dat was de truc: Windows had mijn pc ‘beter beveiligd’, maar dat had ik nu ongedaan gemaakt.

Sql Server databases vergelijken (freeware tool)

xSQL data compare en xSQL Object

Deze (gebundelde) tools wil ik jullie niet onthouden.
Met deze twee tools kun je databases vergelijken, compare scripts genereren, Sql insert script data dumps maken etc. etc.
Je herkent het misschien wel, dat je bij de ontwikkeling van een nieuwe versie van je Wicked app niet helemaal hebt bijgehouden wat je aan de database hebt aangepast. Oftewel: je wilt een schema vergelijking doen.
En als je dan verschillen ziet, en je wilt de oude database updaten, dan is het ook handig als er een update script beschikbaar is.
Of een van mijn favorieten: je hebt mooie testdata in je database, en die wil je ook wel gebruiken in je testproject: je wilt een script dat je aan je database kan aanbieden om deze in een bepaalde state te brengen.
Wat deze tools ook kunnen: verschillen scripten tussen de content van 2 databases.

En dan komt natuurlijk de catch … of toch niet…..
Je mag de versie 2 weken full gebruiken, daarna wordt het de lite versie, die gelimiteerd is aan het aantal database objecten: niet meer dan x tabellen of niet meer dan x stored procedures.
Maar die restrictie geldt niet voor Sql Express! Als je met Sql Express ontwikkelt op je lokale pc, en dat gebeurt in mijn geval nogal eens, kun je gratis de full versie gebruiken.
Of hoe ze het zelf zeggen: “Note: The (…) limitations do not apply to SQL Server Express edition. As of June 18, 2007 xSQL Software’s comparison and synchronization tools are FREE with no restrictions for SQL Server 2005 Express edition.”.

Downloaden kan hier:
http://www.xsqlsoftware.com/Product/Sql_Bundle_Schema_Data_Compare.aspx

ASP.NET Charting Control

Net bezig geweest met het ASP.NET Charting Control.
‘k had wel eventjes iets nodig om te ‘grafieken’; ik heb maar eens even wat statistieken gemaakt voor mijn site.
De voorbereiding was eenvoudig: 2 downloads en je kunt aan de slag. Op de blog van Scott (zie verder) staan links naar de downloads en een link naar de sample environment. Het leuke daarvan is dat alle types grafieken staan vermeld, getoond en ook voorzien van wat sample code.
De ervaring: met wat copy-paste uit de sample code ben je zo van start. Met een half uurtje was de eerste chart gereed en na een uurtje was de 2e ook klaar en zagen ze er nog leuk uit ook:

Dus voor de volgende grafieken een ASP.NET project zal ik deze zeker gebruiken.

Hier klikken voor de blog van Scott voor de links

Barcode voor de consument: Microsoft tag

We kennen allemaal wel de barcode voor zakelijk gebruik: de streepjes op een pak melk en een schrijfblok.
Iets minder bekend is de 2d-barcode: niet echt een ‘barcode’ omdat het geen ‘bars’ zijn, maar je kunt er wel lekker veel informatie op kwijt.
Je ziet ‘m steeds vaker, helemaal als je met barcodes bezig bent er een beetje op let (ik zit op dit moment op een project bij een klant die veel met RFID en barcodes doet, dus automatisch gaat dan je aandacht meer naar verschijnselen ervan in de dagelijkse pratijk uit).

En nu komt Microsoft met ‘Microsoft Tag’. Een soort barcode, ik weet niet of het een eigen verzonnen formaat is, om commercieel te gebruiken. Bijvoorbeeld in advertenties in tijdschriften, boeken etc. maar ook op vanaf een beeldscherm is de tag leesbaar.
Je kunt in de tag een stuk tekst of een url ‘verbergen’ of ‘opslaan’. En Microsoft heeft daarbij een gratis applicatie voor op je smartphone of PDA, waarmee je met die smartphone of PDA een foto neemt van de tag, en daarna laat de applicatie je de tekst zien die ‘verborgen’ zit in de tag of hij opent internet explorer en opent de pagina die bij de url hoort die in de tag ‘verborgen’ zit.
Er hoort ook een gratis webapplicatie bij om de tags te maken, dus ‘k kon er gelijk mee aan de slag.
Dus in het kort: maak de tag, plaats hem ergens en de gebruiker neemt er een foto van en krijgt jouw info op het scherm.
Hieronder de tag om naar het 2 minuten durende demofilmpje te gaan; als je nog geen Microsoft tag gebruikt kun je ook deze url gebruiken: http://www.microsoft.com/tag/content/what/default.aspx?autoplay=y.

Jquery

‘k moet zeggen dat ik in eerste instantie niet stond te springen om weer een nieuw soort framework: Jquery.
Het lijkt wel alsof de die dingen de laatste tijd uit elke hoek je om de oren vliegen, en dan is dit er nog eens eentje voor iets wat in de meest positieve bewoordingen nog wordt gezien als ‘een noodzakelijk kwaad’: Javascript.
Maar toen ik luisterde naar de .Net rocks uitzending met Rick Strahl over Jquery, werd ik toch wel enthousiast. Want wat bleek het te zijn: het is een meer een developer aid dan een framework dat is verzonnen om iets nog correcter te maken qua architectuur standaarden.
Bijvoorbeeld: een korte notatie om elementen uit de DOM te halen, code om met WCF services te praten, extension methods om bewerkingen uit te voeren op geselecteerde elementen, grafische effecten, een eenvoudig model voor event handlers en many more. En wat mij persoonlijk altijd stoorde aan Javascript: had je iets moois gebouwd dat goed werkte in IE6, werkte het weer niet in IE7 en Firefox, of wel in Firefox maar niet in IE voor de Mac of Safari.
En ook dat is iets wat JQuery oplost: in dit framework of library zit de code die de browserverschillen voor je heeft uitgezocht en opgelost, en dat is voor mij al een reden om er mee aan de slag te gaan.
Geeft dit stukje je hoop? Download dan gewoon even de uitzending, brand ‘m op CD en luister ‘m in de auto op weg naar je volgende Javascript klus, in de sauna of tijdens het sporten.

http://www.dotnetrocks.com/default.aspx?showNum=351

Lambda expressions op de generic list

Sinds C# 2.0 hebben we generic lists. Ik gebruik ze vrij vaak, want je kunt er zo lekker door for-eachen en het is strong typed etc.

Maar de methodes op zo’n list zoals Find, Exists, ConvertAll etc. nemen als parameter altijd een Predicate. En ik moet zeggen, zo’n predicate die je dan implementeert door een anonymous delegate, het was toch altijd weer even zoeken hoe je het ook alweer typt.  Zoals als je een lijst met objecten hebt van het type MissingOrderregel. Dat type heeft een veld RecordId en dat is nu precies het enige veld waarin je bent geïnteresseerd: je wilt eigenlijk alleen een lijst met RecordId waardes. Een manier is natuurlijk om met een foreach door de lijst heen te wandelen en dan van elk MissingOrderregel object de RecordId te nemen en die in een nieuwe lijst met Int32’s te stoppen.
Maar het kan ook anders:

Met een delegate doe je het zo:
List<int> recordids = regels.ConvertAll(delegate(MissingOrderregel z) { return z.RecordId; });

Maar, met de nieuwe mogelijkheid van Lambda expressions kun je ook dit typen:
List<int> recordids = regels.ConvertAll(z => z.RecordId);
Op de MSDN pagina staat dat je het moet lezen als ‘goes to‘, dus ‘z goes to z.RecordId‘.

 En zo kun je met die Lambda expressions ook gemakkelijk hele Lists casten van het ene type naar het andere (in dit voorbeeld wordt een hele List met Child objecten gecast naar een lijst met Parent objecten):
List<Parent> parents = childs.ConvertAll(z => (Parent)z);
‘z goes to z casted to a Parent type‘.

Top 5 tips voor Mobile development (in industriële omgevingen)

Mijn top 5 ervaringstips:

 5: think small
Als je gewend bent webservices te bouwen op een dikke Windows 2003 server of flitsende DirectX goodies op desktops: de Windows mobile powered terminal is iets minder krachtig. Net als bij de laptop moeten veel device specs worden afgezet tegen de belangrijkste vijand: het batterijgebruik. Veel leuke zaken zoals GPS, bluetooth, WiFi, processor power, memory usage etc. kosten of vreten stroom.
Vraag je dus bij je ontwerp al af: kan mijn device mijn functionele en technische ideeën aan? Een Xmldocument van 5 MB parsen bijvoorbeeld is niet echt een goed idee.

 4: gebruik functietoetsen
Als je ze hebt op je device: gebruik de functietoetsen. Soms zijn de buttons op het scherm gewoon te klein om fatsoenlijk aan te raken met je vinger of de stylus (al is de styles in industriele omgevingen niet het meest gebruikte attribuut….). Dus als je een toetsenbord hebt: een druk op de ‘V’ geeft alle pickopdrachten met de status ‘Verzameld’, de ‘ESC’ knopt sluit het scherm en je werkt net wat gemakkelijker dan elke keer het scherm te moeten aanraken.

 3: Bedien je applicatie met het scherm uit
Als developer ben je gewend naar je scherm te kijken. Ook in administratieve omgevingen zitten de mensen achter het scherm: het werk vindt plaats achter de computer.
De magazijnmedewerker bijvoorbeeld, werkt niet met de computer. Hij werkt met vorkheftruck en palletwagen en voor hem is jouw terminal(applicatie) iets voor erbij: de goederen staan al op de juiste plek, en nou moet hij het alleen nog even in het systeem verwerken. Dus apparaat erbij, scan barcode , scan scan scan en klaar. En dat allemaal zonder op het scherm te kijken, want hij verwacht dat als hij de codes in de juiste volgorde scant, de applicatie dit ook oppikt. Of, met de EAN128 codes, dat hij random mag scannen.
Dus al je mooie feedback met kleurcodes, foutmeldingen op het scherm, hints bij een veld: het wordt simpelweg niet gezien. Wil je de aandacht: PIEP!; laat je device geluid maken en de medewerker zal zijn aandacht verplaatsen naar je scherm.

 2: deploy op het device
Soms moet je deployen op een exotisch device en is er geen beschikbaar, mag je er niet een van de klant gebruiken of moet ‘ie nog worden besteld. Zorg dat je ‘m krijgt. De emulator is een prachtig ding, maar houd rekening met diverse device specifieke ‘features’ als je op het device gaat deployen.
Dus zorg dat je de UI goed scheidt van de BL en DL zodat je die laatste twee gemakkelijk met je testapplicatie kunt doorlopen, en als je de UI moet gaan testen: get the target device.

1: Think BIG!
Tip 5 zegt: think small, houd rekening met de beperkingen van het device.
Maar even belangrijk: met de combinatie Windows mobile, het compact framework en SqlMobile kun je functioneel heel veel bieden.
Tegenwoordig is WiFi op de werkplek heel normaal, dus je mag gewoon een smartclient maken die met webservices op de server communiceert. Data opslaan: ga je gang via data services of met SqlMobile. En programmeren met het compact framework: het is natuurlijk een subset van het full framework, maar het verbaast eigenlijk nog vaker wat er allemaal WEL mee kan.

Dus think big: met de hedendaagse development omgeving en connectivity kun je heel veel mooie oplossingen maken.

.Net 3.5: Linq op een DataSet / DataTable

Ik zit op een project waar in een winform een typed DataTable wordt gebruikt om een DataGrid te vullen.
Een snelle implementatie: een tabel slepen op een dataset en je hebt een typed datatable en een typed datarow behorend bij die datatable.
Nou moest er een kleine selectie uit de gevulde datatable worden gemaakt, en nou is de gangbare manier om dat via een dataview te doen, en ik vroeg me af of het ook met Linq zou kunnen, want een datatable is toch ook een Enumerable object.
De volgende code is het geworden:

TransactieDataTable srcTable = ds.Transactie;
var result = from n in srcTable.Select()
    where n.Field<int>(srcTable.TransactieIdColumn) < 50
    select n as TransactieRow ;
DataTable doelTable= result.CopyToDataTable<TransactieRow>();
dgTransacties.DataSource = doelTable;

Wat gebeurt er allemaal?
- We starten met een strong typed DataTable srcTable;
- daar selecteren we alles uit, waarbij N een DataRow is, en geen typed DataRow;
- dan stoppen we in de where de property field<T>(index) waarbij we de index uit de strong typed DataTable halen;
- de T vervangen we door het juiste datatype van de transactiekolom, zijnde een int;
- en dan casten we N in de select naar de strong typed ‘TransactieRow’;
- de variabele sesult is dan een, let op: System.Linq.Enumerable.SelectIterator<System.Data.DataRow,TransactieRow>
- elke IEnumerable<T> waarbij T afleidt van een DataRow kan gebruik maken van de DataRow-extension method CopyToDataTable die er een datatable van maakt.

Tot slot: die datatable binden we dan aan een datagrid.

Loggen in .Net met Nlog

Een component waar ik al enige tijd gebruik van maak is Log4Net.
Loggen is namelijk iets dat je wel graag doet, maar waar je niet te veel tijd in wil steken. En, omdat het vaak neerkomt op loggen naar een tekstbestand, de database of de eventlog, is het een van die functionaliteiten die zich prima leent voor iets dat nog niet heel vaak gebeurt: hergebruik. (behalve bij sommige klanten, waar ze open source niet toestaan en je een eigen log component moet schrijven. Nu ben ik geen pleitbezorger voor open source, maar in dit geval is het een absolute meerwaarde vind ik. Anyway, ik dwaal af, terug naar het onderwerp).
Wat altijd wel wat rommelig was, was de fase van het configureren van Log4Net. Ook al pakte je de config-file van het vorige project, zelden werkte het in één keer, en het grappige was dat collega’s hier ook last van hadden (voor als je denkt dat het toch vnl. aan mij ligt )
Maar nu op een nieuw project gebruiken ze Nlog. In de introductie ervan verwijzen ze al naar Log4Net (dat ze een vrij gelijke API hebben) maar het mooie is: geen enkel probleem met de configuratie.
Iets dat ik erg prettig en user friendly vind: je hoeft niet aan te geven waar je config-file precies staat, als je ‘m een bepaalde naam geeft en in dezelfde map als je app.config zet, dan pikt Nlog deze automatisch op. En alle config voorbeelden (ik heb gebruik gemaakt van de eventlogger, filelogger en maillogger) uit de help werken direct, en de parameters zijn zo duidelijk genaamd dat ze voor zich spreken.
En het goede (en verwachte) nieuws is dat ie gewoon snel logt. Oftewel: ik ben om naar Nlog.

Watermark textbox met Javascript en CSS

Een van de onderdelen van de ASP.Net Ajax control toolkit is de watermark textbox. Voor hen die deze nog niet kennen, de watermark textbox is een texbox waarin bijvoorbeeld een hint staat wat je moet invullen in die textbox. De bedoeling is natuurlijk dat die hint verdwijnt als je er iets invult, en weer tevoorschijn komt als je je invoer weer verwijdert. Wat er vaak ook bij wordt gemaakt is een aparte opmaak voor die textbox, zodat je duidelijk kunt zien dat je in die textbox nog niets hebt ingevoerd.
Dit zou er als volgt uit kunnen zien:

(er is ook een mini-filmpje van hoe het er uit ziet, maar ik kan bij deze overigens fijne blog dienst geen Flash of Avi’s hosten. Als je het mini-filmpje wilt zien moet je even dit linkje openen.)

Dus, gebruiken en klaar zou je zeggen.
Helaas… de control toolkit is in Visual Studio 2008 als ’standaard’ opgenomen, maar in Visual Studio 2005 is het nog een aparte download, en dat wil niet elke beheerder installeren. En in mijn huidige project, met Visual Studio 2003, is het niet eens beschikbaar.
De oplossing is snel gemaakt, want heel complex is het niet.
Wat hebben we nodig:

• Een CSS voor de opmaak als de watermerk-text zichtbaar is en eentje voor als de watermerk-text niet zichtbaar is
• Een stukje Javascript om bij de onBlur te kijken of de textbox leeg is of de watermerk-text bevat of een ingevoerde tekst bevat en dan de juiste CSS te zetten
• Een stukje Javascript om bij het selecteren van een textbox (focus verkrijgen) de watermerk-CSS weg te halen
• Een stukje code behind om bij het renderen van de pagina de juiste style te zetten en de Javascript aan de textboxen te knopen.

Als eerste de CSS. Is natuurlijk een voorzet, style het the way you like it.

.watermarkOn
{
  font-size: 0.8em;
  font-family : Verdana, Helvetica, sans-serif;
  background-color : #ddffaa;
  font-variant: small-caps
}
.watermarkOff
{
}

Als tweede de Javascript. Mag in de pagina zelf of in een externe file:

function OnWatermarkFocus(elementId, defaultText)
{
  //als de control de focus krijgt kijken of de waarde gelijk is aan de defaulttext
  //dan heeft de control de watermarkOn style maar tijdens invoer moet de control de
  //watermarkOn value hebben en leeg zijn
  if (document.getElementById(elementId).value == defaultText)
  {
    document.getElementById(elementId).className = “watermarkOff”;
    document.getElementById(elementId).value = “”;
  }
}

function OnWatermarkBlur(elementId, defaultText)
{
  //als de textbox leeg is of de waarde van de defaultValue heeft
  //dan de watermarkOn style toepassen
  var textValue = document.getElementById(elementId).value;
  if (textValue == defaultText || textValue.length == 0)
  {
    document.getElementById(elementId).className = “watermarkOn”;
    document.getElementById(elementId).value = defaultText;
  }
  //in alle andere gevallen de watermarkOff style toepassen
  else
  {
    document.getElementById(elementId).className = “watermarkOff”;
  }
}

En tot slot de code behind. Naamgeving is natuurlijk afhankelijk van de namen van je textbox controls die je hebt ingevoegd.

private void Page_Load(object sender, System.EventArgs e)
{
  SetWatermark();

}

private void SetWatermark()
{
  CreateWatermarkCode(TextBoxWoonplaats , “Uw woonplaats aub in hoofdletters”);
  CreateWatermarkCode(TextBoxNaam , “Vul hier uw volledige naam in”);

}

private void CreateWatermarkCode(TextBox textbox, string defaultValue)
{

  //als de textbox leeg is of de waarde van de defaultValue heeft

  //dan de watermarkOn style toepassen

  if ((textbox.Text == defaultValue) || (textbox.Text.Length ==0))

  {

    textbox.Attributes.Add(”class”, “watermarkOn”);

  }

  else //in alle andere gevallen de watermarkOff style toepassen

  {

    textbox.Attributes.Add(”class”, “watermarkOff” );

  }

  //de eerste keer bij het laden van de pagina
  //een hook zetten naar de focus en blur events
  //en de default waarde zetten

  if (!IsPostBack)
  {

    textbox.Attributes.Add(”onfocus”, string.Format(”OnWatermarkFocus(’{0}’, ‘{1}’)”, textbox.ClientID, defaultValue));

    textbox.Attributes.Add(”onblur”, string.Format(”OnWatermarkBlur(’{0}’, ‘{1}’)”, textbox.ClientID, defaultValue));

    textbox.Text = defaultValue;
  }
}

Dit soort grafische zaken heeft natuurlijk eigenlijk niet zo veel met Ajax van doen. Het wordt wel vaak in één adem genoemd en zoals gezegd is het ook onderdeel van de Ajax control toolkit, maar het doet niets a-synchroons en ook al niets Xml’s.

Laatst las ik iemand en die noemde het: JAC (Javascript and CSS). Dat klinkt al beter, en dan noemen we het beestje tenminste bij zijn naam.

The Pragmatic Programmer: From Journeyman to Master

Altijd fijn, als je een boek koopt waar je met plezier in leest. Deze dus ook. Had ‘m volgens mij op aanraden van iemand anders aangeschaft, en toen ik ‘m in handen kreeg was ik gelijk teleurgesteld: het boek was uit 1999! Zal me lekker pragmatisch zijn, zeker tips hoe je moet omgaan met klachten op je MS-Dos scherm? Niets was minder waar.
Een boek geschreven om een tip-lijst heen (dat zie je tegenwoordig ook wel veel, in elke paragraaf een ‘tip’, dus in dat opzicht waren zo ook al bij). Oftewel: het boek vertelt hoe je een goed pragmatisch developer kan zijn en worden, en vat alle stukjes aan het einde van de paragraaf samen als een tip. Het leuke is dat al die tips, met korte omschrijving, ook als uitscheur lijst achterin het boek zit.
En ik heb het nu twee weken uit, en sindsdien markeer ik op die lijst als ik de tip ook in andere artikelen lees, en ik de tip ook van waarde acht. Zo krijg je zo maar je eigen Agile-wiki op papier.
Anyway, het boek bevat 70 tips die variëren van ‘inkoppers’ tot ‘oh ja’ tot ‘oeps in de valkuil stap ik ook’ tot ‘waarom heb ik dat zelf niet bedacht’.
Soms wel een beetje achterhaald als ze het hebben over tooling en dergelijke, maar de principes staan nog altijd overeind.

Functioneel testen

Ik heb even moeten denken over deze blog. Het is namelijk niet iets om even te lezen en weer verder te gaan, niet iets grappigs, maar iets dat je kunt gaan doen.
Om je dus over de drempel heen te helpen om wat tijd te investeren, zit er aan het einde van dit artikel ook een link naar een klein intro filmpje (2 min) over het onderwerp. En wat is dan het onderwerp? Functioneel testen.
Zoef, weg ogen, op naar de volgende blog….
Aha, voor de lezer die dit afhaakpunt heeft overleefd: sinds enige tijd gebruik ik een open source (2e afhaakpunt ? ) applicatie voor het uitvoeren van functioneel testen. En ik moet zeggen: dat werkt heel plezierig. Niet alleen dat er wordt getest, maar als je code hebt aangepast en je eigen unit tests hebt uitgevoerd, dan is het fijn om even de functionele tests te runnen om te zien of niet alleen jouw service nog goed werkt, maar of ook de applicatie, de front-end, nog doet wat je verwacht.
En daarvoor dus: Selenium web application testing system.

Er zijn drie varianten beschikbaar:
Selenium IDE
Een plugin voor Firefox waarmee je acties in je browser kunt opnemen en daarna weer afspelen. Als je hier even induikt en je kijkt naar het filmpje dan ben je binnen een half uur klaar voor de eerste test van je eigen applicatie. Voorbeeldje van een tijdschrijfapplicatie: inloggen in de applicatie, nieuw project aanmaken, controle of die is aangemaakt, tijdschrijven vijf tijdschrijfregels, edit van een tijdschrijfregel, verwijderen alle tijdschrijfregels, verwijderen project en done! Als je binnenkort wat in die code verandert en je runt dit script, dan geeft dat toch net wat meer vertrouwen (hoe gedetailleerder de test, hoe meer vertrouwen natuurlijk). Als je dan met dit testscript de smaak te pakken hebt en je hebt er een stuk of wat gemaakt, dan is het tijd voor stap 2:

Selenium remote control the beginning
Hiermee kun je de scripts die je aanmaakt met de Selenium IDE achter elkaar afspelen in je browser. Druk op de knop, runnen, en klaar. De scripts worden opgeslagen als tekst, dus een parameter is zo veranderd. Helemaal de smaak te pakken en je wilt bv een test 500 keer uitvoeren met verschillende parameters? Check stap 3:

Selenium remote control the sequel
Hiermee kun je de testscripts opslaan in je favoriete code en kun je vanuit Visual Studio testing met deze scripts je functionele tests runnen. De Selenium code zorgt er voor dat je browser wordt opgestart en alles wordt uitgevoerd. De resultaten komen gewoon in je Visual Studio unit test resultaat scherm te staan.

Wat hield mij destijds tegen om ermee aan de slag te gaan? Toch weer wat tijd om te investeren. Maar met de IDE ben je zo aan de slag, en in een half uur krijg je in ieder geval een idee wat er mogelijk is en of het wat voor je is.

En ja, Visual Studio test edition is natuurlijk ook heel mooi, maar door de kosten ook weer niet zo vbaak beschikbaar voor de developer.

Zoals beloofd hier de link naar het instructiefilmpje van Selenium

Boekbespreking ‘Scrum and XP from the trenches, how we do scrum’

Op een vorig project werkte ik samen met Mark. Mark is iemand die ik zeer bewonder en die veel inzicht heeft in het proces van software development en software architectuur. Samen hebben we menig gesprek gehad over software architectuur. Voor allebei was dat leuk en leerzaam, het is prettig om collega’s te hebben waarmee je over dergelijke onderwerpen kunt sparren.
Later kwam John er ook bij, en het onderwerp waar we samen met hem over praatten was Agile Development. En als je praat en leest over Agile Development, dan kom je vaak uit bij Scrum en XP. Een leuk onderwerp, want het gaat over hoe we kunnen doen wat wij doen: software bouwen. We hebben er alle drie veel over gelezen en zijn er individueel al deels mee bezig op projecten, maar we hadden geen van allen een project gedaan waar er echt dedicated Agile wordt ontwikkeld.
Zelf heb ik o.a. het boek ‘Agile Project Management with Scrum’ gelezen met daarin case studies over Scrum, en als je dat leest lijkt het wel alsof een Agile project niet kan mislukken.
En dan komt in de discussie over Agile dus steeds de vraag naar boven: hoe zou het in de praktijk werken ? (dit waren dus meer theoretische discussies in tegenstelling tot de archtitectuurdiscussies met Mark, waar je echt de praktijk van alledag naast elkaar kan leggen)
En toen was er het boek ‘Scrum and XP from the trenches, how we do scrum’ met daarin een schat aan ervaringen uit ‘het echte Agile leven’. Dit boek is na registratie gratis te downloaden en is desgewenst ook als hardcopy te verkrijgen, wat ik ook heb gedaan als fijner naslagwerk en om de schrijver te steunen.
En zoals de schrijver Henrik Kniberg aangeeft: “er is niet de manier om een project met XP en Scrum aan te pakken, en zoals wij (de schrijver en zijn teams) het doen is niet per definitie de juiste manier (zelf zegt hij: misschien vind je onze werkwijze wel waardeloos) maar we kunnen in ieder geval leren van zijn ervaringen”. Want de schrijver heeft verschillende projecten gedaan met Scrum en XP en zijn meest belangrijke ervaringen en keuzes heeft hij in dit boek gebundeld.
Ikzelf las het in één ruk uit: al die vragen die je zelf hebt worden grotendeels beantwoord, of in ieder geval voorzien van argumentatie. Welke detaillering breng ik aan in de backlog, en waarom heeft hij bepaalde details er juist uit weggelaten. Hoe schatten we de tijd van user stories in, en waarom op die manier. En dat is prettig om te lezen: waarom ze bepaalde zaken hebben gekozen, en waarom ze bepaalde zaken hebben gelaten. Het mooie is dat je de argumentatie gewoon kunt volgen, en zelf een andere conclusie kunt trekken als je een andere mening toebedeeld bent.
Een minpuntje is dat er niets in staat over de mensen er om heen, hoe die het ervaren. Hoe ervaart een gebruiker het als hij van te voren alleen een inschatting krijgt wat er gebouwd wordt, alleen een grof idee van de functionaliteit, en alleen een inschatting van de kosten? Hoe breng je deze cultuuromslag bij mensen?
Maar ook zonder deze informatie een zeer nuttig boek.
 
Boekinfo:
168 pages, 6″ x 9″
ISBN: 978-1-4303-2264-1
Gratis copy te downloaden van de InfoQ minibooks site
In Nederland o.a. te koop bij comcol.nl en bol.com

Het technisch ontwerp

In het kader van Agile development wordt er gediscussieerd over de noodzaak van technische documentatie (het TO). En imho: dat is goed: want niets zo verschillend in kwaliteit, bruikbaarheid en gewicht als een technisch ontwerp, dus een beetje discussie er over kan mijns inziens geen kwaad.
Nou denk ik dat veel mensen die hebben gewerkt met TO’s van 8 kg of meer het wel met de Agile gedachte eens zullen zijn: daar heb je niet zo veel aan. Je kunt onmogelijk alles onthouden, en het is voor de makers van een dereglijk TO zo’n klus om alles te beschrijven dat voor sommige zaken toch nog wel eens een shortcut wordt genomen.
Nou zie als developer veel soorten TO’s, en het grappige is dat het bij elk bedrijf weer anders is. Bij het vorige project moest alles van te voren worden opgeschreven: de WSDL, de indexen, de triggers, het verwachte aantal records per tabel etc., en op het huidige project worden alleen de code wijzigingen achteraf gedocumenteerd. Wat echter niet vaak in een TO naar voren komt zijn design- en code keuzes: waarom zijn bepaalde beslissingen genomen, waarom zijn bepaalde stukken code op een bepaalde manier geschreven en wat betekenen bepaalde tabellen en velden in de database.

Nu, vers op een nieuw project, zit ik weer naar een stuk query te kijken waar een hele stapel joins wordt gebruikt, maar geen enkele documentatie beschikbaar is. Waarbij ik me dus afvraag: waarom moet de verbandcode gelijk zijn aan 8120995, de actie gelijk zijn aan 2 en de vId <> -1 om deze set van personen op te halen?
En wat is het verschil tussen de pId, de vId, de Mid, en de nId? De ‘antwoorden’ die ik wel hier op papier heb staan is dat de vorige developer vijf files heeft aangepast, compleet met de melding dat hij voor een class property een getter en een setter heeft geschreven, en een private field. En dat geeft me nou net weer geen enkele informatie waar ik wat aan heb.

Wat me een aardig uitgangspunt lijkt voor een TO is: documenteer je conclusies en waar nodig je keuzes en het denkproces: Wat is de verbandcode, en wat betekenen de codes, zijn die intern gekoppeld aan een enum? Gebruik gerust meer dan 3 karakters voor je veldnamen, en leg uit wat ze betekenen. Besteed geen tijd aan het documenteren van het veld ‘achternaam’ bij je class Persoon, en ook bij ‘huisnummertoevoeging’ kan ik me wel wat voorstellen. Leg wel uit waarom je bepaalde data cacht, en als je denkt: ik codeer hier een veldje bij dat het onderscheid maakt tussen A en B, typ dat er dan wel even bij.

Moraal van het verhaal: houd je niet vast aan een alles of niets strategie bij het schrijven van een TO, maar schrijf op wat je brainwaves waren om een ander de kans te gunnen je gedachten te volgen, en schrijf niet op dat het verwachte verloop van het aantal records in de tabel ‘geslacht’ in de aankomende 5 jaar waarschijnlijk nul zal zijn.

CSS sandbox

Deze pagina kwam ik ineens weer tegen toen ik lekker aan het CSS’en was (alhoewel, voor mij heeft CSS toch vaak wel een hoog oh, zit dat zo gehalte).
Hij heeft als naam de ‘CSS sandbox’. Hij is vooral als je je hierin herkent:

“Hoe zit het nou ook alweer met die property, moet ik nou overflow:auto of overflow:scroll gebruiken, en hoe werkt de background-repeat nou ook alweer? Even aanpassen, Save, reload pagina en ja, of nee, zo is het wel / niet goed….”.

Dan toont de CSS sandbox pagina namelijk een stuk tekst in een DIV waar je al deze propertys met een muisklik kunt aanpassen en direct kunt zien hoe het resultaat is.

Hiernaast zie je een deel van de propertys die je kunt aanpassen. De geselecteerde opties zijn rood, en klik je op een andere waarde dan wordt deze direct toegepast.