Question of the week, do you OO ? - Forum - OpenEdge Architecture - Progress Community
 Forum

Question of the week, do you OO ?

  • Ok, so the subject line isn't quite grammatically correct, but it got your attention

    Some of the discussions in the other threads have started to go down a road of why aren't the samples/examples we're providing currently using the new OO extensions in the ABL.

    So I guess I'd like to ask whether or not there is a huge demand for class based examples? Maybe this also leads to a bigger question, and one that should be in a poll, are you using OpenEdge 10.1? If not, when do you think you will be, 1 month, 2, 3, 6, 12...and if you are, or intend to, how many of you think you will move to an OO based design and implement in classes, and in what time frame?

    Is it only me, or is this forum starting to become some form of big therapy session, where we ask and you tell us about your issues (or maybe that just says more about me) !!

    Mike

    PS. I just had an mental image of John Sadd stood in a white doctors coat, presenting at Exchange, very surreal !!

  • So I guess I'd like to ask whether or not there is a huge demand for class based examples?

    Irregardless of there being a "huge demand", if PSC incorporates new technology in their product offering, it only makes sense to provide examples that show how to use it.

    Leaving these examples out means the developer community has to figure it out for themselves, or calling TS looking for help.

    If a developer figures they have better things to do with their time (ie "real work") than try to figure out a technology that may or may not help them get their job done, then the adoption rate'll be low and all PSC's work'll be for naught.

    If a developer calls TS because there's no docs / examples, that's a resource load on TS, which they could've spent on other things.

  • So I guess I'd like to ask whether or not there is

    a huge demand for class based examples?

    Irregardless of there being a "huge demand", if PSC

    incorporates new technology in their product

    offering, it only makes sense to provide examples

    that show how to use it.

    Leaving these examples out means the developer

    community has to figure it out for themselves, or

    calling TS looking for help.

    If a developer figures they have better things to do

    with their time (ie "real work") than try to figure

    out a technology that may or may not help them get

    their job done, then the adoption rate'll be low and

    all PSC's work'll be for naught.

    If a developer calls TS because there's no docs /

    examples, that's a resource load on TS, which they

    could've spent on other things.

    You mean people out there do "real work"

    All totally valid points, and hence part of the rational behind having something such as OpenEdge Principles.

    Now, would we save more of everyone's time if we produced more procedural based examples, rather than satisfying the need of the few that are at the front of the adoption curve? It's been proven time & time again, the fittest will always survive and the brightest will always work it out, but what about those that are outside of the 5%?

    Don't read me wrong, at the end of the day we need both, but just as the N-Tier/SOA poll is showing (even if it is currently a total of 5 votes, so come on all you lurchers, get voting!), there is a danger that the guidance we produce is "too far" ahead of what the community is looking for, which wouldn't be good either. We've all heard about the people sat in ivory towers

  • Now, would we save more of everyone's time if we produced more procedural based examples, rather than satisfying the need of the few that are at the front of the adoption curve?

    There needs to be a balance of both. Too much of any single topic / subject / etc. is bad.

    It's been proven time & time again, the fittest will always survive and the brightest will always work it out, but what about those that are outside of the 5%?

    And why should the "best and brightest" have to spend time figuring out information PSC could've easily provided in the first place?

    ... a danger that the guidance we produce is "too far" ahead of what the community is looking for...

    Or too focused on a single topic / technology.

  • Well, I've been doing all new development in 10.1A since the start of beta and I will move to 10.1B as soon as the beta starts, so I am 100% OO for all new work.

    While there may not be a huge percentage of the current community doing OO development yet, how do you expect them to get there if you don't provide leadership? Some of them will learn from Java and other language backgrounds, but many of them have no OO background and the best way for them to get that background is for you to show the way.

    One of the biggest millstones around PSC's neck is all the people stuck on old versions. Some of those people are genuinely stuck because they have lapsed maintenance. While it would be nice to pull those people back into the family, they can't really be your focus because they provide no revenue and no future. Other people are stuck because they have customized version X of some VARs product so that they can't upgrade to later releases of either the Progress or VAR product. I don't have any answers for them other than the kind of stuff I am working on. But, there are a lot who are on old versions for no good reason -- don't break what works, licensing issues, etc. -- i.e., things which are understandable reasons, but which are long term things that are bad for PSC to allow keeping people on old versions.

    Certainly one of the ways that I can think to motivate people considering moving forward is by providing examples that show how desirable it is.

    Consulting in Model-Based Development, Transformation, and Object-Oriented Best Practice  http://www.cintegrity.com

  • Don't read me wrong, at the end of the day we need both, but just as the

    N-Tier/SOA poll is showing (even if it is currently a total of 5 votes, so come

    on all you lurchers, get voting!),

    I, for one, haven't voted because I want both and the question is to simple to make a choice.

    Consulting in Model-Based Development, Transformation, and Object-Oriented Best Practice  http://www.cintegrity.com

  • Don't read me wrong, at the end of the day we need

    both, but just as the

    N-Tier/SOA poll is showing (even if it is currently

    a total of 5 votes, so come

    on all you lurchers, get voting!),

    I, for one, haven't voted because I want both and the

    question is to simple to make a choice.

    See, now life is full of difficult choices

    The poll is intended to get some idea of what people think we should do 1st, not that we should do one over the other. It's fairly obvious that we need to do both, and classed based examples, and new UI work when it becomes available, etc, so I'm trying to asses peoples perceived views on priority.

  • >.....

    While there may not be a huge percentage of the

    current community doing OO development yet, how do

    you expect them to get there if you don't provide

    leadership? Some of them will learn from Java and

    other language backgrounds, but many of them have no

    OO background and the best way for them to get that

    background is for you to show the way.

    Now this raises an interesting question. Is our (Progress's) job to teach OO programming? Sure it's our job to teach how to use the OO features of the ABL, but does that mean we should also be teaching OO basics? Aren't there thousands of books & courses out there that could do that?

    Certainly one of the ways that I can think to

    motivate people considering moving forward is by

    providing examples that show how desirable it is.

    Agreed, this is a point I made in an earlier posting. We have to show the benefit of moving, rather that just shouting "Hey, we've released a new version with some cool stuff, aren't we clever"

  • The poll is intended to get some idea of what people think we should do

    1st, not that we should do one over the other. It's fairly obvious that we

    need to do both, and classed based examples, and new UI work when it

    becomes available, etc, so I'm trying to asses peoples perceived views on

    priority.

    I think, though, that it is a false question in a number of ways:

    1. The two are not really separate. Both SOA and N-tier are about learning how to package an application in appropriate units. A body of code that spans multiple layers doesn't make a good service. You have to address both issues simultaneously.

    2. Even if they were separable, there is no reason to pursue either a whole batch of SOA topics and then a whole batch of N-tier topics, or vice versa ... one can do one, then another according to which individual topic seems important.

    3. While it is refreshing and nice to have you asking, you also need to realize that PSC is taking a leadership position here. I.e., the presumption is that you know where we should be heading and you should be the one providing the guidance. Admittedly, I haven't always felt like PSC was doing its job in this regard and that the best guidance on how to do ABL development was coming from people outside the company, but you should be trying to think like leaders (even if you have to look outside for some guidance of your own). As a leader, you have to expect that the followers don't really know what they don't know. So, while our points of pain are important and you should be addressing them, you also need to be charting a path based on your vision.

    Consulting in Model-Based Development, Transformation, and Object-Oriented Best Practice  http://www.cintegrity.com

  • Now this raises an interesting question. Is our (Progress's) job to teach OO

    programming? Sure it's our job to teach how to use the OO features of the

    ABL, but does that mean we should also be teaching OO basics? Aren't

    there thousands of books & courses out there that could do that?

    Thousands of books about other languages, but none about ABL. Feel free to make use of those books and courses where they seem useful, but recognize that most ABL developers are going to look for their guidance from the PSC documentation, so either you point them in the right direction or they end up wandering around and probably not getting very far.

    Apropos of which, there are a lot of bad examples in the existing documentation which should get purged or modified.

    Consulting in Model-Based Development, Transformation, and Object-Oriented Best Practice  http://www.cintegrity.com

  • Now this raises an interesting question. Is our

    (Progress's) job to teach OO programming? Sure it's

    our job to teach how to use the OO features of the

    ABL, but does that mean we should also be teaching OO

    basics? Aren't there thousands of books & courses

    out there that could do that?

    It's your job to deliver an intuitive ABL which shields the programmer from low-level tasks making it more future proof than the old 3GL (I consider C# + VS.NET a 4GL as well). When you claim you provide a highly productive environment and users claim they have a hardtime adopting a new architecture, something is wrong. Host-based 4GL in the 90-ties was very productive, but the community has been struggling with the 4GL since the client/server age.

    Event-driven programming, dynamic widgets and dynamic queries were a big step forward for the Progress community, but it didn't make the 4GL code easier or more robust due to all string manipulations and the verbose syntax. The ProDataSet is a nice feature, but in the wrong hands it's even worse than binding to a direct database query.

    So all the features might be there, but I think we (Progress community) want to make clear that you (Progress) have to create a more complex example with the right technology, before you understand why developers are struggling with certain ABL-concepts. I just have to name the BROWSE-widget on the Windows platform or unlogical restrictions to FUNCTION/ASSIGN statements (KB solution ID: 18223) and people understand what I'm talking about...

    Theo.

  • I just have to name the BROWSE-widget on the Windows platform

    And I suppose we won't even mention browse on ChUI!

    Consulting in Model-Based Development, Transformation, and Object-Oriented Best Practice  http://www.cintegrity.com

  • Event-driven programming, dynamic widgets and dynamic queries were a big step forward for the Progress community, but it didn't make the 4GL code easier or more robust due to all string manipulations and the verbose syntax.

    I don't think the problem is the existence of dynamic widgets and queries, but that PSC didn't take the next logical step with them and provide 4GL/ABL ways of managing them.

    Queries, persistent procedures, and super procedures are some examples that were begging for something to bring out all their latent power. Since PSC didn't provide a standardized way to deal with them easily, I wrote my own. My procedure manager provides me with an OO-ish way of developing applications, and I can do a lot more a lot faster than I could've done without this tool.

    I would much rather've used PSC's native implementation than have spent all that time writing my own.

    The lost opportunities - if PSC had provided a procedure manager in 9.1 days, the language could've had OO-ish capabilities for years now instead of being introduced in 10.1. A query manager which facilitated standad query string specification could make setting up complicated queries a series of method calls on an object handle. Once the query was done, it could be fed to an boolean optimizer which would re-do it so it does better table searches.

    and that's just off the top of my head...

    Getting back to teaching OO - PSC doesn't have to teach all of the OO programming, but they should provide enough to show how each element of ABL OO development works, how they all are tied together, and can be used in a "real life."

    Once that's accomplished, PSC could then provide references to other materials which do a better job of teaching the more advance concepts of OO programming, offer training courses, etc.

  • PSC doesn't have to teach all of the OO programming, but they should

    provide enough to show how each element of ABL OO development works,

    how they all are tied together, and can be used in a "real life."

    I think the key element here is leading by example. If PSC provides good examples that translate well to real world work, then people will follow those examples and end up doing the right thing. If they can't identify with the examples or the examples are incomplete or even bad, then they either won't be followed or, worse yet, they will be.

    This requires a lot of vigilance. An example focused on ProDataSets isn't going to convey a meaningful lesson if it is built on a schema as simple as sports2000 and it is going to convey the wrong message if the demo programs have UI mixed in with the data access. If it is too much to build all the layers for each example, then build the layer which the example is about cleanly and provide a test program which is clearly labelled as such, i.e., something which is very obviously not intended as part of an application, but exists merely to test a component and prove that it works as intended.

    Similarly ... not to get on John Sadd's case ... but one really shouldn't be publishing MVC examples with references to buttons in the controller. It really doesn't take meaningful more work to make the controller in terms of actions and leave the view to the view. Indeed, it would be absolutely ideal to provide two different views which work with the same model and controller to really illustrate the principle that the pattern is all about.

    Consulting in Model-Based Development, Transformation, and Object-Oriented Best Practice  http://www.cintegrity.com

  • Would be interesting to see alternative modified examples posted back from the community illustrating where a difference of opinion exists and highlighting the benefits of the alternative approach. Bear in mind these are reference materials and there is no one correct answer.

    On the subject of productivity - as discussed in other threads the ABL has had to respond to the challenge of developing distributed n-tier and SOA applications. The job is just much harder these days, regardless of the language being used - there is much more to consider upfront and many more use cases that need to be solved.

    I believe the key to reviving the productivity is with tools. The tools should hide the complexity as far as possible - with the complexity being isolated mostly to the definition of the target design patterns. If we had productive tools, then the reference examples would not need to be as extensive. The use of the tools would guide you through the best practices to a large extent.

    Out goal is then to produce concrete examples / patterns for the tools that solve a number of common use cases. Our challenge is understanding what these are.

    Just thought I'd add a few different angles to the discussion.

    Ant