[ros-dev] My thoughts

[Andrew "Silver Blade" Greenwood]

Personally, my main area of interest regarding the recent discussions 
has been that of reverse-engineering. But what I'm about to say could 
probably be applied to the leaked sources, too (this isn't what I'm here 
to discuss, however.)

We all know that some bits of Windows' internals are hidden, often 
intentionally, and that some product may make use of certain hidden API 
function calls, or may interact with the system components in a way 
other than that described in the API reference documentation.

Other times, parameters to API function calls are not clear, or not 
documented at all.

As a result, to make something that is compatible with Windows (or at 
least MORE compatible), it is necessary to use alternative methods (eg: 
reverse engineering) to determine what an undocumented function works, 
how it behaves, or to investigate undocumented flags, etc.

For the sake of the project, any reverse-engineering should be done as a 
2-man job. It seems the case that people often take it upon themselves 
to do both jobs - that of the person looking at the disassembly, and 
that of the person writing the code.

This is how I wrote most of WDMAUD.DRV.

I was skeptical about the morals/legality of it at the time, but was 
told that it doesn't matter.

As this is all now out in the open, and I've exmained the disassembly of 
WDMAUD.DRV, it's probably best that I continue to examine it, and 
document my findings, for another developer to implement later.

For other modules, it depends who's comfortable doing disassembling. I'm 
happy to write code, and would like to do so. But I haven't the first 
clue about kernel-mode debugging so things like the Kernel Streaming 
API, I'd probably struggle with.

As for the rest of the project, the impression I get is that, rather 
than going through the existing code and auditing it, it might be best 
to start over.

This has disgruntled a lot of the major developers.

But don't forget, when the project was in its early days it was focusing 
on NT4 compatibility... Not a lot worked, and there was no clear-cut 
development policy... Then there was an explosion of activity and we've 
been racing forward ever since.

Some may claim we're reinventing the wheel again, but we already *have* 
a working kernel and this time round it shouldn't be as difficult as it 
was previously, provided we can use our original sources as a reference.

There's all sorts of things that can be implemented from the start 
rather than being added on later (maybe translations? - I don't know how 
this works but AFAIK this was something that was discussed further along 
the development line.) We can focus on the current technology and not 
aim low (NT4.)

I just think we need to have people who are good at deciphering 
disassembly and producing documentation, and people who can code from 
that documentation (or other documentation, of course.)

Anyway, those are my thoughts. If any of it doesn't make sense it's 
because I'm tired!