Twee issues bij SharePoint 2013 op Windows 8 afgespeeld in een VMWare Player op een server met Hyper-V...

Je zou het maar willen... SharePoint 2013 op Windows 8 afspelen in een VMWare Player op een server met Hyper-V.

Ja, dat kan gebeuren als je een voorbereid VMWare image zonder al te veel moeite wilt gebruiken.

Toch twee issues tegengekomen waarbij, na wat zoeken op internet, ik niet de enige ben die dit is tegengekomen (toch enigszins een geruststelling).

Voorbereiding bestond uit het kopiëren van het image naar mijn server en deze in de (gratis) VMWare Player proberen af te spelen.

Resultaat: fatal error waarin werd verwezen naar een probleem in het geheugen: "No-Execute Memory Protection option enabled on your motherboard". En dat mijn pc maar moest worden herstart. Niet doen, dat helpt niets, het probleem zit 'm in een instelling in je BIOS (de "No-Execute Memory Protection" van de host machine, niet van de virtuele machine). De instelling heette in mijn BIOS overigens anders, namelijk: "X-Bit".

Nieuwe poging: nu klaagt VMWare dat 't niet wil samenwerken met Hyper-V en dat ik de Hyper-V rol maar moet verwijderen van mijn server (kinderachtig hoor!). Nu was ik dat niet van plan, en in zo'n geval ga ik op zoek naar een truuk: het tijdelijk uitzetten van de Hyper-V rol:

// to disable hyper-v
bcdedit /set hypervisorlaunchtype off

En om 'm weer aan te zetten:

// to enable hyper-v
bcdedit /set hypervisorlaunchtype auto

*Gratis* SharePoint 2013 training for IT pros

SharePoint 2013 training for IT pros...

Een cursus in 14 modules een goede inleiding op SharePoint 2013. Met presentaties en video materiaal.

Module 1: SharePoint 2013 IT pro introduction and overview
Module 2: SharePoint 2013 system requirements
Module 3: SharePoint 2013 architectural changes
Module 4: SharePoint 2013 server farms and site architecture planning
Module 5: Office Web Apps 2013 architecture and deployment
Module 6: SharePoint 2013 service application architecture and individual service applications
Module 7: SharePoint 2013 enterprise search overview
Module 8: SharePoint 2013 social features
Module 9: SharePoint 2013 enterprise content management and web content management considerations
Module 10: SharePoint 2013 customization options and management
Module 11: SharePoint 2013 authentication and authorization overview
Module 12: Overview of SharePoint 2013 business continuity management
Module 13: Upgrading to SharePoint 2013
Module 14: What’s new for IT pros in Project 2013

5 Zaken die NIET in SharePoint architectuur documentatie thuis horen

Ik mijn werk kom ik regelmatig architectuur documenten tegen; ik maak ze zelf, ik gebruik ze en ik review ze. Hoewel iedere situatie weer anders is, kom ik vaak een aantal zaken tegen waarvan ik vind dat ze niet thuis horen in architectuur documentatie.

In deze blogpost de top 5...

1. Een beschrijving van de werking en het gebruik van SharePoint

Op eenzame hoogte: de "SharePoint handleiding" als onderdeel van de architectuur. Pagina's lange beschrijvingen hoe site collecties en site in elkaar zitten, hoe bibliotheken kunnen worden ingericht en welke "out-of-the-box" rollen bij welke rechten horen. Misschien interessant voor een beginnende SharePoint gebruiker, maar niet voor de doelgroep van de architectuur. Bovendien denk ik dat bij SharePoint architecturen juist niet de "standaard" van belang is te beschrijven, maar de wijzigingen die hierop zijn aangebracht.

2. Details, details, details

Er valt aan SharePoint veel in te stellen. En natuurlijk moet dat allemaal gedocumenteerd worden. Het is alleen de vraag waar dat moet gebeuren. Veel informatie hoort niet thuis in een architectuur document en kan verhuizen naar technische documentatie. Een architectuur document hoort de relevante hoofdlijnen te beschrijven en niet de details.

3. Project afhankelijke informatie

Projecten zijn veranderingen op de korte termijn, een architectuur beschrijft in het algemeen de richtlijnen voor de langere termijn. Voor een project relevante principes en richtlijnen (en afwijkingen hierop) horen thuis in een Project Start Architectuur (PSA). Project overstijgende zaken horen thuis in een referentie -, domain - of enterprise architectuur.

