Category Archives: Nethereum

DevCon 5, Super Happy Blockchain Time: Part 1

It was time again for Etherheads to convene, with DevCon 5 being in the land of the rising sun. In particular, where the red ball on Japan’s flag represents the tacoyaki of the nation’s best food destination: Osaka! (And if you’ve ever eaten fresh tacoyaki, it should be colored red since it always has the inside temperature of magma. Sweet, delicious magma.) After learning to navigate the city’s metro (which was much easier with the use of an IC card), we found our way to the ATC Hall along Osaka’s west coast. Though I’m still confused why it’s not APTC instead of ATC, but I digress…

Since the ATC is part of a larger complex that includes eateries and shops, it took a bit of navigation to find it, especially as different parts of the conference center were in different parts of the complex. It was an interesting venue, to be sure. Nestled between an active port for cruises and some industrial warehouses, it had the simultaneous feeling of being both welcoming and gritty. Which is, in some ways, how you could describe Osaka.

And we even had our own little outdoor park, which we was a nice change of pace.

But enough about that…on to the conference itself! Well, after getting the new wristband (that seemed to take the place of the lanyard), we snacked on some local favorites inside the main hall as we planned our first day:

First stop was a session on getting the Ethereum community to create a more open dialogue about creating standards for Ethereum usage, ones that could be embraced by the world at large. Granted, the focus of the conference was aimed at the talk about Ethereum 2.0, since the technical hurdles are the most important priority. However, this kind of discussion was also important, since we do need to think about what comes after the successful implementation of the platform’s next iteration. After all, getting Ethereum into the marketplace will require a lot of negotiating with the outside world, and it’s better to start that conversation now.

Next stop was a must for me, since it was a presentation about building rules engines within Ethereum. And I thought that my baby Wonka was the only game in town! So, with rapt attention, I listened to Michael Yuan and his team at Second State present their rules engine for Ethereum. Since it’s a subject dear to me, I was glad for their talk, and I felt more validated for even putting all the time and work into my own project.

But, in the end, I didn’t see their implementation as the viable one, especially with its variation of the Drools spec. In that scenario, you would use a Drools-like pidgin within a rules contract, which would then transpile your effective rules before eventually compiling the contract into EVM code. But in that case, why wouldn’t the writer of the contract just write Solidity/Vyper code instead? Plus, most Drools implementations use clever versions of the RETE algorithm, which could execute in an Ethereum environment unpredictably (depending on context) and could have immensely unforeseen gas costs with multiple iterations of rules. I still believe that rules engines should be for non technical people, and this way would alienate a lot of that crowd. In the end, though I’m probably incredibly biased, I still thought of my Wonka project as the better path. However, it was still cool to see someone thinking along the same lines, since even most developers have never heard of a rules engine.

And, even though I had already seen them in Brooklyn a few months ago, it was good to see Microsoft again, since it reconfirmed their dedication to the space. Cale Teeter and crew talked about the Azure Blockchain Workbench becoming more dynamic, with the ability to add nodes outside of Azure to their management console. Which is good, since I had been complaining about that for a while now. Plus, they showed off some new abilities with the Visual Studio Code IDE, and they even gave a shout-out to my Ethereum mentor Juan Blanco and the Nethereum team, since their Workbench tools rely on Nethereum for quite a bit.

After a busy day, why not enjoy some quality time with Kabo-chan, the seminal dog that’s the muse of memes and crypto around the globe! That should fun, right?

I love dogs, especially mine…but I’m not hanging around to meet a damn dog. He was too much of a celebrity for me, having to wait in a line to meet him. I instead decided to embrace the mediocrity of my existence and to skip my chance at rubbing elbows with fame. There was too much tacoyaki waiting for me back in the center of town.

Advertisements

DevCon IV, The Resurrection: Part 4

The lectures were interesting, but let’s not forget one of the most important purposes of the conference: to reconnect with old friends (of which I spent most of my time towards the end). And connect with new ones! Speaking of which, it looks like Microsoft has decided to move into the neighborhood, complete with their spanking new workbench:

They did a good job trying to sell it, especially for Ethereum users. For the grizzled developers like me, I appreciate that they’re trying to entice more of the enterprise people (i.e., oldtimers) to Ethereum by integrating existing platforms (like BizTalk) with the blockchain. I’m still not sure about their approach with BizTalk, and I still prefer my solution to their solution…but who knows? Maybe it just needs some time to mature.

It seemed like only a few more minutes passed by, but when I looked up at the board, it was practically over!

I could hear the singing that signaled the unfortunate end of the 4-day event. I couldn’t say what was worse: it was already finished for this year, or somebody still thought that it was a good idea to close the show with a sing-a-long in the style of Ned Flanders at Bible Camp.

Minus the singing, I’m already looking forward to next year!

I Always Start with a KISS

Most of the time in tech, you can stand on the shoulders of giants and reuse great works to your benefit, whether those things be algorithms or engineering methods. But, sometimes, as you venture towards the edge, you realize that you’re now somewhere completely different. You find yourself floating in some unknown ether, and you need to reorient yourself to this new dimension. And the more I play with the Ethereum platform, the more I find myself in that position.

For example, when I first started to create the Wonka rules engine, I had a few plans in mind, with one being to possibly use the Rete algorithm within the project. After all, it provides an efficient solution for a dynamic situation. Specifically, this dynamic situation could be one where a rule at the end might change the data, and then the whole set of data would need to be reevaluated by the rules due to that change. In this case, the Rete algorithm provides a performant method for this possibly recursive set of reevaluations. But that’s in the normal world, not the Ethereum one.

Within most standard computing, there’s minimal cost to using a system’s resources. At worst, you’re paying a cloud provider for cycles; in order to run a limited set of rules, you’re still talking pennies. But in a blockchain environment like Ethereum, where you have a massively distributed database of decentralized shared resources, every execution is an expensively coordinated effort. In order to change the state of the system, the cryptocurrency of the system, Ether, is used to cover the cost of a transaction, which is described as the ‘gas’. And even though the market value for Ether keeps sliding down, it still means that every rule that changes the system is another line item on your ‘gas’ bill. That’s difficult to predetermine since it’s always based on context. Yes, you can run your own private Ethereum blockchain within your own network (instead of the mainnet), and that means you’re not paying real Ether at all…but, in the end, people using blockchains generally still want accurate measures of impending execution.

Which brings us to the ultimate question for anyone using a rules engine within a blockchain like Ethereum: how much is this damn thing gonna cost me to run? Since the answer could be “a lot”, we have to abandon our beautiful, time-proven algorithms and go back to the drawing board. Which is why when you’re dealing with nascent platforms, you have to go back to KISS (i.e., Keep It Simple, Stupid). So, in this MVP version of a rules engine, I did just that, creating a straightforward implementation that just gets the job done. In this current state, its destiny will more than likely be as unwept, unhonored, and unsung. However, at the very least, such a prototype can be used by others to evaluate and perhaps validate the existence of a rules engine in this new space. And, maybe, just maybe, it can serve as the first iteration of something that will eventually become worthy of note.

On a side note, it turns out that getting a ticket to DevCon is a lot harder than I thought.