An alternative is B4J, a free (as in beer) BASIC that compiles to Java, so should run just about anywhere. It also has
* B4A - a free version for Android * B4R - a free version for Arduino and ESP8266 * B4I - a paid version for iOS
The main (sole?) developer is ridiculously responsive and helpful.
It seems that can buy a perpetual license for GBP £5000 / developer, which is equal to 16 years of monthly subscription (quite optimistic for a 3yo project).
- .Net
- JVM
- Android (JDK and NDK)
- iOS, macOS, tvOS, and watchOS
- Windows
- Linux
- WebAssembly
Does XYPlorer work with Wine?
Because they lack something (for worse or better depending on one's requirements) equivalent to NTFS' MFT & USN Journal. Closest is building own file db by first-time full scan and then updating via fanotify/inotify. This is what FSearch tool does.
- Extract selected archives
- Flatten current folder
- Convert selected file(s) to various formats (e.g. JPG to WebP or vice versa)
- Optimize selected image file(s) (smaller file size)
- Prepare image file(s) for publishing on my photography blog: strip irrelevant EXIF, create two variants (thumbnail and a bigger picture); see my post: https://darekkay.com/blog/photography-website/#pipeline
- Prepare image file(s) for sharing - similar as above, but more for sharing vacation photos with my family on WhatsApp)
- Rename files to a certain format (e.g. images to "YYYY-MM-DD HH:mm:ss")
- Check selected file with Virus Total
- Start a weekly backup to my external drive
- Backup my server files to my local drive
- Create a rectangle "album art" file, see my post: https://darekkay.com/blog/resize-album-art-images/
Many of those are just shell scripts and apps that I run right from XYplorer, but it's way faster than through CLI.
I've documented some of the XYplorer stuff here (see also the "scripts" folder): https://github.com/darekkay/config-files/tree/master/xyplore...
> VB6 only available in 32-bit
Extension methods/properties ("class helpers"), generics, enum types, for..in loops, static methods, closures, smart pointers, value types ("records"[1]), attributes, variables can be declared anywhere (removing Pascal's limitation), type inference, multiline strings.
Besides all of this, modern Delphi can compile code for Windows, Linux and Mac, as well as Android and iOS. It seems like there's even a cross-platform library for writing apps that can run on both Mobile and Desktop called FireMonkey.
VB6, on the other hand, is a language frozen in time. It never supported any other platform than 32-bit Windows[2]. It only really works on the new Microsoft Surface Laptops thanks to emulation, but I can also run Nintendo 8-bit games on a Surface Pro 11 using an emulator — that doesn't say much.
Unicode support is also a mess. VB6 always used Unicode internally, but this was implementing during the UCS-2 heyday (so you need hacks to use Emoji for instance). Worse yet, is that VB6 was never really designed to run natively on Windows NT, so it's mostly using using the XxxYyyA family of APIs instead of the XxxYyyW family of APIs. This means that you can only display text in a non-English writing if your system's ANSI codpeage is set to that language (in the past you had to restart Windows to change this, not sure if it has improved). To make things worse, some languages (from countries that were too pair to get ANSI pages in Microsoft during the 1990s). So no Ethiopian languages or Mongolian as the author claims. Windows ANSI codpeages also do not "fully support" Japanese and Chinese as the author claims. Over the years the governments of Japan, China, Taiwan and Hong Kong have updated their national standards (which defined tables of characters that should be digitally encodable) and introduced more characters that were previously not mapped. These characters were not new or fake[3] — they were just less common, but still in use. All of these various government standards (like JIS X 0213, GB 18030, Big5-2003) got quickly incorporated into newer versions of Unicode, but the Windows ANSI codepages stagnated and they don't support some of the characters in these codepages. I'm not sure how it's going to affect VB6, but I'm pretty sure that some Unicode CJK characters would just not map into ANSI and would not be displayed even if your system code page is set correctly.
With all of these things considered, no developer who cares about their users should choose VB6 for writing a modern app. I'd also argue that no developer who cares about themselves would do that. VB6 wasn't a great language to begin with. It was better than VB3, but it was still inferior to Delphi even when it was out. Customizing the UI beyond the basics, often needed custom ActiveX components written in C++ or messing around with a lot of raw Windows API calls. Error handling was very painful too. It was never a great developer experience even back of the day if you wanted to do anything beyond the basics.
---
[1] To be fair, Borland's Pascal dialects had value types support since they've implemented object oriented programming (that came in either Turbo Pascal 5.5 or 6.0, I don't exactly remember). Turbo Pascal "objects" could be put on the stack or as pointers like in C++. They even had destructors that would be invoked automatically when the object went out-of-scope, again like C++'s RAII. But the old "objects" kinda botched polymorphism (I don't even remember the details), so when Delphi came out they've been replaced with "classes" that are Reference-only (like Java, but initially without any form of automatic memory management).
[2] VBA was originally ported to Mac, but it is not exactly the same language, lacks the GUI designer and can't run most VB6 apps
[3] In most cases, at least: https://www.dampfkraft.com/ghost-characters.html
Male programmers would call in and do a bit of intro so you knew they were not dumb, just busy.
VB6 programmers would say things like "I am a very senior VB developer". They were the only "very senior" programmers who did not seem to understand things about OS stuff. Like exported functions and their different calling conventions, why you need to "register" COM .dlls, environment blocks, handles, etc.
Don't forget nodejs.
Never observed such a thing with any other language. (Of course I am too young to have met people building business apps off COBOL or BASIC).
I did some VBS ASP back in the day (not VB), and the language was more just annoying, at least partially due to the BASIC legacy stuff. Like it didn't even have a hashmap, you had to import something from Internet Explorer.
I wish we had a new drag and drop WYSIWYG to get people interested. Put Python or Go or even Basic behind it. QT maybe? Heck make it Electron.
I'm not sure I would be where I am today without VB having existed, and it's a shame kids today don't have the same tools available.
Simple website in a minute without any need to know HTML.
No free tool that does that today. Dreamweaver does, but it's paid.
I went to a restaurant last night that had QR codes instead of a menu. The QR code took you to their Linktree, which linked to some PDFs on Google Drive. You could criticize that for looking unprofessional, but it sure looked better than a Frontpage site.
The other day I went looking for information on a neighborhood business that's a bit cagey about saying what they do. Their website (built by a consultancy that charges US$450, according to the Wayback Machine) seems to have been online from 02013 to 02018, but they have active pages on Facebook, Instagram, and YouTube, which apparently is good enough for them. (It turns out to be a school for mentally disabled teenagers, if I've interpreted the multiple layers of euphemisms correctly.)
So the niche of "build a web page for free without learning HTML" where Frontpage and GeoCities followed NaviPress is not just not dead; it's thriving.
We called it Don’tPage.
"What is Lazarus? Lazarus is a cross-platform integrated development environment (IDE) that lets you create visual (GUI) and non-visual Object Pascal programs, and uses the Free Pascal compiler to generate your executable. Its aim is write once, compile anywhere: you should be able to just recompile your program source code with Lazarus running on another operating system (or a cross compiler) and get a program that runs on that operating system."
There are also tools like Gambas and Gnome Builder that'll let you drag and drop UI components, but I find the software designed to run on Linux kind of lacking in comparison.
I mean, look at EverQuest Online, insanely old MMO client, still has people building private servers, and even clients.
On the other hand, this rubs me the wrong way:
> So, wouldn’t it be logical to conclude: If such an application can be written in VB6 then VB6 cannot be that bad after all?
Yes, it absolutely could be bad. Our industry consists, in no small part, of turd polishing. Plenty of good software is written in bad (or ill-fitted) languages, and vice versa.
That's because you mention VB6 as a language. VB6 is not about the language, but about the platform and vertical integration; from the IDE to the app to the distribution.
It was magical that dropping a telephony component into a form enabled the form to make phone calls. Or you could drag-drop a Web Browser component, and have a browser inside your app. Or a database component, and a thousand other things. Few of these required reading the docs.
There are many apps that can be written (and deployed!) faster in legacy VB than with anything available today.
the magic of COM[0]!
But when it crashed it crashed hard. And the underlying programming model (beyond just using premade ones) are a bit hard to grok and fraught with footguns that shoot not only yourself, but the OS as well.
And you don't even need COM. You could do the same things today with RAD components in, say, Java. But it's just no longer a fad. Programmers nowadays don't think that dragging a component that makes phone calls and linking it to a button.
Nowadays, they would just write "npm install telephony" and then add a couple of lines that they got from the README.md on GitHub (or from their AI assistant) to make a call:
import { Dialer } from "telephony";
const dialer = new Dialer();
dialer.call("+1 800 1234 1234");It's a grandiose vision. It just didnt work out because of how complicated it is in practise to implement the COM interface(s), and not enough apps did it anyway.
It is slightly different from a library, since that library would have to be useable from your language (or have some sort of FFI mechanism).
Many things were designed at the level of Microsoft App 1 (e.g. Word), and then when they needed something different for another app (e.g. Shell) they extended the interface in a different interface, and so on. The only authority for interfaces was Microsoft. Nobody else was really able to come along and make a set of interfaces that would become universal for something new, so you had to wait for Microsoft's design, and then it would be designed to support the way it was implemented in Word, Excel, or Internet Explorer, and they would not release the implementation details, just an interface specification and some hastily-written documentation.
Naming things was hard for Microsoft, so they came up with idiotic names like "IClassFactory" because they couldn't decide if they wanted to call something a Class (Smalltalk-style) or a Factory.
It took forever to learn because the documentation was not oriented around practical things, it was toy examples that didn't even work within the system. As a young programmer, it took me a long time to understand how everything was registered, what the difference between a CoClass and an interface really was, where to get that initial IUnknown pointer, etc., because the books were so focused on vtables and toy examples, etc.
The system was mostly replicated by Netscape/Mozilla for XPCOM, so it had areas where you could apply the same principles on other platforms. It also had superficial similarity to SOM/CORBA so learning those systems (thankfully mostly gone now) was also somewhat easier after learning COM.
There were several categories of applications.
- Those that used COM/OLE fully, as the underlying basis of everything they did, used structured storage, and exposed components and automation to the rest of the world.
- Those that implemented some sort of automatability and things like shell preview.
- Finally, those that used the minimal amount to support drag and drop and the like.
After a while, Microsoft's habit of introducing the next big thing and mostly abandoning it a few years later caused Windows application development to decline. COM has always been around, but many related technologies come and go. .NET blurred the lines between COM and the .NET runtime, and then Microsoft started making substantial overhauls of the Windows runtime without, IMO, getting buy-in. Why write WPF when it's similar to but incompatible with UWP? Why write UWP when Win32 works just fine? I wonder if they're going to introduce yet another? Oh, sure, Windows App SDK. Should we use GDI+ or Direct2D? Which one is going to "win"? Why do any of this when Microsoft themselves is using Electron in VS Code?
https://www.npmjs.com/package/react-native-telephony
And it’s nowhere near these neat 3 lines. Same for ui.
I agree that the spirit of VB/Delphi is in theory easily transferrable to any modern runtime. But in practice we suck at it and there’s nothing even remotely close to just dropping a component on a form. All we have is miles of vaguely explained boilerplate and the most convoluted idioms that don’t connect. The basic technology is lost and only miraculously exists as a windows support artifact.
I wanted to use Excel from within Delphi - I wasted more than a few weeks and ultimately failed. I always suspected that the COM/OLE integration had problems with some of the advanced features I was trying to use (I was trying to do something rather complicated). Plus the documentation and support was lacking for Delphi - Microsoft best supports Microsoft tools. I did use Delphi and COM successfully in many other situations but that one failure really soured me towards COM and Delphi together. I am typically capable of making complex integrations work, so I was surprised to fail.
It depended on the existence of the RS-232 Communication Port object, MSCOMM32.OCX. Which often turned up missing :\
Plus unlike most of the other activex objects, mscomm32 had a certificate that was set to expire, and in only about 5 years, but loads of people never knew it until about 5 years later when it happened, and it's been a shitshow ever since Windows XP.
Just searched a bit and the situation may be looking up:
https://www.vbforums.com/showthread.php?897698-MSCOMM32-OCX-...
You may still need to "locate" a suitable version of mscomm32.ocx since there are probably more expired versions in archives than there are acceptable files which will register properly.
This may be one, still referred to as a trick at the time:
https://github.com/davidanger/MSCOMM32
You may need to copy mscomm32.ocx to additional Windows folders and register the file there for different versions of Windows and/or Office too.
Having said that COM itself wasn't that bad. If you read the Don Box book he justifies pretty much all the technical decisions they made.
In the end my productivity doubled when I shifted from C++/COM to C#/.Net.
I can get Modern iterations of Visual Basic such as VB.Net. The syntax and semantics hurt my eye and my brain, but if that's your thing, yeah the language is very serviceable. It's a modern language with modern features and a lot of legacy baggage. It's not worse than PHP or maybe even JavaScript (though I would much prefer JavaScript).
But VB6 means taking the language and tooling as they were in 1998, frozen in time, and writing a modern application to a modern user base.
Also opening the standard window to open/save a file is a missing feature. You can use a vbx control but it's difficult to distribute, or you can use the API, but the null characters are a small problem.
That's better than you can say for a lot of software these days
Eg the moment you need to deal with security like certificate or whatever this goes out the window.
The point is: prejudice is bad. Use whatever floats your boat
I'd say security is a problem if one uses a 30 year old piece of software but apparently Microsoft still releases security updates: https://www.microsoft.com/en-us/download/details.aspx?id=507...
>A security issue has been identified that could compromise your Windows-based system running Microsoft Visual Basic 6.0 Service Pack 6
>The Visual Basic 6.0 IDE is no longer supported as of April 8, 2008, however, the Visual Basic team is committed to “It Just Works” compatibility for Visual Basic 6.0 applications
>Date Published: >3/23/2021
The installer was originally digitally signed with a sha1 certificate. The sha1 certificate with replaced with sha256 on 3/23/2021.
It's honestly blazingly fast in comparison to Windows Explorer on Windows 11.
Native Windows apps just never seem load that fast or work that great. It’s kind of crazy how much better the basic OS apps feel in macOS compared to Windows.
I wish Microsoft would have gone in a direction more similar to Apple, with an AOT compilation and reference counting.
JIT and garbage collection sound great in theory, but in practice I’ve found them both to be loaded with footguns that more than eliminate any benefits. At least with .NET, that is.
I’m hard pressed to think of any Microsoft software at all that I think feels really nice. Except for VSCode, which is of course built on Electron and not .NET.
The only thing that comes to mind is Paint.NET, which doesn’t seem like all that big of an application. It’s very nicely done, but I think it’s only got like a single dev working on it, so couldn’t be that big.
and in context to the thread files-community/files is great and open-source and .NET * https://files.community/ (its actually 96% .net and 3.1% c++)
Most of them. An implementation would have to go out of its way to make itself perform poorly if it is built on top of, say, .NET 8.
Have you heard of Ryujinx? Or Nethermind? Or Garnet? Or have you seen that .NET's Regex engine, written in pure C#, is the third fastest in the world after Intel's Hyperscan and Rust's Regex crate?
We are only just now wrapping up the conversion at work to .NET 8 from 4.8, so it will be interesting to see the performance numbers once that is complete.
Our .NET application has millions of lines of code, so JIT compilation time in particular in the old .NET could be very painful.
The difference between 4.8 and 8 can easily be tenfold, depending on the workload and bottlenecks (if it's a slow DB query - EF Core might compile it to a more efficient variant in, say, EFC 8, but if it's linear scan - not much can be done).
Edit: I stand corrected, based on reply in a sibling comment most of the perception stems from how .NET Framework works. Understandable.
This is because there are many limitations in what can be compiled this way, and most C# applications and libraries were never built with such limitations in mind.
But a lot of people are completely out of touch, thinking something along the lines of "Clearly Golang is managed by YouTube and Google Search teams" except about .NET whenever complaining about whatever happens to Windows nowadays.
On NT, process creation is very slow compared to most (all modern?) other operating systems, where-as thread creation is near-instant.
Not sure what you mean by 'work that great'.
> JIT and garbage collection sound great in theory, but in practice I’ve found them both to be loaded with footguns that more than eliminate any benefits.
I can't think of a single C# Console, Web, or WPF app I've created where I have to explicitly concern myself with JIT or GC. That doesn't mean they're not out there (games? maybe? Fez? Stardew Valley?), but I think you'd find one calling explicit GC methods somewhat rare, or being concerned with how long an app takes to JIT.
I used to deal with SharePoint Server quite a bit which is _slow_ to start due to JIT, but I didn't care because I'd just have an uptime monitor app fetch a page or few on the front end to make sure it JITs before (re)adding it to the load balancer.
In my experience, main performance killers are:
- calling blocking functions on the UI thread
- N+1 problem
And there's nothing specific to C# about it. .NET garbage collection becomes an issue only when you allocate lots of objects per second (100k or millions), and very few UI apps do that. If there's perceived sluggishness, I doubt it's the runtime.
Slow as a dog and will often not render after all, compared to how it would act for decades up until less than a year ago.
It's a new defect in relation to the video drivers, badly incompatible with the default Microsoft Standard Display Driver, so what can you say?
I would expect that's an indication that XYplorer is a much more advanced, well-developed and mature alternative not relying on flaky emerging APIs that have too few decades of reliability to compare.
https://answers.microsoft.com/en-us/msoffice/forum/all/micro...
It's written by a single person, and they're very responsive. I've recently reported a bug with the search (the first that I've noticed in all those years), and it's been fixed within a day. I'm only worried about the bus factor a little.
I have a GitHub repo with some of my settings/scripts/notes for XYplorer if someone's interested: https://github.com/darekkay/config-files/tree/master/xyplore...
And there are three things I learned about it
1. There is a lot more money in it than you would think. The good part of "there is a lot of newbie using it" is that there is a lot of newbie using it and tons of software in it out there, and once you prove you know what you're doing you drown in high paid work, and with a bit of job selection it's not the bad horrible maintenance kind but decent fun too.
2. There is no need trying to argue with people about it online or whatever. You're not going to convince anyone they're better language than they think. PHP 8 is a top notch language and people are still dumping on it using php 4 things.
3. Ultimately there are people who spend their time talking about what language is right and people who get things done, build something great and it doesn't matter if it's cpp or Javascript or whatever. So at the end of day I've made a fair bit of money improving or building stuff used by lots of people to generate tons of revenue, and everyone involved is happy about it.
Maybe the things they've added lately have been well designed, but did they ever actually fix the WTFs from PHP 4?
JavaScript has the same problem. They added `let` and `const` but never removed `var` or `==`. If you take a look at ESLint rules there are dozens of footguns that could have been fixed in the language. Not as bad as PHP's footguns, but still...
IMHO, although its improved A LOT it’s still a mess. But with the right tooling you can kinda-sorta make it behave like a sane language if you squint a bit.
There should be a name for the "nothing is perfect so everything is equally bad" fallacy. It's surprisingly common.
https://www.greaterwrong.com/posts/dLJv2CoRCgeC2mPgj/the-fal...
> The Sophisticate: “The world isn’t black and white. No one does pure good or pure bad. It’s all gray. Therefore, no one is better than anyone else.”
> The Zetet: “Knowing only gray, you conclude that all grays are the same shade. You mock the simplicity of the two-color view, yet you replace it with a one-color view . . .”
> —Marc Stiegler, David’s Sling
I think this falls under splitting (black-and-white thinking), a form of defense mechanism or (I suspect) mere rhetorical tool.
What can be confusing is mixed lifetimes of nested generators using `yield from`. If any outer generator has a shorter lifetime, when it is garbage collected `yield from` will forward `close()` to the inner generator. Attempting to re-use the inner generator will result in a premature `StopIteration`. Iterators do not have `close()` and so are unaffected. This affects only `yield from` and not `for i in gen: yield i`.
The one I'm talking about is the fallacy of grey, linked from a sibling comment.
Java is probably the longest lasting language that I would consider good. Are there things that I hate about it? Of course. But it got a lot of things right - even things that more modern languages have done much worse at, like IDE support.
What do you mean? The time & date API in Java is excellent, and the float and double types follow the IEEE standard.
Dunno what's up with getYear() though!
I'd love to see a PHP without the warts. Something that is trivial to embed in a web page just the way PHP is but without the foot guns.
If you have a background in C programming, most of the "wtf" is completely reasonable - the only thing "modern" and novice PHP programmers will still raise the WTF flag about is the standard library, mostly the string manipulation functions, their names and argument order. Old dogs know that this comes from early PHP being not much more than a thin wrapper around libc and various other C libraries.
Other than that, if you write modern PHP it's almost like Java, just without threads/concurrency in general, and without extremely braindead tooling required to get something built. PHP Composer is a breeze compared to Gradle, Maven and messing around with Tomcat, Glassfish and classpaths to get your application deployed...
Honestly 90% of web apps could be easily built with PHP, Laravel, Inertia and React/Vue in half the time.
Also, you still run artisan to view your code after you save. Same thing with Python's FastAPI: I run FastAPI's server. I just save my code just like PHP.
If webpages from 30 years ago stopped working because 2025 developers favor aesthetics and disrespect legacy, I'd be pretty angry.
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...
How does something like this even happens.
Anyway, if you "use" strict mode, but the browser doesn't support it, you're effectively not running in strict mode, so you can't actually assume the Javascript will execute differently.
0777 style octal numbers are a footguns inherited from C. Don't ask my why they made that mistake! Modern languages use 0o777.
Mostly though I don't care if we break old stuff. It happened all the time when developing for the desktop. People just dealt with it. The ones most impacted are lazy enterprises and I have no sympathy for them.
Clinging on to the past stifles innovation.
If you start telling people they have to install an obsolete web browser, and then an obsolete operating system, and then patch the drivers because all the hardware doesn't support it anymore, you have effectively gatekept information that was once available in the open web to the tech elite.
Yes, "tech" is redone from scratch every 6 months so 5 years ago is an eternity, but there are plenty of fields where 30 year old information is just as invaluable as something published today.
Nobody is maintaining webpages published in the 90's. Nobody is going to update them. They are just there, sitting on some university's server that barely gets any hits. The author probably died 12 years ago and nobody even remembers who is responsible for it or that it's running. And it's in everyone's best interest to keep it that way: online.
We could implement a version declaration system that removes and fixes elements of JavaScript when properly declared.
Depends what you class as a WTF. The older parts of the standard library are still wildly inconsistent in function naming and argument order, but that’s never going to change because it’s simply not worth the BC break.
But they’ve done a good job cleaning up the actually problematic bits of the language. Previous horribly insecure defaults like register_globals and magic quotes are long gone. And in recent years they’ve worked on tightening things up: many obviously incorrect behaviours have been promoted from notices or warnings to outright errors.
It might take a while to enumerate them all ;)
I really have very little annoyance with PHP despite retaining some WTFs. In fact, with a modern language server and psalm I find it downright comfortable.
It's easy to use, easy to get into for beginners, and is a requirement for WordPress. But performance? Flexibility? Some other random metric-word?
1) Easy hotfixing/debugging on production servers. Just edit a file and save. Our teams which program in PHP solve blockers way faster than the Go teams.
2) "Shared nothing" architecture, which has two advantages:
a) it's scalable without additional effort, because PHP processes are stateless
b) better security, especially if you're doing multitenant SaaS, because all requests are isolated from each other (there was a bug in ChatGPT when you could view chats of other users because requests from different users were served by the same OS process in Python and they had a race condition bug when switching between users inside the same OS process - such bugs are very rare in PHP)
Not saying it's unique to PHP, but these 2 advantages for real production code are often overlooked; people instead focus on non-essential minutiae like "inconsistent function name, I'd name it differently tbh"
For my company: minor apps with laxe requirements, hotfixes usually involve editing a single file, in place, then push to Git. We don't have "serious" apps in PHP, but we have a few low tier apps using it, it's simple and convenient.
It's been ages since I've last seen Delphi in real life - must be over 20 years ago by now.
But I'd not put PHP in the same league of "dead and bad" with it... yes, it's not the "hipster" language these days, that's been taken over by <insert JS framework of the day> in frontend, NodeJS in the backend and Go for "need to quickly cobble something together"... but it still powers dominant parts of the web. Obviously Wordpress, Typo3 and Drupal in the CMS area which power a large amount of individual websites, and then the large behemoths Facebook, Wikipedia and Fandom/Wikia.
It's dead to the extent that you are unlikely to start a new project in it but I wouldn't classify it as bad. It's just of it's time.
Agreed! Also, typically far lower memory usage.
The catch? I don't know Pascal, and there is no way to learn it. There are so many versions of Pascal that every tutorial you find will be about a different version. The GUI tutorials are for Borland Delphi, not Lazarus. There is no documentation or recipes for doing basic things, e.g. if you want to make a simple to do list CRUD that adds items to a list, you have no idea which widget is the correct list widget. Normally in this case you have a model-view list and a string list. Doing anything with lists that have columns is often a confusing nightmare, but and it becomes even more confusing with no documentation about it.
On the forums, the recommendation is to just press F1 in the source code editor to read the documentation for a function, but that doesn't help you when you have no idea what function you need to call, and you won't know it often. How do you append an item to an array, for example. How do you REMOVE an item. Is there a splice function? A remove function? Where are the dynamic arrays. Is there something like classes, and if not, how are you supposed to organize objects that you want to instantiate. How the lifetime of things work. Every time you ask "is this the correct way to do it using this tool?" you'll have no answers. How do you structure your project? It's completely different from how modern languages work and from how even C works.
> Why: There are many books and resources about Pascal out there, but too many of them talk about the old Pascal, without classes, units or generics. So I wrote this quick introduction to what I call modern Object Pascal.
Beauty in languages or tool chains is one thing, but the satisfaction of solving an issue for someone within some weird constraints for whatever reasons is real.
5. Poor coding practices can produce unmaintainable code in any language.
The pain of the maintenance programmer is caused by the implementation programmer, not the implementation language.
So, I did. This was literally the push I needed to switch to open source tooling, and it put me in the right time and place to be a Rails early adopter.
I downloaded XYplorer mostly out of curiousity, and it's actually so fast that I am slightly shocked to say that I might be switching to it.
PHP has the same issue, it is awesome and powerful but gets a bad rep because the versions before 2004 had issues and the low barriers to get started means beginners love PHP.
I do know VB since VB 3.0 days, did quite a couple of VB 6 to VB.NET, and VB.NET to C# portings, so it isn't like I don't know the subject.
On the topic of "wait what that's VB6", here's an entire 3D modeling and rendering suite in pure VB6: https://github.com/Planet-Source-Code/kaci-lounes-a-3d-digit...
Other options all had their quirks that made their apps look out of place on Windows. It was easy to say an app was built with Delphi or FoxPro. VB apps just looked like Microsoft apps and felt perfectly at home.
I remember how easy it was to even get the 3D look popularised by Office in VB apps.
I guess I skipped this app before because on the screenshot it looks like it just has one panel. But after trying it out, it has "dual pane" mode, so I will give this a shoot.
That isn’t quite correct, because you can take the address of a VB6 procedure and pass it to win32 CreateThread. See the related chapter in Hardcore Visual Basic for example. And of course you can use win32 mutexes and such. Thanks to the win32 interoperability, there aren’t a lot of limits of what you can do in VB6.
xyplorer has been providing partial compatibility with 64-bit windows shells by way of some "sidecar" executables, which act like hosts for 64-bit shell extensions, thumbnailers, and whatnot.
iirc some of these sidecar tools were originally written in autohotkey; now that's another interesting language.