4. Architectuur als schetsboek van een eilandbewoner

Een architectuur is een communicatiemiddel; het geeft regels die in de praktijk gebruikt moeten worden. Daarvoor is 1) begrip en 2) draagvlak nodig. Veel architectuurdocumenten verdwijnen in de spreekwoordelijke lade omdat ze niet worden bijgehouden, daarom verouderen en onbruikbaar worden. Zonde van tijd en geld en uiterst frustrerend voor de architect en voor de CIO. Oorzaak hiervan ligt vaak bij de betrokkenheid van de organisatie bij het opstellen van de architectuur en door het type architect. Organisaties hebben veelal de neiging om "het maken van een architectuur ergens te beleggen" en vervolgens het resultaat af te wachten. Daarnaast zie ik dat architecten vaak de neiging hebben om "het beter te weten", "de hele wereld volgens eigen inzicht te willen modelleren" en dit "in hun eigen taal" te willen doen. Met dat laatste doel ik op de bonte verzameling PowerPoint plaatjes waarmee architectuurdocumenten regelmatig worden opgefleurd.

5. Her-her-her-herhaling

Copy and paste is makkelijk en staat garant voor lijvige documenten. Nadelen zijn: verminderde leesbaarheid en verminderde onderhoudbaarheid (wijzigingen moeten op meerdere plaatsen worden doorgevoerd). Ook hier geldt: "less is more".

Om de bovenstaande valkuilen te vermijden, de volgende tips voor SharePoint architecten:

1. Schrijf een architectuur document met het doel ervan in gedachten. Stem het document hierop af en beperk je daarbij. Aanvullende informatie wordt niet gebruikt en ontmoedigt het lezen en gebruiken ervan. Beperk je tot het niveau (waarom, wat, hoe en waarmee) en tot de aspecten (Business, Informatie, Informatie systemen, Infrastructuur, Security, Governance, et cetera) die echt relevant zijn.

2. Voortbouwend op het vorige punt: baken de scope van de te beschrijven architectuur duidelijk af. Bepaal hiervoor vantevoren duidelijk hoe het architectuur landschap wordt ingedeeld en welke delen in het de betreffende architectuur document worden beschreven. Geef ook expliciet aan welke delen buiten scope vallen.

3. Schrijf je architectuur document met de gebruikstermijn in gedachten. Legt een architectuur document richtlijnen vast voor de gehele organisatie (zoals een enterprise -, referentie of domain architectuur), dan mag dit slechts zeer beperkt aan verandering onderhevig zijn.

4. Kom van je eiland af en betrek de doelgroep!
Gebruik architectuur als een echt communicatiemiddel; stem het al op de doelgroep, gebruik raamwerken, talen en technieken (b.v. Archimate, IAF) die open en vrij verkrijgbaar zijn en betrek de doelgroep actief vanaf het begin. Zodoende kan voldoende getest worden of de doelgroep de architectuur nog begrijpt (b.v. door regelmatige reviews, inspraak sessies en informele gesprekken) en of de architectuur nog "gedragen" wordt.

Maatwerk, configuratie en out of the box: waarom en hoe onderscheid maken?

Ik hoor de discussie overal; waar ik ook kom, altijd wordt dezelfde discussie gevoerd: wat is precies maatwerk? En hierbij wordt maatwerk ook altijd angstvallig vermeden.

Tijd om eens wat dieper in te gaan op dit vraagstuk, om duidelijkheid te scheppen en handvatten te geven hoe hiermee om te gaan.

Waarom onderscheid tussen out of the box en maatwerk?
Maatwerk wordt in het algemeen geassocieerd met dure software ontwikkeling in een programmeertaal als C#, lange trajecten, duur in onderhoud en lastig overdraagbaar. Out of the box, daarentegen, wordt geassocieerd met goedkope en snelle ontwikkeling.

Het laatste is voor klanten (management, business) natuurlijk veel aantrekkelijker dan maatwerk, terwijl voor de gebruiker (business) en voor de programmeur (techniek) maatwerk interessanter is.

Voorkeur wordt voor een belangrijk deel gekleurd door emoties (ja, zelfs bij technici) en de gevolgen daarvan kunnen voor een project of programma het verschil betekenen tussen succes of falen.

