back
3 comments
The word for German in many Slavic regions is something like Njemacki (and similar). Loosely translated it means "Those who cannot speak".

Of course, Germans can speak and languages of German descent are just as rich, precise and expressive as any other. But the term Njemacki probably stuck around out of an initial ignorance about a foreign culture in earlier times and lack of general education.

>initial ignorance about a foreign culture in earlier times and lack of general education

I upvoted your comment because I agree with it in the context of the parent, but this ending explanation is frankly ridiculous. It sounds like early Slavs had no idea that Germanic tribes had their own languages which is just plain impossible. Proto-Slavic němъ meant also unintelligible/hard to understand. So contrary to popular opinion those Slavic words for Germans doesn't (and didn't) mean mute (or "cannot speak"), it's just that in modern Sl. languages words stemming from němъ evolved to indicate mostly muteness.

Thank you for the clarification. I tried to exaggerate my point, but what you say is obviously true and much more nuanced.

In fact it's so easy to forget or ignore that we humans were just as smart and creative thousands of years ago as we are today.

But it's interesting and funny to think that our ancestors called each other mute, or rather unintelligible, because they didn't understand what the other one was saying. I find it endearing how we often stumble over our own limitations and quirks, so much that it is often ingrained in language and culture.

Good reply. Thank you!
> out of an initial ignorance about a foreign culture in earlier times and lack of general education.

Like how the Ancient Greek lacked education (Barbarians). ;)

Only for the first half an hour. Coming from C I found the Zig syntax very straightforward after writing a couple of hundred lines of code.
To whom?
To me, for example.

> .{}

That's the same as using `{}` in C to initialize a struct. The dot only makes more clear that it's a struct literal and not a scope.
The language cetainly seems to like using that 'dot' operator:

    const exe = b.addExecutable(.{
        .name = "demo",
        .root_source_file = .{ .path = "src/main.zig" },
        .target = target,
        .optimize = optimize,
    });
It's not invented by zig: https://en.cppreference.com/w/c/language/struct_initializati...

Although more widely used.

For the example you cited (anonymous struct literals), there are two parts to it:

1) It omits the constructor name. My uneducated guess is that "modern" languages try to avoid the Java-style pattern of repeating a type/constructor many times in a single line (e.g., "Point pt = new Point(0, 0)") when it can infer things to help the developer.

2) It starts with a dot, while C++'s compound literals (for example) don't. The pros and cons of this are discussed in https://github.com/ziglang/zig/issues/5039.

Is C foreign to you? Zig syntax is nearly identical to how C initializes structs.