SOAP-Lite reviews

RSS | Module Info

SOAP-Lite (0.716)

No Ratings. Just to mention that IO::Session* are missing from the toolkit. XMLRPC::Lite does not install without them.

SOAP-Lite (0.715) **

It was very hard at the beginning. When I finally figured out how to use it, I discovered that it generates an element xsi:nil="true" for methods called with no parameters (is this a bug?) and the server gives me an error message intead of the correct answer.

I guess it's time to try SOAP::Simple or maybe SOAP::WSDL...

SOAP-Lite (0.711) **

Wow, this is the best CPAN has to offer? Docs are poor. As a perl user of ten plus years it nearly numbed my mind to figure out how to make a basic call to an external SOAP API with some raw xml. This was painful to say the least. So painful I resorted to a simple LWP script for said need. No, my LWP script doesn't have the fancy OO interface, but it does work and in record time compared to trying to dig through the docs for this module.

SOAP-Lite (0.710.10) ****

I made a web service use REST and JSON when one of our major users called us to ask if we could make it available in SOAP. Grinding my teethes, I searched CPAN for SOAP in the hope of finding an easy way to implement it...

Let's say that I was not reassured when I started reading the docs for SOAP::Simple: "Let's face it. SOAP is painfull. It's a dumb idea, the only reason you should ever consider using SOAP is if someone holds a gun to your head or pay you a lot of money for it."

I then stumbled upon and things started looking good. In in couple hours I was able to extend my web service to SOAP with very little effort! :)

The only thing that took me a while to find out was that I was using 'use warnings "all"' and it caused the script to return a warning to the web server, causing a "Incomplete headers" error to be sent to the browser, while not showing any warning when running it from the command line...

SOAP-Lite (0.710.10) *

This module has fairly poor documentation and reading the source code is definately not recommended. You will find many hacks and odd constructs there.

Whats worse: the basic symmetry principle that objects representing incoming SOAP requests (or responses) should be identical to objects representing outgoing requests (or responses) is not adhered to. If you want to do anything beyond basic SOAP processing, this will really ruin your day. Especially because the module tries to behave as a black box, trying to force you to manipulate SOAP messages in a few, very inflexible ways.

But what will completely ruin your day is that the module tries to guess some clever perl structures to use for SOAP messages as well as autoguessing types in the envelope. What does this mean? It means that if you have a response saying


...SOAP::Lite will happily claim that the type of myversion is an integer. Next time you send a message with slightly different content:


...the module will claim that the type of myversion is text.

The same goes for the perl structures returned when parsing SOAP requests:




{row => 1}







{row => 1},

{row => 1}

This behaviour is absolutely not something you want in any system using SOAP integration, since it makes it inherently unreliable. Its a great way of writing software that you'll be bound to maintain for ages.

SOAP-Lite (0.69) ****

SOAP::Lite is one of the hardest packages I've had to work with in a long time.

That said, it's an almost trivial package to use and get basic SOAP to work. For more complex operations, there's a bit of detail work involved; but not as much as most people would fear.

On the other hand, there are also some really painful pratfalls waiting for those who have to deal with non-trivial remote interfaces. A really good exercise is to use the supplied module to break a WSDL and look at the generated code. This will show you how to construct detailed interfaces with confidence.

<BadHumor>As always, the hard part is using SOAP in your application without leaving a ring around the bathtub.</BadHumor>

Stand forewarned, there are several points in the code where Paul apparently didn't have the ability to test all combinations of input and servers. Not surprising for a module with this outright level of combinatoric explosion. Also, the verbosity of some constructs is a bit high; do yourself a favor and write helper functions to simplify Header and Data object creation.

Some other users' comments had me worried about the module's code complexity. They were wrong. The code is non-trivial, but very straightforward. Paul uses a few really slick methods to auto-generate consistent code interfaces. His code is something that we all can learn from. Kudos to the man!

SOAP-Lite (0.67) ****

If you come into this module looking for something "light" because it has "Lite" in the name, this isn't it. SOAP::Lite is comprehensive and I've found it to be very useful. The documentation is not as well organized as it could be, but check out the examples directory. I'm not a huge fan, but this module works pretty nicely.

SOAP-Lite (0.67) ****

SOAP-Lite implements a huge range of web service functionality. "Lite" is a misnomer IMHO. The interface is very perlish. An experienced user of SOAP-Lite can build or access a service with a tiny amount of code. WSDL support is limited, but effective.

The documentation is adequate, but just barely. This is a package that has great power buried in its guts, but most users should expect to just use the common features unless they want to expend a lot of time learning. Expect to spend a LOT of time debugging (or just figuring out how to debug). The package sorely lacks for good examples. The provided examples are either trivially simple, or head-scratchingly complex.

Whatever you do, *DON'T* look at the code if you can help it! This is the hardest to read CPAN module I've ever seen. It borders on Perl Golf complexity in places. I've spent the last few months working closely with SOAP:Lite -- at first I craved to rewrite it, but now I wouldn't dare. The author, Paul Kulchenko, is either a genius or a madman. Probably both, I'd guess.

My greatest fear is that there is some huge security hole in this package. I have no reason to believe there is one, but the code is so complicated that I'm not sure how one would manage to audit all of it.


Update for v0.67: Byrne Reese seems to be working hard to decipher and fix parts of this code, based on the number of new "TODO"s and CHANGES entries. Kudos to Byrne for taking on this difficult task.

This particular release has a rather painful wart. The SOAP::Lite::uri() method, which is called by EVERY SOAP::Lite client, has been deprecated. However, even the SOAP::Lite code itself was not updated to avoid calling this method! There are also 6 places where the documentation still shows examples using this deprecated method.

If you are a SOAP::Lite user, try to avoid v0.67.

SOAP-Lite (0.60a) **

Well, my needs are simple, so I did get a 1 line working project out of it. But I recently switched to SUSE Linux 10.0, and so had to reinstall, and that's just not happening. From a cpan point of view this is the heaviest 'lite' module I've ever seen. Zillions of dependencies.

SOAP-Lite (0.60a)

No rating from me yet, but be sure to checkout There are alpha versions there which are also in CPAN and some *very nice* getting started documentation ( If you skipped the README like I did initially you may not know about this site.

SOAP-Lite (0.60a) *

The documentation, interface, and code for this module are all atrocious. The code in particular is hack after hack after hack. And the documentation deserves less than a 1. If you are planning to use this module, be ready for hours of trial and error, and wading through a lot of mucky code.

SOAP-Lite (0.60a) **

SOAP::Lite may or may not be a great module. I just can't tell, because it is so poorly documented.

SOAP-Lite (0.60) **

The manpage suggests that you use SOAP::Lite like this:

print SOAP::Lite

-> uri('')

-> proxy('')

-> f2c(32)

-> result;

which is alarmingly different to the conventional way of doing things, which would be something like:

print SOAP::Lite->new(

uri => "";,

proxy => "";


(RPC::XML has a much more sane interface to web RPC stuff.)

SOAP-Lite (0.55) *****

This module may have problems (interface, documentation, etc.) but it deserves a high rating for one simple reason: it implements the SOAP specification very, very well. The SOAP spec is one of the more complicated I've seen and Paul deserves high praise for accomplishing this very difficult feat. If we had more programmers like him we'd probably have an XML Schema implementation by now too!

SOAP-Lite (0.55) ****

It gets simple jobs done simply, but it may be hard to do some finetunning when it comes into the details.

I ran into a lot of problems when it came to utf8 data, but that's probably not related with this module.

The source code is probably the most difficult perl code I have ever seen.

Bottom line.
I know of no better alternative in perl.
2 hidden unhelpful reviews