On 25/08/2014 16:47, Tim Young [Elevate Software] wrote:
> they are probably going to regret doing so

I'll admit I was slowly reaching the same conclusion as Mike, so this is
encouraging. AngularJS isn't an option since a major point of EWB for me
is being able to use my large non-visual OP codebase. However, that
requires features such as Interfaces since I'm making heavy use of them
these days, and an ability to add .pas files to an EWB project. I'd been
checking out the OP competition, rather than JS-based solutions.

The ability to use 3rd party visual JS components is also important.

Cheers, Bob

Bob,

<< I'll admit I was slowly reaching the same conclusion as Mike, so this is encouraging. AngularJS isn't an option since a major point of EWB for me is being able to use my large non-visual OP codebase. However, that requires features such as Interfaces since I'm making heavy use of them these days, and an ability to add .pas files to an EWB project. I'd been checking out the OP competition, rather than JS-based solutions. >>

Interfaces will be added at some point, provided that they are do-able in terms of behaving exactly as they do with native Object Pascal.  I've looked into implementing them a bit, but the devil is always in the details.  EWB 2 does have IFDEF support, so you can alter your existing non-UI Delphi code to "adapt" to a given environment.

<< The ability to use 3rd party visual JS components is also important. >>

You can do so now with EWB 1.x, but the issue is always one of how the Object Pascal code interacts with the JS code.  However, EWB 2 will certainly make this easier since you can wrap such controls in a much easier way and then install them into the component palette.  But, as always, the primary goal is to get to a point where the use of such controls isn't necessary.
------------

Tim Young
Elevate Software
www.elevatesoft.com

Thanks Tim I can always IFDEF around my class declarations for now.

I've successfully tested a number of external JS components with EWB 1
but it's a wrapper that's needed - so good news indeed.

Cheers, Bob

Understood Tim and of course I mean no disrespect.  The idea is
brilliant and I have no doubt it will get where it needs to be at some
point.  I just didn't feel like EWB1 did everything I needed and so
opted to use Angular + Twitter BS instead.

I expected to be able to build the app in HTML/JS, but i didn't expect
it to be elegant.  I was pleasantly surprised.

Mike Margerum wrote:

> I expected to be able to build the app in HTML/JS

I think one of the big issues is that of learning Javascript. Which of
course is fine, but when you watch Crockford you realise that there is
plenty to learn not to do too, and for me using Delphi on both the back
and front end has been a big win. The speed of development has allowed
me to do the complex stuff easily, and no learning penalty.

Crockford video ("Javascript the good parts"):

https://www.youtube.com/watch?v=hQVTIJBZook

--

Matthew Jones

Mike,

<< Understood Tim and of course I mean no disrespect. >>

None taken.

<< I expected to be able to build the app in HTML/JS, but i didn't expect it to be elegant.  I was pleasantly surprised. >>

Yes, it is indeed very elegant, and a very interesting concept/implementation.  It just doesn't, IMO, solve the big problems that Object Pascal developers are trying to solve when writing web applications, such as the issues of multiple implementation languages and live, WYSIWYG coding/design, as well as all of the benefits of using Object Pascal with a front-end compiler.  These are *hard* problems, which is why everyone isn't rushing to solve them.  For example, doing a WYSIWYG IDE for web development almost guarantees four things:

1) You're going to need a top-level language with a type system to front-end JS.
2) You're going to need an interpreter (byte-code, etc.) to handle executing the top-level code in the design-time environment, and it's going to need to match the behavior of the JS code executing in the browser.
3) You're going to have to write a designer that mimics at least 80-90% of the UI capabilities of a browser.
4) You're going to need a runtime library/UI framework that works in both design-time and run-time, and hides the differences from the component/control developer.
------------

Tim Young
Elevate Software
www.elevatesoft.com

> I think one of the big issues is that of learning Javascript. Which of
> course is fine, but when you watch Crockford you realise that there is
> plenty to learn not to do too,

Yeh lots of weird implicit behaviors for sure.


