35

Lisk is going to be a full stack DApp development framework for building and distributing decentralized applications. It's currently in the crowdfunding stage but got also added to Microsofts Blockchain-as-a-Service stack.

It advertises that you can build decentralized applications by simply writing Javascript. But since you can also build JS-DApps for Ethereum, I wonder, what's the difference?

  • 1
    That is a good question and would be nice to have an answer. – axic Mar 17 '16 at 20:12
35
+50

Warning, I'm not a huge fan of Lisk. This is obviously one side of the story and I'm sure there are more advantages of Lisk than I give them credit for. But I don't know them.


A blog post (not by me): Why Lisk is inferior to Ethereum

Author's main points regarding Lisk:

  • Lisk "sandbox" cannot be used to run untrusted code

  • Lisk framework provides no protections against non-deterministic behavior

  • Lisk doesn't have the ability to prevent infinite loops and/or measure total computation

  • Lisk doens't have the ability to prevent unbounded memory growth and/or measure memory consumption

  • Common JavaScript language features (such as iterating over keys in an object) results is hidden non-deterministic behavior

Author's main points regarding ETH:

  • Ethereum shields developers from innumerable problems that plague experienced blockchain developers.

  • Learning a new language syntax is trivial compared to learning how to avoid the millions of ways you can shoot yourself in the foot.

  • Ethereum apps have no possibility of generating non-deterministic behavior.

  • There is no need to manage "undo" state in Ethereum because any exception thrown automatically rolls back all changes (except for the fee).

.


1. Programming Languages

Lisk: Javascript vs Ethereum: go, C++, rust, Solidity, Serpent, etc.

Lisk

One 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".

Their entire system is 100% javascript. Node.js for the backend. The frontend. They do have a database -- SQLlite, originally. Now postgresql.

Ethereum

Smart 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, if you want to learn more.

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 blog post referenced above says is succinctly:

Learning a new language syntax is trivial compared to learning how to avoid the millions of ways you can shoot yourself in the foot.

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 Javascript

What 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. Additionally, 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. Even little things like floating point numbers can break consensus. 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.) On Lisk, if you do use Math.random(), it breaks.

  • 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.

Additional flaws with Lisk include the fact that their "sandbox" cannot be used to run untrusted code and their framework provides no protections against non-deterministic behavior. From the blog post above:

Lisk faces can be resolved with a heavily customized JavaScript environment that removes floating point, implements software interrupts, instruction counting, and cleaner APIs for managing application state. Ultimately, creating a JavaScript compiler for the Ethereum VM might be less error prone than trying to patch a million nondeterministic leaks in JavaScript.

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 (has been recently updated significantly)

  • 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 Lisk

One 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?

The main difference I see between Ethereum and Lisk here is that Lisk is two guys who rebranded a previous coin that had a pre-sale 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 working on the core code (everything is open-source), Dapps, and third-party wallets, etc.

Another key difference is Ethereum has the Ethereum Foundation, a non-profit Swiss organization and Lisk has....an unknown foundation / company associated with it.


[1] Here is a screenshot as well because that link is funky.

[2] Ethereum is mind-blowing with the amount of languages / clients. At this point, we have: Geth (Go), WebThree (C++), PyEthereum (Python), Parity (Rust), EthereumJ (Java), Ethereum-Ruby (Ruby), NEthereum (.net). I see this as a major advantage for Ethereum and, as the Ethereum Team has pointed out, the fact that there are so many clients in so many languages have been invaluable in testing, bug-discovery, and ensuring consensus.

[3] More information from an angry thread.

  • 1
    Lots of very good points, but I would just like to say that Solidity has a lot of issues, as is to be expected from a young language. There's little support for serialization and deserialization of any kind, it has an extremely anemic stdlib, and there are basic features missing, like being able to pass an array of strings into a contract. I don't think it's unreasonable for developers to want something more flexible for certain use-cases. – Jehan Mar 28 '16 at 23:50
  • Thanks for the response @Jehan. I'm not as familiar with Solidity as I should be, and was basing most of my points on what I have read in the documentation and other comments. I have added your points to my initial post but would love for them to be more thorough. Do you have editing capabilities yet? Or would you be willing to throw together a pastebin with some more details / sources? Thanks! – tayvano Mar 29 '16 at 2:17
  • Honestly, I think that a lot of these things will be fixed as time goes on. I don't think that Solidity is bad, but I also don't think it hurts for people to experiment with programmable blockchains that don't have their own built in programming languages. – Jehan Apr 6 '16 at 3:24
  • The difference in contract execution is not explained but it could be important. #4 should be removed or rewritten to look not as ad hominem. – Come-from-Beyond Apr 19 '16 at 13:21
  • @Come-from-Beyond #4 should not removed but better explained, because yes: the team is all. – Roland Kofler Jun 9 '16 at 9:30
