The Imperium programming language - IPL

[tggzzz]

I had very similar thoughts, the major difference being that C# is no worse than other languages.

It is similar to Java in that it compiles to CIL, a stack-based bytecode interpreter, which is touted as "portable".  We all know how portable Java is, and how portable .Net/Mono is: not very, when you start trying to get actual work done, instead of simple examples.  Instead of acknowledging differences between operating systems and hardware architectures, it applies a heavy (again, bytecode interpreter/JIT compiler) abstraction layer to hide them. 

Shortly before C# was released, Anders Hejlsberg gave a talk about it at work. We were all underwhelmed, regarded it at a typical me-too-entend-embrace-extinguish MS ploy. I never programmed in it, and never regretted it. I have never had much faith in Mono either

For this reason alone, C# is not a language one should base their understanding of programming languages on.

At the language level, C# is Java with added insecurities.

At the implementation level, C# is Java with longer application installation times due to static optimisation, and the inability to optimise based on how the code is interacting with the data.

Beyond that, it is better to ignore the details, and free up your brain to concentrate on significantly different languages.

Portability and adaptation to different architectures, and understanding the different approaches (paradigms) different languages have, is utterly paramount for understanding software engineering in a way that one can apply in more than one particular niche (Windows C# programming).  C# is designed to avoid having to do that.

All modern languages are designed to conceal the underlying architecture.

If we ignore the single-vendor control, the reliance on CIL, and just look at the language specification, say the latest version (C# 6.0) standardized by ECMA in ECMA-334.pdf –– noting that Microsoft published it in 2015, ECMA-334 was published in 2022, and Microsoft has already published C# 11.0 –– you could compare it to older versions of C++.  In particular, it does not have specific-size integers, and instead codifies that 'short' is 16-bit, 'int' is 32-bit, 'long' 64-bit, and the 'char' type uses UTF-16; i.e. IP32 or LP64.
In short, meh.

Such delays in standardisation are, ahem, standard. But there are worse phenomena, e.g. I remember a usenet post triumphantly announcing the first complete C++ compiler six years after the spec was released. That alone confirmed my earlier decision that C++ was fundamentally the wrong direction!

I didn't know about that integer issue, because I decided not to trouble my brain with C# details. I presume it was a consequence of the security holes in C# programs containing C/C++ components.

Java ... my Java-cup says "program once, use many"...and I laugh every time I use it to drink my coffee.

Exactly.

If we do not learn from the past, we're doomed to repeat the same mistakes, as well.

Java's portability is far better than C/C++ How much that matters in any given case is up for discussion.

[Sherlock Holmes]

String Literals

How important is a rich support for string literals in an MCU world? C# recently introduced an impressive innovation, is this useful? how important is this kind of feature?

https://www.stevefenton.co.uk/blog/2022/02/raw-string-literals-in-c/

[tggzzz]

String Literals

How important is a rich support for string literals in an MCU world? C# recently introduced an impressive innovation, is this useful? how important is this kind of feature?

https://www.stevefenton.co.uk/blog/2022/02/raw-string-literals-in-c/

"Feature" is the right word. Without "benefit" nobody will care.

The end result is easily achievable right now. Hence it is syntactic sugar, not a benefit.

But no doubt those that go into paroxyisms of delight that the Edge browser may have rounded corners (or not) will become ecstatic.

[Siwastaja]

In MCU world, not only string literals, but ability to include a binary file would be actually handy. Something like

uint8_t coeffs[] =
#binary_include "coeffs.bin"

so that one does not need to write conversion tools from binary to "{0x12, 0x34"} etc.

[Sherlock Holmes]

In MCU world, not only string literals, but ability to include a binary file would be actually handy. Something like

uint8_t coeffs[] =
#binary_include "coeffs.bin"

so that one does not need to write conversion tools from binary to "{0x12, 0x34"} etc.

Now that's an interesting idea, exactly the kind of feature suggestions I'm looking for!

[Sherlock Holmes]

String Literals

How important is a rich support for string literals in an MCU world? C# recently introduced an impressive innovation, is this useful? how important is this kind of feature?

