meta Meta language released

[Kaj de Vos]

I appreciate you testing FreeBSD, though.

 

It could work on your 32-bit machine if you install QEmu.

 

On a 64-bit machine, it should work under FreeBSD Linux emulation. But the compile.ape adapts itself to the machine at first run, so you would have to redownload it and force Linux emulation somehow.

 

In the future, I will publish native executables for older FreeBSD versions, but that will take some more time.

[Kaj de Vos]

Added comparisons of Hello World with REBOL, Red, CC65, Mad Pascal, Millfork and Cowgol:

https://language.metaproject.frl/#examples

[zbyti]

Show me how to use pointers :]

[Kaj de Vos]

I can't, because there are none. ?Meta works at a higher level.

 

Meta has references, which will be safe, whereas pointers are inherently unsafe. The implementation of references is abstracted. The compiler could implement them as managed pointers, or as indexes. Some reference type checking is done at compile time. Run-time bounds checking isn't implemented yet. Until then, you could misuse references as pointers in some cases, but these holes will be plugged.

 

Here's a surprisingly timely treatise on the differences:

http://cowlark.com/2009-11-15-go/index.html#hh5

 

If you really want to use pointers, you can disable bounds checking, or use the integrated assembler. But even there, Meta does type checking as much as possible, to prevent classes of errors it can prevent.

[zbyti]

If you do this example:

 

https://github.com/zbyti/k65-playground/blob/main/src/a8/starfield/main.k65

https://github.com/KarolS/millfork/blob/master/examples/a8/horizontal_stars.mfk

 

in META, I'll learn a lot :]

[drac030]

If SDX relocatable format is supported, could you provide an example of the "Hello World" program using the PRINTF library call?

[Kaj de Vos]

1 minute ago, drac030 said:

If SDX relocatable format is supported, could you provide an example of the "Hello World" program using the PRINTF library call?

That's not implemented yet, but it would indeed be the next thing to do, and would compare very nicely with the other back-ends.

 

The SDX back-end isn't enabled yet on the build server, either. Both the server and client need to learn to support multiple targets.

[Kaj de Vos]

8 minutes ago, zbyti said:

If you do this example:

 

https://github.com/zbyti/k65-playground/blob/main/src/a8/starfield/main.k65

https://github.com/KarolS/millfork/blob/master/examples/a8/horizontal_stars.mfk

 

in META, I'll learn a lot :]

I've been eyeing that. I think I can do it. It's similar to a larger demo I have on the shelf.

[Kaj de Vos]

Found Hello World for Action! and PL65:

https://language.metaproject.frl/#examples

[zbyti]

More examples in Meta please  I tested Action! and PL65 2 years ago

 

BTW if You need some simple examples in Action! for comparison look at: https://github.com/zbyti/a8-action-playground/tree/master/src/ZBYTI

Edited November 8, 2021 by zbyti

[Kaj de Vos]

Too late, I added Logo, too. ? Most of these languages inspired Meta to some extent.

[zbyti]

Every code example from my repositories is a result of learning A8 programming. I started quite recently.

 

If META had similar examples, I would have been able to understand the language without big manual.

Edited November 8, 2021 by zbyti

[ilmenit]

15 hours ago, Kaj de Vos said:

I can't, because there are none. ?Meta works at a higher level.

 

Meta has references, which will be safe, whereas pointers are inherently unsafe. The implementation of references is abstracted. The compiler could implement them as managed pointers, or as indexes. Some reference type checking is done at compile time. Run-time bounds checking isn't implemented yet. Until then, you could misuse references as pointers in some cases, but these holes will be plugged.

 

Here's a surprisingly timely treatise on the differences:

http://cowlark.com/2009-11-15-go/index.html#hh5

 

If you really want to use pointers, you can disable bounds checking, or use the integrated assembler. But even there, Meta does type checking as much as possible, to prevent classes of errors it can prevent.

Will there be at least option to "simulate" use of pointers by byte array placed as selected memory address? Lets say I want to use PMG graphics and place the data at $4000 in memory - how it can be accessed from the language for read/write?

[Kaj de Vos]

