DEV Community: omar-saadoun

Make a Blockchain Speak to You

omar-saadoun — Wed, 26 May 2021 20:33:23 +0000

The æternity Middleware puts blockchain data into context so you get the information you need

There are good technical reasons for blockchain protocols to leave bits of information stored in their granular way. Although a good source of immutable trustful data, only connecting the dots between all available information unleashes the full value of blockchains. Have your questions, the open-source æternity Middleware has the answers.

“What is the most popular token?”

“How many owners of this token are there, what are their balances and how did they change over the last blocks?”

“Tell me whenever something happens with regard to my oracle/account/contract!”

To keep the chain data of the æternity protocol concise, æternity would not store answers to the questions above. Projects requiring this information for their use cases though (especially in the De-Fi sector) have a tool at hand, that automatically gathers lots of important correlations between on-chain data to process it into an easily digestible form.

Introducing: The new æternity Middleware

You might have seen it in action already: It runs æternity’s Explorer under the hood.

It was developed with any kind of usage scenario in mind: You can spawn it up to visualize what is happening on your private network or follow along the progress of the æternity mainnet. And yes, you get both the back-end service as well as the beautifully designed web interface if you want to. And the next good news is: It’s open-source and very easy to set up. You can follow the steps in the Github Repository and always ask for help on the forum if you get stuck.

For Techies and End-Users alike

