Getting the ball rolling. Which VB6 projects are you working on?

[yereverluvinuncleber]

I find myself able to code again in VB6. Life is not quite as stressful as my Mum has gone into a home for better care. After two years I am released to do some of what I want.

I have already refactored some of my dock code, fixed several of the larger and more 'threatening' bugs (threatening me to fix the buggers). Added a Disable Icon option for each icon in my dock. Managed to make MSGBOXes open in front of any apps by sending the offending apps to the back (there may well be a better way).

Enjoying being able to dip into VB6 at any time without being interrupted continuously.

Following RADBasic as a patron and watching the new releases for TB too. No longer feel I am coding using a dying language.

[fafalone]

Speaking of TB, UserControl support is far enough along now I've released twinBASIC versions of my shell controls, ucShellBrowse and ucShellTree, upgraded to 64bit compatible. Even supports IOleInPlaceActiveObject hooking to provide proper keyboard support in ucShellBrowse. If you missed it, these projects use tbShellLib, my successor to oleexp.tlb that's 64bit compatible and has all add-on modules built in (it's on the twinBASIC package server so you don't need to DL it manually).

RADBasic... is there anything actually new going on? There was supposed to be a new version according to their twitter but that was due out a month and a half ago now. IMO, it's really no longer a serious contender short of some new major development; not worth talking about like it's on the same level as twinBASIC, which as noted, is even supporting hugely complex UserControls now.

[yereverluvinuncleber]

I have not missed your shell controls Faf, I just haven't used them yet.

Re: progress with RB/TB. Well, I am not going to judge RADBasic as I don't enough information (I suppose that is one of the main issues). Carles told me just a few days ago that he hopes in a few weeks they could do a beta release with great improvements compiling real applications.

He also states that the main problem is that his small team is still having to work full time in order to make money to live (as we all do) so their full attention can't be focussed on RB alone, instead having to make incremental improvements, just as TB is doing.

RB did a beta release in November as you know, expectations are raised for another in February/March.

I may offer to Carles to make more information available. I have more time available than previously.

[fafalone]

The November release was mentioned in their twitter but then I never saw anything else about it... is this something you have access to and if so can you describe the status of the project?

[baka]

Im happy that we have 2 projects going on. and I hope both will be successful, as I think people will prefer one or the other depending on IDE and features.
my game is still not working in TB, but it starts and I get to the mainmenu, but I cant click the start-game button it will crash.
but I think it will in the future. I will create a "mini" build that I will send as bug-testing, when I have time, right now I have lots of things to do and it could be it will be fixed on its own without my help.
Im curious about RB if it can handle my game. but theres nothing to download so Im waiting for a release.

[fafalone]

The last RB release from a year ago can't even take small modification to the demos; no conditionals (Or, And, etc), randomly breaks just by moving controls. That's part of why I don't think it's a serious contender.

[OptionBase1]

I have not missed your shell controls Faf, I just haven't used them yet.

Re: progress with RB/TB. Well, I am not going to judge RADBasic as I don't enough information (I suppose that is one of the main issues). Carles told me just a few days ago that he hopes in a few weeks they could do a beta release with great improvements compiling real applications.

He also states that the main problem is that his small team is still having to work full time in order to make money to live (as we all do) so their full attention can't be focussed on RB alone, instead having to make incremental improvements, just as TB is doing.

RB did a beta release in November as you know, expectations are raised for another in February/March.

I may offer to Carles to make more information available. I have more time available than previously.

I'll go on record to count myself as a RadBasic "development traction" skeptic. Clearly, the intention from day 0 for the people behind RadBasic was to build a fully functional, fully compatible VB6 replacement. But the lack of routine project status communication via something like their twitter page is a huge disappointment. I mean, no one can take 2 minutes once a week to just say something about what is being worked on currently? And having a few people slamming out code in their spare time is not a development model that is conducive to writing something as complex as VB7, in my opinion. Every day that passes, the gap between TwinBasic and RadBasic appears to widen, and there appears to be no end to that momentum in sight.

