Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.lang.clipper.visual-objects > #11571 > unrolled thread

Very interesting : XSharp development roadmap for 2018

Started bystavros.spanos2@gmail.com
First post2018-05-02 03:30 -0700
Last post2018-05-11 20:37 +0200
Articles 20 on this page of 40 — 5 participants

Back to article view | Back to comp.lang.clipper.visual-objects


Contents

  Very interesting : XSharp development roadmap for 2018 stavros.spanos2@gmail.com - 2018-05-02 03:30 -0700
    Re: Very interesting : XSharp development roadmap for 2018 D.J.W. van Kooten <vankooten@removethis.ic2.com> - 2018-05-09 23:49 +0200
      Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-10 07:53 +0200
        Re: Very interesting : XSharp development roadmap for 2018 D.J.W. van Kooten <vankooten@removethis.ic2.com> - 2018-05-11 00:32 +0200
          Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-11 12:06 +0200
            Re: Very interesting : XSharp development roadmap for 2018 D.J.W. van Kooten <vankooten@removethis.ic2.com> - 2018-05-11 12:26 +0200
          Re: Very interesting : XSharp development roadmap for 2018 Chris Pyrgas <"chris (at)"@xsharp.eu> - 2018-05-11 16:05 +0300
            Re: Very interesting : XSharp development roadmap for 2018 D.J.W. van Kooten <vankooten@removethis.ic2.com> - 2018-05-11 20:11 +0200
              Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-11 20:32 +0200
                Re: Very interesting : XSharp development roadmap for 2018 D.J.W. van Kooten <vankooten@removethis.ic2.com> - 2018-05-12 16:57 +0200
                  Re: Very interesting : XSharp development roadmap for 2018 Chris Pyrgas <"chris (at)"@xsharp.eu> - 2018-05-12 18:52 +0300
                    Re: Very interesting : XSharp development roadmap for 2018 D.J.W. van Kooten <vankooten@removethis.ic2.com> - 2018-05-15 00:06 +0200
                      Re: Very interesting : XSharp development roadmap for 2018 Chris Pyrgas <"chris (at)"@xsharp.eu> - 2018-05-15 01:44 +0300
                        Re: Very interesting : XSharp development roadmap for 2018 D.J.W. van Kooten <vankooten@removethis.ic2.com> - 2018-05-15 12:36 +0200
                  Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-13 15:01 +0200
              Re: Very interesting : XSharp development roadmap for 2018 Chris Pyrgas <"chris (at)"@xsharp.eu> - 2018-05-12 16:53 +0300
                Re: Very interesting : XSharp development roadmap for 2018 Karl Faller <mail_withoutthat_@_drei-f_andthat_.de> - 2018-05-13 10:08 +0200
                  Re: Very interesting : XSharp development roadmap for 2018 Chris Pyrgas <"chris (at)"@xsharp.eu> - 2018-05-13 16:01 +0300
                  Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-13 15:12 +0200
                Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-13 15:13 +0200
                  Re: Very interesting : XSharp development roadmap for 2018 Chris Pyrgas <"chris (at)"@xsharp.eu> - 2018-05-13 16:54 +0300
                    Re: Very interesting : XSharp development roadmap for 2018 Karl Faller <mail_withoutthat_@_drei-f_andthat_.de> - 2018-05-13 17:55 +0200
                      Re: Very interesting : XSharp development roadmap for 2018 Chris Pyrgas <"chris (at)"@xsharp.eu> - 2018-05-13 19:37 +0300
                        Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-13 19:03 +0200
                    Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-13 18:40 +0200
                      Re: Very interesting : XSharp development roadmap for 2018 Chris Pyrgas <"chris (at)"@xsharp.eu> - 2018-05-14 00:33 +0300
                        Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-14 06:08 +0200
                          Re: Very interesting : XSharp development roadmap for 2018 Chris Pyrgas <"chris (at)"@xsharp.eu> - 2018-05-14 15:50 +0300
                            Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-14 16:01 +0200
                          Re: Very interesting : XSharp development roadmap for 2018 Karl Faller <mail_withoutthat_@_drei-f_andthat_.de> - 2018-05-14 15:13 +0200
                            Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-14 16:03 +0200
                Re: Very interesting : XSharp development roadmap for 2018 D.J.W. van Kooten <vankooten@removethis.ic2.com> - 2018-05-15 00:08 +0200
                  Re: Very interesting : XSharp development roadmap for 2018 Chris Pyrgas <"chris (at)"@xsharp.eu> - 2018-05-15 02:07 +0300
                    Re: Very interesting : XSharp development roadmap for 2018 D.J.W. van Kooten <vankooten@removethis.ic2.com> - 2018-05-15 12:17 +0200
                      Re: Very interesting : XSharp development roadmap for 2018 Karl Faller <mail_withoutthat_@_drei-f_andthat_.de> - 2018-05-15 13:41 +0200
                      Re: Very interesting : XSharp development roadmap for 2018 Chris Pyrgas <"chris (at)"@xsharp.eu> - 2018-05-15 16:13 +0300
                  Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-15 05:41 +0200
          Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-11 15:57 +0200
            Re: Very interesting : XSharp development roadmap for 2018 D.J.W. van Kooten <vankooten@removethis.ic2.com> - 2018-05-11 19:36 +0200
              Re: Very interesting : XSharp development roadmap for 2018 "Wolfgang Riedmann" <wriedmann@gmail.com> - 2018-05-11 20:37 +0200

Page 1 of 2  [1] 2  Next page →


#11571 — Very interesting : XSharp development roadmap for 2018

Fromstavros.spanos2@gmail.com
Date2018-05-02 03:30 -0700
SubjectVery interesting : XSharp development roadmap for 2018
Message-ID<1f81b4a4-fdb0-48cd-a1cb-6b0b729bf621@googlegroups.com>
For all intersted:

I wish we had some more feedback on things going on with XSharp in this forum. Personaly I wouldnt consider it off-topic...

I was very glad to see this post in XSharp site:

https://www.xsharp.info/articles/the-xsharp-development-roadmap-for-2018

Greetings to all, and waiting in anticipatioν.


[toc] | [next] | [standalone]


#11588

FromD.J.W. van Kooten <vankooten@removethis.ic2.com>
Date2018-05-09 23:49 +0200
Message-ID<i2q6fd58vpk2ep7t7c2o8ihqefaqaq5oa1@4ax.com>
In reply to#11571
Replying on message of Wed, 2 May 2018 03:30:29 -0700 (PDT) from
stavros.spanos2@gmail.com:


 Hello stavros.spanos2@gmail.com