Using the Middleware, you can serve the purposes of several stakeholders of your projects alike: have people get visual feedback and allow for quick read-ups on important information, as well as gathering of huge chunks of complicated information for your project’s tech. The latter is supported by over 40 APIs serving different purposes (get a brief overview here and if anything important is missing, you are always welcome to express your requests on the forum. Besides querying APIs for required information you can also use web sockets to be notified about specific happenings in real-time. This means that you don’t have to pull the API constantly for updates with requests causing load on your service, but have all kinds of new information regarding your accounts, contracts or oracles pushed to you via the WebSocket. Think how your dapp’s UX will benefit from having an integrated querying/events notifications service, without the need of using third-party services often used to achieve performance and efficiency in dapps UX.

The Real Deal

Utilizing the Middleware for your project comes with low maintenance efforts: æternity uses the Middleware for its official block explorer you will automatically benefit from all patches, updates, and new features that get introduced to the Middleware.

In the same way that you have oracles, state channels, and the naming system seamlessly integrated into the protocol, you can also count on the advantages of the æternity Middleware out of the box.

Original article:

https://blog.aeternity.com/make-a-blockchain-speak-to-you-3f3a566ca441

The race to connect the world to the blocks

omar-saadoun — Wed, 26 May 2021 20:21:27 +0000

Blockchain adoption has been taking giant leaps forward in the last couple of years, and with DeFi leading the change, oracles have become a necessity, representing one of the cornerstones of blockchains’ utility.

Blockchain oracles allow interaction between real-world data and smart contracts, allowing any publicly available data to be seamlessly integrated into smart contracts. The oracle connects the blockchain and the real world, allowing the smart contracts to change when certain world events trigger such a reaction.

It is well established that æternity was born DeFi-ready, with smart contract capability as well as extremely high scalability and transaction speed. However, it is not common knowledge that æternity also offers an embedded oracle system to its users. What the developers of æternity knew at the time of building the blockchain’s foundations is that oracles will be an integral part of any blockchain that wants to host the plethora of DeFi applications that are currently being developed. By looking ahead and learning from the mistakes of the early blockchain platforms, æternity’s design resulted in a completely modern blockchain, with sufficient performance and functionalities to support the heavy traffic demands of DeFi.

Oracles are just one of many functions essential for what blockchain is trying to bring to the world — efficient independence from the central banking systems and the instant interoperability of the physical world and the decentralized financial system.

However, æternity’s oracles differ from most oracles in the blockchain space in the sense that they do not operate automatically. Instead, æternity utilizes oracle operators — individuals or entities who register oracles and set them up to communicate the relevant data between smart contracts and the world outside the blockchain.

Although this makes the process more complex, it creates a structure in which oracle operators can earn from the parties using the oracles they provide. This means that, in the future, there could be a dedicated Oracle Marketplace where users can choose their trusted oracles, creating strong competition in the market to provide the best possible oracle service.

Undeniably, any business planning to utilize blockchain for its benefit will have to go through oracles. With numerous blockchain projects offering different solutions, it will be a system with the most secure structure and least capacity for manipulation that becomes the standard.

The race to provide the world and blockchain with seamless interoperability is far from over, and oracle systems will continue to be created and improved. The Akshwani haeck held in April and May, organized by æternity, aimed to do just that — find more opportunities to utilize and improve the ways oracles are being used. The brightest minds of the blockchain space took on the ambitious task of testing out the new use cases of oracles and building the digital structures of the future on the æternity blockchain network. The fruits of their labour can be found in the Devpost project gallery of the Akshwani haeck.

While æternity isn’t the only competitor working on advancing oracles and bringing mass adoption to blockchain, one thing is certain — with oracles embedded in its protocols from the start, and with its uniquely active and collaborative community, æternity has a head start.

Original Article
https://blog.aeternity.com/the-race-to-connect-the-world-to-the-blocks-44cfa659edc7

A tale of Layers and Oracles

omar-saadoun — Tue, 20 Apr 2021 10:39:27 +0000

The advantages of having all the options on Layer 1

There’s nothing like being in the middle of a bull-cycle to show which crypto projects can run with the demand of mass adoption and which are scrambling to retroactively create solutions for their short-comings.

Millions of new users are becoming aware of what blockchain technology offers them, thousands of new applications are being created and the traffic on networks reaches billions of transactions. There are no clear winners or losers in the race to bring decentralized finance to the people, however, at the height of the cycle, some major players are starting to show cracks.

Being the trailblazer of smart-contract blockchains, Ethereum is paying the price of being the first. And it’s not just Ethereum, most early blockchains suffer from the same symptoms — lack of scalability, low speed and high transaction cost.

The solution to this problem — Layer 2 applications. And further down the line, possibly even Layer 3. How will it work, what will be the drawbacks, and will these solutions be efficient enough?

Talking to developers about the phenomenon of Layer 2 solutions and their viability, the conclusion I was brought to is that building software is similar to building a house. You need to set the groundwork and design for what it is supposed to be when it’s complete. You shouldn’t build and design at the same time. Imagine starting to build your one-floor house and then, at one point you realise you will need more space, so you decide to add another 2, 3 floors on top and then just do it. Now imagine that entire building collapsing.

When you build software and especially software as sophisticated as blockchain, knowing, planning and designing for the future is the right way. Having a strong architecture that was crafted from the beginning with the features and possibilities in mind is crucial. You want to avoid doing big refactorings that could break backward compatibility, making updates much more complicated and risky.

When we talk about Layer 1 and Layer 2 we talk about that planning, meaning that you’ve created and designed your software already knowing what the needs of your users are going to be, even long after your initial launch. This leads to easier access to resources, less memory consumption and more secure internal processes, resulting in a faster execution.

With æternity, that plan was made ahead, taking advantage of smart design and architecture from the first minute, anticipating scalability issues that are now playing against adoption. The æternity technology was crafted with future demand and adoption in mind, thus the blockchain’s had cutting-edge functionalities incorporated since its mainnet launch in November 2018. That’s why you only need one layer to work with all the features like Oracles, Naming System, or state channels. That also explains why transactions on the æternity blockchain are so efficient , and why you don’t have the need for extra layers.

Æternity was born DeFi-ready, with smart contract capability, extremely high scalability and transaction speed, alongside embedded Oracles, off-chain smart contract executions thanks to state channels, and human-readable addresses, making æternity the best foundation technology for decentralised applications.

With pioneering solutions such as Hyperchains, embedded Oracles and State Channels, æternity’s developers exhibit a rare farsightedness in terms of future capabilities as well as needs of the users and developers when mass adoption inevitably comes. By looking ahead and learning from the mistakes of the early blockchain platforms, æternity’s design defeats the purpose of Layer 2 solutions.

Æternity’s embedded Oracles, for example, allow interaction between real world data and smart contracts. Any publicly available data can be integrated into smart contracts, and events like election results, weather conditions, sporting event results or certain commodity prices trigger changes to those smart contracts. This opens up the field for major applications such as decentralised finance, supply chain management, information markets, insurances, gaming, the Internet of Things and many more. While other blockchain networks rely on third party solutions, to provide Oracles, æternity offers them out-of-the-box for the best user experience, but also for the best developer experience, security and optimization of costs.

Oracles are just one of many functions essential for what blockchain is trying to bring to the world — an efficient independence from third parties to be trusted and the instant interoperability of the physical world and the decentralised web.

As a next generation smart contract platform, æternity blockcain is interwoven with innovation and functionalities most other blockchains don’t offer. And they are all on Layer 1.

Experience the quality of smart design, build on æternity blockchain.

Original post from : https://blog.aeternity.com/a-tale-of-layers-and-oracles-669203069cf6

Erlscripten: Transpiling Erlang to Javascript. Yes, you read it right.

omar-saadoun — Wed, 14 Apr 2021 22:20:41 +0000

It is safe to say that Erlang as a language and framework is the most reliable choice out there to build highly stable applications, running the likes of Whatsapp and Discord. Now, there is a transpiler introducing concepts of Erlang to web technology, which would be near impossible to implement manually using Javascript.

Here at æternity, we’ve envisioned for a long time that running major parts of a blockchain protocol in the context of modern web frameworks would mean a huge leap for the adoption and scalability of distributed ledger technology. What if you could run an ad-hoc blockchain node in your browser, or use state channels to quickly make safe payments using your phone?

As a solid foundation had to be laid for a reliable infrastructure first, that was not conceivable as of yet. Until now.

Erlscripten is here.

Erlscripten (sic not Emscripten!) is a source-to-source transpiler capable of converting most Erlang codebases into semantically equivalent Purescript projects. Purescript is a strongly typed language heavily inspired by Haskell and which compiles down to Javascript. Taking Purescript as an intermediary step, Erlscripten allows you to take your existing Erlang application and easily ship it out to Javascript users — your Erlang code can now run safely in the browser — enabling code sharing between an Erlang backend and the frontend. It is highly interoperable with Javascript — Javascript can easily call the transpiled code and then make use of the results — you can easily map Erlang constructs and types to readily available JS constructs.

It’s zero hassle — you point Erlscripten to an existing Rebar3 Erlang project and in result get a compatible spago project ready to be used in existing Purescript/Javascript projects. While at it, we transpiled the Erlang runtime (ERTS) that allows you to run arbitrary transpiled Erlang code:

https://github.com/erlscripten/erlps-core

Purpose

Besides bringing the components of the æternity blockchain to more platforms and web frameworks, there are two novel use cases for Erlscripten:

1 — Code reuse between Erlang backends and Javascript frontends;

2 — The creation of a new paradigm for developing frontend applications.

æternity is a blockchain platform primarily written in Erlang. In the upcoming era of Hyperchains the need for code distribution between frontend and backend applications is high. Therefore we need to move some parts of æternity infrastructure to the clients’ side in order to provide a more reliable and decentralized system. It doesn’t make sense to rewrite our code in Javascript/Rust manually as this would require a lengthy rewrite and then the need to maintain and sync 2 codebases. The high need of interoperability between Erlang and Javascript is where Erlscripten was born. We can transpile what we need and distribute it to the browser where it’s needed. One side effect of Erlscripten is that it will soon be possible to write Frontend applications directly in Erlang — Erlang’s actor based programming maps really nicely to existing reactive frameworks.

Similar projects

We’re not the first ones with the need of Erlang/Javascript interoperability

— Elixirscript is a Elixir to Javascript transpiler with similar goals as our project. The main downside of Elixirscript is the lack of OTP support (Erlang’s main framework for building failsafe applications) — it works on a really small subset of the Elixir language and they need to rewrite the Elixir standard library in Javascript for it to work. In contrast we are OTP compatible — we transpiled the real Erlang standard library from OTP and distributed it open-source: https://github.com/erlscripten/erlps-stdlib (
Erlang Solutions
).