At this point, RadBasic seems like the Virgin Galactic to TwinBasic's SpaceX.

[Eduardo-]

At this point, RadBasic seems like the Virgin Galactic to TwinBasic's SpaceX.

🤔 And who is Blue Origin?

[OptionBase1]

🤔 And who is Blue Origin?

If I didn't respect the hell out of him, I would probably respond with a picture of the Blue Origin rocket and say "Olaf".

[SearchingDataOnly]

If twinBasic has one or a few competitors, that's obviously a good thing. Olaf's compiler is scheduled to be launched in 10 years, and RADBasic's progress is clearly not comparable to twinBasic (RADBasic's progress may be 0, maybe 0.5, and twinBasic progress is 3 or 4), so now twinBasic has no competition.

In my opinion, the success of a replacement for VB6, in addition to being as compatible as possible with VB6, is whether it can provide an IDE as smooth and simple and powerful as VB6-IDE. There are no less than 1,000 people in the world who can independently develop Basic language compilers, but no more than 10 people can independently develop an IDE similar to VB6-IDE.

Just image, if in 2002 Microsoft had not provided the ridiculous VB6ToVBNet upgrade tool, but provided a VB7-IDE(VB.net IDE) that 100% emulated VB6-IDE, allowing VB6ers to use VB.Net in a familiar IDE environment, then 99% of traditional VB6 developers would have gradually moved to .NET.

An IDE is extremely important for a programming language. FreeBasic already has mature compilers, but there is a 30-year gap between the IDE associated with FreeBasic and VB6-IDE.

[baka]

yeah. the IDE is important. the feeling when u code is all about the look and the features of the IDE.
otherwise I could just start notepad.
RB right now is just a name, an idea. and I will not give any serious feedback until its released in a shape where I can do a really small project and its working. TB is there and it feel solid. sure, theres more to do, its not 100% working, but thats obvious, its a vip project and impossible it would just run whatever u throw at it.
TB is at this moment the only one that works and with a serious working schedule, transparent and good communication.
RB has nothing of that. and Olaf? he will not show anything until its done. so until he releases something its like it doesn't exists.

[fafalone]

The IDE was hardly the problem with .NET; it was the fact it was an entirely different language and the "upgrade tool" couldn't even handle Hello World.

[OptionBase1]

Olaf's compiler is scheduled to be launched in 10 years

Is that an official timeline or just a friendly jab at Olaf?

[wqweto]

Anyone willing to join efforts to complete Olaf's compiler?

I was implementing an internal tool (for localization) which parsed VB6 code (mostly constants) and was thinking to myself how temptingly easy it is to tokenize and parse VB6 as a language and with a little bit of effort a fairly completely parse tree can be produced.