https://www.stevefenton.co.uk/blog/2022/02/raw-string-literals-in-c/

"Feature" is the right word. Without "benefit" nobody will care.

The end result is easily achievable right now. Hence it is syntactic sugar, not a benefit.

But no doubt those that go into paroxyisms of delight that the Edge browser may have rounded corners (or not) will become ecstatic.

Actually its not easily achievable at all, take a look at this more in depth article.

https://blog.ndepend.com/c-11-raw-string-literals-explained/



The number of prefix $ and " characters is variable.

Two $$ for example means single { } are treated as literal text, but {{ }} are interpreted as a runtime expression.

If one wants to embed " inside a string its easy:

"""This is an example of "Heading Label" we can use."""

If we needed to - ever - embed two quotes "" we can do this:

""""This is an example of ""Heading Label"" we can use.""""

[Sherlock Holmes]

In MCU world, not only string literals, but ability to include a binary file would be actually handy. Something like

uint8_t coeffs[] =
#binary_include "coeffs.bin"

so that one does not need to write conversion tools from binary to "{0x12, 0x34"} etc.

So a compile time initialization of static data via an external data file would be useful? I've never heard of this idea before, its extremely interesting.

I did already introduce this better notation too for numeric literals:

Code: [Select]

       counter = FACE B034 D85F BAD7:H;

So including a binary file could be done by converting the file (during compilation, the compiler would do it) to that kind of string...doing that at compile time eliminates any need for the code to have to do any kind of file IO as well, less code, less libraries...

How to express that kind of initialization though. The above was intended initially as just another way to express a numeric constant, I've not thought about the initialization side of this yet...

One could allow an array to be initialized just using that notation:

Code: [Select]

dcl coeffs(1024) bin(8);

coeffs = AB CE 7A 88 96 4E 3D.......:H;


Would expect there to be 1024 sets of 2-digit-hex values and that's it.

Whereas:

Code: [Select]

dcl coeffs(1024) bin(16);

coeffs = ABCE 7A88 964E 3D42 0004.......:H;

Would expect them as bocks of 4-digit-hex values.

The meaning is clear and the logic is basically to populate elements 1 thru 1024 with each successive constant, each space separated chunk would be regarded as the data for a single element.

So if we allow arrays (of primitive types) to be initialized that way, doing a "binclude" would be pretty straightforward for the compiler to do.

Code: [Select]

dcl coeffs(1024) bin(16);

coeffs =

#binclude "adc_table.h"

;

So to speak...I guess this falls under the preprocessor heading, something I posted very briefly about a couple days ago.

[magic]

I hope this thread is not time wasted and the final spec will be ready by early April

In MCU world, not only string literals, but ability to include a binary file would be actually handy. Something like

uint8_t coeffs[] =
#binary_include "coeffs.bin"

so that one does not need to write conversion tools from binary to "{0x12, 0x34"} etc.

Pretty sure that somewhere on stackoverflow there is a stupid little script which achieves this with binutils; then it should be a simple matter of linking the resulting .o into your project and

Code: [Select]

coeffs.h:

extern uint8_t *coeffs;
extern size_t coeffs_size;

[ataradov]

I do that binary inclusion with GCC for some project. It works, but I can't say it is pretty. Here is what I do for that

In the command line pass the files you want to be included as raw byte arrays:

Code: [Select]

RESOURCES = \
  res/icon.png \
  res/image_1.png \
  res/image_2.png \

LIBS += -Wl,--format=binary -Wl,--start-group $(RESOURCES) -Wl,--end-group -Wl,--format=default

And then in the code declare the symbols corresponding to those file:

Code: [Select]

extern uint8_t _binary_res_image_1_png_start;
extern uint8_t _binary_res_image_1_png_end;

Then you can get a pointer and a size as this:

Code: [Select]

uint8_t *data = &_binary_res_image_1_png_start;
int     size  = (int)(&_binary_res_image_1_png_end - &_binary_res_image_1_png_start);

It is better than using external tools, for sure. And in practice I don't find myself needing to do this a lot, so not a huge issue.

[Siwastaja]

