Components for a client/server architecture

[Samuel]

Hi,

I am looking for some recommendations for client/server technologies and 
for the communication involved.

I am currently planning to port a Perl application that has grown out of 
proportion to another language and architecture. For this purpose, I am 
investigating technologies that best fit the requirements.

The current plan for the architecture of the ported software includes:

- A client/server model, where the server provides a service for
  configuring network devices and the client provides a user interface
  that runs on Unix.

- Java (and possibly Jython) or Mono/C# (or possibly IronPython) on the
  server. Requirements are: A strong and fair threading model. This is
  actually what drove me away from Perl and what essentially prevents
  using a normal Python interpreter on the server. I don't know whether
  the GIL and starvation issues also apply to IronPython or Jython.
  Sharing non thread-aware objects of arbitrary type between threads
  without any restriction is absolutely necessary (this is not possible
  in Perl).

- Perl or Python on the client side. Clients have to provide a UI (a
  web application is not an option).

Unfortunately, I have very little experience with client/server 
architectures and the protocols involved, so I would like to collect your 
recommendations as a starting point for further research:

- Are there any standard protocols that make it easy to share objects
  between Java/Jython/IronPython and Python or Perl over the network? I
  am thinking of a portable, language independent object 
  (de-)serialization, if such a thing exists.
  Having a defined protocol/interface between the client and the server
  that makes it easy to switch technologies on either side of the
  architecture is a strong requirement.

- How does bi-directional communication in such a protocol work? I am
  assuming that the client should not poll the server for callbacks,
  OTOH, leaving a TCP connection open also does not seem right.

- What is the security model of that protocol?

If my description of the project is inaccurate or too incomplete I 
apologize; the problem is that I still find it hard to tell which 
requirements actually matter.

If you have any pointers that might be of interest for such an 
architecture, please let me know.

-Samuel