woensdag 15 februari 2017

Meeting energizers for distributed teams: Alternative facts

The team makes use of some video conferencing technology. All team members sit in front of the camera so everybody can see each other. The facilitator makes sure there is a flip-over or a whiteboard available to keep track of the score.
One team member tells something about himself/herself, which could be either the truth or a lie. After telling this (alternative) fact, the rest of the team individually has to decide whether what was said is actually the truth. Each team member does this by thumb-voting; thumb up means it's the truth, thumb down means it's a lie. After all team members decided the one team member reveals the truth about the fact. Scores are being updated on the flip-over or whiteboard.
Every team member gets it's turn, with one or more winners at the end of the game.

donderdag 3 juli 2014

Kwaliteit; een dosis gumption graag!

Wordt het werk dat ik doe wel goed gevonden? Gaat dit stukje code ervoor zorgen dat de applicatie beter wordt? Durf ik deze methode aan mijn collega's te laten zien? Deze en vele gerelateerde vragen komen voort uit onvoldoende kwaliteitsbesef ten opzichte van het werk dat wij dagelijks opleveren. Kwaliteitsvragen die beantwoord kunnen worden door beter stil te staan bij de processen die ons werk beïnvloeden. Wat is het dat die processen beïnvloed en hoe kunnen we ervoor zorgen dat we minder afhankelijk worden van de invloeden die ervoor zorgen dat de kwaliteit van ons werk minder wordt?
 
Elke softwareontwikkelaar kent het gevoel: je hebt net een periode hard gewerkt aan het opzetten van een nieuwe feature in een applicatie. Vol inspiratie ben je aan het begin van de week aan de slag gegaan om een goed ontwerp op te zetten en vervolgens te werken aan de implementatie van het ontwerp. Door onduidelijkheden in de door de opdrachtgever beschreven opdracht heb je meer dan eens stukken code moeten veranderen. Omdat de opdrachtgever de feature liefst gisteren af wilde hebben heb je op sommige plaatsen in de geschreven code gekozen voor een in jouw ogen slechte implementatie van het ontwerp. Aan het einde van de week zit je moe maar voldaan in de vergaderzaal klaar om je werk aan de opdrachtgever te presenteren. Iets meer dan vijf minuten na de afgesproken tijd komt de opdrachtgever gehaast binnenlopen met de onsterfelijke woorden op zijn lippen: "We gaan het helemaal anders doen!"
Blokkade, een gevoel van onwil maakt zich meester van je. Terwijl de opdrachtgever zijn verhaal afsteekt over het nieuwe ontwerp van de feature ben jij vooral tegenwerpingen aan het bedenken om het oude ontwerp te laten bestaan. Aan het eind van de middag is de opdrachtgever weer vertrokken met een flink aantal argumenten op zak die het ontwerp ongetwijfeld nog eens zullen doen veranderen en voel jij dat alle energie uit je lichaam is verdwenen. Terwijl bij de koffiemachine je collega's staan te praten over die idiote bijeenkomst van net staar jij wat voor je uit de verte in. Je werk lijkt waardeloos en al je enthousiasme voor het project is verdwenen. Je hebt geprobeerd je werk te doen maar in plaats van een succes te vieren zit je nu in een kroeg je verdriet te verdrinken of ben je op internet al op zoek naar een nieuwe baan. Het lijkt allemaal flink tegen te zitten en het project en je code kunnen je even helemaal gestolen worden.
 

Gumption

