Hi Any one can explain the difference between the LCDS and BlazeDs. Both are supporting HTTPService,Webservice,Remoting service. So why we need BlazeDs or LCDS?
There's a lot of features that are included only in LCDS. Two main ones for me would be PDF generation and Data Management. Both boost the speed an application can be developed. If I remember correctly there is a free single-CPU licence of LCDS which gives you Data Management but still watermarks PDF-s.
To see how Adobe compares them: link
Two things I can think of off the top of my head for needing LCDS over BlazeDS:
You want proper paid support, and not the serve-yourself approach to support of the open source community.
You need to scale your messaging, especially push messages, to a very high number of concurrent users. BlazeDS apparently does not compare well to LCDS in that regard.
That said, BlazeDS has two key advantages over LCDS, at least from my direct experiences:
It is 100% Java, so can run just about anywhere. (LCDS has native code.)
It is free!
BlazeDS is free and open source... LCDS is pretty expensive. LCDS also provides a lot of other Live Cycle features that are not included in BlazeDS (Like a better push architecture, can handle more clients, etc).
The Adobe comparison page mentions that only LCDS has lazy loading - that sounds rather relevant.
Here is a articles which explains clearly the differnces between LCDS and Blazeds
http://sujitreddyg.wordpress.com/2008/01/31/blazeds-and-lcds-feature-difference/
I used LCDS because it supports PDF generation.
Related
Looking into Meteor to create a collaborative document editing app, because it’s great that Meteor synchronizes data between multiple clients by default.
But when using a text-area, like in Sameer Kalburgi’s example
http://www.skalb.com/2012/04/16/creating-a-document-sharing-site-with-meteor-js/
http://docshare-tutorial.meteor.com/
the experience is sub-optimal.
I tried to type at the same time with a colleague and my changes would be overwritten when she typed and vice versa. So in the conflict resolution there is no merge algorithm yet, I think?
Is this planned for the feature? Are there ways to implement this currently? Etherpad seems to handle this problem rather well. Having this in Meteor would make creating collaborative document editing apps way more accessible.
So I looked into it some more, the algorithm used in Etherpad is known as Operational Transformation:
The solution is Operational Transformation (OT). If you haven’t heard of it, OT is a class of algorithms that do multi-site realtime concurrency. OT is like realtime git. It works with any amount of lag (from zero to an extended holiday). It lets users make live, concurrent edits with low bandwidth. OT gives you eventual consistency between multiple users without retries, without errors and without any data being overwritten.
Unfortunately, implementing OT sucks. There's a million algorithms with different tradeoffs, mostly trapped in academic papers. The algorithms are really hard and time consuming to implement correctly. We need some good libraries, so any project can just plug in OT if they need it.
Thats’s from the site of sharejs. A node.js based ot server-client that you can hook into your existing client.
OT is also implemented in the Racer model synchronization engine for Node.js, that forms the underpinnings for Derby. At the moment, derby.js doesn’t transparently provide it yet, but they plan too, from the Derby docs:
Currently, Racer defaults to applying all transactions in the order received, i.e. last-writer-wins. (…) Racer [also] supports conflict resolution via a combination of Software Transactional Memory (STM), Operational Transformation (OT), and Diff-match-patch techniques.
These features are not fully implemented yet, but the Racer demos show preliminary examples of STM and OT.
Coincidentally, both the sharejs and derbyjs teams have an ex Google-waver on board. Meteor has an ex etherpad/Google Waver in their core team. Since Etherpad is one of the best known implementations of OT I was imagining Meteor would surely want to support it at some point as well…
I've created a Meteor smart package that integrates ShareJS:
https://github.com/mizzao/meteor-sharejs
It's quite preliminary right now, but you can import it into your app, drop in textareas, and it "just works". Please try it out and submit some new features via pull requests :)
Check out a demo here:
http://documents.meteor.com
What you describe seems out of Meteors scope for me. Its not a tool to set up collaboration possibilities!
What it provides is a way to transparently work against a subset of a servers database. But the implementation of use-case specific merging functionality is the job of the application, not the framework.
This spec http://www.w3.org/TR/webdatabase/ says:
This document was on the W3C Recommendation track but specification work has stopped. The specification reached an impasse: all interested implementors have used the same SQL backend (Sqlite), but we need multiple independent implementations to proceed along a standardisation path.
Does this mean that HTML5 database is going away, and for some time we will have a de-facto standard using SQLite, possibly with browser differences? Or has the W3C published a plan of attack for finishing the standard?
According to this article:
[...] we think it is worth explaining our design choices, and why we think IndexedDB is a better solution for the web than Web SQL Database.
In another article, we compare IndexedDB with Web SQL Database, and note that the former provides much syntactic simplicity over the latter. IndexedDB leaves room for a third-party JavaScript library to straddle the underlying primitives with a BTree API, and we look forward to seeing initiatives like BrowserCouch built on top of IndexedDB. Intrepid web developers can even build a SQL API on top of IndexedDB. We’d particularly welcome an implementation of the Web SQL Database API on top of IndexedDB, since we think that this is technically feasible. Starting with a SQL-based API for use with browser primitives wasn’t the right first step, but certainly there’s room for SQL-based APIs on top of IndexedDB.
I'm not personally swayed by the arguments put forth in the article, but it seems clear that (for the time being) Mozilla has decided that Web SQL Database is dead.
Further interesting comments about this article may be found on Hacker News.
My understanding is that this is now called "IndexedDB"
http://www.w3.org/TR/IndexedDB/
Apparently the Firefox team has started implementing this:
http://hacks.mozilla.org/2011/01/indexeddb-in-firefox-4/
I don't know if anyone knows the answer. Mozilla doesn't like the dependence upon SQLite and has decided to go a different way. However, all WebKit based browsers already have it implemented and I don't see them removing it as any websites built to take advantage of the spec would be broken.
This means that at least in certain contexts, mostly within the mobile sphere where most browsers have a webkit implementation, it can still makes sense to use the HTML5 Web SQL spec. I see this as especially true for developers who are looking to create mobile applications using a framework like phonegap.
There are some times where as an application developer you want to provide users with access to data even if they aren't connected to the internet or if the connection is slow and some types of data is just more efficiently stored in a database than in a cookie or JSON cashe. For example, if you have data that has relationships it is much easier and quicker to do a join query to pull the data you need than it is to search a json map.
I don't think the spec is dead, and I actually hope that Mozilla will reverse their stance so that developers can use it to solve problems outside of the mobile webkit world.
Seaside just released a release candidate for the upcoming 3.0 version, so it appeared on my radar again. As I'm currently pondering what web framework to use for a future project, I wonder whether it's something to consider. Alas, most of the publicity for Seaside is from '07, which is probably one or two generations for the web. So I'm hoping that the community here can answer some questions
Continuation-based frameworks were pretty great when most of your workflow was mostly in HTML, e.g. form submits. For today's JavaScript-heavy environments, that hardly seems worthwhile anymore.
Is Squeak able to handle a reasonable workload? From other questions here and elsewhere, it seems that for proper scaling another implementation (Gemstone etc.) would probably fare better in the long run, but I don't have a proper idea how far away that is. Sessions seem to be rather expensive.
I know that comparisons are hard, but most of the articles you find on the net set Seaside and Rails side by side. How would combinations like Scala/Lift, Clojure/Compojure or Erlang/Nitrogen do instead?
I have answers to question one and two:
This is true. However since version 2.8 Seaside is not a strictly "continuation-based" framework anymore. Seaside uses continuations in the flow module only. Since Seaside 3.0 the flow module is even optional. Also note that Seaside has strong Javascript support since 2005, this is long before mainstream frameworks started to add Javascript functionality. Today Seaside comes with JQuery and JQueryUI support built-in.
Of course that depends on what you store within your session objects, but typically sessions are small (less than 20 KiB). Use the memory profiler in your application to determine the exact memory consumption.
And there is a new seaside book: http://book.seaside.st/book
I find the productivity of working in a Smalltalk IDE with a good set of abstractions outweights all other issues in engineering dominated projects. It works well as an enterprise system for a small company with about 100 (simultaneous, but not heavy) users on a single server (without going to SSD). Since 2007:
Seaside has shown to be able to make the switch from html workflows to javascript ones;
Seaside has been ported to a lot of different Smalltalks;
Has seen Gemstone release GLASS;
The new 'cog' vm with much improved performance has been released a few weeks ago and shows great promise for improved performance.
In Smalltalk we have now three web frameworks to consider, besides Seaside also
Aida/Web and
Iliad.
Both later effectively solve three-like control flow, but without needing continuations. Both also have a very strong Ajax integration, actually you don't realize anymore that you are working with Ajax.
Both also scale in memory consumption well. 10.000 sessions spend 220MB in Aida/Web, that is about 23KB per session, which can be further optimized down to mere 400B per session. This means, that you can run not only but many websites from the single Smalltalk image. Of course you can always upgrade to load balancing solution, when you really need. Which is from my experience very rarely needed.
Comparing to Ruby on Rails, a friend of mine complained that he needs 50MB of memory initially for every webshop site he is selling. He then turned to the Aida/Web solution where he needs about the same MB for the image, but then just few KB for every additional webshop site.
Avi Bryant, the developer of Seaside, said that AJAX triumphs continuations in almost all situations. Nevertheless, you can build reasonably powerful applications with Seaside and AJAX, too.
The Application part of a Web-App can be done in other frameworks quite well using Ajax.
I think a Seaside integrated Smalltalk-to-Javascript Framework like Cappuccino-for-Clamato is missing, currently. I'd like to be able to build real Javascript-Apps using Smalltalk.
Javascript is awesome but being capable of dealing with complicated workflow in a clean cheap way in the server side (as Seaside allows you to) is preventing it to become obsolete. Economy and utility are things that gives return in the short and long run. But telling this in the abstract has no value at all. You should be talking about a precise application and deciding if seaside is part of your bunch of competitive advantages to form an equation that rocks (and knowing why).
About scaling workload with Seaside, the short answer is that you can scale it like hell yah (for the long answer check my answer here: Does Seaside scale?).
too unanswerable man :) rty a variation of what you're really trying to ask
I think the best thing you can do is a prototype of something in a weekend.
If you can do a prototype in two days and you can capture some attention and you enjoyed the developing experience of doing it with seaside then you'll have the foundation of your next thing.
It costs only your time (you can publish in an amazon server).
BTW, this week I've heard about a startup that made its prototype by hand (was everything static and they processed stuff manually). Pretty amazing and crazy and cheap. When they felt that they had enough traction on the idea (which the had) they implemented the app (with whatever tech, I'm sure is no challenge for a seaside developer)
I've been evaluating several opensource message queue technologies, such as RabbitMQ, ActiveMQ, OpenAMQ, etc. My question is, what benefits are gained by using a commercial technology such as Tibco EMS, WebSphereMQ, Sonic, etc. instead of something like Active or Rabbit? PHP will be the primary language involved, although Java systems will be interacting as well.
I'd say the benefits are few and far between. You really need to be sure that a commercial system is for you before you invest as there is likely to be no going back.
Some of these things are so esoteric, so prone to vendor lock-in, so damn heavyweight that you'll feel like you have a gorilla on your back, not just a monkey ;)
Those commercial technologies are good, but investment in them can be steep. Both yearly license costs and on-going support costs must be considered when making a decision. As far as vendor lock-in goes, in the commercial world there's only one vendor offering support for a given product. In the open source world, there's typically more than one vendor offering support. Consider ActiveMQ for example. Both Progress Software and SpringSource offer support agreements for ActiveMQ as well as some others.
Also, in the commercial world, you won't ever get to look a the source code yourself. For a product like ActiveMQ, anyone can grab the source code. This is pretty powerful because it means that you can add features, etc. and quite possibly get them added to the product.
ActiveMQ has a great community and is very widely deployed. ActiveMQ provides client APIs for many languages including C/C++, Java, .NET, Perl, PHP, Python, Ruby and more.
There are great communities around projects like RabbitMQ (check out the mailing list for example). Also, if cost is an issue, obviously open source is a win there.
The biggest difference I have found is operational support and management. The commercial vendors usually provide better tools for ops/support staff to resubmit, edit messages etc.
This is often a weakness of open source offerings, which if rectified, should cause some serious lack of sleep for commercial vendors.
I think it's always best to thoroughly examine your requirements before choosing a messaging system:
Not all the commercial vendors will support PHP for example. ActiveMQ and RabbitMQ will.
Not all the messaging systems can support very large Queue sizes - though ActiveMQ does
Not all the messaging systems survive a hard broker stop without loosing messages ActiveMQ will - without you having to use transactions.
And if you are going to use open source - always look at the community - ActiveMQ is the most active community of any open source message vendor - and it's also Apache - which means diversity and no reliance on any single developer or vendor for delivery.
If you use commercial products it comes with everything(just we have
to use) but all the open source products will have basic features but
still we can implement commercial product features(involves lot of
development)
What is the best way to protect a Cocoa shareware application from software piracy? Are there developer libraries/tools out there for this task?
Allan Odgaard - using openssl for license keys is one way to do it.
AquaticPrime is a simple, easy Cocoa licensing framework. It uses securely signed plist's as it’s “license key”, which makes it simple to embed arbitrary information into the license.
With AquaticPrime one would generally distribute the license as a small file, rather than as a text string, which may be an advantage or disadvantage for your application.
The framework includes code to generate licenses in C#, Carbon, Cocoa, PHP, Python, Ruby and STL. It also includes a GUI one-off license generator. My experience with it has been great.
Speaking of Wil Shipley, he has made his in-application payment and registration framework available for licensing under the name of Golden % Braeburn. I believe that Delicious Library and SousChef both use this framework.
Let's see here.
Home-brewed approaches:
Common Counter-Measures
Serializing
Recommended Service Solutions:
Aquaticmac
eSellerate - Also handles transaction processing
This list is by no means comprehensive, but rather just a brief mention of some of the popular choices. Obviously, they can only detour piracy so there is clearly a compromise on how much time should be invested. I'd also suggest googling Wil Shipley's (delicious app) thoughts about why developers shouldn't go to great lengths to prevent piracy.
Don't forget to do some reading on Common methods of cracking Cocoa apps. Be wary of method swizzling and Input Managers. You don't have to go out of your way to protect your app -- A cracker will always outdo you -- but don't be naive either!
I nice solution that I can recommend is the potion store (from potion factory) together with the cocoafob classes (from gleb dolgich). They provide code generation and verification and an actual store for selling your app(s)
both are open source