>For all intersted:
>
>I wish we had some more feedback on things going on with XSharp in this forum. Personaly I wouldnt consider it off-topic...

I am not sure what you mean with the remark? Do you want more feedback
in this NG? Or on the forum? Just on the roadmap or on something else?


>I was very glad to see this post in XSharp site:
>
>https://www.xsharp.info/articles/the-xsharp-development-roadmap-for-2018
>

My feedback is that it's great to see how much has been realized and
how much is planned for X#.

I think -on the other hand- that many people using VO simply stay with
VO. That is not the quality of X#, certainly not. And transporting
code to X# also works very well.

But most people won't see much advantage in going to .Net. Personally
I am quite disapointed in what is possible in .Net compared to VO. For
example, one of our programs being converted uses OCR from the ancient
Microsoft Document Imaging, based on Office 2003. We thought it was a
good idea to replace that with some of the newest .Net OCR
techonologies. Most of these .Net programs recognized far less than
the good old Micosoft product and we finally managed to get an equal
score (some PDF's not recogonized which the MS engine did recognize
and the other way araound). Ths code was based on Googles Tesseract
(used by Syncfusion).

However the last news is that some of the test PDF's which were
recognized a few weeks ago suddenly started to recognize a 5 as a 6.
For no obvious reasons. Reason under investigation.

I would expect OCR to have become nearly perfect in 15 years but it's
not only "not better" but also unreliable.

Most other things we converted are working (sometimes with lots of
effort) equally well, and usually in less code. But bottom line is: in
VO it worked and still works.

Going to .Net also means you are more or less condemned to use Visual
Studio which I personnaly hate and which I consider in almost every
respect, a step back to VO. I recently started a new program and
decided to do so again in VO. I may convert it one day but I am sure
starting to create the same program in Visual Studio would have costed
me 50% or more extra time with a lot more annoyances.

Nevertheless I do hope that VO users will move to X#; for sure, but I
wonder why many don't.

Do you share my thoughts? Or do you have other reasons?

Dick

[toc] | [prev] | [next] | [standalone]


#11592

From"Wolfgang Riedmann" <wriedmann@gmail.com>
Date2018-05-10 07:53 +0200
Message-ID<fli52oFcq06U1@mid.individual.net>
In reply to#11588
Hi Dick,

as you know I don't like Visual Studio very much, therefore I opted to
do my X# development tool in XIDE.
But in the future I may be forced to use VS when my development focus
goes to .NET Core for development for the Linux platform (web services).

IMHO there are some very important reasons to move VO applications to
X#:

- first of all, the VO development company is dead. There is someone
that has the sources to VO, but you cannot expect any update if the
development system has issues with some new Windows update (with
Windows 10 1709 there are issues with resource compiling - closing and
restarting all VO instances fixes it)
- second but not less important: all new development is done in the
.NET Framework, normal Windows API development has stopped many years
ago. Many things are much easier in .NET, and the use of COM components
is not always the best solution
- third: the GUI of Windows GDI applications is become very outdated,
and WinForms and WPF windows offer much more possibilities. Look only
to the fact that both offer the use of PNG files in the GUI supporting
transparency, or the enhanced possibility of the WinForms RTF control
where you can paste also bitmaps from the clipboard.

Therefore I recommend to use XIDE if you don't like Visual Studio, and
nobody requires you to use only one development environment (currently
I'm starting Visual Studio a few times every week to open some samples
or to compile some open source libraries to be used then in my XIDE
projects).

If you were at the Cologne conference, you had seen that all members of
the development team used both environment, even Fabrice that does the
Visual Studio Integration work. Therefore you can be sure that the XIDE
development will not be stopped.

Of course you are faster in VO because you have at least of 10 or 15
year of experience there.
I can assure you that my development speed in X# has increased a lot
and it is currently near to the speed in VO, and I expect that it will
be faster the more I proceed with my own libraries and utilities.

I plan to do a sample application like the SSA for VO in the next
months, releasing also the needed control and utility libraries with
sources.

Wolfgang


D.J.W. van Kooten wrote:

> Replying on message of Wed, 2 May 2018 03:30:29 -0700 (PDT) from
> stavros.spanos2@gmail.com:
> 
> 
>  Hello stavros.spanos2@gmail.com
> 
> > For all intersted:
> > 
> > I wish we had some more feedback on things going on with XSharp in
> > this forum. Personaly I wouldnt consider it off-topic...
> 
> I am not sure what you mean with the remark? Do you want more feedback
> in this NG? Or on the forum? Just on the roadmap or on something else?
> 
> 
> > I was very glad to see this post in XSharp site:
> > 
> > https://www.xsharp.info/articles/the-xsharp-development-roadmap-for-
> > 2018
> > 
> 
> My feedback is that it's great to see how much has been realized and
> how much is planned for X#.
> 
> I think -on the other hand- that many people using VO simply stay with
> VO. That is not the quality of X#, certainly not. And transporting
> code to X# also works very well.
> 
> But most people won't see much advantage in going to .Net. Personally
> I am quite disapointed in what is possible in .Net compared to VO. For
> example, one of our programs being converted uses OCR from the ancient
> Microsoft Document Imaging, based on Office 2003. We thought it was a
> good idea to replace that with some of the newest .Net OCR
> techonologies. Most of these .Net programs recognized far less than
> the good old Micosoft product and we finally managed to get an equal
> score (some PDF's not recogonized which the MS engine did recognize
> and the other way araound). Ths code was based on Googles Tesseract
> (used by Syncfusion).
> 
> However the last news is that some of the test PDF's which were
> recognized a few weeks ago suddenly started to recognize a 5 as a 6.
> For no obvious reasons. Reason under investigation.
> 
> I would expect OCR to have become nearly perfect in 15 years but it's
> not only "not better" but also unreliable.
> 
> Most other things we converted are working (sometimes with lots of
> effort) equally well, and usually in less code. But bottom line is: in
> VO it worked and still works.
> 
> Going to .Net also means you are more or less condemned to use Visual
> Studio which I personnaly hate and which I consider in almost every
> respect, a step back to VO. I recently started a new program and
> decided to do so again in VO. I may convert it one day but I am sure
> starting to create the same program in Visual Studio would have costed
> me 50% or more extra time with a lot more annoyances.
> 
> Nevertheless I do hope that VO users will move to X#; for sure, but I
> wonder why many don't.
> 
> Do you share my thoughts? Or do you have other reasons?
> 
> Dick



-- 

