https://www.pcworld.com/businesscenter/article/244060/adobe_donates_flex_to_apache.html
Commercial giant Adobe believes his Flex codebase is now worthless and donates it to Apache foundation. I discovered the same early this year when I was developing on Flex Hero (4.5) platform.
No documentation, copy-and-paste development and paid development tools were epic fails. Glad to see the free market working towards extinction of technically inferior solutions.
Facebook platform features some mobile functionalities.
Among others, there is search:
https://developers.facebook.com/docs/guides/mobile
This is first serious shot of Facebook at search functionality in terms of challenging Google.
I hope someone makes cool use of that and earns a lot of money :)
Slightly modified for clearer rant
You appear to be advocating a new:
[x] functional [ ] imperative [x] object-oriented [ ] procedural [ ] stack-based
[ ] "multi-paradigm" [x] lazy [ ] eager [ ] statically-typed [x] dynamically-typed
[x] pure [ ] impure [ ] non-hygienic [ ] visual [ ] beginner-friendly
[ ] non-programmer-friendly [x] completely incomprehensible
programming language. Your language will not work. Here is why it will not work.
You appear to believe that:
[ ] Syntax is what makes programming difficult
[x] Garbage collection is free [ ] Computers have infinite memory
[ ] Nobody really needs:
[ ] concurrency [ ] a REPL [x] debugger support [ ] IDE support [ ] I/O
[ ] to interact with code not written in your language
[ ] The entire world speaks 7-bit ASCII
[x] Scaling up to large software projects will be easy
[x] Convincing programmers to adopt a new language will be easy
[x] Convincing programmers to adopt a language-specific IDE will be easy
[ ] Programmers love writing lots of boilerplate
[ ] Specifying behaviors as "undefined" means that programmers won't rely on them
[ ] "Spooky action at a distance" makes programming more fun
Unfortunately, your language has (checked only *unfortunate features*, Clojure has tail recursion):
[ ] semicolons [ ] significant whitespace [x] macros
[x] implicit type conversion [ ] explicit casting [ ] type inference
[ ] goto [x] exceptions [ ] coroutines
[x] reflection [ ] subtyping [ ] operator overloading
[ ] algebraic datatypes [ ] recursive types [ ] polymorphic types
[ ] covariant array typing [ ] dependent types
[x] infix operators
[ ] call-by-value [ ] call-by-name [ ] call-by-reference [ ] call-cc
Unfortunately, your language lacks:
[ ] comprehensible syntax [ ] macros
[ ] implicit type conversion [ ] type inference
[ ] goto [ ] exceptions [ ] closures [ ] tail recursion [ ] coroutines
[ ] reflection [ ] subtyping [x] multiple inheritance [ ] operator overloading
[ ] algebraic datatypes [ ] recursive types [ ] polymorphic types
[ ] covariant array typing [ ] monads [ ] dependent types
[ ] infix operators [x] nested comments [x] multi-line strings [ ] regexes
[ ] call-by-value [ ] call-by-name [ ] call-by-reference [ ] call-cc
The following philosophical objections apply:
[ ] Programmers should not need to understand category theory to write "Hello, World!"
[ ] Programmers should not develop RSI from writing "Hello, World!"
[ ] The most significant program written in your language is its own compiler
[x] The most significant program written in your language isn't even its own compiler
[ ] No language spec
[x] "The implementation is the spec"
[ ] The implementation is closed-source [ ] covered by patents [ ] not owned by you
[ ] Your type system is unsound [ ] Your language cannot be unambiguously parsed
[ ] a proof of same is attached
[ ] invoking this proof crashes the compiler
[ ] The name of your language makes it impossible to find on Google
[x] Interpreted languages will never be as fast as C
[ ] Compiled languages will never be "extensible"
[ ] Writing a compiler that understands English is AI-complete
[ ] Your language relies on an optimization which has never been shown possible
[x] There are less than 100 programmers on Earth smart enough to use your language
[ ] ____________________________ takes exponential time
[ ] ____________________________ is known to be undecidable
Your implementation has the following flaws:
[x] CPUs do not work that way
[ ] RAM does not work that way
[ ] VMs do not work that way
[ ] Compilers do not work that way
[x] Compilers cannot work that way
[ ] Shift-reduce conflicts in parsing seem to be resolved using rand()
[x] You require the compiler to be present at runtime
[x] You require the language runtime to be present at compile-time
[x] Your compiler errors are completely inscrutable
[ ] Dangerous behavior is only a warning
[ ] The compiler crashes if you look at it funny
[x] The VM crashes if you look at it funny (see example below)
[ ] You don't seem to understand basic optimization techniques
[ ] You don't seem to understand basic systems programming
[ ] You don't seem to understand pointers
[ ] You don't seem to understand functions
Additionally, your marketing has the following problems:
[x] Unsupported claims of increased productivity
[ ] Unsupported claims of greater "ease of use"
[ ] Obviously rigged benchmarks
[ ] Graphics, simulation, or crypto benchmarks where your code just calls
handwritten assembly through your FFI
[ ] String-processing benchmarks where you just call PCRE
[ ] Matrix-math benchmarks where you just call BLAS
[x] Noone really believes that your language is faster than:
[x] assembly [x] C [x] FORTRAN [x] Java [x] Ruby [ ] Prolog
[ ] Rejection of orthodox programming-language theory without justification
[ ] Rejection of orthodox systems programming without justification
[ ] Rejection of orthodox algorithmic theory without justification
[ ] Rejection of basic computer science without justification
Taking the wider ecosystem into account, I would like to note that:
[ ] Your complex sample code would be one line in: _______________________
[ ] We already have an unsafe imperative language
[ ] We already have a safe imperative OO language
[ ] We already have a safe statically-typed eager functional language
[ ] You have reinvented Lisp but worse
[ ] You have reinvented Javascript but worse
[ ] You have reinvented Java but worse
[ ] You have reinvented C++ but worse
[ ] You have reinvented PHP but worse
[ ] You have reinvented PHP better, but that's still no justification
[x] You have reinvented Brainfuck but non-ironically
In conclusion, this is what I think of you:
[x] You have some interesting ideas, but this won't fly.
[ ] This is a bad language, and you should feel bad for inventing it.
[ ] Programming in this language is an adequate punishment for inventing it.
user=> (defmacro re2 [x] (str "a" ~x)) #'user/re2 user=> (re2 1) java.lang.IllegalStateException: Var clojure.core/unquote is unbound. (NO_SOURCE_FILE:0)(only few people on Earth understand this error and actually no one of them understands why this error is not presented by compiler while defmacro)
http://docs.python-requests.org/en/latest
A successful attempt at simplifying HTTP requests in python.
Full support for cookies, headers, HEAD method and sessions (use of with block).
Code looks simple and clean (can't think of better complement).
>>> r = requests.get('https://api.github.com', auth=('user', 'pass'))
>>> r.status_code
204
>>> r.headers['content-type']
'application/json'
>>> print r.cookies
{'requests-is': 'awesome'}
There are hooks available. One can have a function called pre-request or post-request.
http://docs.python-requests.org/en/latest/user/advanced/#event-hooks
This library is used internally at Twitter
Microsoft's IE 10 in Metro (smartphone) mode will not feature any plugins (not even Silverlight). It will only work with HTML5.
Actually this means that Silverlight is dead and Flash is rapidly drowning, despite late iPhone success.
Apple deals massive patent blow to HTC, Android in serious trouble | ZDNet
All right, there you have it. Patents just made Android die. Did it? Well.. at least in the US.
Now Europe has it's chance to outgrow USA technically. We don't have absurd laws that let one company basically smash other legitimate business with a Baseball of Greed.
Now I'll never buy anything from Apple not only for bad usability and aesthetic reasons, but also for moral ones. Any Apple user is from now on an enemy of free market!
AlfaRomeoTargetProduct getByPK(java.lang.Integer languageVersionId, java.lang.Integer alfaRomeoId); SigmaOmegaTargetProduct getByPK(java.lang.Integer sigmaOmegaId, java.lang.Integer languageVersionId);
And several other such getByPK methods. These were generated by O/R Mapping software. They are parts of the same application and are used together.
I've just spend at least half an hour looking for reasons for code below to explode:
... case SIGMA_OMEGA_TEASER_OBJECT_TYPE: productId = sigmaOmegaTargetProductDAO.getByPK(myObjectId, lvId, true).getProductId(); break; case ALFA_ROMEO_OBJECT_TYPE: productId = alfaRomeoTargetProductDAO.getByPK(myObjectId, lvId).getProductId(); break; ...
Until I checked the actual O/R Mapping code for getByPK.
For quirky reasons order of method attributes is shifted between various objects - sometimes languageVersionId is first, sometimes last.
Guess what? It should have been:
productId = alfaRomeoTargetProductDAO.getByPK(lvId, myObjectId).getProductId();
Static hard typing haven't prevented this error. I could be writting this code in dynamic language and save a lot of time.
Let's suppose method signatures are fixed and myObjectId is always first and there is one more attribute lvId.
With language like python or ruby we could just ommit the switch/case structure and write:
dao = getDaoByName('alfaRomeoTargetProduct')
productId = dao.getByPK(myObjectId, lvId).getProductId()
We can't in java. Unless all of these O/R Mapping objects were using the same interface. Which is unsupported in O/R Mapping we use. So sad..
Moral: Static hard typing is useless. Even if no errors/inconsequences are present, static hard typing is counterproductive.
* Ability to Search and Replace in a Project
* Auto-Indent for Common Actions Like Pasting Text
* Auto-Pairing of Brackets and Other Characters
to HTML H4 headers:
<h4>Ability to Search and Replace in a Project</h4> <h4>Auto-Indent for Common Actions Like Pasting Text</h4> <h4>Auto-Pairing of Brackets and Other Characters</h4>By replace
\* (.*)with
<h4>\1</h4>
mencoder HSE_0720.avi \
-sub HSE_0720.srt -subfont-text-scale 3 -utf8 \
-o HSE_out.avi \
-of lavf -lavfopts format=asf -ovc lavc -lavcopts vcodec=wmv2 \
-oac lavc -lavcopts acodec=wmav2
It encodes any video playable with mplayer so that it is playable on Xbox (via uShare or Media Center).
Subtitles are rendered into video stream, so output .avi is standalone.
Lemma:
Employers much prefer that workers be fungible, rather than maximally productive
Proof:
Java Enterprise (J2EE) and UML.
The good parts: standards (Hibernate, Servlets), deployments, security, runtime environment (JVM, app servers), maven. They make it easy to program.
The bad: Bloat of the code, static typing, Eclipse (slowness!), need to reaload classes while developing, UML instead of talking to your team. This makes us inefficient and slows us down.
Static typing creates an well-selling illusion of easy finding the way in the code. Object oriented programming/J2EE methodology and static typing turns 66% of programmer's day into of text generating mini-game (with comming up with cool class name being the fun part). Having to compile and reload the code wastes another 10%. Add 4% for coffee and frustration from slowness of tools... This leaves 20% of time to programm. No wonder that it takes several months to finish simple projects.
Labor cost is highest position in almost any company's budget. But it still obviously pays for them for you to be ineffective. Why? Because with java you are an interchangeable part of the system (just like an object implementtion). Ability to replace you makes your wage drop and makes you easier (more obedient) and cheaper to manage (with poor management).
We all fear the change. Knowing that we are easly expendable and totally unrelevant make us care for our job and put up with unreasonable requirements, methodologies and bad management.
Effectiveness distinguishes programmers from each other, it's our value and currency. By making our main asset irrelevant, Java (J2EE) hurts our souls and sips off our energy turing us into bland Eclipse operators.
To break free, we need to go from irrelevant to being importand and catually appreciated for not being easly replacable.
Examples and inspirations:
Dark side is easier, but it eats your soul. Think carefuly what shade of gray are your doings...
I've just read interesting article of upcomming (wishful thinking) Java replacement: http://blog.talawah.net/2011/04/gavin-king-unviels-red-hats-top-secret.html
One of core points was:
Static Typing (find errors at compile time, not run time)
Static typing is a major feature of language that makes code written in it run faster than ever possible with dynamicaly typed languages. But this comes at price of extreme difficulties with doing real-time evaluation/interpretation. Yes, staticaly typed languages typicaly use some binary (intermediate or direct) format (.class, .obj, .com) for running.
What is a common mistake is that some importand types of errors are affiliated with compilator, but not with static typing. For example compiler (linker to be exact) is able to catch a problem with using non-existand method as methods are symbols in libraries. Staticaly typed language would also enforce properly using that method (parameters).
Ruby makes a use of lack of compiler by providing method_not_found() method. It is requested if someone used a .methodThatDoesNotExist(). For one interesting application see Ruby chapter in '7 languages in 7 weeks' by Bruce Tate (already a must-have classic book).
Let's see.. Some serious and very common problems on this list. Somehow using a Map instead of List become less importand in face of SQL Injection... ain't it?
As professionals, we test our software before our clients test it. We employ alot of cool and efficient techniques to protect our reputation:
These are not tied to languages, but to profesional attitude towards programming craft.
Happy developers with power at their hands are precious resources. Do not waste it in staticaly typed environment. Do not confuse static typing with compiler or linker. Do not confuse static typing with strong typing.
When choosing next languge for your project, start with interpreted languages considering frameworks maturity. If JVM (and J2EE deployment) is a must, take a look at Scala, Clojure, Jython or JRuby.
I've recently read a C praising article, that rants at Java:
http://www-cs-students.stanford.edu/~blynn/c/ch08.html
Author seems to take it personally and is more biased than a scientist should be. But he is mostly right in his java rant.
In another chapter he mentions C lang problems, that he beliefs could be walked around. And this is where he is mistaken. Most C programmers read glibc and linux code and take it as example. Since there are obscure macros there, most programmers will write the same. The result is that coding C is no longer simple and will never be. Obscure macros will make any language fall (and fail) - and this is why Clojure will vanish after few moments of glory.
Most blows at Java are blows at lack of functionality, speed and inheritent code bloat. Java also indeed does some things the worst possible way, namely multiple inheritance.
Author is forced to admit that Garbage Collector and code divided into packages are seriously importand features of Java platform. If he ever did any web deployment, he'd also notice that jars, wars and ears packaging in J2EE are unique and save a lot of hassle. No other language has working deployment out of the box (maven war - one liner that builds the world).
Ooh.. maven :) Another killer app. In fact so good, everyone want to reinvent it.
Scala is functional (mostly, pragmaticaly they allow object state and imperative loops) programming language written in Java and running on JVM. You get J2EE packages, deployment and state of the art Garbage Collection for free.
Scala has also one nice feature - it's C-style formatted language
edata, newfunc, value = fReturnTuple()
C language is broken. Has no namespaces (all functions are visible everywhere), most code uses obscure macros. Pointers syntax is complicated to a perl-level. C is error prone. C requires deeper understanding of machine and memory (ever switched 32bit code to 64bits?) that is practical for average programmer to learn... Only bad things happen when you program in C.
Instead of fixing Java with C, and wishing C had JVM features, one should look at Scala.
Most things in this book is way beyond what CS students learn. At the same time these things are absolutely essential to become a programmer. This is good for self-tought programmers: we have a chance ;)
This book is a corner stone and a basic requirement to be any good in programming industry.
A closure is a function that returns a function parametrized by variables from lexical scope of the creator. Returned function encloses variables from outside of it's scope.
Javascript:
function createDestroyer(divId) {
return function() {
jQuery(divId).remove()
}
}
var popupLayer = jQuery(document.createElement("DIV")))
popupLayer.attr("id", "popup5")
// fill popupLayer
// prepare layer closing button
var closeButton = document.createElement("A")
closeButton.addEventListener('click', createDestroyer("popup5"), false)
// other very good example is the anonymous function below:
repeats = 0
animationId = window.setInterval(function() {
// animate something
if (repeats++ > 100) {
window.clearInterval(animationId); // access and capture outer scope variable
}
}, 250)
A monad is a wrapper around data type. Each function called on a monad has access to wrapped data and returns the monad.
We have just seen one monad: jQuery. It wraps around any DOM element, each call returns jQuery object (so that we can chain for example ajax().css().show()) and each method has direct access to wrapped DOM node.
Effectively every object composition with methods that return instance (this) is a monad.
Let's build one in python (IDLE session dump):
>>> class MyMonad(object):
def __init__(self, anArray):
self.obj = anArray
def add(self, elem):
self.obj.append(elem)
return self
def butLast(self):
self.obj = self.obj[:-1]
return self
def rest(self):
self.obj = self.obj[1:]
return self
def toString(self):
print str(self.obj)
return self
>>> MyMonad([1, 2, 3, 5]).butLast().toString()
[1, 2, 3]
<__main__.MyMonad object at 0x90b556c>
>>> MyMonad([1, 2, 3, 5]).add("a").toString()
[1, 2, 3, 5, 'a']
<__main__.MyMonad object at 0x90d862c>
>>> MyMonad([1, 2, 3, 5]).butLast().add("a").rest().add(90).toString()
[2, 3, 'a', 90]
<__main__.MyMonad object at 0x90d83ec>
Always returning self is so useful (especially when creating DSLs), that I came to expect this feature everywhere ;)
Few days ago I posted some unpleasant truths about LISP. Today is the day to straighten some things up: I love LISP. I won't use it for producing code, but still admire it, and think that it was a very good investment to learn a little of it.
That's right, it pays to learn LISP (think Clojure).
It might be bad taste to compare it to racing cars of today but... well.. it's slow.
Nothing will ever compare to the Spider. Nothing. But you wouldn't use it to race today.
It's even cheaper to use a purpose-build crouch rocket like Python or Ruby ;)
I started to learn lisp december '10 with the book Programming Clojure. It was first language I started to learn in many, many years - being tied to Java.
I've been enlighted and astonished. LISP totally 0wned me for few months. I finally understood recursion, functional programming and many other important concepts of software craft.
I started to play with WebServices (AXIS) and twitter client. Then I wrote a very simple templating engine, similar to what can be seen in LIFT Framework. Started to think of building even more, but ...
Yes, it took me far too much time to write all the above stuff. Was it my fault? Yes, of course. But it made me stop and look closer at the whole LISP thing.
Yes sir! Thank you sir!
However I humbly ask you to please read these rants as LISP:
How I lost my faith (very long) - comp.lang.lisp | Google Groups - 2002
What are programming languages for? - by the same author, 6 years later.
What's more, once I got knocked off my high horse (they had to knock me more than once -- if anyone from Google is reading this, I'm sorry) and actually bothered to really study some of these other languges I found *myself* suddenly becoming more productive in other languages than I was in Lisp. For example, my language of choice for doing Web development now is Python.
There's another problem with the shorter-is-better premise, which is that the brevity of a program is much more dependent on the available libraries than on the structure of the language.
What I lost faith in was that Lisp was the best programming language for everyone (and everything), and that the only reason that people didn't use Lisp is that they were basically ignorant.Unrelated, but too good to miss
In fact, I am in certain circles a notorious critic of UML, which I consider one of the biggest steps backward in the history of software engineering.
Steve Jobs posted (2010) his reasons not to support flash on iPad and iPhone:
http://www.apple.com/hotnews/thoughts-on-flash/
If developers grow dependent on third party development libraries and tools, they can only take advantage of platform enhancements if and when the third party chooses to adopt the new features.
Yes, because he has the money :> But also, sadly for flash developers, his is very, very right and insightful on flash technology. While having competing product (WebKit) is not an argument by itself, having open source competing product is. WebKit browsers made it possible to have animated demos in HTML5 on every possible device (Firefox/Chrome made it possible on non-mobile machines before).
Observe how mobile technology drawbacks (battery life, CPU performance) now drive the web industry. Drains battery == Bad idea. But my PC does not have a battery? -> PC is obsolete.
Third party development tools hinder innovation. Bold statement. But, sorry Adobe, this is so true. I made a few Flex apps (video players mainly) and noticed:
Bad developer experience, Flex is going in wrong direction. Flex 3 was pretty nice and much more powerful that javascript at the time it war released. But now HTML5-generation browsers are so fast that writting operating systems in javascript seems actually a good idea. Backed with full CSS3 support, the HTML reclaims what flash has taken.
HTML5 already won. Jump in and don't look back.
As programmers we are part of projects that are project-managed. Whatever that would mean, our payroll and job security often depend on projects' successes. If not, lucky you to work on badly managed, yet resorceful company. Go get a raise :)
For unlucky rest of us, I present this survival guide.
Your work is evaluated in relation to the project. If project fails, you are part of failure. No raise, no respect. You should care about project management because projects needs to be managed to succeed, little beasts.
If projects fail, how the company prevails? If you ask this, maybe you know too little of your company? Maybe you assumed wrong business model? What if your company earns 90% on hosting the solutions not on programming them? What if your clients also undergo moral hazard of not depending on project outcome? Example? A corporate manager in charge of huge budget that wants part of it for himself.
What if there are many projects in parallel and internal accounting process makes it impossible to evaluate financial outcome of managers work?
What if company makes so much money, that no one cares about projects you are part of?
Bad management sometimes exists also because of high pressure to use Project Management Methodologies (while forgetting WHY WOULD YOU USE THEM IN THE FIRST PLACE). If you use methodology just for a buzzword or have established a culture of 'I made this by the book, don't blame me' - your company might soon fail.
Google was lately (Jan '11) accused of allowing content farms to gain high page rank. We have their answer now (for US market). This is major change affecting 12% of search results, thus we have an revolution.
This actually is very impressive as Google is one of the biggest corporations in the world. They had a major flow undermining their credibility and they were able to come up with an proper answer in ... 3 weeks? Most medium companies wouldn't even had a plan in such a short term.
Google noticed that most of today's internet is copy & paste (aka webspam). They found a way to find out where the chain starts (ie. information/signal origin) and rank it waaay higher than copies. Good, wise, simple (to explain at least :).
Impact is on those who mainly copy content and on linking-only sites (without comments and so on). In short: the less home-brewn content, the lower the points in rank.
Since content farm is just automated copying of prepared content with little changes, whole farms hopefully get taken down with this change.
This is however a war for really big $money$ and webspammers might come up with something new, like using HBGary's idea of creating and managing whole fake societies (aka Sockpuppet Management Software). That would give them randomized social content, forums full of generated posts and so on. That would be hard to catch, because social activities are very, very hard to measure with math. Also facebook makes real humans' conversation very shallow:
There have been numerous posts about Nokia going down because of partnership with Microsoft.
I can't imagine any other reason to write such things than "being first with any blog post".
Granded, Microsoft is rightly hated by all of linux/java developers and Apple lovers. But why would such a partnership be bad for Nokia? And why it would be bad for us, customers?
What we have with Micronokia is a partnership of market leader in software development with strong player and recognized brand in mobile devices. Something like beer maker partnering with dvd-rental stores to make your evening even more enjoyable.
Now, what's BAD about that?
There arguments are all either based on accusations or emotions. Take a look at Pros and use pragmatic common sense. We may all only benefit from strong, prepared players joining the market. Like maybe devices would drop prices? Or maybe someone finally does some cool mobile Xbox-aware toy?
Have faith brothers in free market...
as img src="data:image/png;base64
One of bloggers argues that in development process, the developer part is the most important. Not the tests nor the processes, but brilliant star-like personality.
See the post and discussion below
There has also been a discussion on Hacker News lately
Of course I fully support the bloggers opinion - developer is the key to project success. Tests and procedures are very important, but good design, and clean, simple code is much more.
Unfortunately, what I believe is most common is the Get Me Promoted Methodology (GMPM), described here. (along with Asshole Driven Development and so on ;-)
The fundamental fact of the software industry is that the demand for software exceeds the supply of good programmers by about an order of magnitude.
The problem with good design is that it's good because it takes under consideration future changes and maintenance. But TDD allows for less painfull maintenance of bad code. So what does a bad programmer do? He sells quick-dirty-hack-shit to your boss and gets promoted for that over your ass.
Yeah, ever thought why bad code exists? Most people work for money, not for deep soul-clearing feeling of sending out perfect lines of holy code.
That's the sad reality besides TDD buzzword...
It's not the first time math shows beautiful face, but this time everyone can appreciate it: http://weavesilk.com/
This incredible silky-hazy image generator is one of the most beautiful things I've ever seen on web. White background wallpaper with blue silk is like my dreams came true.
Allegro is polish e-bay style auctioning service (actually e-bay was unable to compete with Allegro on local market). Allegro engeneers have set up a Web Service AllegroWebAPI, which is base for discussion below: http://webapi.allegro.pl/uploader.php?wsdl
I decided to finally take a first step towards learning WebServices and went for Allegro Web API. Downloaded Axix 1.4 (Allegro uses very old style of WSDL), generated SOAP Proxy as ant suggests (polish, see scripts only) and used it to login to allegro.
Next I have inspected the SOAP proxy code that Axis generated and, man this is scary!
Now this is WRONG path. This is not object programming and this is functional programming neither. This is Big ball of mud heading straight to unmaintainable, buggy applications.
How such a mess can be so widely used?
API changed. Whoa, my app no longer works - I need to regenerate my SOAP proxy just to log in. There is no way to know for application that WSDL needs to be reprocessed. Unless of course application reads developer forums. Mine doesn't, I'm toast...
SOAP RPC over HTTP, on the other hand, encourages each application designer to define a new and arbitrary vocabulary of nouns and verbs (for example getUsers(), savePurchaseOrder(...)), usually overlaid onto the HTTP 'POST' verb. This disregards many of HTTP's existing capabilities such as authentication, caching and content type negotiation, and may leave the application designer re-inventing many of these features within the new vocabulary. Examples of doing so may include the addition of methods such as getNewUsersSince(Date date), savePurchaseOrder(string customerLogon, string password, ...).
UPDATE:
Please drop the SOAP - another rant about SOAP bloat.