LIBS += -Wl,--format=binary -Wl,--start-group $(RESOURCES) -Wl,--end-group -Wl,--format=default

Excellent tip, and well demonstrates how the ecosystem and tooling is as important as the language itself. And that is the strength of C, despite all the shortcomings of the language itself.

[SiliconWizard]

I do that binary inclusion with GCC for some project. It works, but I can't say it is pretty. Here is what I do for that

In the command line pass the files you want to be included as raw byte arrays:

Code: [Select]

RESOURCES = \
  res/icon.png \
  res/image_1.png \
  res/image_2.png \

LIBS += -Wl,--format=binary -Wl,--start-group $(RESOURCES) -Wl,--end-group -Wl,--format=default

And then in the code declare the symbols corresponding to those file:

Code: [Select]

extern uint8_t _binary_res_image_1_png_start;
extern uint8_t _binary_res_image_1_png_end;

Then you can get a pointer and a size as this:

Code: [Select]

uint8_t *data = &_binary_res_image_1_png_start;
int     size  = (int)(&_binary_res_image_1_png_end - &_binary_res_image_1_png_start);

It is better than using external tools, for sure. And in practice I don't find myself needing to do this a lot, so not a huge issue.

I am using this as well. It's the easiest way of including "resources" in your programs.

I've written a small library to make it easier to use, it does essentially what you are showing, but allows declaring and accessing 'resource' objects easily. Very lightweight.

[magic]

 

I knew it has to be a solved problem
It even gives you those _size symbols, so you don't need to calculate blob sizes manually.

Code: [Select]

$ ld -o opa2604.o --format=binary --start-group opa2604_30v.png opa2604_48v.png --end-group
ld: warning: cannot find entry symbol _start; not setting start address
$ ls -l opa2604*
-rw-r--r-- 1 m users 45920 2019-03-27  opa2604_30v.png
-rw-r--r-- 1 m users 44319 2019-03-27  opa2604_48v.png
-rwxr-xr-x 1 m users 94956 01-14 20:33 opa2604.o
$ objdump -t opa2604.o

opa2604.o:     file format elf32-i386

SYMBOL TABLE:
08049000 l    d  .data  00000000 .data
00000000         *UND*  00000000 _start
0805f07f g       .data  00000000 __bss_start
08049000 g       .data  00000000 _binary_opa2604_30v_png_start
0805f07f g       .data  00000000 _binary_opa2604_48v_png_end
0805f07f g       .data  00000000 _edata
0805f080 g       .data  00000000 _end
08054360 g       .data  00000000 _binary_opa2604_30v_png_end
0000ad1f g       *ABS*  00000000 _binary_opa2604_48v_png_size
08054360 g       .data  00000000 _binary_opa2604_48v_png_start
0000b360 g       *ABS*  00000000 _binary_opa2604_30v_png_size

edit

It even gives you those _size symbols, so you don't need to calculate blob sizes manually.

But they are not ordinary variables and trying to use them as such causes segfaults.
You need to take the address of that symbol to get the size of its corresponding blob.

[Sherlock Holmes]

So injecting binary static data in this manner is deemed sufficient? an ability have a compiler do this simply by compiling the code, wouldn't be that helpful?

[ataradov]

In a newly designed language I would do something better, of course. But this is such a minor thing that it would not be a consideration for switching languages or anything like that.

[SiliconWizard]

So injecting binary static data in this manner is deemed sufficient? an ability have a compiler do this simply by compiling the code, wouldn't be that helpful?

It's not "injecting" data any more than a compiler injects data with compiled object code. It's the same thing.

I actually kinda like it. It's generating object files from binary files, adding this in the programming language itself doesn't add anything much, except possibly making it cuter, but this can be made cuter by wraoping it with a few lines of code (as I mentioned.)

The plus point is precisely that it's language-agnostic. Writing a wrapper for the language you use is relatively trivial.

This is pretty much what resource compilers were doing on Windows and MacOS. But this approach only requires binutils and is thus portable as long as you are using binutils.

[Sherlock Holmes]