22

@tayvano: Unfortunately, I can't comment directly. I need "50 reputation" for this. Therefore I will write it as a new answer.

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.

The range of clients at Ethereum in Go, C++, Python, JavaScript, Java and other languages is a support disaster. Right now it may work OK, but once Ethereum attracts a critical mass there will be 1 (or maybe 2) clients which will be used by 99% of the users. Otherwise, it's just not feasible.

You also say that Ethereum is trying to appeal a wide range of developers. Lisk tends to focus on the JavaScript group, it's just a fact that this is a huge crowd already. Lisk removes friction, it's very hard to get developers for a platform. If they now need to learn a new language (besides the whole blockchain concepts) attracting them will be even more difficult. Lisk is all about staying lean, efficient and focused.

Btw. JS is extremely powerful: asmjs.org, pyjs.org etc.

Above only covers Smart Contracts for Etheruem; what about the more fully-encompassing "Dapp"?

Here is the difference between Lisk and Ethereum. Ethereum is doing smart contracts which are all saved on one blockchain. If you want to develop a dapp in Ethereum you need to connect the functionalities of several smart contracts.

In Lisk you get a complete package. You don't develop single smart contracts. You build an entire application which is running on its own blockchain. It's like you develop a new crypto-currency platform with an extended feature-set, the platform itself is already finished and provided by our Lisk SDK. As a developer you just need to implement the necessary new features on top of the already existing platform.

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.

We never said that JavaScript developers cannot create dapps for Ethereum. Of course they can, but they need to learn a new language first. This is like you would say a plumber cannot paint walls.

At Ethereum they can use JavaScript for the dapp front end, and Solidity for the dapp back end. It's not like they are using JavaScript "for the [complete] dapp" as you said. No, only for the front end.

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).

Yes, we tend to focus on one technology. Focus is key.

Your statement that Ethereum "allows for JavaScript where you need it most (the UI)", is really only the case for Ethereum. JavaScript is globally accepted for many different tasks on the front and back end (e.g. NodeJS). Not just for "the UI". You are making JavaScript smaller as it is, only to get more arguments for Solidity.

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.

We are only using integers at Lisk. For big numbers we are using bignumber.js. It's not about the language you choose, it's about your coding skills. If you know what you are doing JavaScript is entirely fine. However, yes this is a weakness. But a weakness which is manageable.

Javascript uses weak dynamic typing. If you are not careful, you can pass strings instead of numbers.

Honestly, if you are building a serious project you should at least get this thing right. Otherwise, every JavaScript project would fail according to your argument.

Lisk has "rules" that they ask contract developers have to follow to avoid breaking consensus.

Yep. It seems Ethereum has these "rules" directly embedded into their compiler, at Lisk developers just have to follow them. The biggest difference here is, if they do a mistake and the consensus is broken, then the dapp needs a hard fork. But Lisk itself is entirely fine, because the dapp is only running in a sidechain.

This is a huge security advantage. If a dapp fails, the Lisk network doesn't even hiccup. However, if one smart contract fails at Ethereum, it can mean game over for Ethereum.

Disadvantages of Solidity

Other disadvantages may be that it's a very young language and therefore unproven. Also there is very little documentation available, and even less developers know this language.

On the blockchain

You are mixing up different things now. You download the Bitcoin client also from an HTTP link. However it "cannot be corrupted, can be audited, cannot be changed, can reach consensus". That means all these important properties you mention are also valid for Lisk. If you change a dapp code, your node will end up on a fork. Same as if you change the Bitcoin code.

The HTTP link is only the way to distribute a dapp source code. Later on we will integrate decentralized storage methods (e.g. IPFS), so the distribution itself can be decentralized as well.

However, the distribution model doesn't define if an application is centralized or decentralized. Or do you say that every crypto-currency on the market is centralized? Because you download the clients from a centralized location? If yes, then how can Ethereum dapps even be decentralized, if the network itself is centralized? ;)

