Printable View
The twinBASIC IDE may not be final; Wayne has mentioned building a new one, and the current one will certainly be getting upgrades-- a few in the next couple months before v1 at a minimum. If you want to weigh in on the most important IDE features for that stop by the 'IDE enhancements' thread on the tB Discord.
I guess there's also RadBasic but at the rate it's progressing it will be a decade or more before it even approaches being able to run real VB6 programs, while tB can run many now.
What do you have in mind?Quote:
Originally Posted by Daniel Duta
A VS Code version of the IDE was started but is currently on hold. This is certainly more modern than the VB6 IDE but further away from VB6.
What features do you think are missing from (or should be done differently to) the current twinBASIC IDE?
Wayne is asking for suggestions to enhance the twinBASIC IDE. He'd like a list of your top 3 IDE enhancements.
https://discord.com/channels/9276381...71955052982312
BETA 262 of the twinBASIC programming IDE is now available...
Download from here... https://github.com/twinbasic/twinbasic/releases
- Click on "Assets" for the latest release
- Download and Extract the ZIP file into a local folder
- Then run the twinBASIC.exe from that local folder
How to install https://nolongerset.com/how-to-install-twinbasic/
Why is the TwinBASIC/discussions on GitHub so dead? That used to be so lively. The last thing said there was 2 weeks ago. What's happening?
Many posts seem to be into Discord now.Quote:
Originally Posted by Niya
But there are still lots of posts to GitHub twinbasic/issues.
Maybe people find Discord easier.
Ah Discord. That makes sense. It seems to becoming more and more popular among programmers looking to discuss and share ideas.
Wayne is asking for suggestions to enhance the twinBASIC IDE...
https://discord.com/channels/9276381...71955052982312
He'd like a list of your top 3 IDE enhancements.
Gave 2 for now. :DQuote:
Originally Posted by VB6 Programming
discord seems to require you to register just to view - so that's a non-starter.
twinBASIC status update:
twinBASIC Update: March 5, 2023
Highlights include the addition of MonthView and DatePicker controls, new methods, properties, and events, and a note about the twinBASIC splash screen.
https://nolongerset.com/twinbasic-update-march-5-2023/
BETA 263 of the twinBASIC programming IDE is now available...
Download from here... https://github.com/twinbasic/twinbasic/releases
- Click on "Assets" for the latest release
- Download and Extract the ZIP file into a local folder
- Then run the twinBASIC.exe from that local folder
How to install https://nolongerset.com/how-to-install-twinbasic/
It is free. But if you have a twinBASIC issue, or suggestions for improvements to the twinBASIC IDE, you can post on Github or in this forum.Quote:
Originally Posted by 2kaud
BETA 264 of the twinBASIC programming IDE is now available...
Download from here... https://github.com/twinbasic/twinbasic/releases
- Click on "Assets" for the latest release
- Download and Extract the ZIP file into a local folder
- Then run the twinBASIC.exe from that local folder
How to install https://nolongerset.com/how-to-install-twinbasic/
BETA 265 of the twinBASIC programming IDE is now available...
Download from here... https://github.com/twinbasic/twinbasic/releases
- Click on "Assets" for the latest release
- Download and Extract the ZIP file into a local folder
- Then run the twinBASIC.exe from that local folder
How to install https://nolongerset.com/how-to-install-twinbasic/
BETA 266 of the twinBASIC programming IDE is now available...
Download from here... https://github.com/twinbasic/twinbasic/releases
- Click on "Assets" for the latest release
- Download and Extract the ZIP file into a local folder
- Then run the twinBASIC.exe from that local folder
How to install https://nolongerset.com/how-to-install-twinbasic/
Congratulations on your breakthrough in technology.Can generate controls, but also 64-bit, really comfortable. It would be nice to have a separate development IDE interface that doesn't rely on vs code or support both IDE's. Add VB6 and you have three IDE.Quote:
Originally Posted by VB6 Programming
Applause is very good. One more choice is definitely better, after all, to generate 64-bit, there are more features to implement.Quote:
Originally Posted by yereverluvinuncleber
vb7.0【VFB,Visual Free Basic】like Visual Basic6 IDE
https://www.vbforums.com/showthread.php?891422-vb7-0
Compare the two development tools. It would be better if I could write a complete evaluation article.
Quote:
Originally Posted by Daniel Duta
How many lines of source code and how many controls does your project have? How many windows? Can you upload a screenshot to have a look? I can make a most complex CP project, source code is made public, everybody goes testing, that has conviction more.Quote:
Originally Posted by vbrad
It would be even better if registration-free dynamic calls could be added. In the code, um, three five different controls or ActiveX DLLs are called dynamicallyIt would be nice if you could also load standard DLLs or ActiveX DLLs into memory.Quote:
Originally Posted by WaynePhillipsEA
I haven't used your product carefully. If your visual development interface is implemented on the web. It would be better if we could also make an IDe that supports JS code. In this way, he can generate Excel and save web pages. That is, one IDE supports two languages.
It's hard to tell due to the language barrier, but it looks like VFB does not use the VB6 language, so there is no comparison.Quote:
Originally Posted by xiaoyao
tB hasn't relied on VSCode in a year now; it has it's own IDE. Still fairly simple, but getting better. There's a solid form editor, code folding with custom regions that can be folded, intellisense, autoindent, history, outline, callstack, debug console, etc. Bookmarks added today.Quote:
Originally Posted by xiaoyao
Here's a shot of it in action with my ucShellBrowse control:
https://www.vbforums.com/images/ieimages/2023/03/5.jpg
Form editor:
https://www.vbforums.com/images/ieimages/2023/03/6.jpg
it's run ok ,very nice
Code:Dim Excel1 As Object
Dim book1 As Object
Set Excel1 = CreateObject("Excel.Application")
'
Excel1.Visible = True
Dim file1 As String
file1 = App.Path & "\test1.xls"
MsgBox file1
Set book1 = Excel1.Workbooks.Open(file1)
MsgBox book1.Worksheets("sheet1").Range("a1")
Excel1.Quit
End Sub
Feel the biggest problem is that the project file is a single file, which is very bad, not conducive to large project management, in fact, should be used like VB6 in the form of multiple files, such as forms, FRM, bAS file etc. . It would be nice if it were 100% compatible. Just add a project profile. Because many general-purpose modules or class files can be shared by multiple files, it is better to save modules, classes, forms in multiple file formats for file sharing and reuse, it also reduces the amount of disk space it takes up. Add another feature to export the full project to another directory. VB6 project is because some files in the shared directory, the need to complete the project to copy to the U disk, can only copy one by one, spend a lot of time. If the addition of function library management, code snippets, modules, class file database management, when the need for a key search, reference or import code snippets more convenient. What surprised me the most was that Twinbasic ran and compiled almost in real time, and the speed was absolutely superb. So for the function of the test, the complete module of the test can be displayed on the form code compilation run, similar to the web page to learn JS code, real-time test code.
I agree about the single file being the only option and have been told VBP-like project files referencing individual source files are absolutely a planned feature.
Right now there is a feature to export the individual source files (File->Export) and you can then import them to other projects (Right click on Sources->Add->Import file). There's also packages, and an online package server. You add these as references. (The IDE is missing the ability to publish to the package server right now, but you can still do it via the old VS Code plugin, this is supposed to be fixed soon).
It's still Beta software with quite a bit on the list of things not yet done, but it's coming along very quickly and is getting very close-- able to run large, complex projects like forms with my ucShellBrowse UserControl. Just today one of the last few major missing pieces became available (automatic importing of .res files from VB6 projects).
Not tried tB myself, however the thought of a single file would make me concerned about how well it would integrate with any decent version control system.Quote:
Originally Posted by fafalone
BETA 267 of the twinBASIC programming IDE is now available...
Download from here... https://github.com/twinbasic/twinbasic/releases
- Click on "Assets" for the latest release
- Download and Extract the ZIP file into a local folder
- Then run the twinBASIC.exe from that local folder
How to install https://nolongerset.com/how-to-install-twinbasic/
So I wrote this for a post in a random thread in the VB6 forum, but thought I should add it here.
The WWW site for tB only lists a few of the new features, and there's no centralized list available yet. So I made a list of all the new features I could recall right now. I've included LongPtr/64bit LongLong as these are new vs VB6 but obviously VBA7 has them. These are all available *right now*...
- LongPtr data type (4 bytes on 32bit, 8 on 64bit)
- LongLong data type, available in both 32bit and 64bit (VBA LongLong is only available in 64bit Office)
- True Decimal data type instead of just inside a Variant.
- All the standard accessories for the new data types, e.g. DefDec/DefLngLng/DefLongPtr, CDec/CLngLng/CLongPtr, and vbDecimal/vbLongLong/vbLongPtr constants for type checking.
- Define interfaces and coclasses in language, [ InterfaceId(GUID) ]/Interface IFoo Extends IUnknown/.../End Interface
- Implements allowed on inherited interfaces-- e.g. you can just implement IShellFolder2, and provide all the methods for IShellFolder, and tB will automatically respond to QI for IShellFolder *and* IShellFolder2.
- If you have an interface multiple others extend from, you can write multiple implementations, or specify one implementation for all: e.g. IOleWindow_GetWindow() As LongPtr Implements IOleWindow.GetWindow, IShellBrowser.GetWindow, IShellView2.GetWindow
- Implements allowed on interfaces with 'As Any' parameters-- you can substitute LongPtr.
- Implements Via to extend classes
- vbNullPtr allows passing null pointers to UDT members of APIs/interfaces (in VB6 you'd have to declare them As Any and then could pass ByVal 0)
- Short-circuit conditional operators OrElse and AndAlso
- Support for modern image formats
- Transparency on forms
- Bitshift operators << and >>
- New assignment operators: += -= /= *= ^= &= <<= >>=
- Thread safety/multithreading support-- no native language syntax yet (planned), but you can call CreateThread directly with no hacks
- Ability to define custom packing for UDTs with [ PackingAlignment(n) ] attribute
- AddressOf can be used on class/form/UC members, including from outside the class by specifying the instance. Also, no need for FARPROC-type functions, you can use it like Ptr = AddressOf Func
- Overloading, both with type of argument and number of arguments
- Generics
- DeclareWide to disable Unicode-ANSI conversion on API declares
- Built in support for making standard DLLs with simple [ DllExport ] attribute
- CDecl support for API calls and procedures (though The trick has a patch for VB6 that adds this); this is respected for standard DLL exports as well.
- Continue For, Continue While, Continue Do, Exit While
- Return syntax for functions
- Err.LastHResult and Err.ReturnHResult to get/set COM interface hresults
- Parameterized class constructors
- [ Description("text") ] attribute for APIs, UDTs , Consts, Procedures, Interfaces, and CoClasses that are shown in popups when you hover over uses of them; exported to typelib as helpstring() where applicable.
- Built in support for making kernel-mode drivers
- Built in support for overriding entry point
- Option to put all API declares in the import table rather than runtime calls like VB6 (VB6 puts TLB-declared APIs in the import table; tB replicates this too but further provides an option for in-project declares).
- Built in support to mark projects DEP-aware and LARGEADDRESSAWARE
- [ RunAfterBuild ] attribute-- you can specify a function that runs after your exe is built (there's App.LastBuildPath to know where it is if you're e.g. signing the exe)
- Register ActiveX builds to HKEY_LOCAL_MACHINE option
- Private/Public modifiers for modules and classes
- All tB-implemented controls support Unicode
- Detects stale/dangling pointers for strings, replacing them with warning symbols
- Warnings for likely-incorrect hex literals &H8000-&HFFFF and &H80000000-&HFFFFFFFF (these almost always should be e.g. &H8000& to avoid being interpreted as a negative Integer).
- tB-implemented controls all support x64 and are all dpi aware (Currently available ones: CommandButton, TextBox, ComboBox, CheckBox, OptionButton, Label, Frame, PictureBox, Line, Shape, VScrollBar, HScrollBar, Timer, DriveListBox, DirListBox, FileListBox, Image, TreeView, ProgressBar, DTPicker, MonthView, Slider, and UpDown. For others, Krool's VBCCR and VBFlexGrid are now available as x64 compatible for tB. Additionally, the Microsoft-provided OCXs for others will work, but the x64 version of MSComCtl.ocx doesn't come with Windows and isn't legally redistributable-- but if you have Office 64bit, it works in tB).
- Form.DpiScaleX/Y properties
- Per-procedure [ IntegerOverflowChecks(False) ], [ FloatingPointErrorChecks(False) ] and [ ArrayBoundsChecks(False) ] attributes to disable those checks on performance-critical routines while leaving them generally in place.
- Constant function folding: You can specify a [ ConstantFoldable ] attribute for functions where when called with non-variable input, will be computed at compile time, rather than runtime. For example, a function to converted string literals to ANSI. The result would never change, so the resulting ANSI string is stored, rather than recomputing every run.
- Removal of limits on line continuations, procedure size, etc.
- Handles and Implements procedure syntax so you can use different names if you wish, for instance instead of Form_Load you can have Sub AppStart() Handles Form.Load
- IsNot operator
- CurrentComponentName CurrentProcedureName CurrentProjectName CurrentSourceFile and CurrentComponentCLSID variables; easily make boilerplate code like error handlers.
- Compiler warnings for common bad practices or likely oversights, with ability to set them to ignore or turn them into an error both project-wide and per-procedure with [ IgnoreWarnings(TB___)], [ EnforceWarnings(TB____) ], and [ EnforceErrors(TB____) ] attributes
- Customize COM initialization call used by hidden entry point (CoInitialize STA, CoInitializeEx MTA, OleInitialize STA)
- Built-in ability to make a console project rather than a GUI project with default Console class for reading/writing console IO and provided debug console.
- Form .MinWidth, .MinHeight, .MaxWidth, and .MaxHeight properties
- Control anchors-- control x/y/cx/cy can made relative, so they're automatically moved/resized with the Form.'
- Form.Opacity property for alpha blending
- Form.TopMost property
- TextBox.NumbersOnly
- PictureDpiScaling property for Forms/UCs/PB
- CodeLens allows running Subs in modules with no arguments right from the editor without starting the full program
- Internal functions like MsgBox now support Unicode
- IDE features long desired that VB6 lacks: Code folding (with ability to define Regions that can also be folded via #Region ... #End Region), sticky scroll, multiple modules/classes per file, Unicode support in editor/properties, info on hover, advanced info option for hover shows Len/LenB/alignment for UDTs and offsets for UDTs and interface methods, and the full inheritance chain for interfaces. Also History panel, parenthesis/bracket color matching, minimap, and Variables panel that dumps the values of ones in use by that procedure on break, controls with Visible=False are faded, Outline panel with control over what's outlined. Type library viewer shows the entire source in tB language syntax.
- Online package server for code packages that can contain any type of tB code-- modules, classes, etc. (They can be used offline too.)
- Inline initialization of variables (e.g. Dim x As Long = 1)
- [ Unimplemented ] attribute for methods allows showing a compiler warning about it being unimplemented wherever it's called (you can upgrade it to error too).
- Can have module-level declares in between Subs/Functions instead of needing to all be above them (while often bad coding practice this is good for e.g. very simple 1-line macros directly related to declares).
- [ SetDllDirectory (True/False) ] attribute to allow an explicitly loaded DLL to load it's own dependencies from it's load path. Also has the effect of allowing searching the app path for the DLLs in the base app's declare statements (used per-declare).
- Support for block and inline comments with /* */ syntax, e.g. Sub Foo(bar As Long /* out */)
- [ TypeHint() ] attribute allows populating Intellisense with an enum for types other than Long.
- [ CompileIf(condition)] method attribute for more advanced control over conditional compilation.
- LoadPicture can now accept a byte array as a source for images.
- Len and LenB can now be used on type names as well as variables, e.g. LenB(Of LongPtr) will return 4 or 8 depending on 32/64bit, and LenB(Of MyUDT) will return the size of Type MyUDT without needing to declare a variable of those types.
- Short-circuiting If() function to guarantee consistent behavior not offered by VB's IIf.
- Binary literals: b = &B100110110
- Grouping for literals with _ (underscore): b = &B01010101_10101010
And I guarantee I'm missing some (still-- I've been updating this post as I remember or am reminded about others). There's a whole bunch more planned, including unsigned types, aliases defined in language, inheritance, etc.
So there's *already* a lot of compelling reasons to use tB over VB6.
I've been working on a more detailed writeup of each one, but it's only about 2/3rd complete.
Edit: 6 months after originally posting this, I'm still finding things I missed... today, it was binary literals! &B10010110101
You can set it to export after save, to a path with project variables-- so you can create an export for every version that updates it until you build and change the version number.Quote:
Originally Posted by PlausiblyDamp
Then you have the [RunAfterBuild] attribute you can apply to a function, so you could write one to copy everything from the export folder to somewhere linked to a source control system, or directly to an online one.
Wow, he's added a lot of stuff since the last time I checked it out.Quote:
Originally Posted by fafalone
Is there an easy way to import automatically as well? Otherwise it would seem this is fine for committing changes to a version control system, but would make it really difficult to do anything that involved frequently branching, rolling back, or pulling from a central server.Quote:
Originally Posted by fafalone
Not yet, tB is moving along at an excellent pace compared to every other attempt but it's still in beta with a long to-do list and unfortunately there's only one Wayne... certainly sounds like a good feature request to make.
It will all be much better when project files can act like VBP files and just reference external sources. That would sidestep the need for a specific import feature for the time being.
There is an 'Import from folder...' option on the New project dialog which takes the output from the Export Project feature and recreates the twinproj file.Quote:
Originally Posted by fafalone
The external files support will be available before v1.
BETA 268 of the twinBASIC programming IDE is now available...
Download from here... https://github.com/twinbasic/twinbasic/releases
- Click on "Assets" for the latest release
- Download and Extract the ZIP file into a local folder
- Then run the twinBASIC.exe from that local folder
How to install https://nolongerset.com/how-to-install-twinbasic/
Crikey, I thought that was the list of "greatly desirable functionality in TB". However, if it is truly what is in TB already, then that's impressive.Quote:
Originally Posted by Niya
I don't know if it's time to ask this, but the TB executable is faster than the VB6 EXE. Or have you not reached this stage yet?
It still produced unoptimized native code last I checked. I seem to recall talk of an optimizing compiler being available only in paid versions. I don't know if any of this has changed though.
The unoptimized native code tB currently produced is faster than VB6 P-Code but slower than VB6 native code optimized for speed.
But tB has some features here I forgot to list.
You can specify [ IntegerOverflowChecks(False) ], [ FloatingPointErrorChecks(False) ] and [ ArrayBoundsChecks(False) ] on a per-procedure level, so you can leave those on generally, but disable them for performance-critical routines, and greatly improve performance. I don't recall what the numbers came out to vs. VB6's code without disabling those options project-wide.
Another one I forgot is [ ConstantFoldable ]-- tB has constant function folding, which can resolve function calls that will never change at compile time, rather than executing them at runtime.
So for example.
When constant function folding is enabled,Code:[ ConstantFoldable ]
Private Function ToANSI(sIn As String) As String
Return StrConv(sIn, vbFromUnicode)
End Function
is computed and the result stored in your exe at compile time, so the function doesn't need to run when the result will never change.Code:Private Foo As String
Foo = ToANSI("Bar")
AFAIK the plan for optimized exes to be subscriber only hasn't changed; but I don't think that's too unreasonable.
@yereverluvinuncleber, yes, that's a list of new features you can use right now in the current build of tB. I've updated the list with these and some others I forgot at first. The list of planned but not yet implemented features is a separate list with a lot more on it.
BETA 269 of the twinBASIC programming IDE is now available...
Download from here... https://github.com/twinbasic/twinbasic/releases
- Click on "Assets" for the latest release
- Download and Extract the ZIP file into a local folder
- Then run the twinBASIC.exe from that local folder
How to install https://nolongerset.com/how-to-install-twinbasic/
@fafalone,
It seems that tB already uses method-attributes like VB.NET and C#, which makes the language much more flexible and expressive, but does this greatly increase the complexity of the language? Also, why does tB use C#'s square brackets instead of angle brackets similar to VB.NET when marking method-attributes? Eg:
Code:<ConstantFoldable>
Private Function ToANSI(sIn As String) As String
Return StrConv(sIn, vbFromUnicode)
End Function