Voorbeelden hiervan te over, bijvoorbeeld op aanbestedingsgebied. Hierin wordt door de klant vaak "out of the box" geëist waaraan in eerste instantie ook door de leverancier wordt voldaan. Gedurende de implementatie blijft dat maatwerk toch de voorkeur geniet (of zelfs noodzakelijk is), waarna zowel de implementatie doorloop tijd als de bijbehorende kosten door het dak gaan.

Resultaat: klant ontevreden en de leverancier en/of de gekozen technologie (of het platform) krijgen de schuld.

Jammer en niet nodig, als vantevoren maar nagedacht was geweest over de verschillende "smaakjes" en de gevolgen daarvan. In het woord "nadenken" zit het woordje "na", maar dat wil niet zeggen dat je pas ergens na moet gaan denken.

Maar waar gaat het eigenlijk mis?

De beloften van platforms en tooling
De laatste jaren bieden (webportal)platforms (dms,ecm, collaboration), veel beter dan vroeger, mogelijkheden om snel tot resultaat te komen door standaard (out of the box) basis functionaliteit te bieden waarmee de eindgebruiker relatief snel aan de slag kan. Ook tooling biedt steeds meer mogelijkheden voor niet software "gurus" om de functionaliteit van platformen aan te passen en uit te breiden.

Allemaal mooie ontwikkelingen, maar ontwikkelingen die hoge verwachtingen kunnen veroorzaken... en zelfs te hoge verwachtingen...

In de praktijk blijkt namelijk het volgende:
1. Out of the box functionaliteit is vaak te generiek om specifieke business processen te ondersteunen.
2. De eindgebruiker (en de business in het algemeen) weten te weinig af van de standaard mogelijkheden van platforms.
3. De eindgebruikers (en de business in het algemeen) zijn onvoldoende bereid zich neer te leggen bij de discrepanties tussen de eigen werkwijze en de werkwijze die het betreffende platform oplegt.
4. Projectmanagers (ICT, business) bieden onvoldoende weerstand aan de eis van de business om het platform te veranderen, hebben te weinig inhoudelijke bagage om te weten waar de grenzen van een platform liggen en geven specialisten te weinig inspraak bij belangrijke beslissingen die hierover worden gemaakt.

Om juiste beslissingen (lees: waar de klant tevreden mee is en waarvoor hij een redelijke prijs/doorlooptijd voor betaalt) is het nodig om zicht te hebben op de volgende zaken:

Wat wordt (in termen van het platform waaraan gesleuteld wordt) verstaan onder maatwerk? Zijn er gradaties hierin? Welke zijn dit, wat bieden ze aan mogelijkheden, beperkingen?

Wat zijn de gevolgen van de keuze voor een bepaalde gradatie? Wat is hiervoor nodig in termen van kosten en doorlooptijd?

Van out-of-the-box tot maatwerk: definities

Laat ik beginnen met een aantal definities die ik al een tijdje gebruik, en kijken of we die kunnen verbeteren (let wel: het gaat hier om SharePoint):

Out-of-the-box (OOTB): the supporting platform supports the recommended solution by default;
Configuration: the configuration of the supporting platform needs to be changed to support the recommended solution;
Limited Customization: adaptations by means of configuration, browser supported or SharePoint related tooling (e.g. Designer, InfoPath , XSLT);
Customization: software components of the supporting platform need to be changed / extended to support the recommended solution;
Extension: new, independent, software components need to be added to the supporting platform to support the recommended solution.

Van out-of-the-box tot maatwerk: definities
De volgende stap is even terug te gaan naar de vraag achter de vraag, namelijk waarom onderscheid gemaakt wordt tussen de verschillende categorieën. Deze vraag komt vaak neer op het willen beoordelen of een bepaalde oplossing te veel "pijn" gaat doen of niet. Ik heb expres de term "pijn" gebruikt, want in iedere situatie is deze pijn weer anders en wordt deze pijn andere gevoeld. "Pijn" kan betekenen dat een bepaalde oplossing duur is om te ontwikkelen, te veel onderhoud kost of lastig te migreren is naar een ander platform en daarom toekomstige pijn in de portemonnee (lees: budgetten) kost. Pijn kan ook betekenen dat de eindgebruikers (de business) onvoldoende worden ondersteund door de betreffende oplossing omdat deze bijvoorbeeld te weinig mogelijkheden biedt of te ver afstaat van de bestaande werkprocessen.

Bij de afweging tussen maatwerk en het gebruik van out-of-the-box functionaliteit moet dus gekeken worden  waar de "pijn" gelegd moet worden.