Yes. See the Series chapter of the REBOL documentation for how series references work:

https://language.metaproject.frl/#documentation

 

Much of the design work to tweak REBOL into Meta is to enable the more precise programming we are used to on Atari. REBOL's series! abstraction is very universal and powerful, but it only applies it to its own high-level data types. Meta applies the series! abstraction to everything that is naturally a series. The Rainbow examples show how the declaration dialect allows to specify addresses for scalar values. This will be extended to specify arrays.

 

Yesterday it struck me that one barrier to understanding Meta is that the terms high-level and low-level are not adequate to describe it. I would call Meta a right-level language. It has a high-level syntax, but for any part of a program, it analyses how far it needs to compile it down to a lower level to achieve your goals. REBOL doesn't always have the low-level information to achieve that, so in those cases, I add it to the design, which at the highest levels is just a matter of extending the dialects.

[ilmenit]

12 minutes ago, Kaj de Vos said:

Yesterday it struck me that one barrier to understanding Meta is that the terms high-level and low-level are not adequate to describe it. I would call Meta a right-level language. It has a high-level syntax, but for any part of a program, it analyses how far it needs to compile it down to a lower level to achieve your goals. REBOL doesn't always have the low-level information to achieve that, so in those cases, I add it to the design, which at the highest levels is just a matter of extending the dialects.

so it's basically a programming language in which "do it yourself" applies to the language itself?  

[Kaj de Vos]

Can you elaborate?

[zbyti]

1 hour ago, Kaj de Vos said:

Yesterday it struck me that one barrier to understanding Meta is that the terms high-level and low-level are not adequate to describe it.

In my opinion, this is not a problem. On AtariAge we are wonders about the usefulness of this language on A8.

 

I write my programs in Mad Pascal on A8 then I need to have a quick effect, although I don't like Pascal and I get sick from using semicolons

 

Personally, when I have more time, I prefer to write in K65.

Millfork and KickC are serious option - they are versatile, fast and compact.

 

All this compilers are tailored to 8-bit systems and they are suitable for my hobby. I don't see yet where META prevails on 8-bit systems.

Edited November 9, 2021 by zbyti

[Kaj de Vos]

You can't expect Meta to prevail anywhere yet. It was released only two weeks ago and isn't finished yet.

 

From my viewpoint, your post is full of the misunderstandings between high-level and low-level. From the earliest times, we were imprinted that we need two languages: BASIC, which is surprisingly high-level, for quick and dirty programs, and assembly to make full use of the machine. There was a great demand for better BASIC's and better assemblers, but it didn't fix this divide. When Action! came, it was awesome because it was in the middle. It seemed to be able to be a universal language. But it was greater as a concept than in practice: not that much software was written in it. Many other languages were great in concept, too, and ever since I acquired PL65, I wondered why other languages could not mix high-level and assembly seamlessly.

 

Meanwhile, 32-bit machines were stealing the show, with all new languages and assembly instructions. Nothing from 8-bit ran on it, and there were too many to own and learn. Then, the industry consolidated on PC, with all new languages and assembly instructions, and if you wanted to make a living, you needed to learn them.

 

PC's got bigger every year, and the low-level problem was "fixed" by just declaring it obsolete. Operating systems started blocking you from accessing the machine, anyway. You should program everything in a high-level language.

 

PC's weren't big enough yet to fix the compilation delay in the edit-compile-run cycle, so new interpreted languages were invented and became popular. They are two to three orders of magnitude slower than a low-level language, but who cares. Python is the new universal language.

 

Oddly, all the infrastructure of the world was still written in the lowest of the high-level languages: C. Somehow it can't be obsoleted, and performance is still important, but we pay a high price in bugs in everything. And we're still stuck with the great divide: Python instead of BASIC, and C instead of assembly, and never the twain shall meet.

 

For a quarter century, I lost the ability and joy to program for Atari, because there was no overlap with my work platforms.

 