[toc] | [prev] | [next] | [standalone]


#11596

FromD.J.W. van Kooten <vankooten@removethis.ic2.com>
Date2018-05-11 00:32 +0200
Message-ID<jag9fd1pb07tjpf7fff0mjrik61na7crpd@4ax.com>
In reply to#11592
Replying on message of Thu, 10 May 2018 07:53:28 +0200 from Wolfgang
Riedmann:


 Hello Wolfgang,

All arguments Wolfgang gave are valid on it's own. But still the
number of VO users -still- seem higher to me than those who actively
use Vulcan or X#. I would like to learn why by asking comments from VO
users.

A few remarks, on what Wolfgang wrote, also for other readers:

1 Interesting to learn that the resource compliation problem is a
Windows 10 problem. I can tell you that I've experienced that too in
the 1703 (1st Creators update). 

2 VO development is dead for many years now but that hasn't rushed the
whole VO community to Vulcan.

3 About the outdated GUI: I am surprised how many users of my software
couldn't case less of how the program looks like. They were actually
quite pleased to see my WPF window returned to a VO window......

4 XIDE is a lot more VO like but as fas as I know you can't run both
on the same project? And Xide has no WPF editor, you can only program
xaml code.

5 I 've been programming things in Vulcan since 2005 and in C# for
years as well. Ok, most time I spent with VO during that years but I
am sure I can call myself experienced. But Microsoft software and me
have never been good friends and I almost hate every second I spend
using Visual Studio. I can show several often used options, techniques
or whatever you could call it, which, when done in VO and in Visual
Studio on the highest possible speed, are so much faster in VO. It
starts with just starting the program - 1 second for VO and I can
start, VS takes at least 6 seconds. Then due to the VO repo system, I
can reach my last changed entity in a few clicks while it can take
minutes or more in VS, because there is no built in system to find
last changed code. I've also more than once lost code in VS because on
removing some code I accidentaly removed another method as well
because all code is opened together in the same editor. On debugging,
the Ctrl X system to enter VO statement does not -yet- work in
Vulcan/X# with Visual Studio's Immediate window unless you can guess
how th X# statement would look like in C# -including the right
capitalization. 

I can add quite a few more reasons why X#, mainly due to Visual
Studion as the most logical development environment, takes a lot more
time to program and experience is maybe number 10 on the list but
certainly not the main reason. 

That's why I started the most recent project in VO. When it's fully
ready, the way I want it, a couple of .Net /WPF based screens will
improve usability and -maybe- give some chance to market the product.
So if I value these last 2 reasons enough I will invest time to
convert from VO to X#, and I will still have saved time and lots of
annoyance. Or maybe I leave it in VO - for my own use.

So once again: all arguments Wolfgang gave are valid. But it looks
like there are reasons for quite some users to stay in VO. These are
mine and these are valid as well, at least for me.

Does it mean I recommend users to stay in VO? No, I encourage everyone
to start experimenting with X#. The development team and their
dedication and support is fantastic. I particiapte in the FOX programs
and I do intend to keep doing that. But I am not setting VO aside -
yet.

Dick

[toc] | [prev] | [next] | [standalone]


#11602

From"Wolfgang Riedmann" <wriedmann@gmail.com>
Date2018-05-11 12:06 +0200
Message-ID<fll88cF3khuU1@mid.individual.net>
In reply to#11596
Hi Dick,

first of all: the world moves forward, and not all new things are
better than old ones. It is the "overall" that decides.

I may be one of the few that likes the VO repo system (ADAM), that
permits a lot of things like incremental compining or entity based work.

But (unfortunately) no main development system uses a repo - and
therefore we have to accept that.

You are right that XIDE does not supports XAML - and I think it will it
never. But for the migration of VO software this does not matter.
Chris has done a fantastic work in making it a very productive tool.

Maybe I will be able to do a WPF editor for XIDE somedays... an window
editor that does not output XAML, but X# (or C#) code like the WinForms
editor does.

I will try to migrate all my VO programs that are in active development
because of a few reasons:
- I cannot afford it to have a non-working development platform someday
- programming in .NET is much more advanced than Win32
- I have the possibility to enhance the GUI where it makes sense
- the .NET runtime is more enhanced than the VO runtime: a better
memory managment, x64, ...

Of course, I will use XIDE for this purpose. And I will give Roberts
WinForms based GUI classes a very good look, maybe I can move my VO
applications entirely to WinForms.....

Time goes, and we have to adapt or to disappear.... I have the
responsibility to my customers to maintain their software, so in fact I
don't have any other chance than to adapt me to the changed times.

And I think everyone that produces software should think the same.
Software is something business critical for many companies, and
therefore we need to maintain it and search the best way to the future.

And IMHO we as VO developers are very lucky: we have a path other than
rewrite our applications - we can move them with more or less effort to
X#.

I don't expect that every VO programmer will take this opportunity, and
not all applications will be worth the migration work, but some need to
be migrated to remain alive.

Wolfgang


D.J.W. van Kooten wrote:

> Replying on message of Thu, 10 May 2018 07:53:28 +0200 from Wolfgang
> Riedmann:
> 
> 
>  Hello Wolfgang,
> 
> All arguments Wolfgang gave are valid on it's own. But still the
> number of VO users -still- seem higher to me than those who actively
> use Vulcan or X#. I would like to learn why by asking comments from VO
> users.
> 
> A few remarks, on what Wolfgang wrote, also for other readers:
> 
> 1 Interesting to learn that the resource compliation problem is a
> Windows 10 problem. I can tell you that I've experienced that too in
> the 1703 (1st Creators update). 
> 
> 2 VO development is dead for many years now but that hasn't rushed the
> whole VO community to Vulcan.
> 
> 3 About the outdated GUI: I am surprised how many users of my software
> couldn't case less of how the program looks like. They were actually
> quite pleased to see my WPF window returned to a VO window......
> 
> 4 XIDE is a lot more VO like but as fas as I know you can't run both
> on the same project? And Xide has no WPF editor, you can only program
> xaml code.
> 
> 5 I 've been programming things in Vulcan since 2005 and in C# for
> years as well. Ok, most time I spent with VO during that years but I
> am sure I can call myself experienced. But Microsoft software and me
> have never been good friends and I almost hate every second I spend
> using Visual Studio. I can show several often used options, techniques
> or whatever you could call it, which, when done in VO and in Visual
> Studio on the highest possible speed, are so much faster in VO. It
> starts with just starting the program - 1 second for VO and I can
> start, VS takes at least 6 seconds. Then due to the VO repo system, I
> can reach my last changed entity in a few clicks while it can take
> minutes or more in VS, because there is no built in system to find
> last changed code. I've also more than once lost code in VS because on
> removing some code I accidentaly removed another method as well
> because all code is opened together in the same editor. On debugging,
> the Ctrl X system to enter VO statement does not -yet- work in
> Vulcan/X# with Visual Studio's Immediate window unless you can guess
> how th X# statement would look like in C# -including the right
> capitalization. 
> 
> I can add quite a few more reasons why X#, mainly due to Visual
> Studion as the most logical development environment, takes a lot more
> time to program and experience is maybe number 10 on the list but
> certainly not the main reason. 
> 
> That's why I started the most recent project in VO. When it's fully
> ready, the way I want it, a couple of .Net /WPF based screens will
> improve usability and -maybe- give some chance to market the product.
> So if I value these last 2 reasons enough I will invest time to
> convert from VO to X#, and I will still have saved time and lots of
> annoyance. Or maybe I leave it in VO - for my own use.
> 
> So once again: all arguments Wolfgang gave are valid. But it looks
> like there are reasons for quite some users to stay in VO. These are
> mine and these are valid as well, at least for me.
> 
> Does it mean I recommend users to stay in VO? No, I encourage everyone
> to start experimenting with X#. The development team and their
> dedication and support is fantastic. I particiapte in the FOX programs
> and I do intend to keep doing that. But I am not setting VO aside -
> yet.
> 
> Dick