So injecting binary static data in this manner is deemed sufficient? an ability have a compiler do this simply by compiling the code, wouldn't be that helpful?

It's not "injecting" data any more than a compiler injects data with compiled object code. It's the same thing.

I actually kinda like it. It's generating object files from binary files, adding this in the programming language itself doesn't add anything much, except possibly making it cuter, but this can be made cuter by wraoping it with a few lines of code (as I mentioned.)

The plus point is precisely that it's language-agnostic. Writing a wrapper for the language you use is relatively trivial.

This is pretty much what resource compilers were doing on Windows and MacOS. But this approach only requires binutils and is thus portable as long as you are using binutils.

Well this is precisely the kind of thing that I want to support, its easy to implement, like the switchable keyword lexicons, I need to think about it though, step back and see the 'big picture', the preprocessor is all about executing code at compile time and I want to take a long look at preprocessing anyway.

[Sherlock Holmes]

Here is some test source code used to help me test the grammar of the new language. This is just to give an idea of how code would look once one started to use it. You'll see a bunch of things in here, using @ for labels and singly/doubly quoted string literals that can contain quoted substrings and span multiple lines, also you'll see subscripted labels too. Most of the comments are fictitious, just to give the code a real world appearance.

Code: [Select]

procedure main (arg);

    /* This is sample code */

    dcl name string(32);
    dcl I bin(15);
    dcl J bin(15);
    dcl S bin(31);
    dcl A(1024) bit(8); // 1 KByte
    dcl root ptr;
    dcl status bin(15);

    type_a = "string literlas can be single quoted like this";

    type_b = ""or double quoted like this, with embedded single quoted text "like this" see?"";

    name = ""demonstration_network_controller"" ;

    title = ""This is the "best in class"
   
    language system"" ;

    //call sys$announce_device(name, status);

    if status ~= 0 then
       return;
    end;

    call sys$install_platform(title);

    root = sys$get_system_bootroot(name);

    call sys$validate_authority(root);

    goto cycle_loop;

@cycle_loop

    I = 100;

    if I > 0 then
       goto cycle_loop;
    end;
   
    I = sys$get_updated_count(J);

@setpoint(0)

    loop while (I >= J)
       I = get_updated_count(J);
    end;

    if I = 123 & J = 321 then
       I = 0;
       goto setpoint(I); // never pass non-zero !!
    elif J + I > J * I then
       goto cycle_loop;
    end;

    call get_latest_faulting_stack(S);

    if S ~= 0 then
       call sys$stack_crawler(S);
    end;

    /* set S to the sentinel for the next operation */

    S = F5D3 03A2:H; // we need to ensure this sentinel is not allocated to any other device types

    call sys$reinitialize_firmware_table(S);

    call sys$sleep (1024);

    goto cycle_loop ;

/* Crawl the stack chain looking for the designated handler */
procedure sys$stack_crawler (handler_id) recursive;

    arg handler_id bin(31);

end;

/* Only call this if we kmow there's no active services still running */
procedure sys$reinitialize_firmware_table(table);

    arg table bin(31);

end;

procedure sys$timer_callback (context) interrupt;

    arg context pointer;

end;

end;



[SiliconWizard]

So injecting binary static data in this manner is deemed sufficient? an ability have a compiler do this simply by compiling the code, wouldn't be that helpful?

It's not "injecting" data any more than a compiler injects data with compiled object code. It's the same thing.

I actually kinda like it. It's generating object files from binary files, adding this in the programming language itself doesn't add anything much, except possibly making it cuter, but this can be made cuter by wraoping it with a few lines of code (as I mentioned.)

The plus point is precisely that it's language-agnostic. Writing a wrapper for the language you use is relatively trivial.

This is pretty much what resource compilers were doing on Windows and MacOS. But this approach only requires binutils and is thus portable as long as you are using binutils.

Well this is precisely the kind of thing that I want to support, its easy to implement, like the switchable keyword lexicons, I need to think about it though, step back and see the 'big picture', the preprocessor is all about executing code at compile time and I want to take a long look at preprocessing anyway.

Well, the "wrapper" I was talking about uses some preprocessor to help, so if you implement a better preprocessor than the simple C one, that sure would help here.

