In Canada, where I live, spring is coming to an end and summer is getting started. I love this time of year; the progression of flowers bursting like a well-funded fireworks show, the lettuce unfolding and gracing the dinner table every evening, the strawberries that are not quite ripe enough but you stuff your face with them anyway.

I see the Holochain developer ecosystem going through a similar flush of growth. I’ll be honest: we’re still young and small, but that means the developers generally know each other and support each other well, and we’re able to support them well too. This seems to be creating a lot of vitality, sort of like those two small garden boxes in your backyard that thrive because they’re just enough for you to take care of.

Here are a few things that have caught my eye lately. If you’re a developer, I bet you’ll find them useful.

Holochain Gym: exercise those hApp dev muscles

The Holochain Gym is a wonderful set of exercises that take you through the basics of Holochain. There are three sections:

There are two sections:

• Concepts gives you a grounding in the fundamentals of Holochain. I love the interactive visualisations using Guillem Córdoba’s Holochain Playground simulator; they turn very abstract concepts into things you can see and touch. I especially love the one that shows how Holochain handles the dreaded 51% attack (or worse) without miners or consensus.
• Developers introduces you to the building blocks of hApp development — data structures, host API calls, built-in patterns. There are code-along exercises that give you experience writing DNA code.

This project is a collaboration between a few active community members, and it’s still in its early stages. If you’re already familiar with hApp development and would like to contribute, I’m sure they’d be super grateful.

Holochain Open Dev: libraries for use in your own hApps

I’ve reported on the Holochain Open Dev GitHub org since the Holochain Redux days. Now with a rapidly maturing Holochain RSM and a bunch of hApps being built, it’s gaining new modules while the existing ones are getting refactored. Here are a few ones that looked interesting:

• https://github.com/holochain-open-dev/profiles lets users choose a nickname (AKA screen name, username, or handle) and save profile information as key/value pairs. It also comes with a sample UI to show you how to use it on the front end. The interesting thing about this module is that nicknames are not exclusive — just like in real life, it’s perfectly okay for two people to have the nickname stina_nilsson if that’s what their name actually is. This demonstrates the beauty and weirdness of an agent-centric, consensus-free system.
• https://github.com/holochain-open-dev/contacts, from the Kizuna team, lets users store lists of friends (contact list) and enemies (block list), as in a social media or communication app. I didn’t see any documentation, but the module’s API looks pretty self-documenting.
• https://github.com/holochain-open-dev/holochain-time-index, from the Perspect3vism and Junto teams (more on them below), is one solution for retrieving data by time range. This is good for social media, blogs, financial records, and other time-based data. It also eliminates DHT hotspots that would normally come from putting a zillion links on one anchor. This repo is exquisitely documented and gives rationales for the design.
• https://github.com/holochain-open-dev/calendar-events implements a basic calendar. This looks like it would be great for shared personal calendars, events, or resource booking. As with profiles, it includes a sample UI.
• https://github.com/holochain-open-dev/file-storage is a generic blob-storage module. It ‘chunks’ files behind the scenes — this prevents DHT hot spots (imagine some poor peer with a 32GB smartphone having to store your hour-long holiday video in their DHT shard) but also may make it possible to implement streaming videos. (And besides, there’s a 16MB limit on DHT entries anyway.)
• https://github.com/holochain-open-dev/reusable-module-template is just what it sounds like — a template that lets you scaffold modules that you want other developers to use.

Holochain In Action: a community of co-learning

I’ve been following the work of the Holochain in Action group for a little while, and I’m excited about what they’re doing. This group meets every Tuesday to learn, teach, share, and develop together. There’s a big focus on exploring and implementing design patterns that are appropriate for Holochain, which I think is important work.

If you’re a developer and want to get involved, jump to the forum and fill out the application form. You can also watch their past videos on YouTube — looks like there are a lot of good presentations.

Finally, you can check out the app they’re working on, called Peer Share, which lets people share content of all sorts with each other. They’re using it to explore various patterns, including an interesting one called the JSON-Schema pattern. Instead of having to define entry types at compile time, DHT administrators can create new types on the fly using the JSON-Schema vocabulary to validate content that’s supposed to conform to those types.

Ad4m and Perspect3vism: a unique take on application development

I find this a very intriguing project. I’m still wrapping my head around it; it feels like it could have profound implications for the way we construct our online experiences. And when I say that, I mean users, not developers. It appears to be an agent-centric approach to building an online life, consisting of ‘languages’ (ways of expressing oneself, such as a tweet, a to-do list, or a chess move) and ‘perspectives’ (spaces in which one wants to participate) that a person can combine in ways that suit them best.

