Hi all!

I've just been watching an EGL demo by Tom Chastain, from IBM Labs, in
an event called Infobahn, in Lisbon.

I must confess I'm a bit disappointed.

We've worked with 4GL since the 80's and we work with Java since late
90's. We've been able to keep away from major detours called "4GL for
Windows", "New Era" (this one fooled us for some time), 4J's, Querix,
etc. We were expecting the "real thing"...

And the real thing should have had, for starters:

1. Full (I mean *full*) 4GL compatibility (syntax, file format,
command line)
2. Object-orientation
3. Java integration (like with C in older versions)
4. Windows & web browser execution

Of course, it would be nice to have also:

* an IDE (eclipse is a good choice)
* multiple simultaneous connections
* more instructions to send mail, read/write files, parse XML, etc.

I sincerely don't understand why this has been so difficult. Let's see:

1. Rewriting the compiler it's not so difficult. Several companies
have done it, and there is even an open source project that has
done it too. Doing it in Java wouldn't be harder
2. Object orientation has been already done in New Era , keeping
(incomplete) compatibility with the original 4GL.
3. Java integration comes easy after the first two
4. Running in Windows has already been done in "4GL for Windows" (are
the 'O' guys smarter?)

Now we've been hearing the EGL spin for some time, about the "New
Informix 4GL", and we are very interested, of course. But unfortunately
the first demos of the product are here and EGL is not what we expected.
Let's see why:

* 4GL is converted into a different, uglier, language, in witch SQL
is not part of the syntax, it is "escaped" like in ESQL-C or SQL/J
* Windows and Browser/applet direct usage is not possible (yet?),
only Web-HTML (with manual conversion of forms and input?)
* Heavy emphasis is placed on Visual editor and JSF, as if any 4GL
programmer cares about it or wants to learn it
* The IDE is very powerful but is also very complex

Well, IBM, try again!... I'd suggest these steps:

* Creating a real 4GL layer to edit/compile/debug, hiding EGL
underneath or generating Java directly, with no need for
conversion tools
* Creating a Java GUI that runs in Windows and in a browser as an applet
* Extending INPUT to handle JSF forms (for the very few programmers
that want to use this fine technology)
* Extending the syntax to do OO (see Python for easy OO) and let
Java Objects be used from 4GL

In summary: 4GL is a simple, powerful, language, in a simple
environment. Simplicity is key. Let me simplify your job and tell you
what I'd like to see in the next EGL presentation:

1. Start with a 4GL program with a form and a report
2. Run a shell and type "newfglpc program.4gl" - creating program.jar
- and then run "newfglrun program" and show a window with the
program running in GUI mode
3. Then, run "newfglpc --web program.4gl" - creating a .war, this
time - and then drop the warfile in an appserver; then go to a URL
like "http://server/4gl/program" and show it run on the browser
with the exact same look&feel that in GUI mode.
4. And then, after establishing that the "New Informix 4GL" can
really substitute on the old one, only then, very carefully, the
demo could go on about JSF, app servers, complex IDE's (editing
and debugging 4GL directly), etc., so that nobody is scared. ;-)

Am I expecting too much? Is it not possible? Is it not profitable?
Anyway, I hope this helps and I'm sorry for any imprecision.

Fernando

--
Fernando Fernandez
http://www.moredata.pt

sending to informix-list

Well... I've been at the same event, and I have some comments.
I should make clear that my view on this may be influenced by my current
employer
Nevertheless, this are my _personal_ opinions... Here goes:

Fernando Fernandez wrote:
> Hi all!
>
> I've just been watching an EGL demo by Tom Chastain, from IBM Labs, in
> an event called Infobahn, in Lisbon.
>

I wouldn't call it an EGL demo... We've saw an .avi of basically a very
simple 4GL batch progam being converted to EGL. This conversion was done
by the upcoming 4GL to EGL converter. There was no focus on the IDE or
even on the EGL language itself.

> I must confess I'm a bit disappointed.
>
> We've worked with 4GL since the 80's and we work with Java since late
> 90's. We've been able to keep away from major detours called "4GL for
> Windows", "New Era" (this one fooled us for some time), 4J's, Querix,
> etc. We were expecting the "real thing"...
>
> And the real thing should have had, for starters:
>
> 1. Full (I mean *full*) 4GL compatibility (syntax, file format,
> command line)
> 2. Object-orientation
> 3. Java integration (like with C in older versions)
> 4. Windows & web browser execution
>
> Of course, it would be nice to have also:
>
> * an IDE (eclipse is a good choice)
> * multiple simultaneous connections
> * more instructions to send mail, read/write files, parse XML, etc.
>
> I sincerely don't understand why this has been so difficult. Let's see:
>
> 1. Rewriting the compiler it's not so difficult. Several companies
> have done it, and there is even an open source project that has
> done it too. Doing it in Java wouldn't be harder
> 2. Object orientation has been already done in New Era , keeping
> (incomplete) compatibility with the original 4GL.
> 3. Java integration comes easy after the first two
> 4. Running in Windows has already been done in "4GL for Windows" (are
> the 'O' guys smarter?)
>

