SCA Basics

[Brian O'Neill <bo...@gestalt-llc.com>]

All,

 

Excuse the ignorance, but I'm trying to understand the benefits of
designing applications using SCA.  From the sample applications in
Tuscany, it appears as though Tuscany functions much like Spring; it
provides a means to map logical services to their implementations
(dependency injection), and then adds a layer to compose services on top
of that.

 

The only SCA specific files I see in the samples are the composition
files. (e.g. Calculator.composite)  Thus, it leads to the question, is
that all it takes to create a "SCA-compliant" application?

 

-brian

 

--------------------

Brian O'Neill

Technical Architect, Gestalt LLC

mobile: 215.588.6024

http://weblogs.java.net/blog/boneill42/
<http://weblogs.java.net/blog/boneill42/> 

 

Re: SCA Basics

[Venkata Krishnan <fo...@gmail.com>]

Hi Brian,

SCA is an infrastructure for building composite applications the parts of
which could be coming from implementations that might be running on
different platforms / runtime technologies, that might be using different
protocol bindings and databindings.  Typically, one might have to go and
code such compositions and put in lots of plumbing code to address
connecting to various containers, dealing with wire level protocols, data
formats and so on.  But with SCA all (or atleast most) of this is spared.
All that you need to do is 'define' the solution/application composition as
a Composite (in a .composite file) and simply deploy it.  The SCA runtime
takes care of interpretting this composition and creating all the necessary
plumbing around it - all during runtime.

Hope this helps to start on further questions :)

Thanks

- Venkat

On 6/15/07, Brian O'Neill <bo...@gestalt-llc.com> wrote:
>
> All,
>
>
>
> Excuse the ignorance, but I'm trying to understand the benefits of
> designing applications using SCA.  From the sample applications in
> Tuscany, it appears as though Tuscany functions much like Spring; it
> provides a means to map logical services to their implementations
> (dependency injection), and then adds a layer to compose services on top
> of that.
>
>
>
> The only SCA specific files I see in the samples are the composition
> files. (e.g. Calculator.composite)  Thus, it leads to the question, is
> that all it takes to create a "SCA-compliant" application?
>
>
>
> -brian
>
>
>
> --------------------
>
> Brian O'Neill
>
> Technical Architect, Gestalt LLC
>
> mobile: 215.588.6024
>
> http://weblogs.java.net/blog/boneill42/
> <http://weblogs.java.net/blog/boneill42/>
>
>
>
>

Re: SCA Basics

[Mike Edwards <mi...@gmail.com>]

Brian,

"Is that all it takes to create an SCA compliant application?"

If I interpret that correctly, you're expressing surprise that there 
doesn't seem to be much to writing SCA applications.  If that's correct, 
then in one important sense, SCA is structured in the right way.

SCA is designed to keep the coding of components simple - the principle 
is that you don't write your code "for SCA", you "just write code". 
SCA, like Spring, aims to keep middleware APIs and middleware structures 
out of your code.  The code concentrates on the business problem at hand 
and simply invokes business interfaces when needing to get at services 
provided by other components.  In Java, those business interfaces simply 
arrive in your component code through injection - they are there when 
you need them.

The SCA composite files then describe metadata about your component and 
the other components & services which it uses.  All the "messy stuff" 
about the set of components that are used to build your solution and the 
way in which they are connected (communication protocols, endpoint 
addresses, infrastructure stuff like Security, etc) are placed into the 
SCA composite files and are used by SCA to generate the right proxies to 
inject into your code when it runs.

You are right in that it does function in a way similar to Spring 
(indeed, SCA + Spring is a good combination).  The stuff that SCA 
provides that goes beyond Spring is:

- it deals with systems built using more than one language, not just 
Java (so you can mix PHP, Java, C++, BPEL....)
- it deals with distributed systems, where different parts run on 
different machines on a network
- it deals with the metadata needed to describe communication protocols 
and infrastructure services in a consistent way

I hope this explanation helps,

Yours,  Mike.


Brian O'Neill wrote:
> All,
> 
>  
> 
> Excuse the ignorance, but I'm trying to understand the benefits of
> designing applications using SCA.  From the sample applications in
> Tuscany, it appears as though Tuscany functions much like Spring; it
> provides a means to map logical services to their implementations
> (dependency injection), and then adds a layer to compose services on top
> of that.
> 
>  
> 
> The only SCA specific files I see in the samples are the composition
> files. (e.g. Calculator.composite)  Thus, it leads to the question, is
> that all it takes to create a "SCA-compliant" application?
> 
>  
> 
> -brian
> 
>  
> 
> --------------------
> 
> Brian O'Neill
> 
> Technical Architect, Gestalt LLC
> 
> mobile: 215.588.6024
> 
> http://weblogs.java.net/blog/boneill42/
> <http://weblogs.java.net/blog/boneill42/> 
> 
>  
> 
> 

---------------------------------------------------------------------
To unsubscribe, e-mail: tuscany-user-unsubscribe@ws.apache.org
For additional commands, e-mail: tuscany-user-help@ws.apache.org