To demonstrate our point we were capable of taking the compiler of our smart contract language (https://github.com/aeternity/aesophia) and converting it to be runnable in the browser:

https://github.com/erlscripten/erlps-aesophia

We tested the transpiled project and it works! Demonstrating our point that we have support for advanced OTP constructs including ETS, Erlang’s in-memory database.

Notably, Lumen has similar goals to our project, after their project is done it will be much faster than Erlscripten and probably more capable — the downside is that Lumen is in WIP phase and it will take a long time for Lumen to be ready whereas Erlscripten is now and here! Ready to be used!

Status quo

What is supported

Majority of Erlang expression
Arbitrary arity functions
Pattern matching
Records (via tuples)
Binaries
Lambdas
Tail recursion
Exceptions
Process dictionaries
Code server, module loading
Imports and exports
Compatibility utilities
Common errors (function_clause, case_clause, badarity, etc.)

What is partially supported

Erlang’s standard library (most essential modules; lists, maps, string, etc.)
Erlang builtins (the list is growing and growing!)
Rebar project transpilation
ETS

What is under development

Bitstrings
Leaking variable scopes
Basic erlang process emulation
NIFs (will be done through C to WASM compilation)

Works on the PureScript compiler

The original PureScript turned out not to suffice our use case perfectly. For instance, we had some issues regarding handling tail call optimization which started several discussions and contributions on their GitHub:

Some of the problems have been already fixed due to our reports, but some of them haven’t been accepted as they involved some overhead on the performance in the general case. Because of this we have forked the compiler and started adjusting it for our needs ourselves. Our works mainly involve the optimization tweaks and updating the backend to EcmaScript6 (instead of 5). For instance, we have implemented a much more aggressive tail call optimizer, increased strictness of AST traversals and completely rewritten the code generation for pattern match alternatives.

During this work we have spotted some performance bugs and started working on fixing them on our own. One of our patches has already been approved and awaits merging:

Fix exponential collapsing of BindingGroups

Examples:

While we are perfectly aware that neither Erlang nor PureScript are the most common sight to see, we invite you to take a look: Here are some examples of how Erlscripten transforms existing Erlang code into PureScript. The generated code is obviously larger as we need to take care of the type system (PureScript is typed while Erlang is not) and tackle some syntactic sugars. Furthermore, we need to emulate the default error handling and exceptions that are being solved much differently in Erlang in order to preserve compatibility.

Factorial:

Find the code example here:

https://github.com/erlscripten/erlscripten/blob/main/examples/factorial.erl

Continuation based list reversal via catamorphic transformation:

Find the code example here:

https://github.com/erlscripten/erlscripten/blob/main/examples/list_reverse.erl

Run Erlang in the browser!

Erlang to PureScript transpiler > https://github.com/erlscripten/erlscripten

Original article from :
https://blog.aeternity.com/erlscripten-92c815786987

Bringing æternity technology closer to you

omar-saadoun — Tue, 09 Feb 2021 11:07:41 +0000

Do the people have a blockchain which is entirely their own, which they can build on and which provides their applications unlimited scalability, integrated oracles, amazing speed of transactions and innovative solutions to problems which even the biggest blockchains such as Bitcoin and Ethereum are struggling to resolve?

Yes, they do, it’s called æternity blockchain. It is yours to shape, use and build on and has been made with Erlang and Elixir. So, shouldn’t æternity blockchain have its own StackExchange site? Of course it should, and behold, one is currently in the process of being created! To be a part of it, however, you should commit in the Area 51 æternity site staging zone.

Why is it important to commit?

Once we get to 100% of the needed commitments, private beta stage will start and only those committed will have access to æternity’s StackExchange site, until we get to the public beta stage. You can view it as becoming founders of the æternity StackExchange site, which is in itself kind of cool. More importantly, though, everyone committed will be able to post or answer questions on the beta site. This will be of great use to enthusiasts and developers learning about blockchain and æternity technology in particular, providing them with aid in coding, solutions others have already created, and, on the other hand, a point of pride and good will for knowledgeable developers to help and teach their peers about the innovative technologies used by the æternity blockchain, and how to apply them to new use cases.

At the moment, about a quarter of the commitments have been achieved. We need your help and hope to kindle your interest in æternity, an open-source, decentralized and innovative blockchain waiting for you to shape it into something everyone will want to use.

⚡️ That said, here is the link to commit {https://area51.stackexchange.com/proposals/124829/ternity?referrer=YjY5MjcyODEyMzRlNTlmZTVmODljMWI3OGNkOTk0NzkzZjJiZmExYjJmZGJkNTg0NGYzYjIxZjcwMzMyNTNlYsPCR-SAlmoKLKR-GSAouPg2GjEH0CCzf23V_CfbkD6S0 and remember that it doesn’t matter if you already followed æternity’s StackExchange page, you still need to commit.

And please, we encourage you to promote this on your networks and between your colleagues. Also don’t forget to improve your reputation by following other SE sites and reaching 200 rep points.

The process of creating a StackExchange site is a sophisticated collection of stages which ensure that a quality site is created and that it will have regular traffic and ample interest of the public.

Launching a StackExchange site goes through the “Area 51” process:

Proposal: a handful of people are needed already within a few days;
Definition: the community must propose and approve 40 typical questions;
Commit: enough individual users must pledge to contribute to the community; *
Beta period: the community must achieve some metrics (e.g. 10 questions/day);
StackExchange site proposals may fail (close) or succeed (be launched).

*We are currently in the Commit stage of site creation and soon hope to be in the Beta, where we will be able to really start working with everyone interested in the technology æternity is offering.