-- 

[toc] | [prev] | [next] | [standalone]


#11604

FromD.J.W. van Kooten <vankooten@removethis.ic2.com>
Date2018-05-11 12:26 +0200
Message-ID<4mrafdt83v5r8a6f3um8kbu85tjchsvttk@4ax.com>
In reply to#11602
Replying on message of Fri, 11 May 2018 12:06:03 +0200 from Wolfgang
Riedmann:


 Hello Wolfgang,

Again I completely agree with what you wrote.

I will make sure I know how to migrate my VO programs should I think
it becomes necessary. Some programs will never need to be converted,
other may. However, I will keep using VO as long as possible and use
X# both to provide functionality to my VO program where this is better
achieved in .Net + to keep my knowledge up to date to convert, some
day.

Dick

[toc] | [prev] | [next] | [standalone]


#11605

FromChris Pyrgas <"chris (at)"@xsharp.eu>
Date2018-05-11 16:05 +0300
Message-ID<pd44cg$1hf1$1@gioia.aioe.org>
In reply to#11596
Hi Dick,

I think more or less all of us here have loved VO, made our living with 
it and enjoyed programming with it. But despite all its good ideas and 
how much powerful it was for the time when it was created, I think it is 
impossible to deny how very outdated it is now.

Thinking about the compiler, it does not even have an Int64 data type, 
or method overloading, strongly typing methods is more complicated than 
it should be, there are no interfaces, enumerators and enumerations, no 
scoped LOCALs, no "decimal" type for easy handling of values 
representing money, no generics, namespaces, array initializers, 
attributes, really the list of language features supported by x# but not 
by VO is endless. If you want I can list you a few dozens more...

About VS, if you don't like it, don't use it. I did not like VS so I 
wrote XIDE (VIDE back then) and I'm using it exclusively for more than 
10 years now, doing all my .Net programming with it and I am very 
productive with it. Ignore all the crap about being it necessary to use 
VS and only VS for your .Net development, that was said during the 
vulcan days from people who didn't want you to use VIDE. We don't have 
that anymore in x#. A lot of people are using XIDE and making money with 
it and X#, having written plenty commercial applications. Also you can 
just fine share the same project with XIDE and VS, I am doing it all the 
time, a couple of the X# components are being developed with XIDE, but 
there's also a parallel VS project file for them, for people who want to 
use VS instead for editing them. It's only things like the form designer 
that you need to decide if you want to use the VS or the XIDE one.

Regarding the debugger, yes, you are right, at the moment it needs 
several improvements on the x# side. It's on our list and I hope we'll 
further improve it soon. Still, it has many very useful features not 
available in VO, for example the ability to tell the debugger to go a 
few lines back or forward while executing code, I use that all the time 
and I am greatly missing whenever I am coming back to VO. Or the ability 
to break on handled exceptions, view loaded modules, pause and resume 
specific threads at will. Ah, speaking about threads, have you tried to 
create some in VO? And then debug an app that uses them? Well, in X# you 
need one line of code to create a thread and managing the is very easy.

I could go on forever about the dozens and dozens features of X# that 
make app development a lot more productive (and in my opinion, a lot 
more fun) than in VO. I also agree, some of the features VO has, 
especially those related to the repo, like being able to quickly sort by 
date changed are fantastic and not available in X# (not yet at least). 
But fortunately or unfortunately, those are very few compared...

Again, this is not a bashing of VO, I have personally practically 
started my professional career with it, earned my money with it and 
greatly liked it and I am very thankful it was created, but after having 
used all the new stuff in the .Net languages, I simply cannot use it 
anymore, I am missing so many things. Sorry to everybody for the long 
post, but I think it was necessary to explain a few things!

