came across this link its worth a read. i think it will really shows the winner hands down
http://ethereum.stackexchange.com/questions/2104/how-does-lisk-differ-from-ethereum 1. Programming LanguagesLiskOne of the things that Lisk heavily promoted prior to their presale was the fact that their Dapp are in Javascript, "the most popular language in the world." In fact, they marketed (via reddit advertisement)[1] themselves as "The Ethereum Alternative for Javascript developers".
EthereumSmart Contracts for Ethereum are in Solidity or Serpent. Solidity is very similar to Javascript, but is custom made for smart contracts. It is extremely easy to read these contracts and understand what they are doing. There are also some big reasons to use a custom language over Javascript (discussed below) when it comes to contracts that move currency, store value, and need to reach consensus. This page, while no longer being maintained, has some excellent points about what Solidity is:
Solidity is perhaps the first example of a contract-oriented programming language; a slight tweak on the notion of object-orientation. While closely related to object-oriented languages, this is a language designed specifically to help express agreements that must encode ideas and relationships relevant to Real Life, or some formal model thereof. As such we see notions such as ownership, identity, protections and restrictions forming a core part of the vocabulary and idiomatic grammar.
I don't know as much about Serpent, but it appears to have the same goals and purpose as Solidity, but is meant to be similar to Python (and therefore be great for Python devs.) This, along with the range of clients, also showcases the dedication that Ethereum has to being appealing to a wide range of developers, not just Javascript developers.
Above only covers Smart Contracts for Etheruem; what about the more fully-encompassing "Dapp"? Well, it's pretty much Javascript for the UI of Ethereum Dapp. I recommend you read ConsenSys's writeup here, specifically Part II. Basically, you have:
Truffle (JS, Sass, ES6, JSX are built-in)
Embark (which is JS)
Meteor (web3.js + meteor (which is also JS))
and more are coming.
Conclusion
So, for Lisk to be implying that Javascript developers cannot create Dapp for Ethereum is a bit misleading. They can absolutely use primarily Javascript for the Dapp and then Solidity (which is so close to Javascript) for smart contracts.
The difference is that Lisk is entirely Javascript (and node.js) through and through, Ethereum has a large number clients in different languages[2], has two custom-written languages for smart contracts, and still allows for Javascript where you need it most (the UI).
2. Disadvantages of JavascriptWhat some people don't realize is that Javascript, while being extremely popular, does not automatically make it the best solution. As I said above, the difference between Ethereum and Lisk here is that Lisk is 100% Javascript while Ethereum has a ton of languages & lets Dapp developers use Javascript for the UI and Solidity for smart contracts on the blockchain. With that, here are some potential flaws with Javascript on the blockchain:
Javascript numbers are....not the greatest or most reliable. Especially when we are dealing with a crypto-currency, you really want your numbers to be on point. Basically JS uses floating point which means some things get approximated and digits get lost in certain cases. Here's some further reading: Be careful with big numbers & Floating point appoximation. So, the fact that everything in Lisk (including Lisk itself) is in Javascript, it means there are potentially big number problems (both in terms of big numbers and big problems.)
Lisk has "rules" that they ask contract developers have to follow to avoid breaking consensus. This includes things like "don't use Math.random()". With Ethereum, you don't have to have rules. The code will not compile if you try to do something wrong. (FYI, you don't compile Javascript.)
Javascript uses weak dynamic typing. If you are not careful, you can pass strings instead of numbers. One of the major differences between Solidity and Serpent and Javascript is that Solidity and Serpent are both strongly typed. Wikipedia on strong vs weak explains it thusly:
A strongly typed language is more likely to generate an error or refuse to compile if the argument passed to a function does not closely match the expected type. On the other hand, a very weakly typed language may produce unpredictable results or may perform implicit type conversion.
Since Ethereum is running contracts on the blockchain and Lisk is sort of running Dapp on the blockchain (sidechain?), you could see why having a weakly typed language could result in problems, specifically regarding consensus. It is much better to know the problem before it turns into an immutable thing on the chain, rather than discover all funds are trapped, or you fork the blockchain the first time someone tries to interact with it.
2b. Disadvantages of Solidity
As user Jehan pointed out, Solidity isn't perfect either.
There's little support for serialization and deserialization of any kind
It has an extremely anemic stdlib
There is no way to pass an array of strings into a contract.
3. On the blockchain
In Lisk, the Dapps actually are not stored on the blockchain, like the smart contract bytecode is in Ethereum. Instead, you have external links to these Dapp. They like to compare their Dapp to the traditional "App Store" model (think Apple). Which, while appealing to some users, is less appealing when you realize they are literally using HTTP: links to .zip files.
With Ethereum, you have the code stored on the blockchain which means they can be audited and the code cannot be changed. It's kind of the entire purpose of having decentralized applications (IMO).
Lisk prefers to use a looser definition of "decentralized", meaning literally not stored in a central place, while Ethereum developers and users prefer to have decentralized mean something that cannot be corrupted, can be audited, cannot be changed, can reach consensus etc. [3]
4. Who is / was LiskOne of the most common arguments by Ethereum lovers against Lisk is that Lisk (1) doesn't have a team of developers behind it and (2) originated as a failed alt-coin, Crypti that was abandoned by the devs (3) those devs that abandoned Crypti are the Lisk devs so (4) is this just a rebrand?
I don't know much about Crypti, but they did have a presale and they did get a decent amount of money (at least $200k USD) but I can't find the exact figures because everything has been wiped. Nothing came of Crypti. Literally. So...that's scary. The lack of transparency, also scary.
So I guess the main difference I want to point out between Ethereum and Lisk here is that Lisk is two guys who rebranded a previous coin that had a presale and delivered nothing while Ethereum has Vitalik Buterin, a large team of well-known, community-engaged, crazy talented developers, and a large community of developers creating Dapp and third-party wallets and hardware wallets and all sorts of amazing stuff. I mean, look at Augur, Slock.it, and ConsenSys alone. It's crazy!
Another key difference is Ethereum has the Ethereum Foundation, a non-profit Swiss organization and Lisk has....an unknown foundation / company associated with it.
One final note: Lisk really likes to claim they have partnerships with big names. First it was ShapeShift. Now it is Microsoft. They loooove to use that partnership word. In reality, they were just using the Shifty button, not really a partnership, and ShapeShift wasn't too pleased with it:
ShapeShift is not hosting or managing the sale of Lisk (contrary to what has been reported). Lisk is using the ShapeShift API to receive deposits with different coins, but that is the extent of ShapeShift's involvement.
Ethereum on the other hand doesn't promote "partnerships" or try to attach their name to others in order to gain reputation. They've tried to distance themselves from Bitcoin and being seen as a "currency" in general, even before the turmoil with Bitcoin came to a head. Instead, in the case of R3, they used Ethereum and Ethereum was like "yay!" but not "omg we're best buddies."
To be continued....maybe.