Let me point out some facts and opinions, that we can like or not:

1- EGL wasn't mean to accept 4GL syntax. EGL is a much bigger picture
than 4GL (more on this later)
2- For people who want an OO language, there are plenty out there...
Java is the most noticeable one.
3- EGL environment has Java integration. You can call Java from EGL and
EGL from Java.
4- AFAIK EGL will allow yout to have multiple connections, to different DBs
5- Since you can call Java from EGL, sending mails, parsing XML etc.
should be easy to do (if you have Java knowledge). Read and write files
is included.

> Now we've been hearing the EGL spin for some time, about the "New
> Informix 4GL", and we are very interested, of course. But unfortunately
> the first demos of the product are here and EGL is not what we expected.
> Let's see why:
>
> * 4GL is converted into a different, uglier, language, in witch SQL
> is not part of the syntax, it is "escaped" like in ESQL-C or SQL/J
> * Windows and Browser/applet direct usage is not possible (yet?),
> only Web-HTML (with manual conversion of forms and input?)
> * Heavy emphasis is placed on Visual editor and JSF, as if any 4GL
> programmer cares about it or wants to learn it
> * The IDE is very powerful but is also very complex
>

The "uglier language" is EGL itself... I wouldn't say it's uggly... It
sure isn't 4GL... But anyone with a reasonable knowledge of 4GL or C
will find it at least very "familiar". It has the usual procedural
language constructs...

The complexity of the IDE is a direct consequence of it's potencial...
As I said earlier, EGL is a much bigger picture than 4GL...


> Well, IBM, try again!... I'd suggest these steps:
>
> * Creating a real 4GL layer to edit/compile/debug, hiding EGL
> underneath or generating Java directly, with no need for
> conversion tools
> * Creating a Java GUI that runs in Windows and in a browser as an applet
> * Extending INPUT to handle JSF forms (for the very few programmers
> that want to use this fine technology)
> * Extending the syntax to do OO (see Python for easy OO) and let
> Java Objects be used from 4GL
>
> In summary: 4GL is a simple, powerful, language, in a simple
> environment. Simplicity is key. Let me simplify your job and tell you
> what I'd like to see in the next EGL presentation:
>
> 1. Start with a 4GL program with a form and a report
> 2. Run a shell and type "newfglpc program.4gl" - creating program.jar
> - and then run "newfglrun program" and show a window with the
> program running in GUI mode
> 3. Then, run "newfglpc --web program.4gl" - creating a .war, this
> time - and then drop the warfile in an appserver; then go to a URL
> like "http://server/4gl/program" and show it run on the browser
> with the exact same look&feel that in GUI mode.
> 4. And then, after establishing that the "New Informix 4GL" can
> really substitute on the old one, only then, very carefully, the
> demo could go on about JSF, app servers, complex IDE's (editing
> and debugging 4GL directly), etc., so that nobody is scared. ;-)

Comments:

1- As it was said in the .avi intro, when released it's supposed to
include a forms converter (or the converter will be able to convert forms)
2- It would be nice... But as you mentioned, there are products which do
this.
3- The GUI in a applet was done by 4Js. I haven't touched it for a long
time, but deploying wasn't easy... You either sent a +300KB applet (not
nice for network) or you tried to install the applet... but this was not
very useful over the Internet... JSF makes more sense...?
4- Once again, EGL is not "the new Informix 4GL" and once again we
haven't saw an EGL demo... only a film of a very basic (and pre-beta)
conversion done by a "yet to come product".

Now... What I mean by a "EGL is a much bigger picture than 4GL"...
I personaly don't think IBM have done EGL for replacing _I4GL_. EGL
intends to be a _4GL_ for modern environments. Note the underlines...
"4GL" and "I4GL". The "target" for EGL is not _only_ the I4GL
environments out there... It's target are the programmig teams that have
to focus on business problems and solutions and want a "RAD" to do it.

if you want Object Orientation, direct Java and JDBC, J2EE etc. and you
are productive with, and know all this things, then you probably won't
need EGL.
But if you, like me, have to do a program very quickly, and you have no
practice on OO environments, and you would love to be able to integrate
your work with modern environments, then, either you're an old timer 4GL
programmer or not, you may find EGL very useful.

Also very important, we haven't seen an EGL demo... EGL is capable of
(but not only):

1- create web services
2- call java
3- call C/C++ etc. programs/functions
4- create web applications
5- create non-interactive batch files
6- in 6.x it will include a 4GL to EGL converter

