Developers Developers Developers Developers

This week feels like a lively one for the hApp development ecosystem. I’ve discovered a fun little project that only took a few nights to build (spoiler alert: decentralised Zoom), read a very encouraging update from Flux (formerly Junto) about their progress, and been pleased to see the folks in the DEV.HC discord continue to build useful little modules. In addition to that, Holo’s admin team is hosting a developer-focused AMA soon, and of course there’s a Holochain release. Lastly, we’re inviting all developers to give us their feedback on the weird groovy biology-based language we use.

Holochain 0.0.132: Unidirectional arcs

Breaking changes: network protocol
HDK version compatibility: 0.0.125, 0.0.126, 0.0.127

We’ve merged more work on the next iteration of rrDHT (#1283, #1288), which will eventually feature a more efficient syncing algorithm between nodes in a network. If you’re familiar with the way rrDHT works, you’ll know that a node’s ‘neighbourhood’ (their region of responsibility in the DHT’s address space) radiates out from their own agent address like an umbrella. This change moves their neighbourhood to their right, so it starts at their agent address.

From what I understand, this simplifies gossip somewhat, because there’s no question about who should be initiating a syncing session with whom. If a node is to your right, you initiate. If it’s to your left, you let it initiate (in fact, you probably don’t know about it until it does initiate).

Finally, there have been more improvements to our automation process (#1307, #1312, #1315).

Read the full changelog.

Holo AMA 50: Developer Focused

The next AMA is on April 4th at 16:00 UTC. I’m bringing this up in the Dev Pulse because the hosts are inviting all development-related questions — submit your questions here!

Doom, a decentralised Zoom

A few weeks ago a developer named Felipe joined the DEV.HC Discord, where devs get together to mentor each other and build hApps. I was amazed when, in the course of just one week, he managed to put together a proof-of-concept for a peer-to-peer video chat hApp!

He’s calling it Doom (no, not that Doom, but ‘decentralised Zoom’), and you can check out the source code at the felri/doom GitHub repository.

Doom mashes together two peer-to-peer technologies. Holochain handles the ‘signalling’, or the ‘making the connection’ part. If Doom were the phone system, signalling would involve me pulling a phone book off my wall, looking your number up, dialing your number, and letting the phone network connect my phone to yours. But while the phone network is semi-centralised, Holochain is almost entirely P2P.

The other P2P component is called WebRTC, and your computer already supports it — it’s built right into your browser. So once Holochain handles signalling and makes the introduction between my computer and yours, our web browsers take over and stream our video directly to each other.

What really excited me is that he put this together in only four evenings’ worth of work!

It is just a proof-of-concept, and will likely take more work to develop into a production-level product if Felipe chooses to do that, but it opened my eyes to how quickly a developer can put together a fully P2P application.

Here’s Felipe’s feedback on the development process:

80% of the time was in the frontend, the holochain part was pretty easy with a bunch of examples you guys sent me

everything took 4 nights of work

yeah, holochain is absurdly easy to play

And finally, here’s a demo video showing Felipe meeting with himself over a local network :)

Wednesday Workshop: Gluing modules together

This week’s workshop demonstrated the advantage of the modularity philosophy that many hApp devs have embraced. Participants (members of the DEV.HC Discord community) created a ‘posts’ hApp, composed almost completely of existing modules from the holochain-open-dev GitHub org.

The UI is pretty basic, but that’s not the point. The point is, they rebuilt Medium on Holochain in less than an hour and a half! That’s the power of modularity for you.

Modularity lets you get started faster on the thing you actually want to build, because you can reuse other people’s code to get you the functionality that isn’t unique to your application. And third-party libraries are often more robust, better maintained, and less buggy, thanks to the contributions of many developers.

From what I’ve seen of the community-created reusable zome modules, they only provide the bare minimum of functionality. This is good, because they don’t make assumptions about how you want to do things. The threaded-comments module, for instance, doesn’t specify that your app’s comments need to be in plain text or HTML or Markdown. For all it cares, your comments could be photos or music! It just defines the data schema that lets you link things together.

I see a lot of Holochain-based initiatives embracing modularity:

• Neighbourhoods is entirely based around a marketplace of small, generic modules that community activators can glue together into an application that fits their community’s specific culture.
• AD4M is a technology-agnostic framework and approach to software design, letting you glue individual languages together into a view on the world that suits you best. (In AD4M-speak, a ‘language’ is the capacity to express things in a certain way with a certain technology — for instance, messages-via-Holochain, transactions-via-Ethereum, photos-via-IPFS, tweets-via-Twitter.)
• Flux, as one of the first AD4M-based apps, demonstrates the power of modularity for serving communities of end-users. (Read more about Flux below!)

Flux update: pivoting to community tools

This morning I found an update from Eric, one of the co-founders of Flux (formerly Junto). I mentioned Flux last month, and for those of you with keen eyes who were part of the Junto alpha testing a few years ago, you’ll notice that the new Flux looks nothing like the old Junto.

This is because the Flux team gained a key insight from the alpha programme: most people didn’t want yet another global social space; they wanted digital tools to support the building of strong, vibrant, healthy communities.

This reminds me of the idea of ‘membranes’ that we often talk about at Holochain — that organisms of any sort (biological, social, etc) need distinct membranes to keep themselves from disintegrating. For a social organism, that could look like community rules or membership-by-invitation. Fortunately Holochain understands that concept at the basic level; your hApp can include a ‘membrane proof’ validation rule that verifies that a person has the right credentials (e.g., that they’ve read and agree to the rules, or that a verified member has invited them).

Currently the Flux app supports three different types of ‘channel’ for your community: messaging, knowledge base (AKA wiki), and long-form (AKA blogging). I’m quite impressed; it already feels like a ‘community in a box’ that supports all sorts of different ways of expressing things. And they appear to have even more channel types planned for the future, along with the ability to support community-created channel types.

So check out Eric’s most recent update. It tells the story of how they got to where they are now, why they made the decision to change course, and where they’re heading now. I found it quite an interesting story.

And of course you can try Flux for yourself! It's purely peer-to-peer now, with a back-end built entirely on Holochain using the AD4M framework. (macOS and Linux only; Windows support coming soon.) If you don’t have a community to try it with, you can join the public testing community with the link neighbourhood://QmXfPUjgF3NCxGYp7SvFueVPSavLWe3DdaS3sw314mBSUU

Call for feedback on Holochain terms

Over the years, lots of developers have taken an interest in Holochain. As they’ve started reading our literature, they’ve had one of two reactions: either “why are they using all this weird biological language; this is confusing” or “these biological metaphors are helping me understand it better”.

Both reactions are valid. The problem is, we don’t know which reaction is more common. And we rarely hear from the developers who were turned off because they found our language inaccessible.

So we’ve put together a small survey to help us gauge whether our language is generally helpful or harmful. If you’re a developer, CTO, or product designer, we’d love you to take this very short survey. I’m especially interested in feedback from those who didn’t stick around — if you know someone in tech who looked into Holochain and decided against it, reach out to them and ask them to take this survey. Thanks!

Take the survey

DWeb webinar on decentralised identity and data privacy

This Thursday DWeb, the Internet Archive, the NY Library Council, and Library Futures are hosting another webinar. The topic of this one is ‘How decentralised identity drives data privacy’. It will feature two speakers who are veterans in the decentralised identity and sovereign data fields, Kaliya Young (AKA Identity Woman) and Joachim Lohkamp of Jolocom.

While Holochain isn’t directly involved with any of these people and organisations, many of us team members are acquainted with them and our vision aligns very closely with theirs. If you’re a hApp developer, you’re likely already thinking about privacy and data sovereignty, so I’m sure this workshop will be relevant. Both Kaliya and Joachim a lot of insight and experience with them, so it should be both thought-provoking and practical.

I should also mention a couple papers on Holochain and privacy that I co-wrote with professors Kirsten Wahlstrom, Anwaar Ul-Haq, Oliver Burmeister, and Anisha Fernando. If you want the tl;dr, here’s a tweet thread summarising the second paper, and a video presentation for the first paper.

That’s it for this week. Stay tuned for more developer-tempting goodies, and share the above hacking success stories with your developer friends!