Your line of arguments is wrong here. Another important fact is, that this method allows Lisk to scale massively easier than Ethereum. Besides the huge advantages our sidechains already bring to the table.

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.

We are not associated with Crypti anymore. However, saying that everything is wiped and that there is no transparency is a huge lie. There are over 600 pages on Bitcointalk (https://bitcointalk.org/index.php?topic=654463) and dozens of blog posts (https://blog.crypti.me) which contain ALL information.

Additionally, if you say that "nothing came of Crypti" then you are completely wrong. Crypti developed a working dapp platform, the huge success of Lisk is proving this. The only thing which just didn't work at Crypti was marketing. That means nobody knows about Crypti. There was also a big lack of leadership at Crypti.

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!

Yes, I'm glad that those two guys at Google never started their company because there were so many great search engines back then with hundreds of employees. :)

Don't understand me wrong, I like Ethereum and the whole team/movement behind it. I'm a big supporter. But you are just refusing innovation at this point of time. You are comparing a 2 years old platform (Ethereum) with 18M in fundings, with a not even launched platform (Lisk) with no access to the funding as of yet. That's kind of silly.

Another key difference is Ethereum has the Ethereum Foundation, a non-profit Swiss organization and Lisk has....an unknown foundation / company associated with it.

Everyone at Lisk knows that we are in the process of creating a legal entity in Germany, most probably as a gGmbH. This is also a non-profit organisation structure.

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.

We had a technologic partnership with ShapeShift. It was a big mis-understanding at that time. They already fixed that mistake.


All in all, I would like to say that your points are quite weak. You didn't point out the biggest weaknesses of Lisk. In my opinion this is sidechain security. That means small dapps probably won't have a chance long-term to attract enough nodes to secure them.

For this I suspect that there will be special dapps, who will run smaller dapps in a SaaS way. Until we implemented a sidechain forging marketplace, finding sidechain forgers is also quite a difficult task. However, these are all just starting problems. Everything is solvable. At the end of the day Lisk is just software which is actively developed.

It's important to mention that Lisk just gets started and we are already making big changes. At this point of time it's just to early to evaluate Lisk and the team (us) behind it. You should just wait for a year before making a final conclusion. All arguments right now just look like you are afraid. Personally, I think there is far more than enough room for Ethereum and Lisk. In the end we are solving the "problems" very differently and are attracting different niches.

I hope that Ethereum and Lisk can work together in the future in order to solve important problems within the dapp and blockchain industry. I say it again, we are in this "game" together.

  • Hi and welcome to Ethereum Stack Exchange. Thanks for providing additional information to tayvanos answer. – Waqar Lim Apr 19 '16 at 12:12
  • It seems I can comment on my own post without the need of "reputation". Thank you for the warm welcome 5chdn. Thank you for asking important questions about Lisk. :) – MaxKK Apr 19 '16 at 12:53
  • 6
    @MaxKK Please add a disclaimer saying you're the CEO of Lisk. – Stanislasdrg Dec 7 '16 at 19:37
  • 2
    "This is a huge security advantage. If a dapp fails, the Lisk network doesn't even hiccup. However, if one smart contract fails at Ethereum, it can mean game over for Ethereum." -- This is extremely incorrect. If a smart contract on Ethereum fails, the contract is broken. Etherem itself is fine. If Lisk really improves upon this, can you explain how so? – notlesh Dec 2 '17 at 17:59
  • @MaxKK Everything you said sounds great! But my personal view (up to you if you want to consider it or not) is that your team needs some big names (people with great educational background), phd's and papers and of course solid Software Engineers who can implement those ideas! They are important to go to next level. LISK is doing well financially so why not hire them ?! If I am a CEO of a company I won't just go by what my CTO has to say in fact I think most CTO's are incompetent. Got to always hire someone smarter than you! and just don't go blind on Oliver!! – user1870400 Feb 24 '18 at 13:00

protected by Waqar Lim Apr 19 '16 at 12:04

Thank you for your interest in this question. Because it has attracted low-quality or spam answers that had to be removed, posting an answer now requires 10 reputation on this site (the association bonus does not count).

Would you like to answer one of these unanswered questions instead?

Not the answer you're looking for? Browse other questions tagged or ask your own question.