In ons werk zijn we allemaal op zoek naar de happy flow waarin alles goed loopt en waar jij bezig kan zijn met je vak; het bouwen van slimme, robuuste applicaties die de tand des tijds kunnen doorstaan. Daarnaast vinden de meesten van ons het ook nog eens leuk om te werken met de nieuwste innovaties in het werkveld. Wanneer we om wat voor reden dan ook worden tegengewerkt in dat werk ondervinden we een gevoel dat ons energie kost. In het boek 'Zen and the art of motorcycle maintenance' [1] wordt dat gevoel omschreven als een verlies van gumption. Gumption is niet te vertalen naar het Nederlands, maar betekend zoveel als: een enthousiasme dat vervuld is van initiatief, ondernemingszin, toewijding en passie. Gumption kun je zien als de olie van je kwaliteitsmotor: wanneer je er veel van hebt draait de motor goed maar wanneer je gumption verliest begint de motor te haperen.
Door te werken bouw je gumption op, door nieuwe dingen te ontdekken of methodes te verbeteren zorg je ervoor dat je jezelf steeds beter voelt over het werk dat je oplevert. Op het moment dat je een gevoel ervaart zoals in dat van het eerder genoemde voorbeeld verlies je gumption. Het verlies van gumption kan betrekking hebben op interne en externe factoren. Zo is het implementeren van slechte code een interne oorzaak van het verlies van gumption en is een opdrachtgever die last-minute een verandering in het ontwerp aanbrengt een externe oorzaak van het verlies van gumption. Interne en externe factoren zijn van directe invloed op de kwaliteit van het product, het product dat een bedrijf waar je voor werkt zijn gezicht geeft; positief én negatief.
Wanneer je beschikt over veel gumption zal dat er voor zorgen dat je beter bewust bent van je eigen werkgebied en hoe jouw werk zich daarin kwalitatief verhoudt ten opzichte van ander werk. Geldende opinies worden door jou opgenomen en gewogen en je bent ook goed in staat een eigen weg te kiezen waarvan jij denkt dat het je werk ten goede zal komen. Gumption zal je in zekere zin in staat stellen meer te kijken naar je werk in de vorm van abstracties en minder in de vorm van concrete implementaties. Voldoende gumption zorgt ervoor dat je een betere vakman bent, en beter vakmanschap leidt tot betere kwaliteit van je werk.
Gumption wordt opgebouwd door te werken aan het product, door onderdeel te zijn van het proces, door dat te doen waar jij je goed bij voelt. Gumption wordt ook opgebouwd door afstand te nemen van je product, even een pauze te nemen van je werk, zodat je de tijd neemt na te denken over datgene wat je doet in, volgens 'Zen' [1], haast meditatieve zin. Dit hoeft niet een proces te zijn van het zitten in een klein kamertje en te staren naar een langzaam opbrandende kaars bij het portret van Bill Gates, maar moet eerder worden gezocht in ontspanning; in het vinden van een manier om je hersenen voor even te kunnen ontlasten.
Gumption bouw je dus op en wanneer je er genoeg van hebt opgebouwd zul je zien dat je werk sneller, soepeler, prettiger en uiteindelijk kwalitatief beter gaat. Je staat midden in je vakmanschap en weet wat er nodig is om problemen aan te gaan en op te lossen. Dit verandert allemaal wanneer je gumption verliest.
 

Gumptionvallen

