qb64 VS racket

Unpopular opinion now, but I also still think BASIC is still one of the most approachable beginner languages, even today. Late-era BASIC was way different than the old-style line-numbered BASIC that got a bad reputation for teaching bad habits, and it was possible to write well-structured programs with later dialects like QBasic. There's even a modern, open-source variant of it still being developed called qb64 that makes it possible to make standalone programs with it and I believe adds new features on top of QB (like for graphics handling, mouse, etc.) while also retaining backward compatibility with old QB code. It would even be possible to carry that knowledge forward to a platform like Xojo, which is like a continuation of VisualBASIC, though I wouldn't necessary encourage that. Would make more sense to start with QB and then take the fundamental knowledge learned there and apply it to learning new languages.

Aqui, ó, pra matar a saudade: https://github.com/QB64Team/qb64/blob/77adfc4e1a537733047fcaf638abfcdeef46db2b/programs/samples/misc/nib64.bas (só copiar e colar no QB64, F5 e alegria!).

QB64 v2.0 is now officially available, and you can get it from the official release page on GitHub: https://github.com/QB64Team/qb64/releases/latest

You might appreciate QB64 too...a 64 bit version of QBasic that is cross-platform to Windows, Mac, and Linux and 100% backwards compatible with Qbasic/QB4.5/QBX which is 90% compatible with Visual Basic 1-6 except for the OOP and extended keywords. You can find it, and the C++ source included (compiled with MinGW or GCC usually) at http://www.qb64.org

https://www.qb64.org

There’s also a GUI toolkit with an interface designer being developed for it: https://www.qb64.org/inform/

Racket—the Language-Oriented Programming Language—version 8.12 is now available from https://racket-lang.org

See https://racket.discourse.group/t/racket-v8-12-is-now-availab... for the release announcement and highlights.

Thank you to the many people who contributed to this release!

Feedback Welcome

Racket version 8.11.1 is now available from https://racket-lang.org/