Projectmanager en opdrachtgever: kijk verder dan jullie neuzen lang zijn
Bovenstaande voorbeelden illustreren dat pijn voorkomt binnen en buiten het project waarin de oplossing ontwikkeld wordt. Een projectmanager is aangeleerd om zijn zaken binnen het project tijdig, binnen budget en kwaliteitseisen te realiseren, hetgeen natuurlijk op zich goed is, maar in de praktijk vaak niet voldoende blijkt te zijn. De "pijn" die binnen het project wordt vermeden kan buiten het project des te harder aankomen. Een goed voorbeeld hiervan is migratie; in migratieprojecten moeten gevolgen van beslissingen in eerder projecten vaak worden gecorrigeerd. Met name ongecontroleerd toestaan van maatwerk komt tijdens een migratietraject een organisatie duur te staan.

Het is daarom een goede zaak om verder te kijken dan het project zelf, bijvoorbeeld naar het overkoepelende programma of zelfs naar het overkoepelende informatieplan of de enterprise roadmap.

Ee doeltreffend denkraam hierbij is de software life cycle. Hierin wordt grofweg weeggegeven in welke levensfasen software zich kan bevinden en vormt daarmee een denkraam vanwaaruit bepaald kan worden welke gevolgen de keuze van maatwerk of out-of-the-box (of een variant hierop) heeft.

Samenvatting en conclusie
Een platform biedt (potentieel) een middel om snel een oplossing te bieden aan de business. Keuzes bij het aanpassen van het platform aan de wensen en eisen van de business dienen vantevoren goed te worden doordacht, waarbij verder gekeken moet worden dan de eerste op te leveren versie.

Vantevoren (samen met experts) nadenken is hierbij een betere investering dan achteraf de gevolgen van slechte beslissingen te moeten corrigeren.

Aanpassen van SharePoint lijst weergaven met JavaScript

Een tijdje geleden heb ik blogposts gemaakt over het aanpassen van de SharePoint user interface middels JavaScript (zie links onderaan deze blog post onder "Verder lezen"). Het ging toen over edit pages van lijst items waarin ik velden manipuleerde door er JavaScripts op los te laten waarmee ik, na het laden van de pagina, veldwaarden, gedragingen en opmaak kon wijzigen.

Onlangs vroeg een klant mij om een soort dashboard te maken waarin bij taken werd vermeld of ze op tijd danwel te laat waren afgerond. Iets dat je gemakkelijk met de juiste tools kunt maken. Helaas had ik ook in dit geval weer niet de beschikking over deze tools (en ook niet de juiste rechten), zodat ik weer moest terugvallen op de "dirty JavaScript tricks" die ik eerder had gebruikt.

Reden om na de opdracht maar weer eens een blog post te schrijven... hieronder het recept van mijn oplossing...

Ingredienten
- Een lege web part pagina.
- Een takenlijst met "due date" (datum/tijd) waarop een taak afgerond moet zijn.
- Een stukje JavaScript waarvan ik de werking hieronder zal toelichten.
- Een Image library met daarin de plaatjes voor de LED's.

Doel
Een lijst met daarin voor iedere taak, waarvan de "due date" datum/tijd kleiner is dan de huidige datum/tijd (today), een indicatie dat de taak niet op tijd is afgerond. In dit geval heb ik gekozen voor een rood LEDje (lampje).

Probleem
In SharePoint is het niet mogelijk om de huidige datum/tijd (Today) te gebruiken in een berekende kolom. Het is dus helaas niet mogelijk om in een berekend veld aan te geven of een taak te laat is afgerond.

Oplossing

Stap 1: Uitbreiden van de takenlijst met een extra kolom met een gemakkelijk te herkennen berekende waarde
Oplossing die ik hiervoor heb gekozen is om een aparte kolom toe te voegen waarin ik de "due date" in een eigen formaat weergeef. Dit formaat heb ik gekozen om er zeker van te zijn dat de datum - en tijd delen (jaar, maand, dag etc.) in een vaste volgorde worden weergegeven. Afhankelijk van instellingen kan het datum formaat namelijk anders zijn dan gewenst. Verder wil ik dat de kolomwaarden van de "due date" gemakkelijk door JavaScript zijn te herkennen zodat ik deze gemakkelijk kan inlezen en gebruiken. Hiervoor heb ik een berekende kolom gemaakt met de volgende formule:

=TEXT(DueDate,"~yyyy~m~d~h~m~s~")

Hierin wordt de DueDate omgezet in een string waarde met daarin het jaar in 4 karakters, de maand in minimaal 1 karakter, et cetera.

Dit resulteert in kolomwaarden zoals: <TD Class="ms-vb2">~2013~3~22~8~30~0~</TD>

In een SharePoint lijst zijn deze velden dus gemakkelijk te herkennen:
<TD Class="ms-vb2">~2013~3~22~8~30~0~</TD>

Stap 2: Aanmaken van een web part pagina met daarin de lijst en een Content Editor Web Part
De lijst moet zichtbaar zijn in een web pagina. Gezien de lijst moet worden aangepast met JavaScript is een Content Editor Web Part nodig waarin we het JavaScript plaatsen waarmee de lijst wordt aangepast. Van belang is dat het Content Editor Web Part onder de lijst wordt geplaatst. Reden hiervoor is dat de DOM nodes in de lijst beschikbaar moeten zijn voor het JavaScript.

Het JavaScript dat ik het Content Editor Web Part wordt geplaatst heeft de volgende functionaliteit:
- GetAllListFields: functie die de speciale lijstvelden opneemt in een array (vIconListFields). Zo kunnen we ze gemakkelijk gebruiken. Leuke extra uitdaging hierbij is dat je hiervoor de getElementsByClassName functie nodig hebt die in IE niet voorhanden is. Daarvoor heb ik een aparte functie gemaakt.
- ConvertFieldsToIcons: functie die de objecten in de vIconListFields array uitleest, bepaalt of de data/tijden daarin eerder of later vallen dan de huidige datum/tijd, en de HTML code in de objecten vervangt door een rood of groen plaatje (LED).

Omdat ik het niet kon laten moest ik de LED's ook laten animeren. Een rode LED wordt geanimeerd zodat het gaat flikkeren. Hiertoe laat ik het plaatje middels een setInterval JavaScript call varieren.

De volledige JavaScript code hieronder, happy coding!

<script language="JavaScript">

// ----------------------------------------
    // Global constants and variables
var vIconListFields = new Array();

// ----------------------------------------
// Functions
    function GetAllListFields(ioIconListFields) {

        // Look for nodes like &lt;TD Class="ms-vb2"&gt;~2013~3~22~8~30~0~&lt;/TD&gt;
 
   vAllMsVb2Nodes = document.getElementsByClassName("ms-vb2");

for (var vIndex = 0; vIndex &lt; vAllMsVb2Nodes.length; ++vIndex ) {

if ( 
   vAllMsVb2Nodes[vIndex].innerText.substring(0,1) == "~" &&
vAllMsVb2Nodes[vIndex].innerText.substring(vAllMsVb2Nodes[vIndex].innerText.length-1, vAllMsVb2Nodes[vIndex].innerText.length) == "~"
) {
   // Add node to Fields array
ioIconListFields[ioIconListFields.length] = vAllMsVb2Nodes[vIndex];
}

}

    }

function ConvertFieldsToIcons(ioIconListFields) {

   var vCurrentDateTime = new Date();
var vTimeDifference;

for (var vIndex = 0; vIndex &lt; ioIconListFields.length; ++vIndex ) {

// Get date in DOM field into Date object to compare with current date/time
var vDateTimeArray = ioIconListFields[vIndex].innerText.split("~");
   var vDateTime = new Date(vDateTimeArray[1], vDateTimeArray[2], vDateTimeArray[3], vDateTimeArray[4], vDateTimeArray[5], vDateTimeArray[6], 0);

vTimeDifference = vDateTime.getTime() - vCurrentDateTime.getTime();

// Change contents off DateTime cell according to TimeDifference
if (vTimeDifference&gt;=0) {
   ioIconListFields[vIndex].innerHTML = "&lt;img src='http://portal.demo.intra/DigitaalLoket/StatusIcons/icon_green.png'/&gt;";
}
else {
  ioIconListFields[vIndex].innerHTML = "&lt;img class='AnimatedLED' src='http://portal.demo.intra/DigitaalLoket/StatusIcons/icon_red.png'/&gt;";
}

// Dispose
delete vDateTime;
}

}