The architectural approach reminds me of Holoscape, and the vocabulary reminds me of the Junto social app, which shouldn’t be surprising: it’s a collaboration between Holo team member Nicolas Luck and Junto lead developer Josh Parkin.

Holo-REA: a toolkit for cooperative economics

I get pretty passionate about non-coercive, appropriately sized, regenerative economies. It’s possibly the biggest reason I got involved with Holochain — because I saw that it had the potential to be a platform for these sorts of initiatives.

So I’m thrilled that Holo-REA is nearing maturity. Holo-REA is a toolkit for economic applications, particularly ones in which the players do their accounting out in the open (though it doesn’t exclude a bit of privacy either). The folks behind Holo-REA are building it to support a big vision of true-cost accounting, or considering all the costs of producing a good or delivering a service. This is something the current economic system isn’t great at.

Holo-REA implements a business ontology called ValueFlows. It looks complicated, but it’s really just a formalisation of things that people do all the time. This gives me hope that Holo-REA, and the applications that’ll be built on it,

You can find the source code for Holo-REA, along with lots of good literature on the why and how of the project, at https://github.com/holo-rea/holo-rea . Lots of people who are building on Holochain are already getting excited about it and planning to use it in their own projects.

Dev Camp postponed until September; lots of opportunities before then

The response to the next community-run dev camp has been overwhelmingly positive — and overwhelming!

More than 700 people have registered, which has resulted in the organisers changing their plans.

It’s moving from June to September, and they’ll be working with us at Holo to provide more learning opportunities — both during and before.

You can still register, and the organisers will send you updates by email so you know what’s going on.

The theme of the Dev Camp sounds really cool:

During DevCamp 8 we’re going to be building a multiplayer game: “Tragedy of the Holocommons”

We will bring every economist’s favorite game to life as a Holochain app! The heart of this game is a demonstration of consensus-seeking in an eventually consistent environment - a crucial part of building any decentralized application!

Of course, we’ll also cover all the other essential building blocks of a Holochain application, with little adjustments to make it more fun and cool!

Reaching agreement without relying on global consensus is a challenging thing to understand, but it’s at the core of what makes Holochain Holochain. This will be a great opportunity to understand more about that in a hands-on way.

Register for the Dev Camp today! And if you have any programmer friends who are disenchanted with blockchain, share it with them too. Maybe they’re ready for something fresh and new.

Can we have some updates on Holochain and Holo too?

Of course! Here are some of the most recent updates:

• Holochain has been having some serious performance issues in stress-testing, and it looks like it’s caused by a memory leak in Wasmer, the virtual machine that runs hApp DNAs. The Wasmer team have been great at tracking down the bug and sharing workarounds, and we expect that they’ll fix the bug soon as well.
• DHT sharding is in active development. There’s been a lot of work to make gossip efficient in a DHT that includes lots of multi-user machines, as well as the previous work of moving the storage backend from LMDB to SQLite which made performant gossip possible in the first place.
• Both dev teams are focusing on improving performance everywhere. Some of these improvements (like batching database writes) will stick around, while others will become obsolete once DHTs can be sharded.
• There’s a new standalone bootstrap server that doesn’t require you to use Holo’s or deploy your own on CloudFlare. This was created for testing, but it could be useful for applications that want to run their own infrastructure. Note that it doesn’t persist any peer information on restart; it’s all in-memory. (If you’re not familiar with the bootstrap server, it makes introductions between peers so they can start communicating with each other.)
• The Holochain dev team is getting ready for the second public release of Holochain RSM, which will include all the changes since the first release in February. Many developers have been tracking the changes in the develop branch; this will support developers who prefer something a bit more stable, as well as ones who prefer not to work in Holonix.
• BREAKING CHANGE: all the DHT retrieval functions are disabled in validation callbacks except three new ones: must_get_entry, must_get_header, and must_get_valid_element. This serves two purposes: first, validation functions should always be deterministic, and this removes the DHT as a source of non-determinism; and second, it removes a lot of boilerplate because you don’t have to manually handle all the different error types when a piece of DHT data can’t be retrieved. All you need to do is use ? at the end of your DHT retrieval function, and the validation will automatically return the right sort of error to the host. Note: this change is not in develop and won’t be until after the next version of Holochain is released.
• The Holo team has been working on dev-ops infrastructure that makes it easy for them to switch their HoloPorts to testing channels and back. This is because Holochain development is progressing rapidly and they need to be able to reliably reproduce environments to test apps against different commits. This won’t matter much to you, dear reader, except that it’ll speed up testing and get us to the next alpha milestone a bit sooner!

Cover photo by Sven Brandsma on Unsplash