[ALG] modulair programmeren > Hoe documenteren?

[supertheiz]

Ik wordt gek! Ik probeer een stukje code functioneel te beschrijven (ja, soms doe je dat achteraf.. )

vanaf de eerste methode worden er 20 'lagen' aan methodes aangeroepen. Methode 1 roept methode 2 aan, die roept weer nr 3 aan, etc.

Dat is gewoon niet te documenteren!! Heeft iemand ervaring hoe het nog enigzins te doen is?

[robbert]

Sja, (als ik het netjes wil doen) maak ik een mooi uml klasse diagram waar ik alles qua overerving, aggregatie, etc aan geef. Vervolgens geef ik in de code per methode en klass aan wat het doet (in javadoc style); voor methodes ook wat de parameters zijn, wat het terug geeft en wat voor een excepties er kunnen optreden. Als je dan echt netjes wil zijn kun je ook nog precondities, postcondities en invarianten op gaan schrijven.

In principe zal de mensen die met jouw code gaan werken het worst zijn wat er in bepaalde methodes gebeurt (dus welke andere methodes en allemaal aangeroepen worden), zolang ze maar kunnen begrijpen wat die methode nou daadwerkelijk doet en waar ze het mogen/moeten gebruiken.

[ Voor 46% gewijzigd door robbert op 09-08-2007 16:02 ]

[supertheiz]

Dat is het probleem: Is niet mijn code dus ik moet gaan reverse engineren.
Is een stukje SAP met 40 user exits welke allemaal weer andere methodes aanroepen.

Die 40 exits zijn ongeveer 120 A4-tjes met code, inclusief de aangeroepen methodes denk ik ongeveer 500 A4-tjes. Hierbij zijn amper comments geplaatst en is door de programmeur (consultant van SAP Nederland...) als documentatie een boekje van 5 pagina's aangemaakt waarin ook nog eens bijvoorbeeld de target audiance is beschreven.

Je begrijpt dat voordat we iets in de code kunnen aanpassen eerst moeten documenteren door reverse engineren.

Aangezien ABAP niet veel afwijkt van bijvoorbeeld C heb ik het topic als ALG aangemaakt.

Ik ga eens op zoek naar een UML plugin voor ABAP.
THNKS!!!

[JKVA]

supertheiz schreef op donderdag 09 augustus 2007 @ 16:14:
Dat is het probleem: Is niet mijn code dus ik moet gaan reverse engineren.
Is een stukje SAP met 40 user exits welke allemaal weer andere methodes aanroepen.

Die 40 exits zijn ongeveer 120 A4-tjes met code, inclusief de aangeroepen methodes denk ik ongeveer 500 A4-tjes. Hierbij zijn amper comments geplaatst en is door de programmeur (consultant van SAP Nederland...) als documentatie een boekje van 5 pagina's aangemaakt waarin ook nog eens bijvoorbeeld de target audiance is beschreven.

Je begrijpt dat voordat we iets in de code kunnen aanpassen eerst moeten documenteren door reverse engineren.

Aangezien ABAP niet veel afwijkt van bijvoorbeeld C heb ik het topic als ALG aangemaakt.

Ik ga eens op zoek naar een UML plugin voor ABAP.
THNKS!!!

Ik denk niet dat je er met een klassediagram helemaal uit zal komen. Uit jouw TS begrijp ik dat de complexiteit niet in de klassestructuur zit, maar in de interactie en dynamiek. Als dat zo is, heb je aan een klassediagram vrijwel niets, want een klassediagram beschrijft de statische structuur van je systeem.

Ik zou eerder denken aan activity of sequence diagrams. Een state diagram kan ook handig zijn.

Klassediagram blijf je overigens nodig hebben, al is het maar als input voor bovenstaande diagrammen.

Als je iets meer input levert over je probleem, kunnen we misschien iets gedetailleerder uitleggen welke diagrammen nuttig zijn. Ze hebben namelijk allemaal hun eigen toepassingsgebied.

http://en.wikipedia.org/w...odeling_Language#Diagrams

[drm]

Misschien ook het overwegen waard om eens een good old dfd te maken?

[flowerp]

Naast de al genoemde activity- en sequence diagrams, alsmede inderdaad de goede oude dataflow diagram, wil het mij ook nog wel eens helpen om gewoon voor een aantal cases een call-hierarchy te maken.

Afhankelijk van hoe de source-code met de rest van het systeem omgaat kun je vanaf het 'begin' beginnen en telkens bij elke functie call de naam van de functie opschrijven met een pijltje vanaf de aanroepende functie. Je kunt ook bij een 'exit point' beginnen en dan terug werken.

Hoe het in SAP gaat weet ik niet, maar bij b.v. Java of C++ kan je IDE je daar dikwijls een flink stuk mee helpen. Het meest eenvoudige is om gewoon door de code te steppen terwijl je je diagrammen tekent. Leer je ook nog dikwijls vrij veel van. Andere mogelijkheid is dat je IDE functies biedt om een call-hierarchy automatisch voor je te tekenen, of je de mogelijkheid biedt om uit te zoeken vanaf waar een functie allemaal wordt aangeroepen.

[Rene59]

Is alles wat aangeroepen wordt ook maatwerk? Ik kan het me bijna niet voorstellen. Die 20 'lagen' waar je het over hebt klinkt me verdacht veel als standaard SAP code in de oren.
Ik zou eerst eens kijken wat er nou precies maatwerk is, en op welke punten standaard SAP functies of klassen worden aangeroepen. Als je die inventariseert krijg je al een beter beeld van de functionaliteit van de exits.