Hacker News Reader

Comment by axaxs | Hacker News Reader

Am I reading this right? A single binary, less than 1mb in size, that handles GC and cross compiles? Color me impressed. Looking at platforms, does it not do 64 bit?

View on HN

You're correct. It's crazy what you can do when you don't bundle 8 zillion MB of C in your install. Rebol is the original parent language, but it doesn't have a system language to compile to, just a < 5 MB interpreter that you could do a lot with. Neat little languages. The creator wanted to take Rebol and write a version that would be the first true "Full Stack" language covering everything from desktop GUI to building OS, to highly advanced parsing, to robotics. If you google it, there is a nice interview with Red's primary author Nenad Rackocevic (forgive spelling) that is from ~2015, but still should be accurate.

Interview:

https://notamonadtutorial.com/interview-with-nenad-rakocevic...

Offtopic nitpick:

I never understood stuff like writing "forgive spelling" or "sp?" when the correct spelling is a Google away.

I'd rather have misspelled information than not have it.

Some folks might be on a mobile device with an interface that makes it difficult to switch to another window. Or perhaps they are offline when they're writing it. Or perhaps they have mobility / accessibility issues that makes switching a challenge. Those are off the top of my head.

To my mind, worrying about someone's spelling when I can understand them perfectly is one of those "life's too short" issues, speeking personaly.

>Some folks might be on a mobile device with an interface that makes it difficult to switch to another window. Or perhaps they are offline when they're writing it. Or perhaps they have mobility / accessibility issues that makes switching a challenge. Those are off the top of my head.

There's also momentum. They want to go write a quick comment and type their thoughts as they come -- not stop and Google things.

This is certainly how I am sometimes. I will stop to check things, but it breaks the flow. And, as comments here point out, docs are a big issue. What isn't always clear is how much effort they take to create. With a small team, it's a constant struggle for where to allocate resources. Right now, Red's priorities are based on deliverable functionality.

Thanks Greg! That is well understood and fine by me. I just don't want to see Red's doc to end up like Rebol's. Honestly, it is probably a non-trivial factor for why it never took off.

Still, https://doc.red-lang.org/en/ has some nice docs, and more are in the works.

As the comments suggest below: Googling isn't worth it on a mobile device and it interrupts the train of thought.

>> just a < 5 MB interpreter that you could do a lot with

Just to note that Rebol 2 is below 1 MB. Depending on platform, Core is normally below 300K and View is around 600-800K - http://www.rebol.com/downloads.html

Unfortunately Rebol 3 (Ren/C branch) is a little beefier at this moment :( The non debug version is usually between 1.2 & 1.9 MB - http://metaeducation.s3.amazonaws.com/index.html

This Rebol 3 size will shrink. Currently there is development on build & extension process which will help. NB. There's been a big refactoring/redesign of the Rebol 3 interpreter in last couple of years so there maybe (still) some artefacts from many forks/merging of codebase that could also be shaken out.

Yes. It also handles GUI for Mac and Windows.

The old 32-bit K2 (K language) had a superfast ACID DB, GUI, GC, no dependencies (but also no compilter) and was 250K, so 4 independent platforms would still fit in under 1MB; Arthur is now working on KPARC, which has no compiler but does boot on metal and includes GUI, editor, db, filesystem, network, and a lot more, e.g. this http://kparc.com/edit.k is the implementation of native nano-style GUI editor. ; Last I heard, it was still <500KB.

kOS sounds like a dream. I'd love more info on it. Related HN link:

https://news.ycombinator.com/item?id=8475809

Not very easy to come by, but if you haven't seen it yet, here's a presentation by geocar from 2014: https://www.youtube.com/watch?v=kTrOg19gzP4

> Looking at platforms, does it not do 64 bit?

Right now, it only compiles to 32 bit binaries (which can run on both 32 and 64 bit OS).

64 bit support will come after the compiler is bootstrapped.

> and cross compiles

Yup, easy cross compilation. You do not need different cross compilers for different platforms a la llvm and gcc, a single 1 mb binary can produce binaries for all supported platforms.

I looked over the code to guage how big this 32-bit problem is. It's going to be a lot of work. 32-bit is hardcoded everywhere. Compiler, linker, libc calls.

So, on one hand, there's massive cross-platform support. On the other hand, those platforms are all obsolete, or about to be. Even the mobile and embedded ones have all gone 64-bit.

Maybe backwards compatibility will be maintained for a few years. But it ruins the embed-red-in-C story already.

The current compiler was written with the aim of quick development till 1.0 is reached (because in the initial development phase, there are obviously many other important things to focus on). So, yeah the toolchain has some issues, eg. there are very few (if any) optimizations. Also, only 32 bit is supported.

There are AFAIK no plans to add 64 bit support before bootstrapping phase because the current toolchain architecture isn't that great and will be heavily improved during 1.x cycle.

A bit more details here -

https://gitter.im/red/red?at=56ac45a1586242210ae0704d

and https://github.com/red/red/wiki/Question-about-contributing-...

64 bit processors (and their OS platforms) will retain backwards compatibility to 32 bit apps for the forseeable future. There are too many situations where 32 bit apps are better for that not to be the case (smaller binary size and better cache performance).

iOS 11 does not.

https://developer.apple.com/news/?id=06282017b

For mobile and desktop, sure 32 bit is fading, but embedded 32 bit is so far from obsolete. I don't know how you can even claim that when even 8 bit platforms still have a huge market share.

ARM cortex-M (32 bit) has only recently been able to chip away at 8 bit platforms and gain major use

https://en.wikipedia.org/wiki/List_of_common_microcontroller...

https://en.wikipedia.org/wiki/ARM_Cortex-M#Overview

Yes, but the embedded platforms that are interesting for high-level scripting are mostly phones. Worse than desktops, they won't bother with 32-bit compatibility layers.

Using the other meaning of embedded (I embedded a Lua script in my C application), compatibility libraries don't help. It simply won't link.

Yeah. Red continually impresses me. Its documentation is what has kept me from really diving in. But over all, it's an impressive language.

>> A single binary, less than 1mb in size, that handles GC and cross compiles?

Yeah, me too. I tried reading the Red source code, hmm still couldn't figure it out. Could someone explain how Red achieve this?

Compared to GCC or FPC, Red is obviously very very very tiny :)

Reply on news.ycombinator.com