De gevaren voor het verliezen van gumption zijn talrijk en niet te benoemen in een boek, laat staan in een artikel. Het verliezen van gumption wordt bij een ieder ook veroorzaakt door andere redenen, maar er zijn veel oorzaken die door de grote groep worden gedeeld. In het eerder genoemde voorbeeld heb je al kennis gemaakt met een aantal oorzaken waardoor je gumption verliest.
Een situatie waarin je gumption verliest kunnen we omschrijven als een gumptionval. De gumptionval is de interne of externe factor die ervoor zorgt dat je een verlies aan gumption ervaart. Één van de grootste voorbeelden van een gumptionval die ik heb meegemaakt was door toedoen van een consultant met een technische achtergrond. Terwijl alle technische basiskeuzes al waren gemaakt in een groot multidisciplinair team en daarna een team van meer dan tien mensen al een paar weken bezig was aan de realisatie van het nieuwe product vond hij dat de basis van het ontwerp beter kon. De consultant overtuigde de opdrachtgever razendsnel van zijn gelijk, omdat er bij de opdrachtgever weinig technische kennis was en omdat hij vanuit zijn rol mandaat had. Hierdoor stond het team voor een enorm probleem. Wij moesten ervoor zorgen dat we konden aantonen waarom we alle beslissingen van de voorgaande twee maanden hadden gemaakt en waarom de ideeën van de consultant niet strookten met de producten die door de opdrachtgever al waren aangeschaft. Het team verloor zo ongeveer alle beschikbare gumption en er is in die periode veel tijd verloren gegaan aan vergaderingen die de voortgang van het project in de weg stonden. De aanbevelingen van de consultant werden door een last-minute interventie van hogerhand niet overgenomen. Voor het behoud van gumption was het al te laat. Het zou nog een lange tijd duren voordat het team weer functioneerde zoals voorafgaand aan dat conflict.
Dit soort situaties, waarin je gumption verliest, doen zich dagelijks voor en zorgen voor vertraagde projecten, verloren projecten, slechte(re) implementaties en personeelsonvrede. Een kleine greep uit gumptionvallen uit eigen ervaringen en voorbeelden uit ‘Zen’ [1] zijn onder andere:
  • Je hebt een onderdeel van de feature over het hoofd gezien. Om dit onderdeel binnen de feature werkend te krijgen moet je alles overnieuw doen.
  • Uit het bugsysteem komt een foutmelding over een feature die soms verkeerde waardes oplevert. De eerste analyses waren al verre van goed en hoe goed je ook zoekt, je krijgt het probleem niet gereproduceerd. Dit terwijl de bug op productie natuurlijk gewoon problemen blijft opleveren.
  • Er is behoefte aan een nieuwe feature en samen met je team ontwikkel je een technisch ontwerp en start je met de implementatie van dat ontwerp om er vervolgens achter te komen dat de huidige versie van het te gebruiken framework niet volstaat en de nieuwe versie van het framework nog niet kan worden gebruikt binnen de applicatie waarvoor de feature bedoeld is.
  • Er zit een fout in je zojuist opgeleverde code. Omdat je de code zelf geschreven hebt denk je de fout direct te kunnen oplossen maar dat blijkt niet zo te zijn. Je moet alles nalopen om erachter te komen waar de fout zat. Uiteindelijk zal je de fout vinden, maar omdat je vooringenomen bent over je eigen werk ben je veel minder goed in staat de fout te vinden en verlies je veel gumption in het achterhalen van de fout.
  • Je bent overtuigd van je eigen denkwerk, kennis en kunde op je vakgebied. De feature die jij zojuist hebt opgeleverd kan geen fout bevatten. Je zegt dat je de werking zult controleren maar doet dit eigenlijk maar met een half oog. Je bent minder in staat een fout in je werk te zien of te accepteren en zult eerder vertrouwen op onjuiste informatie die jouw werk goed doet lijken. Je ego zorgt ervoor dat je gumption verliest.
  • Het voelen van onzekerheid over het werk kan ook zorgen voor een verlies aan gumption. Je bent onder de indruk van de technische kennis van een collega. Omdat je bang bent dat jouw werk minder goed is wordt de kans groter dat je fouten maakt of bepaalde implementaties helemaal niet aandurft.
  • Verveeldheid is een grote gumptionval omdat je afvlakt in het nastreven van kwaliteit door bijvoorbeeld de repetitie van steeds terugkerende taken. Bij een klein bedrijf waar ik werkte moesten er eens in de week servers worden gecontroleerd middels een checklist. De controle werd na verloop van tijd minder nauwkeurig omdat de taak steeds minder leuk leek, eerder een sta-in-de-weg dan een noodzakelijk onderdeel van het werk.
  • Ongeduldigheid kan optreden wanneer een bepaalde taak langer duurt dan vooraf geschat. Je moet opschieten om je werk toch nog enigszins op tijd af te krijgen en bent daardoor gevoeliger voor het maken van fouten. Het corrigeren van die fouten kost tijd, wat een verlies van gumption zal opleveren.
  • Je onderzoekt een bepaald probleem in de applicatie door een hypothese te doen over het probleem. Wanneer je de hypothese probeert te bewijzen blijkt echter dat hij kan worden bewezen maar ook kan worden verworpen. De hypothese blijkt onvoldoende te zijn geformuleerd waardoor jij weer terug naar de tekentafel moet.
  • Wanneer je gereedschap verouderd is loopt je gumption harder terug dan de snelheid van je computer. De software op je computer, de computer zelf, de bureaustoel waarop je zit en het bureau waaraan je zit zijn allemaal zaken die optimaal moeten worden geregeld om een verlies van gumption tegen te gaan.
  • De omgeving waarin je werkt is ook van essentieel belang. Zo zal een te koude omgevingstemperatuur ervoor zorgen dat je sneller gaat werken en daardoor meer fouten gaat maken terwijl en een te warme omgevingstemperatuur ervoor zorgt dat je tolerantiegrens omlaag gaat. De effecten daarvan zijn uiteraard niet gunstig voor het team als geheel. Daarnaast spelen bijvoorbeeld ook licht en geluid een belangrijke rol in deze gumptionval.
  • Projectmethodes zijn een gevaar voor je gumption wanneer deze niet goed voorzien in de grillen van een opdrachtgever. Een verkeerde keuze in methodiek kan desastreuze gevolgen hebben voor het gehele ontwikkeltraject door veranderende wensen bij opdrachtgever en de markt van de opdrachtgever of door onmogelijkheden of juist nieuwe mogelijkheden in techniek.
  • Een opdrachtgever veranderd zijn/haar idee over een bepaalde feature en zorgt er (last-minute of niet) voor dat jij aanpassingen moet doen op verschillende niveaus binnen de applicatie. Hoe dichter de verandering op de deadline zal liggen of hoe ingrijpend de verandering is zal de mate van verlies aan gumption bepalen.
