
Obsidian: A safer blockchain programming language - azhenley
http://obsidian-lang.com/
======
ssalka
Sorry, but without even a basic set of easily-accessible examples, you will
immediately lose a significant percentage of programmers and engineers.

~~~
Legogris
> Obsidian is currently under development and is not ready for general use.
> For more details about Obsidian, for now, please read our papers. Want to
> help? Participate in our user study.

What you are looking for is not in scope for this publication. Keep in mind
that this is an academic project.

~~~
ssalka
Even some pseudocode would go a long way - surely the creators have some idea
in mind of what that would look like.

------
zukzuk
Tezos, which is itself written in OCaml (what originally attracted me to the
platform), already has a relatively well design language for writing contracts
called Michelson
([https://tezos.gitlab.io/master/whitedoc/michelson.html](https://tezos.gitlab.io/master/whitedoc/michelson.html)).
I say "relatively", compared to the dumpster fire that is Solidity...

~~~
ghayes
Personally, I've always wanted take a look at Liquidity Lang [0] which exists
on top of Michelson. At a glance, it seems to solve a large number of issues
that have caused bugs in Solidity smart contracts (e.g. liquidity has abstract
data types, disallows inline mutation of state, etc)

[0] [http://www.liquidity-lang.org/](http://www.liquidity-lang.org/)

------
whyrusleeping
Is there a language spec and examples anywhere? I can only find one example of
what the language looks like in their insurance policy case study paper.

~~~
mcoblenz
There are some examples in the repository, e.g.
[https://github.com/mcoblenz/Obsidian/tree/master/resources/c...](https://github.com/mcoblenz/Obsidian/tree/master/resources/case_studies/Insurance)

Also see a draft paper: [http://obsidian-lang.com/obsidian-
oopsla-19-submitted.pdf](http://obsidian-lang.com/obsidian-
oopsla-19-submitted.pdf)

------
mcoblenz
Glad to see the interest — thanks! What we'd especially appreciate is if you'd
participate in the experiment: [http://obsidian-
lang.com/experiment.html](http://obsidian-lang.com/experiment.html)

------
naasking
Looks promising and is long overdue. This is along the lines of what Ethereum
should have been from its inception. It probably would have avoided many of
the highly publicized exploits.

~~~
willtim
Hopefully carefully considered and well-designed technology will prevail. In
this industry we are often too eager to endorse the first-mover as the
standard.

------
vessenes
Safer coding is important, as are better semantics for state machine
processing on chain, where a mistake can be really costly. So, yay.

On the other hand, three things make this hard for me to dig into and get a
real opinion: no sample code, so I have no idea if I like the way the authors
are going at it, no argument as to why this is not just a solidity extension,
and the compiler seems to need java.

It’s my day job to track stuff like this, but I will probably pass until one
of those three improves

~~~
tehsnitch
If anybody doesn't know about the Mtgox collapse, this man is the reason why
creditors haven't seen any money after 6 years and he recently submitted a
~$16b claim against the estate. All the money and coins in the estate are
customer deposits yet entitled Mr Vessenes feels he has the right to all of
this because he couldn't possibly make money through legitimate business
practices.

How bout you recognize customers entitlement to what's left of their deposits?

You are garbage made flesh.

~~~
Legogris
Username checks out, as they say on Reddit ;)

The last line was unnecessary to get your point across and against HN
guidelines.

------
grubles
Also, check out Blockstream's Simplicity smart contract programming language.

[https://blockstream.com/2018/11/28/en-simplicity-
github/](https://blockstream.com/2018/11/28/en-simplicity-github/)

[https://github.com/ElementsProject/simplicity](https://github.com/ElementsProject/simplicity)

------
twblalock
Can anyone explain why a new language is needed, and why we can't just use
existing languages for this?

~~~
hackermailman
From one of their papers the DSL is geared towards non programmers: "The
target user base of Obsidian is business professionals who will use the
language to write smart contracts, and its design is thus oriented towards
this domain. Obsidian programs consist of contracts – similar to classes in
Java – which contain fields, states, and transactions – similar to methods."

"We will target business students and business analysts with limited
programming experience, in order to collect data from the intended user base
of Obsidian."
[http://www.cs.cmu.edu/~NatProg/papers/barnaby17%20-%20Obsidi...](http://www.cs.cmu.edu/~NatProg/papers/barnaby17%20-%20Obsidian-
plateau.pdf)

In another paper they reveal they're also writing an IDE for this, overseen by
some PhDs in 'human-computer interaction' so it should be simple to use though
I find piles of complexity added by classes/methods the exact opposite of
simple.

~~~
derefr
> though I find piles of complexity added by classes/methods the exact
> opposite of simple.

I mean, the model of your objects calling methods on other objects (that you
don’t control)—and having your methods called by those same objects in turn—is
inherent in the abstract machine being programmed for. You don’t have to use
express the internals of your program as classes and methods, but that’s how
people are going to see your contract “from the outside”, and that’s also how
you’re going to have to interact with other contracts.

------
kreetx
Minor bug on the website: on mobile opening the menu brings up a "view on
github" link which covers the close button.

------
treelovinhippie
Rust. Holochain, Polkadot and others have adopted Rust to solve these issues.

~~~
Legogris
You are talking about implementations of the nodes. This is targeting smart
contracts that will be executed by those nodes.

~~~
treelovinhippie
Nope both. Holochain core is written in Rust and you code distributed apps
("DNA") in Rust. Polkadot core ("Substrate") is written in Rust and you code
smart contracts in Rust ("Ink"). Both compile down to WASM.

~~~
Legogris
Well color me ignorant. I am going to have to looker deeper into both (esp
Polkadot), I have been procrastinating that for too long now.

