Hi, we have a solution for that, with different level of protection:

When you issue something like :

SCATTER FIELDS nValue, cValue, tValue TO arrayName

You get without obfuscation:

  VFPValueHolder[] toFields = new VFPValueHolder[] { __ModuleClass.nvalue, __ModuleClass.cvalue, __ModuleClass.tvalue };
    __ModuleClass.m.arrayname.Set(VFPVM.GlobalVM.ActiveDataSession.DBScatter(new FieldList(toFields, null, null), ref new VFPArrayParameterByRef(__ModuleClass.m.arrayname).m_pArray, "", 0, false, false));

And after obfuscation something like:

   ae[] ae1 = new ae[] { dx.cx(), dx.m(), dx.u() };
    dx.ax().b(et.b().g().a(new eg(ae1, null, null), ref new df(dx.ax()).c, "", 0, false, false));

But the best solution will be provided for the option to compile to native your code. With that you only will get some assembler as this for ix86. Really hard to follow.

10003260 <___main>:
10003260:	55                   	push   %ebp
10003261:	89 e5                	mov    %esp,%ebp
10003263:	53                   	push   %ebx
10003264:	83 ec 04             	sub    $0x4,%esp
10003267:	8b 1d 30 50 00 10    	mov    0x10005030,%ebx
1000326d:	85 db                	test   %ebx,%ebx
1000326f:	75 35                	jne    100032a6 <___main+0x46>
10003271:	a1 50 33 00 10       	mov    0x10003350,%eax
10003276:	b9 01 00 00 00       	mov    $0x1,%ecx
1000327b:	89 0d 30 50 00 10    	mov    %ecx,0x10005030
10003281:	83 f8 ff             	cmp    $0xffffffff,%eax
10003284:	74 24                	je     100032aa <___main+0x4a>
10003286:	85 c0                	test   %eax,%eax
10003288:	89 c3                	mov    %eax,%ebx
1000328a:	74 0e                	je     1000329a <___main+0x3a>
1000328c:	8d 74 26 00          	lea    0x0(%esi),%esi
10003290:	ff 14 9d 50 33 00 10 	call   *0x10003350(,%ebx,4)
10003297:	4b                   	dec    %ebx
10003298:	75 f6                	jne    10003290 <___main+0x30>
1000329a:	c7 04 24 d0 31 00 10 	movl   $0x100031d0,(%esp)
100032a1:	e8 ba de ff ff       	call   10001160 <_atexit>
100032a6:	58                   	pop    %eax
100032a7:	5b                   	pop    %ebx
100032a8:	5d                   	pop    %ebp
100032a9:	c3                   	ret    
100032aa:	31 c0                	xor    %eax,%eax
100032ac:	83 3d 54 33 00 10 00 	cmpl   $0x0,0x10003354
100032b3:	eb 0a                	jmp    100032bf <___main+0x5f>
100032b5:	40                   	inc    %eax
100032b6:	8b 14 85 54 33 00 10 	mov    0x10003354(,%eax,4),%edx
100032bd:	85 d2                	test   %edx,%edx
100032bf:	75 f4                	jne    100032b5 <___main+0x55>
100032c1:	eb c3                	jmp    10003286 <___main+0x26>
100032c3:	90                   	nop    

>Thanks Matt and others. I'll make my way to the google group. IMHO it's worth considering obfuscation if people are planning to compile to NET: depending how Etechnologia implements functions like SCATTER/GATHER that rely on specific variable names, it would be great to include a declaration that means nothing in VFP but will prevent variable obfuscation when the time comes.