Dit is slechts een greep uit potentiële vallen en ik daag een ieder dan ook uit de lijst aan te vullen zodat we een beter beeld krijgen van de gevaren voor de kwaliteit van het werk dat wij als vakmensen opleveren. Met het omzeilen van gumptionvallen ben je echter niet ineens de vakman die je zijn wilt, er komt meer kijken bij het zijn van een vakman dan het omzeilen van valkuilen in het uitvoeren van je werk. Je kunt gumption in mijn ogen zien als de olie die ervoor zorgt dat jij een staat van vakmanschap sneller bereikt. Zoals eerder is uitgelegd zal een tekort aan olie ervoor zorgen dat je machine vastloopt, niet meer goed kan werken, terwijl veel gumption ervoor zal zorgen dat de machine soepel loopt en het werk makkelijk gaat.
Als gumption de olie is die een machine soepel laat lopen, dan is er ook nog steeds een tweede acteur in de vergelijking; de machine. Jij stuurt zelf je vakmanschap aan, beïnvloed door de hoeveelheid gumption die je op een bepaald moment ervaart. Een belangrijk deel van het zijn van een vakman is je ernaar gedragen, ernaar leven. Je moet niet alleen op de werkvloer maar ook daarbuiten vol zijn over je werkzaamheden, over de dingen die je doet. Ik heb het hier uitdrukkelijk niet over het zijn van een workaholic als je dat niet wilt zijn, ik heb het hier over het beter nastreven van de zaken die jij leuk, belangrijk, interessant of tof vindt om te doen... en dat betekent dus ook dat je een workaholic mag zijn als dat maakt dat jij je een goed vakman voelt.
 

Gumption op de werkvloer

De gumptionvallen gaan uit van de persoon of de persoonlijke omstandigheden die ervoor zorgen dat gumption verloren gaat. Daarin staat het individu centraal en lijkt er weinig plaats voor andere omgevingsfactoren die bijdragen aan het omzeilen van de vallen. Misschien gaat 'Zen' [1] expres uit van het individu maar in een werksfeer binnen een bedrijf van meer dan één persoon lijkt dat geen stand te kunnen houden. Het is volgens mij voor zowel werknemer als werkgever als collega belangrijk dat het individu in zijn of haar vakmanschap kan komen en daar kan blijven. De kwaliteit van het product, en daarmee de gezondheid van het bedrijf, zijn juist daarvan afhankelijk. Daarom is het van belang dat iedereen binnen het bedrijf zich bewust is van de gumptionvallen die een rol spelen bij het zo goed mogelijk invullen van de individuele taak.
Je mag als werknemers van een werkgever verwachten dat deze actief helpt bij het identificeren van gumptionvallen en helpt bij het vinden van oplossingen. Je mag als werkgever van je werknemer verwachten dat hij/zij weet wat er nodig is om in zijn/haar vakmanschap te komen en actief streeft naar een situatie waarin de factoren het meest gunstig voor het vakmanschap zijn. Daarom moet er binnen een bedrijf continu gumptionoverleg zijn zodat kwaliteit optimaal wordt nagestreefd. Binnen terugkerende werkafspraken, liefst dagelijks, kunnen nieuwe gumptionvallen worden geïdentificeerd en kan er als aparte taak worden gezocht naar een oplossing voor de gumptionval. Afhankelijk van de grootte van het bedrijf zal dit overleg in één of meerdere groepen/over schijven worden gevoerd. Sommige projectmethodieken voorzien in een bepaalde manier om onder andere gumptionvallen te identificeren. Zo voorziet de Scrummethodiek in die behoefte door een dagelijkse stand-up waarin allerlei zaken, zoals gumptionvallen, kunnen worden besproken en worden aangepakt.
 