We've only seen a tiny bit of point 6 in a pre-made film (AVI format).

I would say that IBM it not passing the write message, and for once,
they maybe talking too much, too soon. EGL already exists, and you can
do work with it. But the 4GL conversion isn't there yet. I think this
two simple facts say very much about the language and environment. As
stated in the presentation, there will be cases where something like
D4GL may be a better environment.

But there are a lot of customers out there that have business
funcionality in 4GL that they would love to put in a modern environment.
EGL can do that and let's hope it can do it well.



>
> Am I expecting too much? Is it not possible? Is it not profitable?
> Anyway, I hope this helps and I'm sorry for any imprecision.

This sure helps to start a friendly discussion, and to let IBMers feel
and know about want customers are thinking.

Some final notes... the EGL course is expected to take 3 days... How
much complex can it be (event considering that the "I" guys are all very
smart)?

Please, take notice that this InfoBahn sessions will happen in several
European cities. Make sure you're there and take advantage of the
presence of influential IBM people to pose your questions and desires.
Eventually you'll also see some news about 9.5 which I'm sure you will
like


EGL (not the converter) is available and also it's manual and some
information:

http://www-306.ibm.com/software/data/informix/4gl-wss/

Take a look for yourself.

>
> Fernando

Regards/Cumprimentos,

Fernando Nunes

Fernando Fernandez wrote:
> Hi all!

(are the 'O' guys smarter?)

Yep.

Fernando Fernandez wrote:
> Hi all!
>
> I've just been watching an EGL demo by Tom Chastain, from IBM Labs, in
> an event called Infobahn, in Lisbon.
>
> I must confess I'm a bit disappointed.
>
Don't be.
You have to learn to lower your expectations to the level where if they
can convert some 4GL, its a good thing. You can not create a language
that is all things to all people.

> We've worked with 4GL since the 80's and we work with Java since late
> 90's. We've been able to keep away from major detours called "4GL for
> Windows", "New Era" (this one fooled us for some time), 4J's, Querix,
> etc. We were expecting the "real thing"...
>
Eeew New Era. Now that brings back bad memories. It was a joke written
by people who didn't understand OO languages. New Era had two serious
killer flaws... No object delegation and way too many subclasses when
they created what little of a library that they had. It was written by
individuals who didn't know jack about OO.

> And the real thing should have had, for starters:
>
> 1. Full (I mean *full*) 4GL compatibility (syntax, file format,
> command line)
> 2. Object-orientation
> 3. Java integration (like with C in older versions)
> 4. Windows & web browser execution
>
Full OO and Full 4GL compatibility?
Aint gonna happen two different things. You have two different
paradigms. Of course one of the characteristics of OO is late binding.
4GL compatibility would mean early binding because you have to retain
your C compatibililty. Remember you said you wanted *FULL* compatibility
with 4GL. ;-)

And now you want "Web Browser capability". What exactly do you mean. You
would want a JSP to call an "EGL" app? Note I put "EGL" in quotes
because your request is for a *new* and *improved* egl...

But getting back to the "web" capability. Web is a thin client. EGL/JAVA
are a thicker client. JSPs are meant for a thin app. (Ok a thick
page). You don't want to use a JSP for an App unless you're using it to
download and launch a java app.

> Of course, it would be nice to have also:
>
> * an IDE (eclipse is a good choice)
> * multiple simultaneous connections
> * more instructions to send mail, read/write files, parse XML, etc.
>
Multiple connections tend to be more of an implementation issue rather
than a language issue.

> I sincerely don't understand why this has been so difficult. Let's see:
>
> 1. Rewriting the compiler it's not so difficult. Several companies
> have done it, and there is even an open source project that has
> done it too. Doing it in Java wouldn't be harder
Uhm, I suggest you try writing a cross compliler. Especially when you're
switching from a langugage that is procedureal and you want to make it
OO and then you have the issues of early bindig vs late binding. C vs
Java functionality. System constraints on multiple platforms, etc ...

What makes it theoretical is that you do have a BNF of 4GL available.
But its a non trivial task.

> 2. Object orientation has been already done in New Era , keeping
> (incomplete) compatibility with the original 4GL.
Bzzzt New Era was a joke and a poor implementation.

> 3. Java integration comes easy after the first two
> 4. Running in Windows has already been done in "4GL for Windows" (are
> the 'O' guys smarter?)
>
[SNIP]

I suggest you put your money where your mouth is. If you think its
trivial, go for it. Its the details that will kill you. ;-)

I don't mean to insult you or start a flame war. However, you're asking
for a silver bullet and none exist.

If you're going to be converting a 4GL app to an OO paradigm, you're
better off doing a rewrite. Yes its more money, however in most cases
your business requirements have changed and you would be better off with
a clean implementation rather than a cobbled hack of translated code.

But hey! What do I know? ;-)