function changeImage()
{

if ( vCurrentImageFileIndex &lt; vImageFiles.length - 1 )
++vCurrentImageFileIndex;
else
vCurrentImageFileIndex = 0;

for ( var i = 0, len = vImageObjects.length; i &lt; len; i++ ) {
vImageObjects[i].src = vImageFiles[vCurrentImageFileIndex];
}

}
   
// ----------------------------------------
   // Helper functions

   // Implement getElementsByClassName because IE does not support this natively

if (!document.getElementsByClassName) {

document.getElementsByClassName = function(classname) {
var elArray = [];
var tmp = document.getElementsByTagName("*");
var regex = new RegExp("(^|\\s)" + classname + "(\\s|$)");
for (var i = 0; i &lt; tmp.length; i++) {

if (regex.test(tmp[i].className)) {
elArray.push(tmp[i]);
}
}

return elArray;
};
}

// ----------------------------------------
// Main procedure

    GetAllListFields(vIconListFields);
ConvertFieldsToIcons(vIconListFields);

// Initialize animation function

var vImageFiles = new Array();
vImageFiles[0] = "http://portal.demo.intra/DigitaalLoket/StatusIcons/icon_clear.png";
vImageFiles[1] = "http://portal.demo.intra/DigitaalLoket/StatusIcons/icon_red.png";

var vCurrentImageFileIndex = 0;
var vImageObjects = document.getElementsByClassName("AnimatedLED");

setInterval("changeImage()", 500);

</script>

Verder lezen
SharePoint 2010 Content Editor Web part maakt rommel van mijn JavaScriptjes
Aanpassen van lijst- en bibliotheekformulieren in SharePoint 2010, zonder SharePoint Designer of InfoPath
Aanpassen van standaard webpagina's voor nieuwe items en bewerken van items: een generieke aanpak

Help! Mijn web part doet het niet! Een checklist voor het debuggen...

Komen de volgende foutmeldingen bekend voor als je een web part werkend wilt krijgen?

"A Web Part or Web Form Control on this Page cannot be displayed or imported. The type could not be found or it is not registered as safe"

"Cannot import web part"

De volgende checklist kan je misschien met de oorzaak van het probleem helpen:

1. Controleer of het betreffende web part is opgenomen in de Web Part Gallery

2. Controleer of de xml in de Web Part Gallery (View XML) overeen komt met de .webpart XML in je solution

3. Controleer de assembly paden in je .webpart files:

Deze paden zijn case sensitive, aaa is anders dan AAA.
Is het Public Key Token in het Assembly Path opgenomen?

4. Controleer de inhoud van de wsp solution file, zitten alle onderdelen erin?

De wsp solution file is een zip-file (of cab file) die je kunt renamen in .cab zodat je de inoud ervan kunt controleren.

5. Na een update van de Web Part solution (retract, delete, add, deploy) worden:
- Web Part Gallery bijgewerkt
- Web Parts in pages updated

Als dat niet het geval is:
- Verwijder en herinstalleer de solution dan handmatig (retract, delete)
- Verwijder de web parts uit de Web Part Gallery
- Disable de bijbehorende feature.

Daarna:
- Handmatig de solution weer installeren (add, deploy)
- Eventueel (als het Web Part nog steeds niet werkt): deactiveer de bijbehorende feature, verwijder de Web Parts handmatig uit de Gallery, en activeer de feature weer zodat de Web Part Gallery weer wordt gevuld.

6. Is de bijbehorende DLL in de GAC opgenomen? Met de juiste naam en versie?

Voor de GAC, zie de commandline tool gacutil of de map "C:\WINDOWS\assembly".
Let op: versienummers als "1.0.*" werken soms niet, gebruik liever de volledige versie nummering, bijvoorbeeld: "1.0.0.0".

7. Controleer of het betreffende web part als "safe" is aangemerkt in de web.config.

Deze wordt aangepast zodra de solution wordt deployed, in de SafeControls sectie. Controleer hier ook de paden, het versienummer en het PublicKeyToken.

8. Controleer de SharePoint logfiles "C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\logs" op fouten.

9. Kijk kritisch naar de programmacode van het betreffende web part:
- Controleer de programmacode op de juiste class declaraties (naamgeving) en het gebruik van "public".
- Fouten als het aanpassen van properties die niet bestaan, etc..

10. En af en toe een extra iisreset na installatie kan ook helpen... ;)

Bij het debuggen van web parts is het belangrijk om nauwkeurig te zijn: een foutje zit in een klein hoekje en SharePoint is erg kritisch.