Door gumption naar kwaliteit

Gumption is geen garantie voor kwaliteit. Gumption kan ervoor zorgen dat je kwaliteit makkelijker kunt, omdat je beter in je vakmanschap staat. Gumption elimineert problemen, omzeilt valkuilen en zorgt ervoor dat je hoofd klaar is voor de volgende uitdaging. Gumption zorgt voor die nieuwe ideeën die maken dat het product beter, uitgebreider of intuïtiever wordt. Gumption zorgt voor liefde voor het vak en voor het product en zal leiden tot het meer verbonden voelen met het product. Gumption leidt naar vakmanschap en uit vakmanschap vloeit kwaliteit voort. Gumption is volgens mij dus geen garantie voor kwaliteit maar wel een heel duidelijke richting voor het bereiken van kwaliteit.
Voldoende gumption, en daarmee een goed vakmanschap, zul je terugzien in het uitdragen van dat gevoel van vakkennis naar je collega's, familie, vrienden en kennissen, online of in de echte wereld. Een waar vakmanschap komt tot uiting in een breed scala aan processen dat zich nauwelijks laat definiëren, zoals het gevoel dat we allemaal wel eens hebben dat de code die je hebt geschreven kwalitatief goed is. We kunnen wel aangeven waardoor wij denken dat ons werk zo goed is geworden; door principes en patronen die we hebben toegepast en door het toepassen van geautomatiseerde tests in onze code. We kunnen dat aangeven omdat we ons hebben verdiept in wat code robuust en goed maakt, we hebben dat gevonden omdat we vol zaten met gumption. Je vakmanschap krijgt vorm door de gumption die jij op een bepaald moment ervaart.
Dat vakmanschap zal er uiteindelijk voor zorgen dat jouw werk kwalitatief beter wordt en die kwaliteit zal zich uitbetalen, voor de opdrachtgever, voor je werkgever en uiteindelijk vooral voor jou. Je bent er zeker van dat je werk goed zal worden gevonden en laat dit graag aan collega's zien. Je ziet dat een stukje code de applicatie verbeterd en hebt processen geïmplementeerd die dit nauwkeurig voor je controleren. Vrijdagmiddag presentaties zijn geen groot probleem meer omdat je weet dat jouw code goed is en zich makkelijk laat wijzigen mocht dat nodig zijn. Opdrachtgevers zijn tevreden omdat je snel wijzigingen kunt doorvoeren, je werkgever is tevreden omdat je zorgt voor betere kwaliteit terwijl de implementatietijd terugloopt en jij bent tevreden omdat jouw werk je niet meer in de weg zit. De kwaliteit is goed en jij kunt genieten van het weekend!

N.B. Door het schrijven van dit artikel ben ik het nut gaan zien voor het schrijven van een nieuw artikel; over het opbouwen van gumption. Want waar gumptionvallen zijn, daar moeten ook gumptionboosts te vinden zijn!

[1] Zen and the art of motorcycle maintenance, Robert M. Pirsig, 1974

maandag 10 juni 2013

Theming in Sitecore MVC

On a recent project I was asked to create some kind of theming depending on the URL in Sitecore. The customer wanted to be able to add a themed logo, a custom color and possibly some more customization's. He also wanted to be able to add, edit and delete these themes on the fly.

At first I started to think about using Sitecore layout items for this purpose. In theory that could be quit a nice way to render different themes. I would create a custom layout template that derived from the standard layout template. After that I would add some custom fields to the custom layout template to save the theme color and the theme logo. So far, so good. Everything works nice and easy and in theory you should be able to swap layout files at runtime.

That sounded like a good idea, but it's actually quit impossible to use field values from a layout template on a content item. So much for this cool theming theory, I had to take a different approach.

If we want to use editable fields on a page we probably can't work without fields on a content item. The problem with this approach is that I don't want extra fields on my content items. Heck, I don't want to have to change my theming on all content items every time something changes.

Sitecore.Context.Items to the rescue! This array is normally empty and can be used to store additional content items for usage on your webpage. This is how I've set up my solution using the Items array:

The customer didn't know how the theming should be presented in the URL. At first they chose a solution in which the theme name is part of the relative URL, something like www.mysite.com/{themename}/restofpath/sitecorewildcard. After some discussions they changed it over to a URL that specified the theme name as the sub-domain like {themename}.mysite.com/path/sitecorewildcard. In the end I ended up with a version that could theoretically work in both ways, with minor changes necessary to switch solutions. I implemented the sub-domain solution.