Chris/X# team
> Replying on message of Thu, 10 May 2018 07:53:28 +0200 from Wolfgang
> Riedmann:
>
>
>   Hello Wolfgang,
>
> All arguments Wolfgang gave are valid on it's own. But still the
> number of VO users -still- seem higher to me than those who actively
> use Vulcan or X#. I would like to learn why by asking comments from VO
> users.
>
> A few remarks, on what Wolfgang wrote, also for other readers:
>
> 1 Interesting to learn that the resource compliation problem is a
> Windows 10 problem. I can tell you that I've experienced that too in
> the 1703 (1st Creators update).
>
> 2 VO development is dead for many years now but that hasn't rushed the
> whole VO community to Vulcan.
>
> 3 About the outdated GUI: I am surprised how many users of my software
> couldn't case less of how the program looks like. They were actually
> quite pleased to see my WPF window returned to a VO window......
>
> 4 XIDE is a lot more VO like but as fas as I know you can't run both
> on the same project? And Xide has no WPF editor, you can only program
> xaml code.
>
> 5 I 've been programming things in Vulcan since 2005 and in C# for
> years as well. Ok, most time I spent with VO during that years but I
> am sure I can call myself experienced. But Microsoft software and me
> have never been good friends and I almost hate every second I spend
> using Visual Studio. I can show several often used options, techniques
> or whatever you could call it, which, when done in VO and in Visual
> Studio on the highest possible speed, are so much faster in VO. It
> starts with just starting the program - 1 second for VO and I can
> start, VS takes at least 6 seconds. Then due to the VO repo system, I
> can reach my last changed entity in a few clicks while it can take
> minutes or more in VS, because there is no built in system to find
> last changed code. I've also more than once lost code in VS because on
> removing some code I accidentaly removed another method as well
> because all code is opened together in the same editor. On debugging,
> the Ctrl X system to enter VO statement does not -yet- work in
> Vulcan/X# with Visual Studio's Immediate window unless you can guess
> how th X# statement would look like in C# -including the right
> capitalization.
>
> I can add quite a few more reasons why X#, mainly due to Visual
> Studion as the most logical development environment, takes a lot more
> time to program and experience is maybe number 10 on the list but
> certainly not the main reason.
>
> That's why I started the most recent project in VO. When it's fully
> ready, the way I want it, a couple of .Net /WPF based screens will
> improve usability and -maybe- give some chance to market the product.
> So if I value these last 2 reasons enough I will invest time to
> convert from VO to X#, and I will still have saved time and lots of
> annoyance. Or maybe I leave it in VO - for my own use.
>
> So once again: all arguments Wolfgang gave are valid. But it looks
> like there are reasons for quite some users to stay in VO. These are
> mine and these are valid as well, at least for me.
>
> Does it mean I recommend users to stay in VO? No, I encourage everyone
> to start experimenting with X#. The development team and their
> dedication and support is fantastic. I particiapte in the FOX programs
> and I do intend to keep doing that. But I am not setting VO aside -
> yet.
>
> Dick
>

[toc] | [prev] | [next] | [standalone]


#11608

FromD.J.W. van Kooten <vankooten@removethis.ic2.com>
Date2018-05-11 20:11 +0200
Message-ID<f5lbfd1pr9hu2sja9deqc9s5ldc12tumsa@4ax.com>
In reply to#11605
Replying on message of Fri, 11 May 2018 16:05:49 +0300 from Chris
Pyrgas:


 Hello Chris,

I'll give you the same reply as I gave Wolfgang: you are 100% right.Or
95% maybe, from my point of view,  as I don't some of the advantages
you describe as an advantage. Or less than 95% (<bg>) depending on how
badly one misses some VO features. 

I must add that I consider a lot of language elements not present in
VO hardly as something I find really more useful than the VO
alternative while a couple of 'missing' features from VO weigh much
heavier for me. That's why I -still- prefer the 'outdated' VO above
the 'modern' but more time consuming .Net languages. However, I do
realize 100% that there will be a tipping point, where replacing X#
with VO is better. That point will differ from application to
application I think.


Let's go through some examples, most the ones you mentioned.

FOREACH. It is more logical to use like e.g. going through all files
of a directory. VO's FOR..NEXT requires just 1 line more code and IMO
is then easier to follow as in the debugger you have a number of files
in a variable. Enumarators is about the same, but I admit it is a more
efficient than using arrays as you would in VO. Or something like a
LIST is definitely better as in an array you don't see what it
contains.

Int64 is certainly true. Fabrice great Fabtools include a Fabzip but
due to VO's limitations it stops when files are >2 Gb. I currently zip
by calling my Vulcan/C# DLL and if that's all in one program it would
be better of course. Strong typing: not needing to declare the
variables is certainly much better.

Scoped locals (I had to look up what you meant with it) are useful
indeed, so far I only used them in C#. Generics I always find hard to
understand when I see code using it, I don't see any advantage in
namespaces (classes are already bad enough - I would love to only use
program wide functions ;). 


I don't see what array initializers add to VO's defining of arrays.
Same for attributes: I wasn't familiair with these either and to me it
looks the same as adding a comment in code. And commenting in and out
works way better in VO anyway....

Interfaces: I know of 1 specific situation where it made sense: where
I had a Vulcan Pc/server based client talk to a C# based server on a
website. Without the interface DLL generated for both it wouldn't
work. For all other instances it's is just more code than necessary.

Stepping back in debugging is, if I understand correctly, something of
VS 2017, which I don't use as long as I still have Vulcan program. But
that should change for me soon. Of course the average VO users will
need the 'Ctrl X' style inspection option much more badly than any of
the other VS debug options. Good to know this option is close!

Finally I would be interested in how to use a project in Xide and VS
at the same time.  Can you say something more about that? E.g. I do
have a few VS X# WPF projects, if I would want to work on the code
(except WPF editor based work) how do I setup that in Xide?

Dick

[toc] | [prev] | [next] | [standalone]


#11609

From"Wolfgang Riedmann" <wriedmann@gmail.com>
Date2018-05-11 20:32 +0200
Message-ID<flm5tsFa7f5U1@mid.individual.net>
In reply to#11608
Hi Dick,

I can give you a feature that alone outweighs all others (from a
accounting software developers standpoint): the decimal datatype.

Then I see collections, interfaces, generics and typed init methods as
advantage, and the one line syntax for properties are a real time saver.

And the come all the source code samples, the 3rd party libraries and a
lot more.

Wolfgang


D.J.W. van Kooten wrote:

> Replying on message of Fri, 11 May 2018 16:05:49 +0300 from Chris
> Pyrgas:
> 
> 
>  Hello Chris,
> 
> I'll give you the same reply as I gave Wolfgang: you are 100% right.Or
> 95% maybe, from my point of view,  as I don't some of the advantages
> you describe as an advantage. Or less than 95% (<bg>) depending on how
> badly one misses some VO features. 
> 
> I must add that I consider a lot of language elements not present in
> VO hardly as something I find really more useful than the VO
> alternative while a couple of 'missing' features from VO weigh much
> heavier for me. That's why I -still- prefer the 'outdated' VO above
> the 'modern' but more time consuming .Net languages. However, I do
> realize 100% that there will be a tipping point, where replacing X#
> with VO is better. That point will differ from application to
> application I think.
> 
> 
> Let's go through some examples, most the ones you mentioned.
> 
> FOREACH. It is more logical to use like e.g. going through all files
> of a directory. VO's FOR..NEXT requires just 1 line more code and IMO
> is then easier to follow as in the debugger you have a number of files
> in a variable. Enumarators is about the same, but I admit it is a more
> efficient than using arrays as you would in VO. Or something like a
> LIST is definitely better as in an array you don't see what it
> contains.
> 
> Int64 is certainly true. Fabrice great Fabtools include a Fabzip but
> due to VO's limitations it stops when files are >2 Gb. I currently zip
> by calling my Vulcan/C# DLL and if that's all in one program it would
> be better of course. Strong typing: not needing to declare the
> variables is certainly much better.
> 
> Scoped locals (I had to look up what you meant with it) are useful
> indeed, so far I only used them in C#. Generics I always find hard to
> understand when I see code using it, I don't see any advantage in
> namespaces (classes are already bad enough - I would love to only use
> program wide functions ;). 
> 
> 
> I don't see what array initializers add to VO's defining of arrays.
> Same for attributes: I wasn't familiair with these either and to me it
> looks the same as adding a comment in code. And commenting in and out
> works way better in VO anyway....
> 
> Interfaces: I know of 1 specific situation where it made sense: where
> I had a Vulcan Pc/server based client talk to a C# based server on a
> website. Without the interface DLL generated for both it wouldn't
> work. For all other instances it's is just more code than necessary.
> 
> Stepping back in debugging is, if I understand correctly, something of
> VS 2017, which I don't use as long as I still have Vulcan program. But
> that should change for me soon. Of course the average VO users will
> need the 'Ctrl X' style inspection option much more badly than any of
> the other VS debug options. Good to know this option is close!
> 
> Finally I would be interested in how to use a project in Xide and VS
> at the same time.  Can you say something more about that? E.g. I do
> have a few VS X# WPF projects, if I would want to work on the code
> (except WPF editor based work) how do I setup that in Xide?
> 
> Dick



-- 

[toc] | [prev] | [next] | [standalone]


#11613

FromD.J.W. van Kooten <vankooten@removethis.ic2.com>
Date2018-05-12 16:57 +0200
Message-ID<b6scfd9ohkm07ps32a71hg4fudd7578mcu@4ax.com>
In reply to#11609
Replying on message of Fri, 11 May 2018 20:32:25 +0200 from Wolfgang
Riedmann:


 Hello Wolfgang,

>I can give you a feature that alone outweighs all others (from a
>accounting software developers standpoint): the decimal datatype.


What is the advantage above a float?

>Then I see collections, interfaces, generics and typed init methods as
>advantage, and the one line syntax for properties are a real time saver.

Collections: agreed.
Interfaces: see previous posts. Except in 1 case I only see it as more
code without any advantage.
Typed init methods: ok, could be useful
One line syntax for properties: no idea what this is

>And the come all the source code samples, the 3rd party libraries and a
>lot more.

Sure, that could be one of the main advantages. However, my guess is
that most of the VO users maintain programs which rarely need
functionality not already present in VO, FabTools and a few of the
other libraries and samples made in VO.

Dick

[toc] | [prev] | [next] | [standalone]


#11614

FromChris Pyrgas <"chris (at)"@xsharp.eu>
Date2018-05-12 18:52 +0300
Message-ID<pd72gq$a15$1@gioia.aioe.org>
In reply to#11613
Hi Dick,

>> I can give you a feature that alone outweighs all others (from a
>> accounting software developers standpoint): the decimal datatype.
>
>
> What is the advantage above a float?

Please compile and run the following code in VO:

FUNCTION Start() AS INT
LOCAL n AS INT
LOCAL fMoney := 0.00 AS FLOAT

FOR n := 1 UPTO 10000
	fMoney += 0.01
NEXT

? fMoney // prints 100.00
? "Is 100.00 equal to", fMoney, "? :", fMoney == 100.00
// RETURNS FALSE!
WAIT
RETURN 0

This should put the value of 100.00 in the fMoney local, right? Well, 
the comparison of fMoney == 100.00 returns false! That's because floats 
cannot represent decimal numbers with precision (due to their binary 
format), so they lack precision. With just a couple operations on them 
you're fine, but once you start making complex calculations, this lack 
of precision propagates and you can end up with a calculation result 
very different than the real one.

The Decimal type in .Net fixes this problem, by storing decimal numbers 
with full precision. Drawback is that their performance is lower than 
floats, or REAL8s/REAL4s, but at least they are guaranteed to be accurate.

Chris

