[alg] phantom requirements

Pagina: 1
Acties:
  • 155 views sinds 30-01-2008
  • Reageer

  • Alarmnummer
  • Registratie: Juli 2001
  • Laatst online: 09-07-2024
Een van de dingen waar ik steeds scherper op let zijn phantom requirements. Requirements die je vanaf het begin al 'kent' en toepast als een soortement van heilige graal zonder dat dit toegevoegde waarde heeft. Phantom requirements zijn eigelijk erg gevaarlijk omdat het een onnodige bron van complexiteit en extra moeite is, met alle gevolgen van dien. (complexiteit = tijd, tijd = geld)

Een van de phantom requirements waar ik steeds meer om moet lachen is de manier van omgaan met or-mappers/dao`s. Je bent druk bezig om de hele or-mapper weg te modeleren zodat je eenvoudig van or mapper kunt wisselen. Maar in de praktijk zul je zien dat dit a) niet voorkomt. b) onmogelijk is aangezien een or-mapper gewoon een bepaalde invloed heeft op de manier van werken. Dit is totaal niet erg, maar je bent dan gewoon onnodig werk aan het verzetten + je maakt gewoon geen gebruik van de functionaliteit van die specifieke tool.

vb:
Ik werk met Hibernate en daarmee kan je eenvoudig met een Criteria informatie uit de db trekken zonder een sloot van finders te introduceren: alleen een find(Criteria c) is voldoende. Verder zijn er nog veel meer van soort handige toepassingen van een bepaalde tool waar je niet eenvoudig bij kan omdat je dus je tool niet volledig benut.

Een ander voorbeeld is compleet database onafhankelijk blijven. Als de klant aangeeft dat dit geen issue is, dan vind ik dat je de volledige functionaliteit van de db moet benutten en mag je in je code/ontwerp ook duidelijk rekening houden met features van die db (bv postgresql en hun typesysteem/functies).

Wat vinden jullie hiervan? Weten jullie zelf ook phantom requirements binnen jullie systeem waarvan je je iedere keer afvraag waarom je het doet. Hebben jullie zelf al veel phantom requirements verwijdert?

[edit]
Keuze van Criteria was eigelijk niet de beste keuze aangezien je voor een Criteria ook een sessie nodig bent en daar kan de DAO erg eenvoudig beschikking over krijgen.

[ Voor 12% gewijzigd door Alarmnummer op 12-08-2005 13:44 ]


Verwijderd

In bepaalde zaken is daar heel moeilijk mee om te gaan. Als je kijkt naar devxpress xpo voor .net, dan ga je werken met attributen en filters om toch functionaliteit voor de mapper te definieren op je classes.

  • Michali
  • Registratie: Juli 2002
  • Laatst online: 22-03 18:12
Kwa data access probeer ik alles redelijk afgeschermd te houden, maar in enkele calls vanuit domein objecten zie ik geen enkel probleem. Als je data access code maar niet geheel in de business code gewoven zit is een aanpassing niet zo veel werk. Het is idd meer werk om het geheel weg te werken en dat is imo gewoon tijdverspilling. Ik implementeer mijn mappers wel zo dat het vrij gemakkelijk vervangen kan worden door een compleet andere manier van opslaan. Maar dat was zo weinig werk dat het de moeite wel waard was.

Noushka's Magnificent Dream | Unity


Verwijderd

Ik merk dat er door veel techies de neiging is tot "over engineering", en een van de verschijningsvormen daarvan zijn de phantom requirements waar jij het over hebt.

Volgens mij is dat de universele zoektocht van techneuten naar de heilige graal, de 'silver bullet', de oplossing die alle oplossingen onnodig maakt. Realiteit dicteert dat deze er niet is, omdat je keuzes moet maken, en iedere keuze voor- maar ook nadelen heeft. Toch blijven techneuten vaak op zoek, waardoor ze soms enorm vernieuwen maar meestal enorm veel tijd verspelen. Het heeft heel erg te maken met de psychologie van waarom iemand een techneut is geworden, waarbij technologie meer een doel op zich is geworden, dan een middel tot een doel.

Ik zie mijzelf als iemand die een beetje techneut - af begint te worden. Na al mijn jaren fascinatie met de technologie op zich denk ik nu (met name met werk) meer in termen van oplossingen, tijd en geld, en erger ik me soms enorm aan de neiging van mensen om mij heen tot dwalende zoektochten naar iets dat niet gevonden zal worden ipv praktische keuzes te maken na een goede afweging van voors en tegens op basis van je huidige kennis. In de prive / hobby sfeer interesseer ik me nog steeds in technologie, maar wel oppevlakkiger.

Dit is overigens een interessant topic dat op de grens van tech en psychologie wandelt, want de phantom requirements zijn mijns inziens meer een gevolg van doorgedreven perfectionisme dan van technologische oorzaken. Wij techneuten zijn interessante mensen. :)

Edit: grappig om te zien dat de eerste twee reacties ingaan op de techniek van het voorbeeld ipv het concept "phantom requirements" .... de zoektocht naar de heilige graal van hoe om te gaan met data access lijkt te zijn ingezet, met alle phantom requirements van dien ;)

[ Voor 10% gewijzigd door Verwijderd op 12-08-2005 14:10 ]


  • Michali
  • Registratie: Juli 2002
  • Laatst online: 22-03 18:12
Verwijderd schreef op vrijdag 12 augustus 2005 @ 14:08:
Edit: grappig om te zien dat de eerste twee reacties ingaan op de techniek van het voorbeeld ipv het concept "phantom requirements" .... de zoektocht naar de heilige graal van hoe om te gaan met data access lijkt te zijn ingezet, met alle phantom requirements van dien ;)
Het is idd niet geheel ontopic, maar op de manier hoe ik ermee om ga is het zeker geen phantom requirement. Het op een bepaalde manier ergens mee omgaan en het praten daarover hoeft op zichzelf helemaal geen phantom requirement te zijn. Het is een bepaalde strategie die je toepast en een strategie is imo geen requirement. Uiteraard kan het daarin wel uitmonden, maar dat hoeft helemaal niet het geval te zijn.

Noushka's Magnificent Dream | Unity


Verwijderd

Zonder eigenlijk op het fenomeen phantom requirement zelf in te gaan, valt het me op dat de meeste van deze technische requirements altijd met ontkoppeling en onafhankelijkheden te maken hebben.

Je wilt onafhankelijk zijn van een widget set (dus bouw je je eigen abstracte layer hierboven op, je zou zo maar eens willen wisselen)
Je wilt browser onafhankelijk zijn (dus je houdt je aan de W3C standaarden en doet niet aan vendor lock-in)
Je wilt DB onafhankelijk zijn (dus je houdt je wederom aan de SQL standaard, en gebruikt geen vendor specific SQL)
Je wilt Application Server onafhankelijk zijn (dus J2EE is jouw wet en je gebruikt geen vendor specific features)
Etc etc...

Aan de ene kant is het een kwestie van je aan standaarden houden (=af en toe jammer, je mist leuke vendor toegevoegde waarde), aan de andere kant een kwestie van tot in het extreme abstraheren. Van dat laatste heb ik zelf wel een handje. Bij mijn designs moet bijna elke class pluggable zijn, dus minstens een interface, een abstracte basis implementatie en een complete simpele default implementatie. Ik krijg wel steeds vaker zoiets, van het is wel mooi en handig zo, maar waar ben ik nu eigenlijk mee bezig? Voegt dit nu -ECHT- iets toe, of ben ik nu al een maand(!) extra bezig zonder dat het business-wise wat heeft opgeleverd.

Kwa phantom requirements zie ik ook vaak de requirement dat dingen (vooral kwa GUI) tot in het extreme simpelder en duidelijker moeten. Alles moet altijd maar duidelijker, en duidelijker en nog eens duidelijker. Alsof elke gebruiker een klein kind is die nix, maar dan ook helemaal nix kan leren.

Ook hier geldt weer. Tot op zekere hoogte is het goed op dingen simpelder en duidelijker te maken, maar je kunt hier niet oneindig mee doorgaan. Het is onzin om bij het eerste de beste telefoontje van een gebruiker die het even niet snapt (mischien omdat ie de nacht daarvoor laat was gaan slapen ofzo), meteen je hele UI design weer op de schop te gooien en allemaal uitleg erbij en pijltjes en dingetjes erbij.

  • Genoil
  • Registratie: Maart 2000
  • Laatst online: 12-11-2023
Ik zit nu met een OR+DAL laag in m'n systeem waar ik op zich wel blij mee ben (Propel voor PHP, gebruikt 'toevallig' ook Criteria), maar zo langzamerhand begint het ook wel tot me door te dringen dat het ook een hele last is om mee te zeulen. Vooral de performance-hit is vervelend. En waar ik het OR deel nog wel okee vind in de delen van applicaties waar objecten ook bewerkt moeten worden ipv louter uitgelezen, kan die DAO laag me eigenlijk gestolen worden, ik werk immers toch altijd met MySQL databases. Ik ga maar eens op zoek naar een OR mapper zonder ingebakken DAL...

  • Michali
  • Registratie: Juli 2002
  • Laatst online: 22-03 18:12
Genoil schreef op vrijdag 12 augustus 2005 @ 14:37: Ik ga maar eens op zoek naar een OR mapper zonder ingebakken DAL...
offtopic:
Tip:

Koop de boeken "Patterns of Enterprise Application Architecture" en "Data Access Patterns" en maak zelf iets wat volledig aansluit op je wensen. Zo veel werk is het niet en je bent geheel vrij in toevoegen van wat je wilt.

Noushka's Magnificent Dream | Unity


Verwijderd

Michali schreef op vrijdag 12 augustus 2005 @ 14:28:
[...]

Het is idd niet geheel ontopic, maar op de manier hoe ik ermee om ga is het zeker geen phantom requirement. Het op een bepaalde manier ergens mee omgaan en het praten daarover hoeft op zichzelf helemaal geen phantom requirement te zijn. Het is een bepaalde strategie die je toepast en een strategie is imo geen requirement. Uiteraard kan het daarin wel uitmonden, maar dat hoeft helemaal niet het geval te zijn.
Ten eerste: ik bedoelde mijn opmerking niet als kritiek op het 'on topic' gehalte, maar als bevestiging van mijn gedachte over hoe de meeste techneuten denken, zonder ook dat als kritiek te bedoelen, maar ik vond het wel leuk.

Ten tweede: Ik reageerde niet heel specifiek op jouw bericht maar op de lijn die ik verwachtte dat ingezet zou worden en die nu ook ingezet is, nl. het praten over data access oplossingen en meer specifiek: het zoeken naar een ideale vorm daarvoor.

Phantom requirements duiken op wanneer een oplossing niet precies uit gaat van de specifieke requirements van de klant of andere, intern vastgelegde requirements. Als je bijvoorbeeld binnen een bedrijf kiest om altijd een standaard architectuur te gebruiken, zal dat misschien voor de specifieke oplossing voor de klant overkill zijn, maar zal inwerken op een project en onderhoud van de software makkelijker gaan omdat gebruik wordt gemaakt van herkenbare structuren en parate kennis. De requirements om de architectuur te gebruiken zijn dan dus geen phantom requirements, omdat het een bewuste beslissing is en dus een interne requirement is waar je aan voldoet.

Hetzelfde lijkt het geval te zijn met jouw beslissing: jij hebt een keuze gemaakt om iets op een bepaalde manier te doen aan de hand van jouw ervaringen. Je kent de voordelen en beperkingen, en je zal een andere aanpak kiezen als die beter past.

Waar ik het echter over heb is dat anderen eventueel op jouw strategie voort te borduren, zonder al de voordelen en beperkingen te kennen, waardoor ze iets doen zonder precies te begrijpen wat de gevolgen ervan zijn. Op dat moment is er sprake van phantom requirements: er wordt een set met regels opgevolgd zonder bewust besloten te hebben dat de regels van de oplossing / aanpak / strategie past binnen de kader van de te bouwen oplossing.

En daarom is een discussie over oplossingen vaak zo zinloos, omdat zelden de beperkingen en nadelen besproken worden, waardoor er geen gedegen beslissing genomen kan worden om een bepaalde aanpak / oplossing / strategie te kiezen. Pas als er nadelen, knelpunten en alternatieven worden besproken is er sprake van een gedegen afweging en keuze.

Ik hoop dat je begrijpt wat ik bedoel. Nogmaals, dit is geen aanval op jou of de discussie over data access aanpak op zich, maar zet wel wat (hopelijk constructief) kritische kanttekeningen erbij.

Verwijderd

Ik ben het wel eens met MrX, als je alleen al kijkt naar de hele discussies op het web over decoupling, en encapsulation. Het gaat zo ver dat overal factories en wrappers voor worden gemaakt, en men blijft eindeloos lullen over DE oplossing.

In feite wilde men gewoon een oplossing die hun in staat stelden om in de toekomst relatief gezien eenvoudig een andere laag te gebruiken, maar door de gehele over engineering hebben ze initieel al teveel tijd besteed aan al die factories en wrappers waardoor een toekomstige swap van een laag (die dan nog niet eens is verkocht) al niet meer rendabel is.

  • Michali
  • Registratie: Juli 2002
  • Laatst online: 22-03 18:12
Je verhaal klopt MrX, maar jou definitie van phantom requirements is dan volgens mij niet gelijk aan die van mij.

Phantom requirements zijn, naar mijn definitie, het bedenken en uitvoeren van eisen die niet direct gevraagd zijn binnen het project en waarschijnlijk ook nooit nodig zullen worden. Hier kun je dan denken aan het invoegen van flexibiliteit op plaatsen waar dat nooit nodig zal zijn of het alvast schrijven van stukken code die niet direct gebruikt gaat worden, maar "waarschijnlijk in de toekomst handig zal zijn". Het overnemen van een bepaalde strategie en het proberen toepassen daarvan is imo niet direct een phantom requirement, maar kan wel leiden daartoe. Als je een bepaalde strategie hanteert die zegt dat je overal interfaces en factories voor moet gebruiken, dan krijg je idd een phantom requirement, namelijk flexibiliteit die niet overal volledig benut wordt of zal worden.

Of is dit ook zo ongeveer wat je bedoelt?

Noushka's Magnificent Dream | Unity


Verwijderd

Verwijderd schreef op vrijdag 12 augustus 2005 @ 15:31:
Ik ben het wel eens met MrX, als je alleen al kijkt naar de hele discussies op het web over decoupling, en encapsulation. Het gaat zo ver dat overal factories en wrappers voor worden gemaakt, en men blijft eindeloos lullen over DE oplossing.
Soms is het wel redelijk moeilijk, phantom requirements gaan niet perse over of decoupling en encapsulation nou goed is of niet. PHP mensen zijn vaak (niet allemaal!) principieel tegen deze zaken, gewoon omdat het te moeilijk is voor ze. De PHP filosofie is om weer terug te gaan naar de jaren 60, zonder abstractie en liefst alle code direct op de pagina in 1 groot monolitisch geheel.

Echter, de software crises die daar op volgde kwam er niet voor niks: de complexiteit van software was niet meer te overzien. Gestructureerde aanpakken ( procedures, objecten, lagen, architecturen, patterns) zijn succesvol ingezet om deze crisis te bestrijden. Het onderzoek naar een nog betere aanpak is nog altijd aan de gang, zeker gezien het feit dat software systemen als maar groter worden.

Wat dat betrefd is de PHP aanpak OOK een phantom requirement: Niet alle software moet compleet zonder architectuur of decoupling gebouwd worden. Geef de echter PHPer z'n zin, en de geschiedenis herhaald zich met de volgende software crisis.

Waar het IMHO om gaat is dat je op de juiste plek de juiste requirements moet toepassen. Voor een operating system zijn layers en een solide architectuur niet weg te denken bijvoorbeeld. Niemand zou een OS in PHP style bouwen (het zou onder zijn eigen gewicht instorten).

Aan de andere kant heeft het ook weinig zin om principes die bedoeld zijn voor grote enterprise systemen te gaan toepassen op het bouwen van een simpele web blog ofzo. Ga je hier ik weet niet hoe veel lagen en abstracte plug-ins defineren (die nooit gebruikt gaan worden, bijvoorbeeld mischien moet de input van de log ooit via SSH gaan gebeuren, terwijl mensen altijd alleen maar het web gebruiken, etc), dan schiet je ook je doel voorbij. Veel mensen die met J2EE bezig zien overal een abstractie en architectuur achter, terwijl dit niet -altijd- nodig is.

Verwijderd

Onze definities liggen volgens mij echt heel erg dicht tegen elkaar, en zijn een klein conceptueel stapje van elkaar verwijderd.

Jij zegt:
Phantom requirements zijn, naar mijn definitie, het bedenken en uitvoeren van eisen die niet direct gevraagd zijn binnen het project en waarschijnlijk ook nooit nodig zullen worden.
In jouw definitie is het ontwerpen en vervolgens implementeren van iets een phantom requirement. Ik ga nog een stapje verder en zeg dat het ontwerpen en implementeren in zo'n geval het gevolg zijn van een phantom requirement. Ik zal het proberen te illustreren met een voorbeeld.

Ik heb een Access projectje gemaakt door formulieren te laten genereren door wizzards, waardoor bijvoorbeeld de naamgeving zuigt. Een andere developer gaf hier commentaar op door te zeggen dat de naamgeving niet netjes was. Ik vroeg waarom dat erg was, waarop hij antwoorde dat de applicatie zo niet onderhoudbaar was. Daarop antwoorde ik dat het snel afhebben van de applicatie een requirement was maar het onderhoudbaar maken niet, aangezien de applicatie slechts een 'proof of concept' was die later vervangen zou worden.

In dit voorbeeld is de phantom requirement: de applicatie moet onderhoudbaar zijn. Het werkelijk bedenken van goede naamgeving en deze doorvoeren zou dus een gevolg van de phantom requirement zijn. In 9 van de 10 gevallen is dit overigens een echte requirement, maar in dit geval niet.

Als ik de standaard aanpak van ontwikkelen van applicaties binnen mijn afdeling had aangehouden, had ik dus overal wel een nette naam aan gegeven, meer gelet op de vormgeving, meer foutafhandeling ingebouwd, etc. Het zou een technisch prachtige applicatie zijn geweest, die ver zijn doel voorbij zou schieten, nl op een korte termijn in een simpele oplossing voorzien, waarvan de opgedane kennis toegepast moest worden om later een nieuwe applicatie te bouwen voor de toekomst.

Ik heb dus gekozen voor een andere aanpak, die beter past en geen phantom requirements met zich meebracht. Die keuze heeft voordelen (snelheid van bouwen, gemak) maar ook nadelen (slechte technische kwaliteit, slecht onderhoudbaar). De keuze is echter volledig gebaseerd op de eisen van de klant, en die was bijzonder tevreden. Ik was als techneut niet tevreden over de applicatie, maar als leverancier van oplossingen wel blij.

Dat is ook waar de schoen vaak knelt als je als liefhebber van technologie in de ICT werkt: vaak zal je moeten gaan voor de oplossing die een mooi compromis is tussen allerlei factoren en daardoor bij lange na geen ideale technische oplossing.

Edit (n.a.v. Gordijstok en leeko):
De oplossing moet ook gezocht worden in het proces van software bouwen ipv in technologie op zich. Als het proces van software ontwikkelen goed is inricht, zal dat steeds beter gaan werken, steeds meer de juiste technologie in de juiste situatie toepassen, e.d.

Om zo'n geleidelijke groei te laten plaatsvinden heb je echter sterke leiders nodig, want software ontwikkelaars zijn stront-eigenwijze mensen, en dan nog is het een grote opgave. Er zijn wel wat verhalen geschreven hierover, waarvan het meest bekende volgens mij het Capability Maturity Model is. De laatste versie daarvan is CMMI, zie http://www.sei.cmu.edu/cmmi/general/general.html voor meer info.

[ Voor 14% gewijzigd door Verwijderd op 12-08-2005 16:33 ]


  • Alarmnummer
  • Registratie: Juli 2001
  • Laatst online: 09-07-2024
Leuk dat er al zoveel replies zijn.

Waar het mij vooral om gaat is om je meer af te gaan vragen waarom je dingen doet zoals je ze doet. Het wil niet zeggen dat je alle goeie technieken dan maar over boord moet gooien. Maar ik wil mezelf in ieder geval meer bewust maken van bepaalde keuzes. Ik wil met meerdere nuances kunnen werken en iedere nuance met argumenten kunnen onderbouwen.

Het valt mij wel eens op dat ik voor een bepaalde aanpak kies en als iemand vraagt waarom, dat ik daar best wel diep over moet nadenken. Verder probeer het ontwikkelproces minder rimpelig te laten verlopen en onnodige complexiteiten te vermijden. Hierdoor komen noodzakelijke complexiteiten trouwens ook beter uit de verf.

  • Genoil
  • Registratie: Maart 2000
  • Laatst online: 12-11-2023
Alarmnummer schreef op vrijdag 12 augustus 2005 @ 17:34:
Het valt mij wel eens op dat ik voor een bepaalde aanpak kies en als iemand vraagt waarom, dat ik daar best wel diep over moet nadenken. Verder probeer het ontwikkelproces minder rimpelig te laten verlopen en onnodige complexiteiten te vermijden. Hierdoor komen noodzakelijke complexiteiten trouwens ook beter uit de verf.
Ik kies ook vaak genoeg voor een bepaalde aanpak waarvan ik eigenlijk al weet dat die een beetje te "bloated" zijn voor het doel, maar omdat er al een hele berg functionaliteit voor het oprapen ligt kies ik voor de snelle maar lompe oplossing. Weten die recalmeboys in Amstelveen veel ;)

Verder merk ik in m'n voorkeur voor de aanpak van problemen een soort golfbeweging tussen de overcomplexe kant en de zo eenvoudig en snel mogelijke. Missing requirements is ook een ding he :) Het doel is om uiteindelijk een beetje in het midden uit te komen.

  • Bbfreak
  • Registratie: September 2002
  • Laatst online: 04-02 10:03
Bij dit onderwerp zie je goed het verschil tussen je opdrachtgever en de programmeurs.
De 1 wil resultaat en de ander resultaat en een goed design.
De meeste programmeurs hechten aan design heel veel waarde en zeker hier soms (te) veel tijd in,
als de applicatie niet te groot is.
Uiteindelijk is het soms best frustrerend dat hier niet altijd naar gekeken wordt.
Phantom requirments blijken op de korte termijn een obstakel terwijl deze later misschien van pas komen. Zoals mijn collega poster hierboven zei: "zoeken naar een goede combo van de 2 werelden"

Twitter @cmeerbeek / Halo Waypoint Profile


  • momania
  • Registratie: Mei 2000
  • Laatst online: 26-04 10:42

momania

iPhone 30! Bam!

Bbfreak schreef op zaterdag 13 augustus 2005 @ 00:12:
Bij dit onderwerp zie je goed het verschil tussen je opdrachtgever en de programmeurs.
De 1 wil resultaat en de ander resultaat en een goed design.
Dat is natuurlijk niet altijd zo...

Ik heb vaak genoeg meegemaakt dat de opdrachtgevers eisen dat de applicatie aan zaken moet voldoen die uiteindelijk helemaal niet worden gebruikt. Dan met name de al eerder genoemde uitbreidbaarheid en onafhankelijkheid van bepaalde tools/type databases/frameworks/etc.

Hier kan een programmeur vaak denken van: 'maar waarom? dit gaat waarschijnlijk toch nooit meer aangepast worden, ook al roept men dat nu wel'. En de programmeur heeft daarin ook vaak weer gelijk in met als gevolg dat er in een project veels te veel tijd aan dit soort zaken wordt besteed.

'een goed design' is vaak voor beide partijen ook een wereld van verschil :)



De andere kant van dit verhaal heb ik ook wel eens meegemaakt idd. Daarbij wilde de business (opdrachtgevers) natuurlijk snel resultaat hebben. Het was ook een vrij 'groot' project gericht op retail klanten. Daar hebben we juist eerst weer goed nagedacht en ge-proto-typed qua design/framework met als resultaat dat we na een maand ontwikkeling al wel veel code hadden staan, maar nog niets waar de opdrachtgever iets aan had. Die begon toen wel erg zenuwachtig te worden, maar gelukkig had de goede voorbereiding hier wel zijn vruchten afgeworpen en waren we na de echte implemtatie tot iets testbaars voor de opdrachtgever ruim binnen tijd en budget klaar :)



Het blijft met dit soort issues altijd een kwestie van goed afstemmen met elkaar wat men nou echt wil. En dat is gelijk ook het moeilijkste gezien de verschillende inzichten die techneuten en opdrachtgevers vaak hebben. (Als ze uberhaupt al direct met elkaar in contact komen, want meestal zitten daar nog wel eens wat lagen tussen.... ) :)

Neem je whisky mee, is het te weinig... *zucht*


  • Alarmnummer
  • Registratie: Juli 2001
  • Laatst online: 09-07-2024
Bbfreak schreef op zaterdag 13 augustus 2005 @ 00:12:
Bij dit onderwerp zie je goed het verschil tussen je opdrachtgever en de programmeurs.
De 1 wil resultaat en de ander resultaat en een goed design.
De meeste programmeurs hechten aan design heel veel waarde en zeker hier soms (te) veel tijd in,
als de applicatie niet te groot is.
Uiteindelijk is het soms best frustrerend dat hier niet altijd naar gekeken wordt.
Phantom requirments blijken op de korte termijn een obstakel terwijl deze later misschien van pas komen.
En hier zit exact het probleem. Op het moment dat een klant niet gevraagd heeft om deze uitbreidbaarheid, waarom zou je het er dan inbouwen? De prijs van de opdracht kan omlaag en je winst gaat omhoog. Als je naar een garage zou gaan om een nieuwe band op te halen, zou jij het dan accepteren als er dan druk meters voor de banden waren geinstalleerd en 4wd omdat het in de toekomst wel eens handig zou kunnen zijn? Op het moment dat een klant heeft aangegeven dat hij wil rally racen, dan vind ik het een logische suggestie. Maar op het moment dat hij alleen maar wil autorijden, dan vind ik het diefstal.

Ik zou dat niet pikken en voor een klant geld hetzelfde. Wees niet bang dat ik een applicatie onnodig allerlei beperkingen op zou leggen. Maar ik probeer me steeds beter te realiseren wat strict noodzaak is en wat niet. Ik zie een systeem als een aantal schillen, waarbij iedere nieuwe schil concreter is. En ik probeer zaken die richting het centrum zitten (dus minder opdracht specifiek) herbruikbaar te maken. Iedere ontwerp fout die meer richting het centrum zit, zal steeds grotere gevolgen hebben voor de bovenliggende ringen. Maar zaken die aan de buitenkant zitten is niet zoveel van afhankelijk, dus een wijziging daar is relatief goedkoop. Daarom probeer ik deze zaken ook zo efficient mogelijk op te zetten qua tijd en geen onnodige uitbreidbaarheid te introduceren. Niemand gaat deze buitenste schil hergebruiken.. waarom dan de moeite erin steken? Niemand zal in de buitenste ringen fundamentele wijzigingen (zoals het switchen van de or mapper) doorvoeren. Waarom dan deze onnodige abstractie aanbrengen die verder totaal niet abstract te maken valt door allerlei or-mapper specfieke zaken wat je toe moet voegen.

Verder wil ik met dit topic mensen (ook mezelf) proberen duidelijk te maken om na te denken waarom je dingen doet zoals je ze doet. Niet omdat je het zo hebt geleerd, maar omdat je begrijpt en kunt beargumenten waarom dingen zijn zoals ze zijn. En als je je realiseert dat dingen te complex zijn, dat je dit ook kunt wijzigen en niet als een kip zonder kop op een wilde stier aan het doorrijden gaat, alleen omdat je het zo hebt geleerd.

[ Voor 25% gewijzigd door Alarmnummer op 13-08-2005 00:40 ]


  • misfire
  • Registratie: Maart 2001
  • Laatst online: 12-10-2024
Hier wordt er vanuit gegaan dat phantom requirements iets negatiefs zijn, maar volgens mij zijn ze het gevolg van verkeerde zaken in andere onderdelen van het project.

Voorbeeld: wie betrekt in software ontwikkeling beheerders als stakeholders bij het project? Neemt de software architect beslissingen in overleg met de klant? Schrijf je fouten weg naar een logbestand?

Een project kent veel meer stakeholders dan alleen de klant. Requirements kunnen van al die stakeholders komen. De opdrachtgever zal uiteindelijk moeten bepalen welke requirements moeten worden geïmplementeerd, zodat de belangen van stakeholders goed worden belegd, maar het project wel binnen redelijke grenzen van tijd en budget kan worden afgerond.

Leuke theorie, maar in de praktijk werkt een opdrachtgever vaak niet zo. Hij kijkt voornamelijk naar tijd en geld, en meestal slechts naar een beperkt aantal stakeholders. Daarom ontstaan phantom requirements: men vindt wel dat er met bepaalde zaken rekening moet worden gehouden, maar kan/wil dit niet expliciet maken. Dat is uiteindelijk de bron van ellende, en is een veel breder probleem dan alleen "techneuten die op zoek zijn naar een heilige graal".

Ik heb deze problemen gezien bij designers die een algemene look & feel af willen dwingen terwijl dit geen wens is van de klant, testafdelingen die bepaalde zeer tijdrovende testen willen doen zonder dat dit expliciet wordt besproken met opdrachtgevers, analisten die vinden dat de applicatie ook moet werken voor blinden enz. Allemaal prima dat zij vinden dat het nodig is, maar het wordt niet expliciet besproken en opgenomen in de lijst van requirements, en niet met een expliciet fiat uitgevoerd. Gevolg: project loopt uit planning en budget.

Nu zul je vast denken: maar dat is de schuld van die mensen, niet van de opdrachtgever. Dat is meestal wat genuanceerder. De opdrachtgever heeft vaak te weinig inhoudelijke kennis, of voelt zich niet betrokken bij sommige stakeholders. Daarom kan/wil de opdrachtgever geen gedegen afweging maken, en schiet automatisch alles af. Vaak worden gebruikers, beheerders, testers, ontwikkelaars, enz. niet eens als een aparte stakeholder benoemd en dan hebben ze uberhaupt niet direct contact met de opdrachtgever.

Uiteindelijk zul je een sterke opdrachtgever en een sterke opdrachtnemer nodig hebben om het proces van bepalen van stakeholders, requirements en het al dan niet implementeren ervan in goede banen te leiden. Dan kun je onderhandelen met een open vizier en phantom requirements minimaliseren.

Dat wil dus allemaal niet meteen zeggen dat phantom requirements slecht zijn. Misschien is de requirement wel heel goed en heel nodig. Van een phantom requirement is simpelweg nog niet bepaald of het nodig is of niet. In de dagelijkse praktijk zie ik ze niet als iets dat ik per sé wil voorkomen. Soms is het handig om een phantom requirement gewoon te implementeren en op basis daarvan de discussie te starten met stakeholders, als een soort prototyping. Soms helpen phantom requirements bepaalde processen in het project. Het voorbeeld van DAO abstractie vind ik bijvoorbeeld heel nuttig, want als de database specifieke code apart wordt gehouden gaat unit testen een stuk gemakkelijker.

Als het netto effect voor tijd en budget neutraal is of een verbetering dan kan ik me best voorstellen dat de opdrachtgever dit niet expliciet hoeft te maken. Vergaderen met opdrachtgevers kost ook tijd en geld, en als de ervaring is dat dit erg moeilijk is en lang duurt dan is de afweging om sommige dingen onder de radar te doen niet altijd zo ongezond. Maar het is imho wel symptoom bestrijding en geen echte oplossing van het probleem. En je moet wel opletten dat je goed weet waarom sommige dingen onder de radar gebeuren, om te voorkomen dat men onder de radar op zoek gaat naar heilige gralen.

Verwijderd

Ik snap heel goed waarom je zegt wat je zegt en ben het met een aantal dingen eens, maar met een aantal andere dingen niet.

In je verhaal over stakeholders zeg je onder andere:
Daarom kan/wil de opdrachtgever geen gedegen afweging maken, en schiet automatisch alles af. Vaak worden gebruikers, beheerders, testers, ontwikkelaars, enz. niet eens als een aparte stakeholder benoemd en dan hebben ze uberhaupt niet direct contact met de opdrachtgever.
Mijns inziens is de aannemer (zoals een interne afdeling danwel extern bedrijf) wel een stakeholder, maar die zou interne organisatie moeten afschermen, waardoor ontwikkelaars of testers nooit en te nimmer een stakeholder worden in de eisen van een softwareproject.

Om even een vergelijking te maken: als ik bijvoorbeeld een keuken bestel en laat plaatsen, zijn de monteurs die de keuken moeten monteren geen stake holders. Ik verwacht dat de leverancier de keuken plaatst op de manier als overeengekomen voor de prijs waarvoor het overeen gekomen is en op het moment dat het overeen gekomen is. Als 1 van de monteurs bijvoorbeeld maar een halve dag kan werken, verwacht ik dat er een andere monteur geregeld wordt zodat de plaatsing geen vertraging oplevert. De organisatie van de realisatie is een verantwoordelijkheid voor de aannemer en moet nooit invloed hebben op de overeenkomst met de opdrachtgever.

Mbt het beheer is het een andere zaak, aangezien de verantwoordelijkheid en kosten uiteindelijk (in ten minste de meeste gevallen) bij de opdrachtgever zelf komen te liggen. Daarom moeten de beheersaspecten van een systeem zeker onderdeel zijn het eisenpakket en zijn de beheerders zeker stake holders, hoewel ze vaak te weinig als zodanig erkent worden.
Ik heb deze problemen gezien bij designers die een algemene look & feel af willen dwingen terwijl dit geen wens is van de klant, testafdelingen die bepaalde zeer tijdrovende testen willen doen zonder dat dit expliciet wordt besproken met opdrachtgevers, analisten die vinden dat de applicatie ook moet werken voor blinden enz. Allemaal prima dat zij vinden dat het nodig is, maar het wordt niet expliciet besproken en opgenomen in de lijst van requirements, en niet met een expliciet fiat uitgevoerd. Gevolg: project loopt uit planning en budget.

Nu zul je vast denken: maar dat is de schuld van die mensen, niet van de opdrachtgever. Dat is meestal wat genuanceerder. De opdrachtgever heeft vaak te weinig inhoudelijke kennis, of voelt zich niet betrokken bij sommige stakeholders. Daarom kan/wil de opdrachtgever geen gedegen afweging maken, en schiet automatisch alles af. Vaak worden gebruikers, beheerders, testers, ontwikkelaars, enz. niet eens als een aparte stakeholder benoemd en dan hebben ze uberhaupt niet direct contact met de opdrachtgever.
Eigenlijk lijk je te zeggen dat de klant tegen zijn eigen beperkingen in bescherming genomen moet worden, en dat daarom phantom requirements ontstaan. De kosten die voortvloeien uit het realiseren van dergelijke eisen stromen alsnog door naar de klant, want als besluit of onbewust worden deze dus alsnog gerealiseerd, met als verklaring dat de klant er uiteindelijk wel beter mee af is.

Eerlijk gezegd klinkt dat een beetje als een garagehouder die tijdens een grote beurt aan je auto meer werk doet dan afgesproken en je met een stevige rekening opzadelt, met als argument: "Ja meneertje, je kunt maar beter voorkomen dat het kapot gaat." Wellicht heeft hij gelijk, maar ik wil als klant zelf een dergelijke beslissing nemen, eventueel op advies van een garagehouder.

Op deze manier wordt je als aannemer verantwoordelijk voor de bedrijfsvoering van de klant, en daardoor zal er nooit een lerend effect zijn, waarbij de klant zich realiseert dat goedkoop soms duurkoop is. Daarnaast zal je uiteindelijk vaak buiten de boot vallen, omdat er mensen zijn die wel precies de requirements kunnen volgen voor een lagere prijs.

Ik ben een groot voorstander van een heel goed en degelijk voortraject waarin je het beslissingstraject van de klant ondersteunt, maar als de klant bewust beslist weinig tot geen beheersfunctionaliteit in te bouwen, dan is hij zelf verantwoordelijk voor de gevolgen. Vaak zal de foute beslissing dan alsnog met meerwerk worden rechtgezet. Juist als je dingen gaat verzwijgen voor je klant ben je bezeig hem te vervreemden van jou en je product / dienst.

Het probleem in de ICT sector is dat we juist te vaak de klant een hand boven hun hoofd houden en uiteindelijk de budgetoverschrijdingen die voortvloeien uit slechte beslissingen delen of zelfs volledig op ons nemen, omdat er ook nooit duidelijke afspraken zijn geweest over wat we wel danwel niet leveren. Daarmee snijden we onszelf in de hand en ontnemen we de klant een leermoment.

Ik ben het met je eens dat begrip van ICT nog steeds beschamend laag is bij de gemiddelde manager, maar dat is niet omdat het zo super complex is, maar omdat ze niet voldoende aandacht eraan besteden, veel ICTers niet management taal spreken of zelfs weigeren dat te doen, omdat er vanuit managementkant te weinig wordt vertrouwd op ICT functionarissen en omdat de meeste managers van interne ICT afdelingen vaak onkundige eikels zijn die zich met glad maar onbegrijpelijk technisch gebrabbel op hebben gewerkt naar die positie en natuurlijk nooit meer weggaan aangezien hun salaris schandalig afsteekt bij hun werkelijke kennisnivo. Dit zijn allemaal problemen die verholpen kunnen worden, maar dat zal pas gebeuren bij de nodige prikkels, zoals een mislukt project.

Een bedrijf moet zijn eigen bedrijfsmiddelen goed bergijpen en beheersen en er is geen excuus voor als ze dat niet doen. Bedrijven zijn ontzettend afhankelijk geworden van ICT, en totdat ze dat realiseren en integreren in hun beslissingsproces, zullen ze fouten maken. En juist daardoor zullen ze gaan begrijpen hoe de vork in de steel steekt. Een Britse vriend van mij en een enorme topper op management consultancy zei ooit tegen mij: "The customer gets what he pays for: if he pays shit, he gets shit, and he'll think twice the next time around."

Verwijderd

Ik denk dat Phantom requirements ook een middel zijn van programmeurs om zichzelf in te dekken. Iedereen die software ontwikkeld voor de markt kent het wel, dat de requirements van een product ingrijpend kunnen wijzigen, of dat er in een sales traject toch iets ander is beloofd. Meestal wordt het resultaat van een dergelijk probleem bij de programmeurs gedumpt, los het maar op, morgen moet het af. Het is niet de situatie hoe die moet zijn, maar wel de situatie zoals die bij veel bedrijven naar voren komt.

Een programmeur dekt zich dan in door in een vroeg stadium al rekening te houden met additionele requirements en gaat dan zijn applicatie defensief designen. Ik denk dat dit ook een reden is van phantom requirements, zelf bescherming.

  • alienfruit
  • Registratie: Maart 2003
  • Laatst online: 18-04 05:37

alienfruit

the alien you never expected

alienfruit moppelt iets van programmeurs zijn toch niet belangrijk, maar de psychologen en interface designers zijn belangrijk :+ Moppelt verder over Gestalt-theorie, perceptie, de eye movement hypothese.

[ Voor 24% gewijzigd door alienfruit op 14-08-2005 15:49 ]


  • misfire
  • Registratie: Maart 2001
  • Laatst online: 12-10-2024
Verwijderd schreef op zondag 14 augustus 2005 @ 04:51:
In je verhaal over stakeholders zeg je onder andere:
[Ontwikkelaars, testers en beheerders kunnen ook stakeholders zijn]

Mijns inziens is de aannemer (zoals een interne afdeling danwel extern bedrijf) wel een stakeholder, maar die zou interne organisatie moeten afschermen, waardoor ontwikkelaars of testers nooit en te nimmer een stakeholder worden in de eisen van een softwareproject.

Om even een vergelijking te maken: als ik bijvoorbeeld een keuken bestel en laat plaatsen, zijn de monteurs die de keuken moeten monteren geen stake holders. Ik verwacht dat de leverancier de keuken plaatst op de manier als overeengekomen voor de prijs waarvoor het overeen gekomen is en op het moment dat het overeen gekomen is. Als 1 van de monteurs bijvoorbeeld maar een halve dag kan werken, verwacht ik dat er een andere monteur geregeld wordt zodat de plaatsing geen vertraging oplevert. De organisatie van de realisatie is een verantwoordelijkheid voor de aannemer en moet nooit invloed hebben op de overeenkomst met de opdrachtgever.
Je zou inderdaad voor de interne projectorganisatie een gedelegeerd opdrachtgever aan kunnen wijzen die als één partner met de echte opdrachtgever overlegd. Dat is een opzet die je wel vaker ziet en ook in sommige methodieken wordt aangedragen. Hoe je het uiteindelijk regelt maakt volgens mij niet zo heel veel uit, zolang je maar expliciet omgaat met requirements voor architectuur, opleiding, testen, beheer, enz. moet je phantom requirements kunnen voorkomen.

Om jouw voorbeeld te gebruiken: de installateur zal in zijn schema kijken en een dag met jou afspreken die uitkomt in zijn rooster, eventueel in combinatie met een monteur-in-opleiding en vakantietijden. Jij mag alleen kiezen uit een aantal standaard keukens met een aantal standaard opties. De installateur zal een bepaald bedrag vooraf vragen en als de keuken voltooid is. Jij hebt de garantie dat eventuele gebreken binnen 6 weken kosteloos worden gerepareerd, maar je moet die gebreken wel zelf kenbaar maken. In dit voorbeeld zijn monteurs, keukenleveranciers, de opdrachtgever en de opdrachtnemer specifieke stakeholders met elk een eigen belang. Een gedeelte van de afwegingen wordt gemaskeerd voor de opdrachtgever, maar ze worden wel expliciet meegenomen in de gemaakte afspraken.

Helaas is een gemiddeld software-ontwikkelproject iets ingewikkelder als het installeren van een keuken, en zijn er vaak complicaties omdat de gebruikersbehoefte nog niet duidelijk is, weinig ervaring met een bepaalde techniek, enz. enz. Als jij een installateur belt met de vraag of ze een keuken willen leveren, maar je weet nog niet of ie wit of zwart moet zijn, of je wilt een type wat de installateur niet kent, dan zal het verhaal voor hem (en ook voor jou) ook een stuk ingewikkelder worden. :) Een installateur zal dan waarschijnlijk zeggen: "bel maar terug als je weet welke kleur het moet worden", in een ontwikkelproject is de kleur bepalen juist een onderdeel van de activiteiten. Software-ontwikkeling wordt wel vaker vergeleken met garages en keukens maar die vergelijking gaat maar voor een gedeelte op.
Mbt het beheer is het een andere zaak, aangezien de verantwoordelijkheid en kosten uiteindelijk (in ten minste de meeste gevallen) bij de opdrachtgever zelf komen te liggen. Daarom moeten de beheersaspecten van een systeem zeker onderdeel zijn het eisenpakket en zijn de beheerders zeker stake holders, hoewel ze vaak te weinig als zodanig erkent worden.
Moet beheer de applicatie kunnen onderhouden en kunnen uitbreiden met nieuwe functionaliteit? Het testen van de applicatie voor de oplevering (de acceptatietest) gebeurt vaak door mensen van de opdrachtgever. Dit zijn meestal gebruikers, maar die hebben dan wel de rol van testers. Ik hoor regelmatig: "dat kunnen we niet testen, want dat is veel te moeilijk". Als tester, maar ook als opdrachtgever zou ik het erg belangrijk vinden dat je zo veel mogelijk testbaar maakt. Beheerders zijn voor de meesten een duidelijke stakeholder (die vaak alsnog vergeten wordt), maar voor mij niet een partij die significant belangrijker is dan andere (interne) stakeholders.
[...]
Eigenlijk lijk je te zeggen dat de klant tegen zijn eigen beperkingen in bescherming genomen moet worden, en dat daarom phantom requirements ontstaan. De kosten die voortvloeien uit het realiseren van dergelijke eisen stromen alsnog door naar de klant, want als besluit of onbewust worden deze dus alsnog gerealiseerd, met als verklaring dat de klant er uiteindelijk wel beter mee af is.
Nee ik zeg dat de situatie nu is dat de klant/opdrachtgever het vaak zelf niet kan of niet wil beslissen. Ik ben het niet eens met die situatie. Het gaat er mij alleen om dat als je discussieert over phantom requirements je de totale dynamiek moet zien van het requirementsproces, en hierin speelt de (on)kunde van de opdrachtgever een zeer grote rol.
Eerlijk gezegd klinkt dat een beetje als een garagehouder die tijdens een grote beurt aan je auto meer werk doet dan afgesproken en je met een stevige rekening opzadelt, met als argument: "Ja meneertje, je kunt maar beter voorkomen dat het kapot gaat." Wellicht heeft hij gelijk, maar ik wil als klant zelf een dergelijke beslissing nemen, eventueel op advies van een garagehouder.
De garagehouder beslist zelf of hij een brug installeert in zijn garage (duur) of een put (goedkoop), welk gereedschap hij gebruikt, enz. Op dat soort strategische beslissingen heb je als klant geen invloed. Ik stel dat de opdrachtgever niet overal in hoeft worden betrokken, mits belangen van stakeholders niet worden geschaad (bijvoorbeeld doordat het duurder wordt of langer duurt), én als het duidelijk is dat het significant veel moeite zou kosten om de opdrachtgever wél te betrekken. Als ik bij een garage een maand moet wachten voor mijn auto omdat ze speciaal voor mijn reparatie een brug aanschaffen, en ik moet de volle meerprijs voor de brug betalen, dan wil ik ook graag hier van te voren over beslissen.
Ik ben een groot voorstander van een heel goed en degelijk voortraject waarin je het beslissingstraject van de klant ondersteunt, maar als de klant bewust beslist weinig tot geen beheersfunctionaliteit in te bouwen, dan is hij zelf verantwoordelijk voor de gevolgen. Vaak zal de foute beslissing dan alsnog met meerwerk worden rechtgezet. Juist als je dingen gaat verzwijgen voor je klant ben je bezeig hem te vervreemden van jou en je product / dienst.
Ik noem het verzwijgen ook symptoombestrijding, ik vind het ook geen gezonde situatie. Het verband wat ik leg is puur om de oorzaak aan te geven, niet om de situatie goed te praten. Het punt wat ik wilde maken dat het niet _alleen_ techies zijn die aan het over-engineeren zijn (alhoewel dat absoluut wel regelmatig voorkomt). Phantom requirements zijn een veel breder probleem en hebben een diepere oorsprong. Over-engineerende technies zou ik zien als een gevolg voor een phantom-requirements probleem, niet als oorzaak.
Het probleem in de ICT sector is dat we juist te vaak de klant een hand boven hun hoofd houden en uiteindelijk de budgetoverschrijdingen die voortvloeien uit slechte beslissingen delen of zelfs volledig op ons nemen, omdat er ook nooit duidelijke afspraken zijn geweest over wat we wel danwel niet leveren. Daarmee snijden we onszelf in de hand en ontnemen we de klant een leermoment.
Juist, alhoewel opdrachtnemers zelf vaak ook niet vies zijn van vage planningen en budgetten. Wat ik erg frappant vind is dat de huidige markt een tegenovergestelde beweging maakt. De gemiddelde klant lijkt liever te horen dat er voor 1 miljoen "iets" wordt gemaakt, dan dat er voor 4 miljoen een duidelijk gedefinieerd product wordt opgeleverd. Ik heb zelf aan dergelijke offertetrajecten met klanten aan tafel gezeten en het is echt lastig om hiermee te concurreren. Als je uiteindelijk dan mensen kunt overtuigen waarom dat je vindt dat iets 4 miljoen gaat kosten dan zijn er bijvoorbeeld nog allerlei bizare Europese aanbestedingsregels, accountants en directeuren, die voornamelijk op de hoogte van de offerte beslissen, niet op inhoud.
Ik ben het met je eens dat begrip van ICT nog steeds beschamend laag is bij de gemiddelde manager, maar dat is niet omdat het zo super complex is, maar omdat ze niet voldoende aandacht eraan besteden, veel ICTers niet management taal spreken of zelfs weigeren dat te doen, omdat er vanuit managementkant te weinig wordt vertrouwd op ICT functionarissen en omdat de meeste managers van interne ICT afdelingen vaak onkundige eikels zijn die zich met glad maar onbegrijpelijk technisch gebrabbel op hebben gewerkt naar die positie en natuurlijk nooit meer weggaan aangezien hun salaris schandalig afsteekt bij hun werkelijke kennisnivo. Dit zijn allemaal problemen die verholpen kunnen worden, maar dat zal pas gebeuren bij de nodige prikkels, zoals een mislukt project.
Het één werkt het ander in de hand, en er valt inderdaad nog genoeg te verbeteren op het gebied van kennis en kunde in de ICT. Ik ben zelf een gelover van Scott Adams's Dilbert Principle. De stelling die in de Dilbert Principle wordt verdedigd luidt: "All people are idots". Als je er vanuit gaat dat iedereen een idioot is dan is het niet voldoende om vast te stellen dat het huidige systeem niet werkt omdat er te veel idioten zijn. Je zult dan op een andere manier moeten werken die wel functioneert ondanks dat het idioten zijn. In de Dilbert Principle wordt dit toegelicht met grappige en heldere voorbeelden die laten zien dat je het inherent idioot zijn van mensen ook kunt gebruiken voor positieve doeleinden.
Een bedrijf moet zijn eigen bedrijfsmiddelen goed bergijpen en beheersen en er is geen excuus voor als ze dat niet doen. Bedrijven zijn ontzettend afhankelijk geworden van ICT, en totdat ze dat realiseren en integreren in hun beslissingsproces, zullen ze fouten maken. En juist daardoor zullen ze gaan begrijpen hoe de vork in de steel steekt. Een Britse vriend van mij en een enorme topper op management consultancy zei ooit tegen mij: "The customer gets what he pays for: if he pays shit, he gets shit, and he'll think twice the next time around."
Daar ben ik het absoluut mee eens. Gelukkig worden de strategische voordelen van goede ICT steeds belangrijker voor de marktposities van bedrijven, waardoor de aandacht en noodzaak van goede ICT voorzieningen steeds verder stijgt. Zolang het voor de klant maar duidelijk blijft dat hij niet alleen geld moet pay-en, maar ook moet investeren in kennis en aandacht voor zijn ICT projecten. Genoeg geld alleen garandeert geen shit-vrij project.
Pagina: 1