Just be aware that writing good compile-time stuff that can fully replace a preprocessor (and do more and better) is no simple task.

[Sherlock Holmes]

So injecting binary static data in this manner is deemed sufficient? an ability have a compiler do this simply by compiling the code, wouldn't be that helpful?

It's not "injecting" data any more than a compiler injects data with compiled object code. It's the same thing.

I actually kinda like it. It's generating object files from binary files, adding this in the programming language itself doesn't add anything much, except possibly making it cuter, but this can be made cuter by wraoping it with a few lines of code (as I mentioned.)

The plus point is precisely that it's language-agnostic. Writing a wrapper for the language you use is relatively trivial.

This is pretty much what resource compilers were doing on Windows and MacOS. But this approach only requires binutils and is thus portable as long as you are using binutils.

Well this is precisely the kind of thing that I want to support, its easy to implement, like the switchable keyword lexicons, I need to think about it though, step back and see the 'big picture', the preprocessor is all about executing code at compile time and I want to take a long look at preprocessing anyway.

Well, the "wrapper" I was talking about uses some preprocessor to help, so if you implement a better preprocessor than the simple C one, that sure would help here.

Just be aware that writing good compile-time stuff that can fully replace a preprocessor (and do more and better) is no simple task.

Yes it isn't simple, Antlr4 however is extremely powerful, it makes it easy to experiment and iterate the grammar rules without writing a line of code. The way to do the preprocessor too would be to devise a separate grammar for the preprocessor language, then that would become an initial phase, consume source and perform preprocessing then, the output from that gets parsed as a phase 2, using the actual language grammar. Once again I'll be studying PL/I's preprocessor, I hardly used it when I used to write PL/I but apparently it was very powerful supporting meta-loops, meta-ifs and even meta-procedures, there may be a truly useful core that I can "borrow".

See page 699 of this doc if you're interested in the PL/I preprocessor.

C's #define is based on PL/I's %replace and C's #include is based on PL/I's %include.

Here's an example that expresses a loop as a preprocessor loop, the loop is replaced by multiple distinct assignment statements by the preprocessor:



This does something similar (it seems) the stuff that the Zig preprocessor can do.

[DiTBho]

Pure garbage. Again.

[DiTBho]

@SiliconWizard
"But this approach only requires binutils "

Yup, not supported by Acorn DSE (riscOS), CodeWarrior-SONY-ps1 (Windows) and Sierra (dos).

No binutils -> you need a specific tool.

The Nintendo sdk for GB and GBA come with a tool to convert a gif image into a c file stuffing an array with hex values.
The Acorn DSE does the same.

[SiliconWizard]

@SiliconWizard
"But this approach only requires binutils "

Yup, not supported by Acorn DSE (riscOS), CodeWarrior-SONY-ps1 (Windows) and Sierra (dos).

No binutils -> you need a specific tool.

The Nintendo sdk for GB and GBA come with a tool to convert a gif image into a c file stuffing an array with hex values.
The Acorn DSE does the same.

As long as your tools use a separate linker and object files, then it's usually doable as with binutils one way or another - you may have to write your own utility to generate an object file from binary data if it doesn't exist already.
Now if you use a compiler that has an integrated linker and gives you no easy access to intermediate object files, then obviously your only bet is to stuff data in variables directly in the programming language itself.

[Sherlock Holmes]

Pure garbage. Again.

Perhaps programming language design isn't a good fit for you, you feel inadequate, unable to contribute meaningfully, so you lash out, your emotions take over.

You might do better with flower arranging or something less intellectually strenuous, a man must know his limitation after all...

[DiTBho]

Pure garbage. Again.

Perhaps programming language design isn't a good fit for you, you feel inadequate, unable to contribute meaningfully, so you lash out, your emotions take over.

You might do better with flower arranging or something less intellectually strenuous, a man must know his limitation after all...

 

[DiTBho]

@guys, ignore this troll, seriously, and he will leave the forum.
Otherwise we have to babysit this grown dude.
I am seriously going to ignore the whole topic, I have seriously enough.