• Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Campbell Ritchie
  • Paul Clapham
  • Ron McLeod
  • Jeanne Boyarsky
  • Tim Cooke
Sheriffs:
  • Liutauras Vilda
  • paul wheaton
  • Henry Wong
Saloon Keepers:
  • Tim Moores
  • Tim Holloway
  • Stephan van Hulst
  • Carey Brown
  • Frits Walraven
Bartenders:
  • Piet Souris
  • Himai Minh

Architecture question

 
Ranch Hand
Posts: 53
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
I am not sure where to post this question, but thought this will the most likely place. I am reading about SOA (service oriented architecture) at the same time is mentions MDA (model driven architecture) and AOP (aspect oriented programming). I am getting confuse what is the difference between SOA and MDA and where does AOP fit in this picture???
I am trying to understand SOA and know nothing about MDA and AOP.
Thanks
 
Sheriff
Posts: 6920
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
SOA is an architectural approach which considers an application as a collection of "services". A design approach such as this is well suited to distributed applications, where individual components may be unavailable or upgraded at any time, but can also be a useful framework for thinking about traditionally more closely coupled systems.
MDA is an architectural philosophy aimed at using some abstract "model" (typically expressed using the UML) to provide input to a process which automatically results in either a more detailled system design, or even a directly executable system implementation. There is currently a lot of discussion about the usefulness of this approach, and whether it is merely another form of programming or something more radical.
AOP is a complementary design technique to the more familiar Object Oriented (OO) approach. AOP seeks to solve the irritating problem of "cross-cutting concerns" - aspects of a system which would have to appear in multiple places in a traditional OO design hierarchy.
These three acronyms may often be used in the same context, but they mean very different things. Keep researching!
 
Jean Miles
Ranch Hand
Posts: 53
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
thanks for your reply.
It is really a challenge trying to keep up with technology. An architect told me recently that the direction is toward SOA (service oriented architecture). If we are using a MVC framework architecture for development and so far what I read about SOA is appears to be address web services only? But the architect said that SOA is more than just address web services development, it is for all types of development? I think we can have multiple architectures in a system that addresses solving the problem at hand. But everytime I talk to the architect is seems to a single architecture solution---> SOA.
 
author
Posts: 11962
5
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Regarding the single architecture thing, I'd be inclined to say that's the wrong answer. Even a medium size application can employ a number of architectural styles -- which I consider MVC and SOA being examples of (another term/concept used to describe MVC is architectural pattern).
I think the architect in question is relying too much on what his favorite columnist/website/blog is touting. There is no silver bullet. Never has been. Except in the werewolf movie.
 
author
Posts: 608
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
For some thoughts on MDA, see www.agilemodeling.com/essays/mda.htm.
I'm not a big fan of MDA, I've seen stuff like this fail miserably in the past and don't see the MDA community doing anything to address the inherent problems in the MDA concept. I wouldn't take it too seriously.
- Scott
 
Ranch Hand
Posts: 185
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
I have no opinion on MDA yet. I would like to try it though. Here is an interesting case study on MDA:
http://www.middleware-company.com/documents/TMC_MDA_Comparison.pdf
http://www.middleware-company.com/casestudy/
 
Lasse Koskela
author
Posts: 11962
5
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
...and while reading, keep in mind that this particular case study was paid for by Compuware -- an MDA tool vendor...
I lost my confidence for TMC's case studies after the .NET/J2EE Petstore benchmark fiasco (paid for and facilitated by Microsoft, who by the way owns a part of TMC).
I'm not saying that they're lying. I'm suggesting that you should *always* make up your own mind, considering facts and facts only.
 
Ranch Hand
Posts: 62
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
We're actually fully applying MDA in our current project.
The architecture that I inherited when I came into the project five months ago basically followed the Spaghetti Bolognese (anti)pattern; what we're doing now is using TDD, refactoring, and continuous integration to transform the application to a three-tier architecture (UI layer -> Domain/business logic layer -> persistence layer).
The single most important tool that keeps us moving forward and that maintains cohesion of vision amongst the developers as to what we're refactoring towards is a collection of UML diagrams (mainly class, collaboration, sequence, activity) that rougly abstract the current State of the Code and that depict the envisioned future architecture. That is, we're just using plain-vanilla UML diagrams, and merely that in itself is almost revolutionary at my client and in this project; most of the developers have had to come face to face with the fact that they haven't actually previously really used UML in anger, and are only now truly learning it.
It's our UML model that drives our implementation and refactorings, that is holding everything together, and that forms the common language among the development team.
Thus, we are using MDA.
(This is not a joke.)
[ January 15, 2004: Message edited by: Allan Halme ]
[ January 15, 2004: Message edited by: Allan Halme ]
 
author
Posts: 14112
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Originally posted by Allan Halme:
It's our UML model that drives our implementation and refactorings, that is holding everything together, and that forms the common language among the development team.
Thus, we are using MDA.
(This is not a joke.)


So you are modeling using language neutral UML diagrams, which then automatically code is generated from using some template mechanism? How do you do this using TDD?
 
Lasse Koskela
author
Posts: 11962
5
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Ilja, as far as I know, they're not generating anything. They're maintaining the vision with a domain model.
And, to duplicate my comment to Allan's blog just a couple of minutes ago, the "real" MDA (according to OMG) involves both a Platform Independent Model (PIM, something like the domain model) and a Platform Specific Model (PSM, e.g. a more detailed model specific to the selected technology -- a mapping of the PIM into Java constructs, for example). Finally, the PSM is transformed into an executable application using a PSM-specific transformation.
 
Allan Halme
Ranch Hand
Posts: 62
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Actually, I was being obnoxious on purpose ... trying to puncture the MDA bubble ... I've not investigated MDA myself in any detail, so I don't have an informed opinion, just an attitude ;)

Originally posted by Ilja Preuss:
So you are modeling using language neutral UML diagrams, which then automatically code is generated from using some template mechanism? How do you do this using TDD?


Like Lasse said, we're not generating anything (apart from occasionally forward-generating class skeletons for new classes from Rose). And thus we're doing TDD (or trying to) the normal way.
We do actually have a tool that we've built on top of AndroMDA which takes a domain model class diagram (as an XMI file) and generates from that a full set of stateless session beans and entity beans using a set of templates that defines a custom pattern of ours. The structure of the pattern itself is another issue, but the point is that a significant part of the implementation is automatically generated. This code, naturally, has no and needs no unit tests. In some boundary situations the generated code has to be subclassed with hand-written custom code, which is of course unit tests as normal.
 
Ilja Preuss
author
Posts: 14112
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Originally posted by Allan Halme:
Like Lasse said, we're not generating anything (apart from occasionally forward-generating class skeletons for new classes from Rose).


Mhh, I always thought that MDA was meant to capture all the domain specific things in the UML model and than somehow automagically generate the code from it. Could be wrong, of course - I am not a MDA expert, either.


We do actually have a tool that we've built on top of AndroMDA which takes a domain model class diagram (as an XMI file) and generates from that a full set of stateless session beans and entity beans using a set of templates that defines a custom pattern of ours. The structure of the pattern itself is another issue, but the point is that a significant part of the implementation is automatically generated. This code, naturally, has no and needs no unit tests.


Then how do you know that it works?
 
We've gotta get close enough to that helmet to pull the choke on it's engine and flood his mind! Or, we could just read this tiny ad:
free, earth-friendly heat - a kickstarter for putting coin in your pocket while saving the earth
https://coderanch.com/t/751654/free-earth-friendly-heat-kickstarter
reply
    Bookmark Topic Watch Topic
  • New Topic