[Modelinterpreter] EXE cikk javaslatok

[Boldizsár Németh]

Sziasztok!

Alaposan átrágtam magam a cikken és produkáltam egy hosszabb irományt. 
Mindenki nézze meg, hogy azok a dolgok amit a részére írtam helytállók-e 
vagy sem. Legkésőbb holnap estig (22.00) várom a válaszokat, mert 
éjfélig el szeretném küldeni a cikket (tudom, még lehetne szombat 
délelőtt is, de jó lenne még holnap).

  Na szóval, a lista:


Általánosságban:

Arról egy szó sem esik a cikkben, hogy a trace-ek segítségével a külső 
komponensek üzenetei is rögzítésre kerülnek. Ezt szerintem meg lehetne 
említeni, hogy nem csak a randomizáció miatt van.

Introduction:

" However, UML models are usually non-deterministic by nature." => 
However, there is no accepted semantics for the execution of an UML 
model that is completely deterministic.
"A deterministic model simulator hides this, and execute only one 
execution path of the many possible" => A deterministic model simulator 
chooses only one execution path of the many possible.

"A better approch is to keep the execution non-deterministic (or even 
randomize it intentionally), " => A better approach is to choose 
randomly from the possible pathes,

"The results make it clear that the requirement about high runtime 
performance leads to the code generation solution." - Ezt nem az adott 
fejezet végére kellene tenni? Kicsit korai az eredményekről beszélni az 
introduction-ben.

"What is the difference between model execution via code generation and 
model compilation?" - Ide írnám zárójelbe, hogy model simulation, mert a 
felsorolásban már így van említve.

"Model simulation has to be prepared to replay traces" - Talán execution 
traces egyértelműbb lenne, így szerepelt korábban.

"Model compilers might have to emit" => szerintem itt a might fölösleges

Mintha duplikáció lenne itt: az első hasáb alján már szó van arról, hogy 
milyen részei vannak a cikknek, majd ez újra kezdődik a második hasáb 
alján. Szerintem az utóbbi helyen kellene maradnia, az előbbi helyről 
meg eltűnnie a Section III-at leíró résznek.

Related work:

"but it needs improvement in the mass test execution use case" => but is 
not sufficient for mass test execution - ez nem igaz?

A végére egy mondat, ami összefoglalja a tapasztalatainkat? Mondjuk hogy 
sok ilyen eszközt megvizsgáltunk, de nem volt olyan open source, ami 
kielégítette volna a követelményeket.

Architecture:

Az ábra jó lenne, ha nem az előző fejezetben lenne, hanem mondjuk a 
hasáb alján.

"We realize both animation and breakpoint support using Java 
breakpoints" -> Both animation and breakpoint support is realized using 
Java breakpoints

"we get a notification via the JDI" -> a notification is delivered from 
the JDI

"we signal this on in the frontend and wait for user action" -> the user 
is notified and the runtime waits for user action

" we highlight the corresponding state or transition" -> The 
corresponding state or transition is highlighted

"the compiler inserts the information needed to track the currently 
executed file and line number with a debugger" -> the compiler inserts 
the information needed to find the line of source code corresponding to 
a given instruction

"However, the code generated for model execution will not be debugged as 
an ordinary Java application. Instead, the debugger should animate state 
diagrams and step over the lines of action code statements." -> However, 
interactive model debugging should support highlighting the actual state 
in running state machines or stepping through them as well as stepping 
over lines of action code or highlighting them.

"unique Java identifier for each UML named element" -> unique Java 
identifier to each UML named element

"it is currently serialized into a separate binary file and loaded by 
the debugger itself." - elé be kellene szúrni, hogy "in the tool 
presented in this paper"

"to let the debugger to decode and show the original names of model 
elements." -> to let the development environment show the original names 
of model elements during debugging.

"to acess debugging capabilities of a Java virtual machine." -> to 
access debugging capabilities of a running Java virtual machine

"uses this technology to implement its debugger" -> uses this technology 
to provide debugging support

