Surface is cool. Iedereen die er naar gekeken heeft is dat wel met me eens. Hoewel de hardware op het eerste gezicht niet echt indrukwekkend is (een tafel met een PC erin, dat is toch niets nieuws?) zijn er behoorlijk wat geavanceerde technieken toegepast. Niet voor niets heeft Microsoft meer dan 100 patenten aangevraagd op toegepaste ideeen in de tafel. De meeste daarvan hebben te maken met het projectie en vision gedeelte, ik neem aan dat er heel wat drempels overwonnen zijn om dit allemaal voor elkaar te krijgen.
Het programmeren voor Surface is makkelijk. Nou ja, makkelijk voor mensen die ervaring hebben met WPF. Ook XNA kenners kunnen goed aan de slag met Surface maar ik denk dat 90% van de developers met de WPF versie aan de gang gaan.
Als ik een demo geef aan mensen zegt iedereen dat het zo eenvoudig is om software te schrijven voor Surface. WPF, wat extra controls en meer heb je niet nodig. Iedereen kan het! We moeten echter niet vergeten dat 'die paar extra controls' heel wat manjaar werk in zich hebben: het is vaak zo dat hoe makkelijker iets in het gebruik is, hoe moeilijker het is geweest om het te bedenken en te bouwen.
Maar goed, hoewel de hardware dus best indrukwekkend is en de SDK goed in elkaar zit, is er eigenlijk niets dat ons tegenhoudt om hele mooie applicaties te schrijven voor Surface. Toch? Nou. er is nog een klein dingetje dat we moeten doen: het verzinnen van een goede applicatie voor Surface.
En daar schuilt het grote probleem.
Surface is een heel nieuw platform. Niet qua hardware en zeker niet qua software, maar wel voor wat betreft het gebruik.
Surface is een platform voor de Natural User Interface (NUI). Dit is iets heel anders dan de Graphical User Interface (GUI) die we gewend zijn. Ik durf zelf te zeggen dat de overgang van GUI naar NUI net zo groot, dan niet groter is dan de overgang van Command Line Interface (CLI) naar GUI! En dat was al geen makkelijke stap!
In een GUI maken we gebruik van metaforen. We maken afbeeldingen die iets voorstellen in de echte wereld. Denk aan een icoontje van een prullebak om aan te geven dat we iets weg willen gooien. Een tekening van een papiertje zal wel iets met afdrukken te maken hebben, en zo voorts. Ook het gebruik van de mousepointer, menus, windows en dergelijke zijn allemaal metaforen voor dingen uit het echte leven. De bedoeling is dat de gebruikers die zaken herkennen en snappen wat de bedoeling is. Dat dit niet altijd zo werkt wordt wel bewezen door de enorme hoeveelheid trainingen en documentatie die applicaties nodig hebben om duidelijke te maken wat de gebruiker met de software kan doen. Blijkbaar is voor veel gebruikers de mentale stap van abstract icoontje naar 'real-life' toch te groot! Voor de duidelijkheid: ik heb het niet over mensen zoals jij en ik: wij zijn dit gewend en we weten niet beter. Ik praat hier over de gemiddelde gebruiker die slechts af en toe achter een computer zit. Voor die mensen is het allemaal erg ingewikkeld!
Een NUI gaat een stap verder. In plaats van een abstracte afbeelding maken we gebruik van echte, fysieke objecten. In plaats van gegevens op een formulier in te vullen met je naam en wachtwoord om in te loggen, leg je je visitekaartje neer op de tafel. De machine weet nu wie je bent, je hoeft verder geen actie te ondernemen. In plaats van iets te selecteren en dan op een knopje met een prullebak te drukken, sleep je een foto op het scherm naar een prullebak: zelfs mijn dochter van 6 snapt dat.
De uitdagingen voor Surface zijn echter groter.
In Surface kennen we in principe geen CurrentUser. Een applicatie kan gelijkertijd door meerder mensen bedient worden. Dat betekent dat als we een systeem schrijven we bijvoorbeeld geen acties kunenn maken die de state van de gehele applicatie veranderd. Een voorbeeld verduidelijkt dit:
Stel, we maken een vingerverf applicatie. Op het scherm kunnen we een kaartje neerleggen met een kleur erop: op het moment dat bijvoorbeeld een groen kaartje neergelegd wordt worden alle vingerbewegingen op het scherm neergezet als groene strepen. Halen we het groene kaartje weg en vervangen we deze door een rode, kun je met rood verfen. Hartstikke leuk natuurlijk, maar wat als jij en ik nu samen aan onze versie van Mona Lisa bezig zijn? Ik wil het haar zwart maken, maar net op het moment dat ik met mijn vingers dat begin in te kleuren vervang jij het zwarte kaartje door eeen witte (want jij wilt de ogen inkleuren). Op datmoment kan ik niets meer doen: ik moet wachten tot jij klaar bent met wit.
Daarnaast zijn wij, als traditionele programmeurs, gewend aan een aantal standaard metaforen. Zo zie je in veel applicaties een of andere vorm van een 'save' button om de huidige status op te slaan. Als je hier over nadenkt is dat best vreemd: in het echte leven doen we dat ook niet. Als ik iets op een papiertje schrijf hoef ik dat niet op te slaan. Dus in een NUI zou ik dat ook niet moeten doen!
Nu is het niet zo moeilijk om software zo te schrijven dat de state altijd opgeslagen wordt. Maar wat als je nu de state voor meerdere cases wilt opslaan? In onze vingerverf applicatie wil ik een tekening kunnen maken, maar ik wil niet dat jouw tekening de mijne overschrijft (andersom vind ik persoonlijk niet zo erg :-) ) Hoe lossen we dat nou op? Dat kunnen we bijvoorbeeld doen door iedereen een object te geven (bijvoorbeeld een pasfoto). Op het moment dat die pasfoto op het systeem ligt weet Surface voor welke gebruiker deze tekening is. Als ik mijn foto weg haal en jij legt de jouwe neer, zal mijn kunstwerk opgeslagen worden en komt de jouwe tevoorschijn (indien het tekenen een groepsactiviteit is kunnen we een groepsfoto plaatsen.) Geen 'save' knop meer: altijd toegang tot mijn werk en ik heb geen toegang tot jouw werk. Precies zoals een normale gebruiker verwacht.
Surface is een tafel. Het leuke van een tafel is dat mensen er om heen gaan staan. Het nadeel is dus wel dat je geen applicaties kunt maken die een duidelijke onder- en bovenkant hebben. Immers, als er tekst op het scherm staat is dat voor een persoon goed te lezen, maar de andere gebruikers kunnen daar niets mee (nou ja, ze kunnen het op z'n kop lezen maar handig is dat niet). Je moet dus rekening houden met dit aspect. Niet eenvoudig!
Ik denk dat veel ontwikkelaars in het begin dit soort fouten gaan maken. Ook ik maak me daar nog steeds schuldig aan. Ik heb op zich een goede oplossing: mijn dochter van 6 is een geweldige beta tester. Hoewel ze niet begrijpt wat de systemen doen, kan ze er wel mee overweg. De User Interface heeft geen geheimen voor haar. Als die geheimen er wel zijn, heb ik mijn werk niet goed gedaan.
Ik hoef nu alleen nog maar even een killer applicatie voor Surface bedenken..