I am fixing all of that. REBOL's implementation is of the same interpreter generation as Python and Ruby, but its language principles are capable of much more. I am morphing it into the successor of PL65. Meta can do low-level things as well as high-level things. In one language, and if you really need to, you can insert assembly seamlessly. Like REBOL, it is great for quick programs, not even dirty, because it is based on solid language design. With the native Atari back-end, I have shown that Meta can generate executables as efficient as K65.

 

I don't know if Meta will ever be better than other 8-bit languages, because several of them are very good. That is not the point, at least on 8-bit. Meta will be as good as the others, but it can do more high-level things, and it will be universal. Now I can't say the same thing about PC languages. Most of them are so inefficient, that Meta is two to three orders of magnitude better, just by not wasting the experience of 8-bit.

 

For me, Meta is extremely liberating. I can afford to program for Atari again, because everything I do there now helps my work on PC. Conversely, I can test algorithms in Meta on PC before I run them on Atari. I will never need a different language anymore. I don't need different languages for different platforms, and I don't need different languages for low-level and high-level work. If I want to program something new or target a new platform, I just extend Meta for it, because it can do it.

[ilmenit]

I have to agree with @zbyti here - I still do not see how this language is going to be "better" than alternatives for A8. What is "better" depends on the use case - the language does not seems to be the fastest, the most readable, the most newbie-friendly, the widely known (like C or Pascal). 

1 hour ago, Kaj de Vos said:

From my viewpoint, your post is full of the misunderstandings between high-level and low-level. From the earliest times, we were imprinted that we need two languages: BASIC, which is surprisingly high-level, for quick and dirty programs, and assembly to make full use of the machine. There was a great demand for better BASIC's and better assemblers, but it didn't fix this divide. When Action! came, it was awesome because it was in the middle. It seemed to be able to be a universal language. But it was greater as a concept than in practice: not that much software was written in it. Many other languages were great in concept, too, and ever since I acquired PL65, I wondered why other languages could not mix high-level and assembly seamlessly.

There were other languages available than Basic or Assembler, except the mentioned Action! there were other quite popular languages for different domains (e.g. Logo, Forth, C, Pascal) so I do not think your point about being "imprinted" is correct. Even without tons of commercial software written in Action! it was a great language also in practice, not only in concept.

Other languages allowed to mix the code with ASM, sometimes through inline assembly (e.g. Kyan Pascal), sometimes through through USR function (e.g. Basic, Deep Blue C).

1 hour ago, Kaj de Vos said:

I am fixing all of that. REBOL's implementation is of the same interpreter generation as Python and Ruby, but its language principles are capable of much more. I am morphing it into the successor of PL65. Meta can do low-level things as well as high-level things. In one language, and if you really need to, you can insert assembly seamlessly.

Do you know that basically any cross-compiler nowadays (like CC65, MadPascal, KickC, Millfork) allow to insert inline assembly or link it with assembly modules, so it's nothing that unique.

1 hour ago, Kaj de Vos said:

Like REBOL, it is great for quick programs, not even dirty, because it is based on solid language design. With the native Atari back-end, I have shown that Meta can generate executables as efficient as K65.

So far it was presented only on trivial example. Try to do it on e.g. "standard benchmark" that computes primes.

1 hour ago, Kaj de Vos said:

Meta will be as good as the others, but it can do more high-level things, and it will be universal.

any example of these high-level things not available in other languages like e.g. MadPascal?

1 hour ago, Kaj de Vos said:

For me, Meta is extremely liberating. I can afford to program for Atari again, because everything I do there now helps my work on PC. Conversely, I can test algorithms in Meta on PC before I run them on Atari. I will never need a different language anymore. I don't need different languages for different platforms, and I don't need different languages for low-level and high-level work. If I want to program something new or target a new platform, I just extend Meta for it, because it can do it.

I think it's great approach, do stuff that is primarily fun for you. Basically all the arguments you wrote here I apply to C language - I can write the same algorithms on PC and for Atari, do development and debugging in Visual Studio and then with cross-compiler compile version for 8bit Atari. 

[Kaj de Vos]

You're focusing on embedded assembly. In those three decades, my ideas developed to incorporate much more low-level support.

 

And yes, REBOL and Meta work on a higher level than most other languages, including Pascal.

 