"As JDI provides inspection and manipulation of the connected virtual 
machine through a simple API, it the convenient choice to implement a 
visual debugger for a model executor process." -> As JDI provides 
inspection and manipulation of the connected virtual machine's state 
through a simple API, it the convenient choice to provide interactive 
visual debugging for UML models.

"and implemented in tools.jar" - utána: bundled with jdk distributions 
(és cite)

"Only the underlying IDebugTarget instance should be replaced to a 
custom implementation." - szép lenne, de ezt így nem lehet megcsinálni, 
túlságosan bele van a debug target drótozva az eclipse-be. Helyette azt 
megsemmisítettük és a Moka debug targetjén keresztül prezentáljuk a 
program futását. Tehát itt igazából a kettősséget szűntettük meg azzal, 
hogy az implementációhoz kapcsolódó debug targetet kilőttük.

"Communication with the target virtual machine is asynchronous." -> Ez 
szerintem nem igaz, inkább használható így is meg úgy is.

"several events could be created by a virtual machine at a given time" 
-> several events could be fired by a virtual machine at the same time

"between virtual line numbers and lines of the generated Java class is 
available." -> between virtual line numbers and lines of the generated 
Java source code is available.

setDefaultStratum: kód formázás

"It can also notify
about unexpected disconnection of the target process through
the event queue. Any further operations on a disconnected
virtual machine will result in an exception." - szerintem ez a rész 
fölösleges

Table 3: Nem kellene kinormalizálni az értékeket a BP hits alapján? 
Mondjuk breakpoints hit in a ms vagy running time (ms) per 10K 
breakpoints hit/set/disabled?

"When the virtual machine detects a breakpoint" -> When the execution of 
the virtual machine hits a breakpoint

"Two approaches we tried were to simply let the execution in the
virtual machine continue, or log a message before continuing
on; logging did not significantly increase execution time, and
is not shown in the table." - szerintem ez nem kell

Konzolos képernyőképen is az a modell legyen, ami a GUI-son van.

"These results are unfortunate, because the model simulator
would incur a perceptible slowdown if all of the breakpoints
were set on all relevant lines of a translated model if the model
is large enough, and then suffer even worse once execution
is started. To mitigate this effect, the simulator can place
breakpoints only on lines that are important, that is, lines
related to model elements visible on the user interface. As
the number of such lines can be expected to be much lower
than the total lines of the model, it is good to see that disabling
breakpoints is cheap if there is not too many of them."
-> These results show that a visual model debugger that is using 
generated code for execution must limit the number breakpoints it uses. 
It can be seen that the model debugger only needs to keep breakpoints on 
lines that correspond to model elements currently seen (for animation) 
and model breakpoints set by the user. To further optimize the 
performance the debugging environment can disable breakpoints that are 
likely to be used again instead of removing them.

Nekem az alternative ways of communication rész nagyon gyengének tűnik 
és a fontosabb pontok már tárgyalva voltak az előző részben. Ha csak nem 
jut esztetekbe, hogy hogyan lehetne földobni, én kivenném.

models may contain only a single class including a single flat state 
machine -> Igazából a megszorítás csak arra vonatkozik, hogy egy state 
machine futhat, class és SM lehet akármennyi.

" The class can have attributes (limited to
primitive types as of release 0.4) and operations with param-
eters, and associations with multiplicities"
-> Classes have attributes, operations and associations with 
multiplicities (a zárójeles megjegyzés nem igaz, csak signalokra)

" The execution engine at each step
will look at the available events, nondeterministically chooses
an applicable one, and then progresses to the appropriate
state." - ez most nem így működik...

"it can invoke external Java code,
thereby providing the other end of two-way communication
with the external world" - igen? Én ilyenről nem tudok... A kétirányú 
kommunikáció event-ekkel történik, nem?

"can later be replayed deterministically" -> can later be replayed, 
producing the same execution

"In this paper, we have compared two approaches for model execution" - 
utána: execution by interpretation and execution by compilation

" Analysing the differences further, we have come to
the conclusion that code generation is better suited for our
purposes." - utána: "We inspected a few design decisions that are 
specific to execution by compiling and running models"


Boldi