My explanation for this phhenomenon is the VB6 as a BASIC-y language is uniquely *daft* (close to dummy even) and so very easy to reason about -- i.e. the preprocessor directives are easy to discern (start with #), the procedures are easy to distinguish even without parsing the rest of the code (start on new line *after* module level variables).

It looks not that hard to produce complete source project typelib -- all interfaces (incl. private ones) w/ all methods (incl. private ones) w/ all parameters. Combine this typelib info with external referenced typelibs and you have a good database to start producing scopes i.e. list of variables available to local procedure, local module, local project and external references. This will allow the parse-tree from above to be resolved to actual AST where each identifier is bound/resolved unambiguously.

Having an AST for a funcrtion the easiest would be to interpret it within a running context. Another option is to produce p-code and interpret this within a VM. Third option is to produce C code and run this with libtcc. Final option is to produce C code and compile this with MinGW to object files and link to final binaries.

Runtime can be staticly compiled, just a big single C/C++ source file with every possible function the compiler might emit. No need to complicate things with runtime DLLs etc. Just allowing copy/paste deployment of the final binary.

First target would be to interpret standalone projects from source code using libtcc (however buggy it is) then produce Std-EXEs and ActiveX-DLLs w/ MinGW and doubt anyone would have Wayne's stamina to tackle OCXs and legacy VB forms subsystem compatibility. Frankly forms subsystem is worthless in this day and age as the it is a boiling pieces of shhh... so let's leave it rot its ANSI death in peace. There are better alternative for desktop UI in 2023.

This is what I consider doable, it's the IDE that is another big effort and here something based on RC6 would be ideal. Unfortunately I'm not aware what is the current level of its Widgets project, certainly don't expect there to be an editor comparable to Scintilla for instance. Using RC6 allows for the compiler to start on VB6 and ultimately become self-hosted i.e. from VB6 to be able to build compiler/IDE and then using this stage1 compiler/IDE be able to build working stage2 compiler/IDE.

cheers,
</wqw>

[SearchingDataOnly]

The IDE was hardly the problem with .NET; it was the fact it was an entirely different language and the "upgrade tool" couldn't even handle Hello World.

A familiar IDE can shorten the sense of differences between different languages.

Is that an official timeline or just a friendly jab at Olaf?

Olaf is very confident in the vitality of VB6. He thinks VB6 will last at least 20 years, so it's never too late to develop a new compiler at any time within 10 years

[OptionBase1]

Olaf is very confident in the vitality of VB6. He thinks VB6 will last at least 20 years, so it's never too late to develop a new compiler at any time within 10 years

It is already over 20 years old. Or do you mean an additional 20 years from now? Is it even Y2038 compliant?

[Niya]

and Olaf? he will not show anything until its done. so until he releases something its like it doesn't exists.

This is a tall order for one man to do, especially if you're also writing an optimizing x86 compiler. Quite frankly, I have no idea how Wayne(TwinBASIC) is even able to do it by himself. The guy is clearly some kind of super human.

[SearchingDataOnly]

I was implementing an internal tool (for localization) which parsed VB6 code (mostly constants) and was thinking to myself how temptingly easy it is to tokenize and parse VB6 as a language and with a little bit of effort a fairly completely parse tree can be produced.

My explanation for this phhenomenon is the VB6 as a BASIC-y language is uniquely *daft* (close to dummy even) and so very easy to reason about -- i.e. the preprocessor directives are easy to discern (start with #), the procedures are easy to distinguish even without parsing the rest of the code (start on new line *after* module level variables).

It looks not that hard to produce complete source project typelib -- all interfaces (incl. private ones) w/ all methods (incl. private ones) w/ all parameters. Combine this typelib info with external referenced typelibs and you have a good database to start producing scopes i.e. list of variables available to local procedure, local module, local project and external references. This will allow the parse-tree from above to be resolved to actual AST where each identifier is bound/resolved unambiguously.

Having an AST for a funcrtion the easiest would be to interpret it within a running context. Another option is to produce p-code and interpret this within a VM. Third option is to produce C code and run this with libtcc. Final option is to produce C code and compile this with MinGW to object files and link to final binaries.

Runtime can be staticly compiled, just a big single C/C++ source file with every possible function the compiler might emit. No need to complicate things with runtime DLLs etc. Just allowing copy/paste deployment of the final binary.

First target would be to interpret standalone projects from source code using libtcc (however buggy it is) then produce Std-EXEs and ActiveX-DLLs w/ MinGW and doubt anyone would have Wayne's stamina to tackle OCXs and legacy VB forms subsystem compatibility. Frankly forms subsystem is worthless in this day and age as the it is a boiling pieces of shhh... so let's leave it rot its ANSI death in peace. There are better alternative for desktop UI in 2023.

If you can contribute to the generation of AST, the generation of pcode, the debugging of the code, editing and continuing, it will be very helpful for some people (including me). But most of the time, you're just providing fragmentary code snippets and scattered tools. IMO, it would be more valuable to provide a complete tool.

This is what I consider doable, it's the IDE that is another big effort and here something based on RC6 would be ideal. Unfortunately I'm not aware what is the current level of its Widgets project, certainly don't expect there to be an editor comparable to Scintilla for instance.

RC6-Widgets are already powerful and mature, but Olaf is the only one in the world who can develop a decent Code-Editor with RC6-Widgets or RC6-Cairo. That's why I abandoned RC6-Widgets in favor of GdiPlus for my CodeEditor.

I've been looking for the best solution for my Code-Editor since 2018. Obviously, I don't think Scintilla is the right solution, because I've never seen any Code-Editor or IDE developed with Scintilla reach the level of VB6-IDE. IMO, the new Code-Editor must be much better than Scintilla to meet the requirements of the new IDE in order for the new IDE to reach the level of VB6-IDE. If the Code-Editor of the new IDE cannot be better than the VB6-IDE, then the chances of it being accepted by VB6ers will be very small.

Using RC6 allows for the compiler to start on VB6 and ultimately become self-hosted i.e. from VB6 to be able to build compiler/IDE and then using this stage1 compiler/IDE be able to build working stage2 compiler/IDE.

Yes, this is a scenario worth trying.

[SearchingDataOnly]

It is already over 20 years old. Or do you mean an additional 20 years from now? Is it even Y2038 compliant?

Yes, I mean an additional 20 years from now. What I'm quoting, though, is what Olaf said 2 years ago (maybe 1 year ago).

[SearchingDataOnly]

This is a tall order for one man to do, especially if you're also writing an optimizing x86 compiler. Quite frankly, I have no idea how Wayne(TwinBASIC) is even able to do it by himself. The guy is clearly some kind of super human.

If Olaf can develop his compiler full-time, I believe he can do it as fast and as well as Wayne (TwinBASIC), and I believe that Olaf's compiler(IDE) and TwinBasic will have different features and advantages. Unfortunately, Olaf only worked on his compiler in his spare time, so everything became unpredictable.

[OptionBase1]

Yes, I mean an additional 20 years from now. What I'm quoting, though, is what Olaf said 2 years ago (maybe 1 year ago).

Very interesting, thanks, I didn't know that.

[georgekar]

This is M2000 code run from VB6 (from compiled dll, and you can run it from the IDE and most of the code written at "stop" intervals).

It is a BASIC style, but has two major differences.
The first one is obvious here: We may have any level of inner modules/functions.
The second one is the use of lambda functions.
VB6 has no Lambda functions. But here the code under this interpreter is VB6 so there always a way to make anything, it is just a matter of programming.

This code prepare counters for Permutations to be used from "outside". We call the function and get the next permutation and a by reference value to indicate the end of permutation. So instead of using for/next which has to be "Static" on code, we may have lambda functions which have closures other lambda functions. So we make a deep chain as the items we need to permutate. And that chain can be called from the top lambda which can call the inner one, until the deep end. At any stage we can place data in other closures.

Closures are copies (but for variables who hold pointers to objects, they are copies of pointers).

I define/programming the lambda functions in about two days, because the M2000 had the effort to use inner functions/modules

The VB6 is a flat system. Although we have modules as namespaces, and there is a AddressOf operator to make true lambda, we have to write them from ide and the parser has to make them "first citizen".
My lambda when assign a new value (another lambda) take a copy of closures too. So from a point of view is like a structure with a last field, the function pointer. The function has to defined as Variadic. Also to be precise the structure has two things, a list of closures and the function pointer.

So here are the challenge: I give the idea about lambda functions as they work in M2000 (no delegates needed), using variadic type of signature, and a variant as return value, so anyone can be think for a way to implement this in his BASIC, or in VB6.


About this code
(1,) return one byte array (is like Array(1) in vb6)
(,) return an empty array

Car(m) get the first item from array in pointer m, and put it on an array of one item
Cdr(m) return an array, of all items but not the first (so can return an empty array (,))
Cons(m, m, m) make a new array from the list of arrays, here is the m, so we get three times the m.


The PermutationStep return a lambda function, so we call a function which return a lambda function (which have a chain of lambda functions).

clear is a statement but any identifier can be used as variable if we want, and here we want.

The & used for passing by reference. You need to use & from the other side to get the weak reference and make it normal reference.

So do not stay at VB6 because there was a pretty and productive IDE. We have to evolve the language using Tuple (like the one I make using only parenthesis and the comma), and Lambda functions. It is better the closures to be defined in the definition of lambda, as copies.

Module StepByStep {
    Function PermutationStep (a as array) {
        c1=lambda (&f, a) ->{
            =a
            f=true
        }
        m=len(a)
        if m=0 then Error "No items to make permutations"
        c=c1
        While m>1
            c1=lambda c2=c,p=0, m=(,) (&f, a, clear as boolean=false) ->{
                if clear then m=(,)
                if len(m)=0 then m=a
                =cons(car(m),c2(&f, cdr(m)))
                if f then f=false:p++:  m=cons(cdr(m), car(m)) : if p=len(m) then p=0 : m=(,):f=true
                }
            c=c1  
            m--    
        End While
        =lambda c, a (&f, clear as boolean=false) -> {
            =c(&f, a, clear)
        }
    }
    k=false
    StepA=PermutationStep((1,2,3,4))
    while not k {
        Print StepA(&k) 
    }
    k=false
    StepA=PermutationStep((100,200,300))
    while not k {
        Print StepA(&k) 
    }
    k=false
    StepA=PermutationStep(("A", "B", "C", "D"))
    while not k {
        Print StepA(&k) 
    }
    k=false
    StepA=PermutationStep(("DOG", "CAT", "BAT"))
    while not k {
        Print StepA(&k) 
    }
    k=false
    once=true
    Print "Next Start"
    Print StepA(&k, True)
    while not k {
        Print StepA(&k)
    }
}
StepByStep 

[Eduardo-]

The VB6 IDE... like the VB6 IDE... because the VB6 IDE...

The VB6 IDE looks quite simple to me. Perhaps that's why it is good.
But I mean, what's so hard to do? (It doesn't seem a too difficult project to me.)

IDK if "the IDE" includes the language parser, in that case, it gets more complex.

But what is particularly good in the VB6 IDE, besides its simplicity, is the Edit & Continue feature.
But... I think that must be more a feature of the compiler than the IDE.

You could say: "if this is 'easy' why nobody did it?".
Why would someone do it, if he's not going to do also the rest? I mean, the compiler, etc. There is no point in making an IDE alone.

10 years?
In 10 years my plans are telling an AI to make the program I want on demand, in seconds, using whatever languages it chooses (or invents at the moment, or just producing raw machine code).

[Niya]

The VB6 IDE... like the VB6 IDE... because the VB6 IDE...

The VB6 IDE looks quite simple to me. Perhaps that's why it is good.
But I mean, what's so hard to do?

An IDE is not so easy to write. I wrote one way back in the day for a game engine language called DECORATE. It actually takes a lot more work than one would assume even for a very basic one.

[Eduardo-]

An IDE is not so easy to write. I wrote one way back in the day for a game engine language called DECORATE. It actually takes a lot more work than one would assume even for a very basic one.

Well, AFAIK in my experience that also applies to any program (to underestimate the effort and the time).

So, yes, it is normal that I'm thinking "it is easy". But easy or not, things take time...

[SearchingDataOnly]

This is M2000 code run from VB6 (from compiled dll, and you can run it from the IDE and most of the code written at "stop" intervals).

It is a BASIC style, but has two major differences.
The first one is obvious here: We may have any level of inner modules/functions.
The second one is the use of lambda functions.
VB6 has no Lambda functions. But here the code under this interpreter is VB6 so there always a way to make anything, it is just a matter of programming.

This code prepare counters for Permutations to be used from "outside". We call the function and get the next permutation and a by reference value to indicate the end of permutation. So instead of using for/next which has to be "Static" on code, we may have lambda functions which have closures other lambda functions. So we make a deep chain as the items we need to permutate. And that chain can be called from the top lambda which can call the inner one, until the deep end. At any stage we can place data in other closures.

Closures are copies (but for variables who hold pointers to objects, they are copies of pointers).

I define/programming the lambda functions in about two days, because the M2000 had the effort to use inner functions/modules

The VB6 is a flat system. Although we have modules as namespaces, and there is a AddressOf operator to make true lambda, we have to write them from ide and the parser has to make them "first citizen".
My lambda when assign a new value (another lambda) take a copy of closures too. So from a point of view is like a structure with a last field, the function pointer. The function has to defined as Variadic. Also to be precise the structure has two things, a list of closures and the function pointer.

So here are the challenge: I give the idea about lambda functions as they work in M2000 (no delegates needed), using variadic type of signature, and a variant as return value, so anyone can be think for a way to implement this in his BASIC, or in VB6.


About this code
(1,) return one byte array (is like Array(1) in vb6)
(,) return an empty array

Car(m) get the first item from array in pointer m, and put it on an array of one item
Cdr(m) return an array, of all items but not the first (so can return an empty array (,))
Cons(m, m, m) make a new array from the list of arrays, here is the m, so we get three times the m.


The PermutationStep return a lambda function, so we call a function which return a lambda function (which have a chain of lambda functions).

clear is a statement but any identifier can be used as variable if we want, and here we want.

The & used for passing by reference. You need to use & from the other side to get the weak reference and make it normal reference.

So do not stay at VB6 because there was a pretty and productive IDE. We have to evolve the language using Tuple (like the one I make using only parenthesis and the comma), and Lambda functions. It is better the closures to be defined in the definition of lambda, as copies.

Module StepByStep {
    Function PermutationStep (a as array) {
        c1=lambda (&f, a) ->{
            =a
            f=true
        }
        m=len(a)
        if m=0 then Error "No items to make permutations"
        c=c1
        While m>1
            c1=lambda c2=c,p=0, m=(,) (&f, a, clear as boolean=false) ->{
                if clear then m=(,)
                if len(m)=0 then m=a
                =cons(car(m),c2(&f, cdr(m)))
                if f then f=false:p++:  m=cons(cdr(m), car(m)) : if p=len(m) then p=0 : m=(,):f=true
                }
            c=c1  
            m--    
        End While
        =lambda c, a (&f, clear as boolean=false) -> {
            =c(&f, a, clear)
        }
    }
    k=false
    StepA=PermutationStep((1,2,3,4))
    while not k {
        Print StepA(&k) 
    }
    k=false
    StepA=PermutationStep((100,200,300))
    while not k {
        Print StepA(&k) 
    }
    k=false
    StepA=PermutationStep(("A", "B", "C", "D"))
    while not k {
        Print StepA(&k) 
    }
    k=false
    StepA=PermutationStep(("DOG", "CAT", "BAT"))
    while not k {
        Print StepA(&k) 
    }
    k=false
    once=true
    Print "Next Start"
    Print StepA(&k, True)
    while not k {
        Print StepA(&k)
    }
}
StepByStep 

Very valuable work. I'll take the time to study your M2000 carefully.

[SearchingDataOnly]

The VB6 IDE... like the VB6 IDE... because the VB6 IDE...

Simple, powerful, and smooth are often the hardest to do, and that's the charm of VB6-IDE, and that's the charm of VB6. I don't think twinBasic-IDE is better than VB6-IDE.

The VB6 IDE looks quite simple to me. Perhaps that's why it is good.
But I mean, what's so hard to do? (It doesn't seem a too difficult project to me.)