Standard examples are not the best way to show that, because they are usually examples from lower-level languages.

 

It is a well-known problem in higher-level languages that people don't get them, because they only know lower-level languages. And it is a well-known problem in REBOL that noone from other languages gets it, because it brings new and unique concepts to the table.

 

Look, I can repeat this a thousand times, and you can disbelieve me a thousand times, but that's not what I'm here for. I'm looking for people who are willing to learn something new, something better. That's what I will focus on, and it will require effort and patience from others.

[ilmenit]

I'm here also to learn something new, but the problem, also mentioned by the others, is that so far your arguments hardly convince that it's better, especially for A8 platform.

[Kaj de Vos]

That's why patience is required. Some effort to try Meta and study REBOL wouldn't hurt, either.

[ilmenit]

3 minutes ago, Kaj de Vos said:

That's why patience is required. Some effort to try Meta and study REBOL wouldn't hurt, either.

In fact, I did try Red 0.4 when was released, but didn't use it much. General concept of dialects for me is a big "no" for the language. While it may sound cool, ability to redefine basic keywords depending on the context for me looks like https://gist.github.com/aras-p/6224951 . Basically the whole language looks like a macro preprocessor, where anything can mean anything and does not have clear syntax (it's free form). Problems that already exist with classes conflicts, that are partially solved by namespaces, here are taken to the next level.

Maybe I didn't use a proper IDE for Red that would allow good code navigation to easily understand what is what, with lookup for definitions, but this shouldn't be mandatory for using a language. Also errors produced by compiler were sometimes on the level of errors for C++ templates.

[Kaj de Vos]

Ah, great, then we have a frame of reference.

 

Some of your objections are common objections to REBOL. A long time ago it occurred to me that a number of those are objections to REBOL's free form, as you say. It provides me a great feeling of freedom, but many others seem to be scared by it. It's interesting, and I don't know how many people can overcome that fear. Depending on that, Meta could become popular, or it could remain niche, but it certainly can be a considerable niche.

 

Also interesting is that REBOL is favoured among advanced programmers and not so advanced programmers. It seems the group inbetween that is scared, the group that has experience with other languages, but don't trust themselves to try something different. Some of them are also defending their profession, seeming threatened that REBOL empowers not so advanced programmers.

 

With great power comes great responsibility. You can certainly shoot yourself in the foot by using REBOL's abilities wrong, but C also gives you enough rope to hang yourself. Any language can be misused, and geeks delight in constructing such examples. But if that hurts, then just don't do it.

 

REBOL uses its abilities to provide a fairly common functional language in the default "do" dialect. In Meta, it's even more fake, because the dynamic abilities aren't there yet. As long as you stick to that, it looks fairly much like other languages. This is also why it's hard to convince people that REBOL and Meta are different from other languages.

 

Note that REBOL is a quarter century old and Red a decade. I'm making a lot of effort to improve those designs. REBOL's error messages can indeed be quite confusing, and Red's aren't even properly implemented yet, certainly in 0.4. I spent a lot of effort on Meta's error reports. They can still be improved, but they are much better than REBOL, and much earlier, because it's a compiler doing static analysis, instead of an interpreter postponing all decisions to run-time.

 

REBOL's binding of words to contexts is much better than macro preprocessors, because preprocessors usually ravage contexts. You shouldn't fault REBOL for the problems of others. On the other hand, Red introduced a preprocessor in such primitive form, and I don't agree with that. I don't see a need for a preprocessor in Meta.

 

IDE's are not common for REBOL and Red. Most people are content with the interactive console. This will also come for Meta, but it requires some big steps. Specialised IDE's could assist the language principles quite well, but they haven't gone far beyond the concept stage yet.

[zbyti]

1 hour ago, Kaj de Vos said:

A long time ago it occurred to me that a number of those are objections to REBOL's free form, as you say. It provides me a great feeling of freedom, but many others seem to be scared by it. It's interesting, and I don't know how many people can overcome that fear.

After all, I am one of the few who try programming in K65 and the K65 mnemonics are considered by many to be magical runes

 

Fear not! I'm not scared