>and for me using Delphi on both the back
> and front end has been a big win.

The same could be said for javascript and node.js :D

Their is a *very* steep learning curve for sure and as long as you don't
try to use Javascript like a classical OO language, it's quite powerful
and expressive.  I could see it being very hard to use to build very
large projects with large teams without really good docs.



The speed of development has allowed
> me to do the complex stuff easily, and no learning penalty.
>
> Crockford video ("Javascript the good parts"):
>
> https://www.youtube.com/watch?v=hQVTIJBZook
>

I own and read that book.  The fact that its like 200 pages speaks
volumes lol.  Still, ill say it again.  JS in capable hands is
incredibly powerful and expressive.  I really favor composition over
deep object hierarchies.

This video from Eric Elliot is really good.  Explains why people
generally misunderstand what makes JS so powerful.


http://vimeo.com/69255635

Mike Margerum wrote:

> The same could be said for javascript and node.js :D

Indeed, though I had a good think about that once and decided that the
limitations were too high for my purposes. I need worker threads that
can do really powerful stuff, and Delphi does that effectively for me.
Node would be a ton of work to do the same. (Perhaps someone who's
spent a year on it could do it, but that isn't me and I have to earn a
crust sooner.)

I will watch the video - thanks.

--

Matthew Jones

On 8/26/2014 10:44 AM, Tim Young [Elevate Software] wrote:
> Mike,
>
> << Understood Tim and of course I mean no disrespect. >>
>
> None taken.
>
> << I expected to be able to build the app in HTML/JS, but i didn't expect it to be elegant.  I was pleasantly surprised. >>
>
> Yes, it is indeed very elegant, and a very interesting concept/implementation.  It just doesn't, IMO, solve the big problems that Object Pascal developers are trying to solve when writing web applications, such as the issues of multiple implementation languages and live, WYSIWYG coding/design, as well as all of the benefits of using Object Pascal with a front-end compiler.  These are *hard* problems, which is why everyone isn't rushing to solve them.  For example, doing a WYSIWYG IDE for web development almost guarantees four things:
>
> 1) You're going to need a top-level language with a type system to front-end JS.
> 2) You're going to need an interpreter (byte-code, etc.) to handle executing the top-level code in the design-time environment, and it's going to need to match the behavior of the JS code executing in the browser.
> 3) You're going to have to write a designer that mimics at least 80-90% of the UI capabilities of a browser.
> 4) You're going to need a runtime library/UI framework that works in both design-time and run-time, and hides the differences from the component/control developer.
> ------------
>


I look forward to the monitor the progress you are making Tim and just
because i'm not renewing now doesn't mean i'm done using your toolkit.
 Best of luck.

On 8/26/2014 12:38 PM, Matthew Jones wrote:
> Mike Margerum wrote:
>
>> The same could be said for javascript and node.js :D
>
> Indeed, though I had a good think about that once and decided that the
> limitations were too high for my purposes. I need worker threads that
> can do really powerful stuff, and Delphi does that effectively for me.
> Node would be a ton of work to do the same. (Perhaps someone who's
> spent a year on it could do it, but that isn't me and I have to earn a
> crust sooner.)
>
> I will watch the video - thanks.
>

Having to do everything in Async via node.js can be a PITA frankly.
Promises do help, but sometimes you want to just rely on the fact that
you are in a thread and so can write statements sequentially.  Not every
web service has to scale to thousands of connections.

I don't find JS nearly as useful on the server as I do on the client.
I also don't like relying on 45 NPM packages written by people who are
going to get bored and move on.  The fact that node has no standard
library is a big issue.

There's other issues i've run into as well.  Starting with basic math
which JS apparently sucks at:

..1 + .2 = 0.30000000000000004

I did work it all out though and built a fairly capable web app that's
every bit as functional as a native app.

the biggest reason to try out  angular isnt even that you will use it,
but it will get you thinking in the right direction.  I was inspired to
begin working on implementing MVVM patterns in my delphi code.