Volg de onderstaande video om te zien hoe je onze site als web-app op je startscherm installeert.
Opmerking: Deze functie is mogelijk niet beschikbaar in sommige browsers.

)YellinD zei:ik heb nog nooit gewerkt als software tester, ik weet maar 1 ding:
iedereen HAAT testen...![]()
Stimpy zei:jij werkt voor een bedrijf ergens op de woluwelaan mss?![]()

QplQyer zei:Ik vraag mij altijd af bij die functies ... of daar tools zoals model checkers (SPIN, TCL, ...), theorem provers (VDM++,Isabelle/HOL,Coq,Perfect Developer...) enzo ooit gebruikt worden?
Lijkt me dat die "architects", om het met een duur woord te zeggen, beter al hun design formeel zouden beschrijven en laten checken door een model checker of een theorem prover, waarna de testers het ook gemakkelijker zouden hebben om een automatische test te laten genereren uit de specificaties.
Wel ja, ik weet dat het in theorie zeker mogelijk is, maar vroeg mij vooral af in hoeverre die testing functies die je wel eens bij vacatures ziet wel iets inhouden van de zogenaamde "formele methoden". Aangezien ik daar vaak het profiel van prof. bachelor in de informatica zag passeren leek me dat kennis van dergelijke technieken niet echt nodig was en die technieken en tools dus zeker niet door testers werden gebruikt. Tenzij prof. bachelors dingen zien over model checking, specificaties, valideringen etc, maar voor zover ik weet heb ik dat toch nog nooit ergens in zo'n opleiding zien staan.Mooncat zei:
.Afhankelijk van wat je testing noemt is het nu niet zo erg jong: model checking bv. bestaat al sinds de jaren '80. En dat is in principe een vorm van geautomiseerd testen.Het probleem met testautomatisatie en testing in het algemeen, is dat het nog vrij jong is.
Daar ben ik het niet met eens eigenlijk.Testautomatisatie is momenteel dus enkel nuttig voor testen waar je een bepaalde waarde moet vergelijken en is dus erg nauw. Testen op het gebied van lay-out, usability, taal, inhoud, ... zullen nooit geautomatiseerd kunnen worden.
Dat is inderdaad een probleem. Alhoewel er reeds boeken zijn verschenen die tonen hoe formele methoden kunnen passen in bv. een "agile development" (ik heb iets tegen buzzwords) omgeving (de Software Engineering reeks van Bjorn Diner heeft daar een stuk over als ik mij niet vergis).In de toekomst kan en zal testautomatisatie een belangrijke rol spelen, maar er zal dan een groter onderscheid moeten komen tussen black box en white box tester dan nu. Werken met modellen en state transition diagrams wordt nu nog zelden gedaan, maar kan bijvoorbeeld heel erg nuttig zijn voor het testen van embedded software.
Het probleem van testing is eigenlijk dat het nu wordt beschouwd als een aanhangsel in het ontwikkelingsproces en niet iets als een volwaardig onderdeel van de development life cycle. Wanneer die bewustwording er wel komt, kunnen bestaande methoden worden aangepast om testing te formaliseren en te integreren in development zoals nu al scrum en extreme programming wordt gebruikt in agile development.
QplQyer zei:Daar ben ik het niet met eens eigenlijk.
Op het gebied van lay-out kan zeker testautomatisatie komen: een bepaalde lay-out vorm die ongewenst is en die plots tevoorschijn komt kan gedetecteerd worden. Een vereiste is dat gekend is aan welke regels een goede lay-out moet voldoen. Hetzelfde geldt voor usability, het enige wat nodig is, zijn formele regels die zeggen wanneer iets usable is. Met behulp van vaaglogica kunnen we dan eventueel zeggen dat een programma voor 90% als usable kan worden beschouwd, wat dan eventueel voldoende zou zijn.
Voor één welbepaald product schiet het zijn doel voorbij, maar op lange termijn niet. Het lijkt me dat lay-out en usability regels redelijk algemeen kunnen worden gehouden en transporteerbaar naar andere programma's.Mooncat zei:Nu spreek ik voor m'n eigen werk, maar het probleem van usability en lay-out is dat het niet altijd exact is, wat het moeilijk maakt om die te formaliseren. Je moet echt op 1001 details letten waardoor het eigenlijk onbegonnen werk is om dat allemaal in regels te gieten en streef je je doel voorbij als je alles zou formaliseren. Het bespaart immers meer tijd om dit manueel te doen.
QplQyer zei:Voor één welbepaald product schiet het zijn doel voorbij, maar op lange termijn niet. Het lijkt me dat lay-out en usability regels redelijk algemeen kunnen worden gehouden en transporteerbaar naar andere programma's.
Specifieke fine-tuning voor eventuele extra vereisten van een bepaald programma moet natuurlijk ook nog blijven gebeuren.
De inexactheid van de regels maakt vaaglogica bijvoorbeeld een ideale kandidaat om te gebruiken bij het formaliseren.
Menselijke controle blijft nog altijd nodig, maar het kan wel helpen als een machine al veel lay-out en usability schendingen kan oplossen.
Ik heb nergens gezegd dat het volledig formeel beschreven moet worden. In een discussie over of "computer science" een "science" of een "art" is ga ik mij nu niet direct storten, maar laat ons zeggen dat het van beide heeft (en naar mijn mening dat het meer van een toegepaste wetenschap zou kunnen hebben, maar momenteel bijlange nog niet heeft).[BAT] Hydra;9781135 zei:Een groot systeem of programma maken is niet iets dat volledig formeel beschreven kan worden. Goed programmeren en designen is een kunst, geen exacte wetenschap. Formele verificatie kan enkel efficient zijn tot op een bepaald niveau. Als jij een goede lay-out checker kan schrijven, compatibel met een veelgebruikte technologie en spreektaal, die een aanzienlijke meerwaarde heeft tov. van een mens dan ben jij mijn held!
Ik weet niet of er nu al tools bestaan die dergelijke tests kunnen doen. Maar ik bedoelde dat het mij in principe perfect mogelijk lijkt om zoiets semi te automatiseren (zoals ik zei blijft menselijke controle wel nog altijd nuttig, maar een automatische test kan het werk verlichten van de tester en een groter vertrouwen in het systeem voortbrengen). Een programma blijft immers niets meer dan wat sourcecode, als je de sourcecode hebt kan je bepaald gedrag controleren (als je de sourcecode niet hebt is het inderdaad lastiger, dan zou je al muisklikken moeten gaan emuleren met een ander programma, alhoewel ook dat me wel mogelijk lijkt).Wat ik dagelijks doe is functionele tests op webapplicatie's.
Daar kan je voor zover ik weet geen testautomatisatie doen?
De verschillende schermen waar de gebruiker moet doorlopen veranderen constant van lay out. De enige manier afaik om layout testen te automatiseren is dmv play and record tools. De effort die je daar insteekt gaat nooit het gewenste resultaat opleveren omdat alle grafische elementen van een webapplicatie constant veranderen.
Bedrijf waar ik zit heeft op 1 jaar tijd 4 keer van layout geswitched ^^.
QplQyer zei:Ik weet niet of er nu al tools bestaan die dergelijke tests kunnen doen. Maar
ik bedoelde dat het mij in principe perfect mogelijk lijkt om zoiets semi te
automatiseren (zoals ik zei blijft menselijke controle wel nog altijd nuttig,
maar een automatische test kan het werk verlichten van de tester en een groter
vertrouwen in het systeem voortbrengen). Een programma blijft immers niets meer
dan wat sourcecode, als je de sourcecode hebt kan je bepaald gedrag controleren
(als je de sourcecode niet hebt is het inderdaad lastiger, dan zou je al
muisklikken moeten gaan emuleren met een ander programma, alhoewel ook dat me
wel mogelijk lijkt).
Niemand zegt dat de omgeving niet meer mag veranderen. Mijns inziens zijn er universele constraints die men kan opleggen aan GUI's voor specifieke toepassingen die voor elke toepassing kunnen gebruikt worden. Daarnaast kan men bij verandering ook additionele constraints opleggen die erbij zijn gekomen door de veranderingen. De oude kan men dan eventueel verwijderen, of controleren of ze nog steeds voldaan zijn (in principe verschilt dat niet veel met het testen van het oud gedrag bij een update).chine zei:in een omgeving die niet meer verandert is dat mss wel heel handig, maar de applicaties zijn te specifiek om bepaalde gedragingen te generaliseren.
dus de effort die je erin steekt ga je er nooit uithalen ^^
dus wrm doen ?
QplQyer zei:Niemand zegt dat de omgeving niet meer mag veranderen. Mijns inziens zijn er universele constraints die men kan opleggen aan GUI's voor specifieke toepassingen die voor elke toepassing kunnen gebruikt worden. Daarnaast kan men bij verandering ook additionele constraints opleggen die erbij zijn gekomen door de veranderingen. De oude kan men dan eventueel verwijderen, of controleren of ze nog steeds voldaan zijn (in principe verschilt dat niet veel met het testen van het oud gedrag bij een update).
Het controleren kan via statische en/of dynamische analyse gebeuren.chine zei:ja maar hoe check je of aan die constraints voldaan is dan ?
en wat zouden dan universele constraints zijn ?
plus wat doen je als je eerst door een flow moet voor je layout kan checken ? muisklikken emuleren zou tof zijn maar dan zit je weer met de zever als die knop verplaatste wordt of zo d: