Oh yeah I'm enjoying QB64

[madscijr]

The ease at which it puts the modern machine on call for me is very appreciated.

Absolutely! I know these days Python is the popular cross-platform language,
but I never really grew to like the language itself.
Also Python (like a lot of languages these days)
just seems way more complicated than it needs to be with all these 3rd party libraries
that you need to do basic stuff like graphics, that are all version-sensitive.
Managing all that is a pain - especially when you have to worry about other people running your program,
having to make sure their computers have the right version of everything, etc.

I wasn't crazy about Python being interpreted, or not having variable types,
whereas QB64 supports strong typing, compiles to a native EXE, and works on PC, Linux and Mac.

I'd often prototype or bash out a routine in basic before making it work with C/C++ and assembler.

If you can handle C/C++/assembly then QB64 will be a breeze.
You might end up teaching us some things!

I sometimes worry the ease of access to very powerful features is teaching me to be lazy

That seems to be one of the big reasons I think the programming commmunity got away from languages like Visual Basic,
and moved to languages based around more "modern" and "correct" methods like pure OOP and design patterns,
and stuff that is just overkill unless you're programming some enterprise application.
What these people forget is that you CAN write non-spaghetti code that is easy to reuse and maintain,
using simple procedural code, without having to resort to all those crazy OOP methods. 
It just takes a little discipline to write clean code.

but that passes when I can knock off a little program
without having to learn a framework or an API
and how a particular implementation of the programming language does or doesn't deal with said features
inside a RAD suite.  

For programming little desktop apps, utilities & games, BASIC is way easier to work with than the complicated mess that has become "modern" programming.

Looked at some old coding tricks and I realized...wow 80-90% of this was to get around the segment limits and the memory model. 
Actually being able to casually knock out a program that uses dozens if not hundreds of megs of ram is a pleasure.

I was thinking the same thing - looking back on old programs I wrote for other systems, so much of it was just jumping through hoops to get around the limitations of whatever particular system it was coded on. That is the kind of stuff that makes it hard to reuse your code later on other systems.

(I still get nervous about garbage collection.)

It can be an issue depending on what you're doing. For example you want to make sure you release graphic images from memory with _FREEIMAGE!