ps. VO uses SetFloatDelta() in order to workaround this problem, you can 
specify (it works in X#, too) what difference between numbers must be 
treated as unimportant so that comparisons return true. The moer 
calculations you are doing with floats, the more you need to increase 
this number. And you can end up with comparions returning true for 
numbers that are very different and the inherent lack of correct decimal 
representation of FLOAT is always there...



>
>> Then I see collections, interfaces, generics and typed init methods as
>> advantage, and the one line syntax for properties are a real time saver.
>
> Collections: agreed.
> Interfaces: see previous posts. Except in 1 case I only see it as more
> code without any advantage.
> Typed init methods: ok, could be useful
> One line syntax for properties: no idea what this is
>
>> And the come all the source code samples, the 3rd party libraries and a
>> lot more.
>
> Sure, that could be one of the main advantages. However, my guess is
> that most of the VO users maintain programs which rarely need
> functionality not already present in VO, FabTools and a few of the
> other libraries and samples made in VO.
>
> Dick
>

[toc] | [prev] | [next] | [standalone]


#11634

FromD.J.W. van Kooten <vankooten@removethis.ic2.com>
Date2018-05-15 00:06 +0200
Message-ID<9m1kfdpn6o5iuefvl5jcjdmcg2b4fua32f@4ax.com>
In reply to#11614
Replying on message of Sat, 12 May 2018 18:52:24 +0300 from Chris
Pyrgas:


Hello Chris,

>Please compile and run the following code in VO:
>
>This should put the value of 100.00 in the fMoney local, right? Well, 
>the comparison of fMoney == 100.00 returns false! 

In some extreme cirumstances I've seen rounding problems like this in
VO. However, there's a simple solution for this:

fMoney:=Val(NTrim(fMoney))

This solves the problem completely.

Only if you do this:

(fmoney-100.00)*1000000000

you get a non zero value (0,01).

So I real life I can't imagine that accounting software goes wrong
with these very small rounding differences. It's too small for that.
For comparing, yes. But I don't need to change datatypes for that; the
above trick will do the job as well.

Or in other words: of course it's better to use the datatype in new
projects. But I see no reason to rush converting my programs to this
decimal datatype....

Dick

[toc] | [prev] | [next] | [standalone]


#11636

FromChris Pyrgas <"chris (at)"@xsharp.eu>
Date2018-05-15 01:44 +0300
Message-ID<pdd3du$aes$1@gioia.aioe.org>
In reply to#11634
Hi Dick,

>> Please compile and run the following code in VO:
>>
>> This should put the value of 100.00 in the fMoney local, right? Well,
>> the comparison of fMoney == 100.00 returns false!
>
> In some extreme cirumstances I've seen rounding problems like this in
> VO. However, there's a simple solution for this:
>
> fMoney:=Val(NTrim(fMoney))
>
> This solves the problem completely.

It may solve this, but it does so by coincidence and only under specific 
circumstances. If something has changed the internal setting for visible 
decimal spaces on fMoney, then it will not work. For example, add this 
code, before using the Val() trick:

fMoney := 1.00000000000 * fMoney

then the Val() trick does not work anymore. Not to mention it is 
extremely slow. Do you mean you use that after every calculation with 
float numbers?


> So I real life I can't imagine that accounting software goes wrong
> with these very small rounding differences. It's too small for that.
> For comparing, yes. But I don't need to change datatypes for that; the
> above trick will do the job as well.

I posted an extremely simple sample which already goes wrong. If you 
start doing more complex calculations, start using multiplications and 
divisions and not only additions/subtractions on FLOAT numbers, then the 
precision problems appear a lot earlier.

The biggest app I have written in VO is an accounting app, which is 
doing an extreme amount of calculations on money values and each one of 
them has to be absolutely precise, even just a 0.01 difference in end 
results causes nightmares to find out what's causing it. Very soon I 
realized that I could no way rely on FLOAT values to store money in 
xxxxx.xx format, so I thought about using INTs instead, which are faster 
anyway and then always divide by 100 in order to display the value on 
screen.

That worked fine, but then we started selling this app to bigger 
customers that we had expected, and the range of values supported by 
INTs (2 billion cents) were not enough for them and unfortunately VO 
does not have a 64bit INT data type that we could simply use instead, so 
we ended up using floats again (REAL8s actually), using only their 
integer part and again dividing by 100 when displaying them on screen. 
If I had written this app in X#, I would had used the Decimal data type 
from the very beginning and would had saved probably 100s of hours 
programming, testing and debugging this inherent issue with the float type.

Chris




>
> Or in other words: of course it's better to use the datatype in new
> projects. But I see no reason to rush converting my programs to this
> decimal datatype....
>
> Dick
>

[toc] | [prev] | [next] | [standalone]


#11644

FromD.J.W. van Kooten <vankooten@removethis.ic2.com>
Date2018-05-15 12:36 +0200
Message-ID<chdlfdpvotbik5ull7u2as88luntn9t5r3@4ax.com>
In reply to#11636
Replying on message of Tue, 15 May 2018 01:44:47 +0300 from Chris
Pyrgas:


Hello Chris,

>It may solve this, but it does so by coincidence and only under specific 
>circumstances. If something has changed the internal setting for visible 
>decimal spaces on fMoney, then it will not work. For example, add this 
>code, before using the Val() trick:
>
>fMoney := 1.00000000000 * fMoney
>
>then the Val() trick does not work anymore. Not to mention it is 
>extremely slow. Do you mean you use that after every calculation with 
>float numbers?


That's true but why should I multiply with 1.00000000000  ;)

I didn't use ntrim I saw, but Str. Then it still works even with this
multiplication:

fmoney:=val(str(fmoney,12,2))


We have a lot of accounting code too. It's interesting to check if
cent differences could origin from these rounding problems. I have
just a few locations where I know that exact comparing needs the
string trick so it's not really influencing code execution time. I
think most cent differences comde from something like this, by getting
an exchange value e.g. EUR x USD exchange rate:

Calculated Exchange value post 1 = 100,015
Calculated Exchange value post 2 = 100,015

Sum both: journal entry is 200,03
Sum of 2 sbledger entries = 100,02 + 100,02 = 200,04.

This isn't solved with a precision calculation.

But I'll analayze some earlier cent differences (they usually surface
on the client's year's end and we help them with some correcting
posts) and see if they could have been prevented with more precies
calculations.

Dick

[toc] | [prev] | [next] | [standalone]


#11617

From"Wolfgang Riedmann" <wriedmann@gmail.com>
Date2018-05-13 15:01 +0200
Message-ID<flqr9bFathtU1@mid.individual.net>
In reply to#11613
Hi Dick,

> > I can give you a feature that alone outweighs all others (from a
> > accounting software developers standpoint): the decimal datatype.
> 
> 
> What is the advantage above a float?


no more rounding errors! This alone would be enough for me

> > Then I see collections, interfaces, generics and typed init methods
> > as advantage, and the one line syntax for properties are a real
> > time saver.
> 
> Collections: agreed.
> Interfaces: see previous posts. Except in 1 case I only see it as more
> code without any advantage.

I have several samples where interfaces permit you to use completely
different classes with the same interface. So I like this feature very
much


> One line syntax for properties: no idea what this is

property MyProp as string get _cMyProp set _cMyProp := value


In fact, this is a complete access/assign pair in one single line

> > And the come all the source code samples, the 3rd party libraries
> > and a lot more.
> 
> Sure, that could be one of the main advantages. However, my guess is
> that most of the VO users maintain programs which rarely need
> functionality not already present in VO, FabTools and a few of the
> other libraries and samples made in VO.

IMHO there are many: Excel interface, PDF manipulation, access to
https, secure email sending, a better RTF control, a more beautiful
menu control and much more.

WOlfgang



-- 

[toc] | [prev] | [next] | [standalone]


#11612

FromChris Pyrgas <"chris (at)"@xsharp.eu>
Date2018-05-12 16:53 +0300
Message-ID<pd6rhk$1t5p$1@gioia.aioe.org>
In reply to#11608
Hi Dick,

I did not say that X# is better than VO because it is more modern, there 
are a lot of modern tools/app/programs that I very much dislike because 
they are harder to use, with less capabilities etc, for the sake of 
making them more good looking or "modern". For X# compared to VO, I only 
said X# has a myriad more useful features and in my opinion helps us 
programmers becoming a lot more productive and to create more robust 
code/applications, nothing having to do with it being more modern or 
not. Of course if you do not find all those features unimportant, then 
we have to agree to disagree about that :)

About the "go back/forward" while debugging, no, it's not a VS2017 
specific feature, this has been available also in XIDE/VIDE for more 
than 10 years. And in all VS versions of course, at least since VS2005 I 
think.

About sharing the same code from XIDE and VS, you just need to create a 
project/app and add to it the exact same files that the other 
environment is using. For WPF it is a little more complicated, because 
of the many "hidden" files VS creates for WPF apps, but it is still very 
doable, but no need to clutter this ng with that, please send me a WPF 
project of yours and I will show you exactly how to do it.