Racket (https://racket-lang.org) has an IDE (DrRacket) which isn't EMACS. ARC (which powers hacker news) is (was?) written in Racket.

Nice! Repeating a comment I just made on HN: I signed up for RacketCon, will be joining remotely. I am looking forward to it a lot. Usually I use the Racket language perhaps for 10% of my personal projects, but I am currently writing a Racket AI book, so all things Racket are of current interest. Past RacketCons have been a lot of fun. I usually use Common Lisp, but Racket is batteries included Scheme, and more, and is a very pleasant language and ecosystem. Just in case you don’t have Racket installed: https://racket-lang.org/

I signed up for RacketCon, joining remotely. I am looking forward to it a lot. Usually I use the Racket language perhaps for 10% of my personal projects, but I am currently writing a Racket AI book, so all things Racket are of current interest.

Past RacketCons have been a lot of fun.

I usually use Common Lisp, but Racket is batteries included Scheme, and more, and is a very pleasant language and ecosystem. Just in case you don’t have Racket installed: https://racket-lang.org/

I'd suggest Racket (https://racket-lang.org) which is a batteries-included language environment that includes scheme and has a lot of high-quality documentation.

Guile (https://www.gnu.org/software/guile/) isn't quite as learner-focused but is another great choice.

How did I get to the bottom of the page and not ONE person has recommended racket?

The Racket fork of CS supports Apple Silicon natively, and can be installed independently: https://github.com/racket/racket/blob/master/racket/src/ChezScheme/BUILDING Chez adds a few features (threads, ffi, ...) to R6RS; there is a useful combined index to TSPL4 and the CS User Guide at http://cisco.github.io/ChezScheme/csug9.5/csug_1.html

If you're using SICP in Scheme (or are you doing the JS version?) then you may want to look at How to Design Programs. It uses Racket which is a Scheme descendent so much of the language you've learned in SICP will work in it without issue. It also has a pretty good set of GUI and drawing capabilities you can find through the Racket docs page and will use some of with HTDP.

My info is a bit out of date, but I'll try to go through big block of concerns...

> Do I want to iterate every 18 hours waiting for the pkgs.racket-lang.org build server to finish building my package? Then do it again because the build failed (my mistake, but now my users have to wait until later that week…)?

( https://pkgs.racket-lang.org/ is one way of sharing an open source package, through a public repository analogous to PyPI. There is a small delay upon uploading a new package/version, because the server builds the package, runs the package's tests, formats the package's documentation, etc.)

I don't know why it would take 18 hours, and I don't see a bug report linked.

Maybe the author was just doing a commit to their own random GitHub repo, without telling the Racket packages repository, and so waited for the packages repository to do a periodic scan of all third-party packages' random Git/Web sources for new versions? (I'd always go to the Racket package repo Web UI, and push a button of some kind there, and the new version would go through promptly.)

> Do I want to worry about packaging and deploying Racket code or could I simply do the same in most other languages without any fuss? I tried packaging Racket in Nix, it did not go well.

What didn't go well? Racket runs on a wide variety of systems. I once experimentally packaged it for plastic OpenWrt routers, and it was straightforward. https://www.neilvandyke.org/racket-openwrt/

> Do I want to invest trust in a programming platform that considers umask of optional importance? https://github.com/racket/racket/issues/4511

That was a helpful bug report, and looks like Matthew Flatt followed up on it promptly, and the bug report even got Matthias Felleisen's interest.

Then, given Racket's emphasis on cross-platform and backward-compatibility, Matthew's decision to add the semantics support without breaking production for all of the existing users. That seems reasonable and predictable to me.

> Do I want to force users to adopt an application written in a language that uses at the very least 122M resident memory on my workstation? Or do I consider Python or Guile which both use less than 10M?

I don't know how the author is running their code, so this might be the best Racket can do with the code, or maybe...

DrRacket (IDE) can run code with very heavy debugging instrumentation, and you can also do similar things from the command line.

DrRacket also has a feature that limits memory usage to a specified amount, IIRC defaulting to 128MB, which is great for alerting programmers on workstations with multi-gigabytes of RAM that they might be doing something inefficient.

Code can be run from source files (silently compiling/recompiling on demand and caching for later runs), from the compiled form, or into a more packaged form (which IIRC does some tree-shaking).

What libraries you pull in can also mean surprises (e.g., I see a later comment by author in which they mention a third-party package having inappropriate dependencies).

If you want to run in really tight memory, that will affect how you program, and will include an awareness of the garbage collector.

But also, small executable size probably isn't a top priority for Racket.

> Do I want to force users to package Racket which itself has no clear custody of its build inputs - can you produce a Racket tarball yourself that is exactly like the one on the release site? Who knows what’s in those tarballs!

I suspect the author is talking here about what's now called "reproducible builds".

> Do I want to invest in a community without a mechanism to apply community feedback constructively? RFCs?

The author got Matthew Flatt and even Matthias Felleisen giving prompt attention to the bug report they linked.

They'll find similar responsiveness on the mailing list.

> Do I want to write 4x the code (in Racket) because I forgot my secret move was actually all the pypi packages that I took for granted in Python?

Depends what you need to do. The normal case, with programmers who are performing at normal levels and with normal practices is just to using PyPI (or NPM, or Cargo, or whatever), and bang out a solution to a normal problem.

But if you need to do something unusual, or you have programmers who are super-effective and can even judiciously bang out that reusable code as needed (better than the reused packages), then consider getting out of their way -- whether they just do it in Python or NodeJS, or they say this will go better in Racket, Rust, or something more exotic.

> Do I want to wonder about what was meant by “contributions welcome” when most of the core racket codebases at best have a README, at worst have no contributor documentation?

Documentation is one of Racket's strengths. From near the top of https://docs.racket-lang.org/ , see, for example, the document "Building, Distributing, and Contributing to Racket".

> Do I want to invest in a platform where leadership is building Rombus a.k.a. Racket2 instead of focusing on making core Racket just that much better and easier to adopt? (see also: Future of Racket.)

That's a good question. Racket is solid for production, has features that other languages still haven't discovered or done as well, and the author saw the prompt attention to their bug report. (The Rhombus thing has been going on much longer.)

> Do I want to wait 10+ minutes for my package to build in CI because some other package maintainer decided to pull in racket or racket-doc (which pulls in the entire big Racket distribution)?

Talk to the developer of that third-party package?

> Do I want to ship multi-gigabyte docker images because of the above kitchen sink package?

Talk to the developer of that third-party package, and there might be additional things you can do.

> Do I want to deal with being blocked due to not understanding how to use the less understood features of racket such as continuations, syntax-parse/syntax-case macros, units/signatures? You’ll want to know about all these things to write effective Racket code.

You'll need to understand first-class continuations to work on all the Racket internals as a compiler developer. But I don't recall ever seeing a non-internals use of that.

For the syntax extension mechanisms, you can learn that as-needed and at your own pace, because it's for things that most languages can't do (and does it better than languages that can). And you can definitely learn them incrementally, and start with the higher-level forms, which might just do what you need.

Units/signatures are ancient, and you probably don't need to use them. Just use the very nice module system (including submodules), and then decide whether you need more.

> Do I want to add business risk by writing a product in Racket? Does anybody work as an industry Racket coder at all? Would I struggle to hire more talent?

It's probably needless additional risk/unknown to use for business unless you have more or more people who are able to dig in and figure out technical stuff without Stack Overflow. (Though there are helpful forums, but you'll need to rise to the occasion more often.)

And one of the the secret weapons of beloved fringe languages/platforms is that they attract those mythical "10x" programmers on basis of technical/aesthetic/community merits rather than employability, so there's more of them than there are great jobs using Racket...

> Do I…. yeah there’s more but let’s move on ;)

OK, skipping...

> Where did the racket-money mailing list go?

https://www.neilvandyke.org/racket-money/

It's quiet most of the time, but picks up when a new person joins or there's a question/idea.

> Or really all the production users? I only found one production user.

There's more than that, including doing spectacular productivity and importance, but there's not many.

One thing the author of the blog post might be realizing is that the Racket professors are generally super-capable, they support production users like most professors couldn't, they'll provide technical support to any random person around the world. They'd love more commercial uptake, but that's been far from their top priority.