Zinc instead of vJass?

Hey..

I have wondered...

What do you people prefer?
Still vJass, or do you switch to ZINC?

For those who don't know: ZINC Manual.

I have a few questions about it aswell:
Why do we have a c syntax jass, if it just converts it to jass again?
Isn't that a waste, because basicly, all those who code with cJass, have
to learn the basic jass, so it isn't that hard to just stay at jass?

And also, as some might have said: But we know C, so we can actually
code in it, and that while being in wc3!

Well, but its not good everytime,.. Just think about it.

Why would I code CSS as PHP or HTML?
Or why should I code with JAVA syntax in JS, Perl or something like that?

I mean, its really not hard to write in vJass once you got it, and if you didn't, you can't code in C either, because in fact, vJass has alot less limits and districts as c, and so ZINC seems for me a bit waste of compiling/whatever.

Using the word "code" alongside HTML and CSS proves how ignorant you are of these concepts...

Anyway. I think Vex added Zinc mostly to combine parts of cJass in to vJass reducing some of the need/desire for cJass, holding his monopoly on the JASS-extension market. (Not really a bad market to have a monopoly in...)

Boa is likely because he already did the work of adding Zinc to JH, so another one wont be that much work. (Writing a grammar file is simple, if you know what you're doing.)

I am a Web Developer, so I shouldn't be that bad actually, its just that I suck at english, as most guys here already noticed...

Anyway, you gave no point why using it, so I guess I can just stay at vJass?

I don't care how much you suck at English. If you can define the word "code" at all correctly, you know it is not applicable to data markup languages, and style definition languages... <.<

There is no point to using it instead of vJass, as it compiles to vJass. It's appeasing those who want C-style syntax while also having a chance to start over from scratch in many ways. It's likely that Zinc and Boa will eventually be more coded in than vJass itself, as they will provide more structured programming.

Zinc and boa are really all about me experimenting with grammars and multilanguage support as a practice for some bigger plan I have which you also have had (although mine is more like a fixed version of vJass).

The idea is:
- I practice with grammars.
- We get to experiment how would better structure work in this community.
- I have an option to use quicker syntax without wanting to kill myself.
- I add -> instead of type meh() to keep the cJass freaks away from my belloved Zinc.
- Dilute vJass' market. (yes, vJass')
- People slowly move on towards files.
- All is set to the real migration.


I was really meaning to do boa first, the reason I didn't is that it turns out {} is much easier to compile than identation based stuff. And well, there was a big fad going on around C-like syntax, so I'll take that fad as a platform...

Anachron: Stick to vJass if you want. Move to cJass if you want. Move to Zinc if you want.

Zinc is mostly pointless for the reasons you mentioned. However, it has a little advantages over vJass:
- It is structured better.
- You can use library privates before you declare them.
- private is by default inside libraries.
- public in libraries involves no _ stuff


The C-like syntax is not really an advantage, as in at all.

There are also shortcomings to Zinc (some of these are not really short comings):
- Less features than vJass.
- harder to read.
- It is a new syntax, if you already know vJass and don't want to waste time learning a new syntax, this is a waste of time.
- must use libraries , no scopes.


Anyway, since vJass and Zinc can both use each other, there is no reason to move on to Zinc if everybody began releasing libraries on it...

Is zinc a response to cJass? Well, not that much, I am not really interested in its market share, if I was I would have added defines and ++ and -- stuff... (not ever going to happen)

The best thing about ZINC is that is it file based.

Since everything I code gets released as a resource, I won't switch to Zinc/Boa unless its use becomes fairly standard and it supports all the needed features from vJASS.

Most likely, Zinc/Boa won't become widely used because they aren't meant to be. They are just experiments leading up to vJASS2.

As far as I am concerned, vJASS is almost done; it only lacks a couple important features. After that no one should be able to complain that what they want to do isn't possible.

Any really big changes (such as rewriting the entire struct phase) are better off with a total rewrite, and wiping the slate clean so that it doesn't need to maintain compatibility with old syntax. So I guess it is time to start planning a successor.

change syntax to keep code same == useless.

code is not really the same == your argument is useless.

In my case, I just use what I understand. As long as I know that my script works as I intend it to do then I'm content.

the problem with programming languages is tat people hate to unite, and wanna keep their standard. i liked this zinc thing, but then i saw tat it use crappy -> returnType as syntax, which is not standard in many languages, its annoying to have to remember syntax for different languages, when u work alot with 1 u become rusty with another... this is why i think all languages should try to unite to a standard...
and i really miss the ++ and -- in zinc, as i didnt see anything about it...

You are funny.

There's no such thing as an "standard in many languages". i.e: Most scripting languages do not use that "type funcionname" stuff.

Zinc and Jass are scripting languages. They are on a lower end than C, C++, Java and C-Swastika... When looking for examples on how 'standard' code would look like, we need to take a look to the likes of Jass2, php, javascript, python, ruby, lua, squirrel and angelscript. Of course, Zinc does not really copy them either. Hence the reason I am looking forward to Boa, a lot of people are declaring jihad on -> because it takes them 2 more characters than the old syntax. Boa will save a lot of typing time...

Blizzard did not just pick a verbose syntax for Jass to torture us and make us feel less manly for having to type keywords. The truth is that this sort of syntax is more optimal for the job Jass was meant to do.


The reason there are many languages and there will always be new languages is that there is no way to have an "end all" syntax. Languages have different intentions. Zinc's -> is awesome, it's intention is precisely to scare people that think C is a 'standard' for whatever lame trauma they might have with it...

But it also looks awesome, really, it does. I love it, these are the reasons:
* It is self-descriptive.
* It is not backwards.
* It is a magnitude easier to read than "nothing Killall" or the much lamer, "void killall".
* It allows me to kill the nothing keyword, and the least readable of them all void.
* method and function syntax are not ambiguous.
* It is consistent with the code value syntax (i.e: function onCase ).
* It keeps people that think C syntax is a standard away from Zinc.

Maybe this is part of self-descriptiveness, but anyway it looks compatible with functions in mathematics. Looks familiar to CS guys.

Zinc takes less time to write when you get hang of it.

I see. Thanks for clearing this up guys.