I created an item-resolver which was inserted into the pipeline right after the custom Sitecore item-resolver. This item-resolver checks whether the Sitecore solution contains an item with the same name as the theme name we got from the URL. It does so by trying to get a Sitecore Item from a custom Sitecore repository for unit testing purposes. The GetItem method does nothing more than getting a Content Item based on the specified path. This method also dictates that you name the Content Item the way you specify it as a sub-domain. If there is an item in the CMS I put it in Context.Items array for use on out webpages, as shown in the screenshot below:

Itemresolver implementation.


When you look at this picture, you see that I call a UrlPartsHelper class to get the current domain. The method I'm calling is the one below, which I in turn got from a the internet from a website that I no longer recall...

Url helper class


I added the www because that's not one of my preferred theme's. When I wouldn't add this check the solution wouldn't return strange values for an www theme as long as I don't add an www theme to the Brand-folder.

One final thing needs to be done before we can see the final version working on our website. You need to hook up the item fields on a webpage. You can do this by creating your own custom HTML helper and call it for all fields on your page. I created a HTML helper that expects a fieldId as a parameter. In the method I check for the Theme Item to exist in the Context.Items collection and when it's there, I check for a field with the id that I passed as a parameter. If it exists I return the required output.

One final note: to ensure more robust code I would advise for creating string constants which hold the various content item paths, names and id's. This way your template looks more readable while you can manage your item constants from code.

Cheers!

vrijdag 26 april 2013

Sitecore and MVC rendersections

Currently I'm working on a project for a customer who wants a Sitecore website based on ASP.NET MVC 4. After working on the project now for a couple of weeks I walked into some problems regarding Sitecore, MVC and RenderSections in Razor, here's what happened:

I created a standard layout in Sitecore, deriving from a Razor file which contained all HTML you normally would expect in a Razor layout file. After that I created a view rendering that derived from another Razor file, a partial file containing some extra information for the page. I actually didn't do anything to create a Sitecore content placeholder, I just referenced the view rendering by it's guid in the Sitecore layout Razor file. So far nothing special, as you would expect I had no problem showing the content from the view rendering on the layout.



Things got complicated when I tried to add a normal Razor RenderSection in the Sitecore layout Razor file, just adding this to the file triggered a yellow screen with the follow error message: "The file '/Views/Shared/_Layout.cshtml' cannot be requested directly because it calls the 'RenderSection' method". Allright, what just happened?! After some searching I found blog-posts saying I shouldn't put a Razor RenderSection on a Razor view file... Well ok, I didn't do that while I put my Razor RenderSection on a layout file, right?

No, not so right. While I've got a Sitecore layout item with a Razor view file referenced to it I actually didn't create a layout file. When you create a layout page in Sitecore and reference it to a Razor file you actually create a view page which isn't able to contain a Razor RenderSection and that's why I saw that yellow screen.

If you want to be able to include Razor RenderSections on your page you should create an actual Razor Layout file. You can do this by referencing another Razor file on top of the one you referenced in your Razor template that is included in your Sitecore layout item. In this new and 'real' Razor Layout file you can add Razor RenderSections, although there is a minor glitch when you setup your solution this way. 



Normally you would use the Razor RenderSections to place some content from your content item in a specific place in your Razor Layout page, you could for example create a Razor RenderSection for including page specific javascript at the bottom of your Razor Layout page. When you create a new page in Sitecore you basically create a content item based on a Sitecore Layout page. Your Sitecore Layout page normally would consist out of one or more renderings, which are a kind of Razor partial views.

Those renderings pose the real problem while Razor RenderSections can't be addressed from a Razor Partial view because it has no hard reference to it's Razor layout file. So if you'd like to have a RenderSection on a Sitecore rendering the default way; you're gonna have a bad time. The only way to add content to a Razor RenderSection is by declaring the content on the Sitecore content item, but that would also mean an extra dependency between the Sitecore content item and the Sitecore rendering while you'd have to manage content for one Sitecore rendering in two places.

There's no easy way to get around this problem. The best way probably is by creating two custom HTML helpers, one for accepting content to be displayed and one for rendering that content on a page. An example of the solution could be found on stackoverflow: http://stackoverflow.com/questions/5433531/using-sections-in-editor-display-templates/5433722#5433722.