what is the best dialect to use for new development?
I have to admit that I have worked a lot with the Core dialect, but since the X# runtime is available, my productivity has increased (before I had rewritten some important VO functions in X# core).
The first idea would be the Core dialect, but since I need the Transform() function together with pictures a lot (and this is something I need also in the future), the Core dialect cannot be used because the Transform() function is not written in the Core dialect because of the support for usuals and dates.
So the option is between the Vulcan and the VO dialect. I would therefore select the VO dialect because in the Vulcan dialect some VO features are not available like the single apostroph as string delimiter.
Are there other things I should considerate?
In X#, the runtime does not have the limitations of Vulcan's runtime (like forcing you to use x86 target only), so I don't see any reason avoiding the VO dialect, if you like it. I also prefer it for the same reason that you mentioned.
So my suggestion is to use the dialect you feel comfortable with, there's no major reason to only use Core. But just in case it's only Transform() and a few other functions that prevent you from going Core and you otherwise prefer it, then you can simply copy/paste the code of those functions and adjust them so that hey do not use usuals etc.
thank you very much for your answer! And it is interesting to hear that you prefer the VO dialect also.
I like also the "date" datatype because most of the time the time part of the DateTime datatype is not used, so I would like to avoid that overhead.
But just in case it's only Transform() and a few other functions that prevent you from going Core and you otherwise prefer it, then you can simply copy/paste the code of those functions and adjust them so that hey do not use usuals etc
No, for me this is not an option. I have no intention to have duplicate code in my applications. I prefer to use the functions in the runtime: they work (and if not, I will file a ticket <g>), and if I pass code away, others have no problems with it because I use the standard functions.
I like it to have the sources of these functions for other reasons: first, I understand better how you as development team "think" your language (I was very surprised how many other functions of the runtime were used in some runtime functions), second, I understand how it works and can make my own code better, and third, if something does not work, I can use it to debug and discover the errors (that most of the time are in my own code).
It was a similar proceeding I have used in the past with the VO class libraries.
Some differences between VO and Vulcan:
- VO single quoted strings, Vulcan not. In VO you must prefix the single quote with a 'c' to indicate a string literal
- VO allows 4 letter abbreviation of keywords, Vulcan only allows full keywords (except FUNC and PROC)
- VO uses 1 based indexer for PSZ, Vulcan uses 0 based indexer for PSZ
- VO allows && as well as // as comment characters (Vulcan only //)
- VO allows MEMVARs (when they become available)
- Neither VO nor Vulcan allow named arguments (to avoid problems where people have used assignments inside method calls). Only Core allows that
XSharp Development Team