Chris/X# team


> Replying on message of Fri, 11 May 2018 16:05:49 +0300 from Chris
> Pyrgas:
>
>
>   Hello Chris,
>
> I'll give you the same reply as I gave Wolfgang: you are 100% right.Or
> 95% maybe, from my point of view,  as I don't some of the advantages
> you describe as an advantage. Or less than 95% (<bg>) depending on how
> badly one misses some VO features.
>
> I must add that I consider a lot of language elements not present in
> VO hardly as something I find really more useful than the VO
> alternative while a couple of 'missing' features from VO weigh much
> heavier for me. That's why I -still- prefer the 'outdated' VO above
> the 'modern' but more time consuming .Net languages. However, I do
> realize 100% that there will be a tipping point, where replacing X#
> with VO is better. That point will differ from application to
> application I think.
>
>
> Let's go through some examples, most the ones you mentioned.
>
> FOREACH. It is more logical to use like e.g. going through all files
> of a directory. VO's FOR..NEXT requires just 1 line more code and IMO
> is then easier to follow as in the debugger you have a number of files
> in a variable. Enumarators is about the same, but I admit it is a more
> efficient than using arrays as you would in VO. Or something like a
> LIST is definitely better as in an array you don't see what it
> contains.
>
> Int64 is certainly true. Fabrice great Fabtools include a Fabzip but
> due to VO's limitations it stops when files are >2 Gb. I currently zip
> by calling my Vulcan/C# DLL and if that's all in one program it would
> be better of course. Strong typing: not needing to declare the
> variables is certainly much better.
>
> Scoped locals (I had to look up what you meant with it) are useful
> indeed, so far I only used them in C#. Generics I always find hard to
> understand when I see code using it, I don't see any advantage in
> namespaces (classes are already bad enough - I would love to only use
> program wide functions ;).
>
>
> I don't see what array initializers add to VO's defining of arrays.
> Same for attributes: I wasn't familiair with these either and to me it
> looks the same as adding a comment in code. And commenting in and out
> works way better in VO anyway....
>
> Interfaces: I know of 1 specific situation where it made sense: where
> I had a Vulcan Pc/server based client talk to a C# based server on a
> website. Without the interface DLL generated for both it wouldn't
> work. For all other instances it's is just more code than necessary.
>
> Stepping back in debugging is, if I understand correctly, something of
> VS 2017, which I don't use as long as I still have Vulcan program. But
> that should change for me soon. Of course the average VO users will
> need the 'Ctrl X' style inspection option much more badly than any of
> the other VS debug options. Good to know this option is close!
>
> Finally I would be interested in how to use a project in Xide and VS
> at the same time.  Can you say something more about that? E.g. I do
> have a few VS X# WPF projects, if I would want to work on the code
> (except WPF editor based work) how do I setup that in Xide?
>
> Dick
>

[toc] | [prev] | [next] | [standalone]


#11615

FromKarl Faller <mail_withoutthat_@_drei-f_andthat_.de>
Date2018-05-13 10:08 +0200
Message-ID<efsffd9upjn93f8h5g8na7t38as6uhttm6@4ax.com>
In reply to#11612
Chris,
>About sharing the same code from XIDE and VS, you just need to create a 
>project/app and add to it the exact same files that the other 
>environment is using. For WPF it is a little more complicated, because 
>of the many "hidden" files VS creates for WPF apps, but it is still very 
>doable, but no need to clutter this ng with that, please send me a WPF 
>project of yours and I will show you exactly how to do it.
please, make this "visible" e.g. in the samples part of the X# site,
i'm sure quite some folks would like to see this ;-) 
Regards

Karl

[toc] | [prev] | [next] | [standalone]


#11616

FromChris Pyrgas <"chris (at)"@xsharp.eu>
Date2018-05-13 16:01 +0300
Message-ID<pd9ct3$1vid$1@gioia.aioe.org>
In reply to#11615
Hi Karl,

>> About sharing the same code from XIDE and VS, you just need to create a
>> project/app and add to it the exact same files that the other
>> environment is using. For WPF it is a little more complicated, because
>> of the many "hidden" files VS creates for WPF apps, but it is still very
>> doable, but no need to clutter this ng with that, please send me a WPF
>> project of yours and I will show you exactly how to do it.
> please, make this "visible" e.g. in the samples part of the X# site,
> i'm sure quite some folks would like to see this ;-)

Do you mean about the WPF thing specifically? Because apart from that, 
it is straightforward I think, you just need to include from one IDE the 
exact same .prg files that the other IDE uses as well.

Or do you mean just to demonstrate to people that it is actually 
possible to do that? Maybe because of the complexity of the VO repo and 
the way code is stored in it, we are used to think that such sharing of 
code is very difficult, but since everything is file based in .Net 
languages, it's only just a matter of using the exact same physical .prg 
files. But yeah, I can create a WinForms and WPF dual solution and 
upload them to the site.

regards,
Chis

[toc] | [prev] | [next] | [standalone]


#11618

From"Wolfgang Riedmann" <wriedmann@gmail.com>
Date2018-05-13 15:12 +0200
Message-ID<flqrt7Fb1sjU1@mid.individual.net>
In reply to#11615
> Chris,
> > About sharing the same code from XIDE and VS, you just need to
> > create a project/app and add to it the exact same files that the
> > other environment is using. For WPF it is a little more
> > complicated, because of the many "hidden" files VS creates for WPF
> > apps, but it is still very doable, but no need to clutter this ng
> > with that, please send me a WPF project of yours and I will show
> > you exactly how to do it.

> please, make this "visible" e.g. in the samples part of the X# site,
> i'm sure quite some folks would like to see this ;-) 
> Regards

.... or publish it on the docs site, or write a blog article about it.

Wolfgang

P.S. I already know how to do it, but I prefer WPF in code





-- 

[toc] | [prev] | [next] | [standalone]


#11619

From"Wolfgang Riedmann" <wriedmann@gmail.com>
Date2018-05-13 15:13 +0200
Message-ID<flqs01Fb2alU1@mid.individual.net>
In reply to#11612
Hi Chris,

> About sharing the same code from XIDE and VS, you just need to create
> a project/app and add to it the exact same files that the other
> environment is using. 

since you have made the XPorter, you know how to write a VS
solution/project file, so it should be no problem to maintain one
synchronized between XIDE and VS...

Wolfgang



-- 

[toc] | [prev] | [next] | [standalone]


Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.lang.clipper.visual-objects


csiph-web