CodeEditor is essential component of the IDE. If you could make a decent CodeEditor with pure VB6, then you can help a lot of people. Not only is it needed for my script-language IDE, but also for those looking for an alternative to RichTextBox.

IMO, a decent CodeEditor is worth much more than a TabControl, because we can find a lot of alternatives to TabControl on the internet, but not a decent CodeEditor developed in VB6. The trick once wrote a CodeEditor, but it was a very simple prototype.

Scintilla is a professional CodeEditor component, and dz32 also wrote an excellent wrapper for VB6. However, Scintilla is not developed with pure VB6, and we cannot customize Scintilla at will.

I can easily develop a decent TabControl, but I couldn't develop a decent CodeEditor with VB6, which kept my script-language's IDE from completing.

I put almost 20 times as much effort into CodeEditor as I do with my Spread control.

[Eduardo-]

[answers to nonsense deleted]

[SearchingDataOnly]

The issue was that I needed a themed tab control but not a code editor, because I'm not planning to make an IDE anyway.

I prefer to make a spread control bye

In other words, you don't know anything about CodeEditor, but why do you say that developing an IDE is easy?

[SearchingDataOnly]

Yeap, whatever you say, I know nothing.

But you know that developing an IDE is easy.

[SearchingDataOnly]

I saw the offensive words you wrote, and by the time I replied to you, you had deleted it. It seems that I have no need to reply. But I still want to post my reply, not in response to your attack, but to clarify something (I'm just asking for in this forum without giving back).

In addition, the comparison of workload and difficulty is only an estimate, not to humiliate you. You are a single-language developer like me, so your understanding of VB6 is very deep, and I hope to invite you and baka to test my scripting language in the future and give valuable comments. Here's my reply to Air:

Zero.

I admire you for posting something at Code-Bank that is valuable to other people, although none of it is valuable to me (mainly because I have a different design philosophy for controls).

Do you know why the VB6 community is in constant decline? Because people seem to be more willing to release something repetitive than to venture into some new area. For the VB6 community, a decent CodeEditor is a new area, and an IDE comparable to VB6-IDE is new area.

Yes, I'm not posting anything at Code-Bank, that's because everything I do is so difficult that I havn't finished them for 5 years:

(1) The workload and difficulty of a decent CodeEditor are 100 times that of a themed TabControl.
(2) The workload and difficulty of a multilingual transpiler are 150 times that of a themed TabControl.
(3) The workload and difficulty of a set of controls similar to .NET WinForms are 200 times that of a themed TabControl.
(4) The workload and difficulty of an IDE comparable to VB6-IDE is 300 times that of a themed TabControl

So, what do you need me to post? Everything I do will be open source(for an individual's work, there is no vitality without open source), but that will be after my scripting language is finished and matures, maybe it will take 10 or 50 years.

[SearchingDataOnly]

Man, there's no need to take strife and battles on the forums so seriously. It's just a game in a virtual world.

Good Luck!

[SearchingDataOnly]

It is not an easy task to make money by selling commercial components developed by VB6 now. But since someone has developed a commercial print component with VB6, I suggest that he develop a commercial Spread component with VB6, which will obviously make more commercial sense.

My point is this:
(1) The most powerful Spread control right now is GrapeCity's ComponentOne Spread.
(2) It's perfectly feasible to develop a commercial component like ComponentOne Spread with pure VB6.
(3) If someone intends to do this, I can offer some help and guidance.

[Niya]

It is not an easy task to make money by selling commercial components developed by VB6 now.

It's been my experience that clients don't care what something is written in as long as it works. Of course the exception is if your clients are other developers buying components to use in their own programs. I mean you can't sell a component written in VB6 to a C++ programmer. Outside of this, you can make a living in any programming language.

[DaveDavis]

It is not an easy task to make money by selling commercial components developed by VB6 now. But since someone has developed a commercial print component with VB6, I suggest that he develop a commercial Spread component with VB6, which will obviously make more commercial sense.

My point is this:
(1) The most powerful Spread control right now is GrapeCity's ComponentOne Spread.
(2) It's perfectly feasible to develop a commercial component like ComponentOne Spread with pure VB6.
(3) If someone intends to do this, I can offer some help and guidance.

We hated your bragging but never willing to release your Grid control. I am afraid it is copycat.

[georgekar]

If you have time prepare a VB6 code to do this:

// modern style, using high order functions
module generic_iterator {
    do_while = lambda (f, p)->{
        {
            if p(f()) then loop
        }
    }
    funcA=lambda (start_from, do_what) -> {
        =lambda i=start_from, do_what ->{
            call do_what(i)
            =i        
            i++
        }
    }
    funcPrint=lambda ->{
        print number
    }
    call do_while(funcA(1, funcPrint), lambda->number mod 6 <>0)
}
 generic_iterator 

These things I do with M2000, but I would like to see the same at the new Twin Basic/ Rad Basic/ Olaf's Basic.
See all the code for the Rosetta task here:

https://rosettacode.org/wiki/Loops/D...00_Interpreter

Also can run old style BASIC like this:

module Old_Style {
    10 REM Loops/Do-while
    20 LET I=0
    30 LET I=I+1
    40 PRINT I    
    50 IF INT(I/6)*6 <> I THEN 30
    60 END
}
Old_Style 

This language is a tool for testing algorithms for education, and has many programming paradigms, like functional style, and an environment with editor with syntax highlight, console with graphics, user defined Forms, and can connect with external dll, and ActiveX objects, also can use external controls for user forms.
The difference with forms in M2000 is that we make them by code, and in one module we may have several forms, including arrays of forms (and arrays of controls on forms if we like). This is like RC5/6 style, but with the exception of handling events, which we make static functions to serve events.

I am working on Version 12, revision 4, which change a lot the language (in code, but old m2000 code run as is). In this version I use the class RefArray which I introduce here, so this can be used (see the as integer):

dim alfa(-1 to 5, -10 to 10) as integer=100
? alfa(2,2)=100
alfa(2,2)++
? alfa(2,2)=101 

the alfa() array is a mArray class which have a ActualData variant, which can be either an array when used with no type same using as variant, or an object RefArray when we use type (we can use types boolean, integer, long, long long, double, single, currency, decimal, string, object).

So the ++ operator works either with one or other type and the good news for me was that I didn't have to alter the code for that, the same code works for ActualData as object and as Variant Array. Because the refArray has Default properties, with Optional arguments. So VB6 can use the parameter entry list according to what type ActualData is at Run Time. I don't now if that can be done with the Twin Basic and others.

Especially for string, I had to improve Interpreter to accept strings without the $ at the end. So now we can make string like this: s="alfa" or string s="alfa" or variant s="alfa" (variant can change types, but if we don't use it, variables can't change type in M2000, after first assign, or using type information at creation).

So today or tomorrow I put the revision 4 in git, stay tuned.

[Shaggy Hiker]

Man, there's no need to take strife and battles on the forums so seriously. It's just a game in a virtual world.

Good Luck!

THAT is certainly true.

[Shaggy Hiker]

It's been my experience that clients don't care what something is written in as long as it works. Of course the exception is if your clients are other developers buying components to use in their own programs. I mean you can't sell a component written in VB6 to a C++ programmer. Outside of this, you can make a living in any programming language.

There are some who DO care. It's not that they SHOULD care, but they DO. So far, those people have generally not known what they were talking about. They had heard something complicated that they simplified down to "X > Y", and decided that the rule to learn is "we must do X". At that point, you have two options: Educate them, or decide that there are better battles to fight.

The point of that is that there are people who do care because they think they understand when they don't. What I have never heard is somebody of that sort of ignorance saying that they should move to VB6. That's one of the problems. VB6 isn't a buzzword. Whether TwinBasic will be, remains to be seen.

[Elroy]

It's been my experience that clients don't care what something is written in as long as it works.

Man, that is not at all true for me. I can't really tell you why at all, but my primary client is totally freaked out that my software isn't written in a language that's still under active support by Microsoft. They still use it, but they've looked into having it all converted to .NET. Those, explorations have all fallen flat on their face, and they've mostly forgotten about it (and still very actively use my software). But it is some strange concern of theirs. Also, for reasons I don't understand, they're all bothered that there's not a 64-bit version.

[yereverluvinuncleber]

I love the way my "keep the ball rolling" thread has become an argument about the complexity of an IDE and the limited capabilities of members to achieve anything similar. My threads tend to cause arguments but I don't mean them to do so.

Keep happy chaps and tell me what you are up to. No judgement here. Note my code is ****e but it will do a certain job when I finally manage to complete it.