Closures, Objects, Actors, and Picos
I've been intrigued by closures since I taught introductory computer science from SICP at UC Davis in 1988. This post dives into a little programming language theory to trace a line from closures to objects to actors to picos, showing what each step adds. A pico is a closure that has been made to answer for itself in the world, with persistent state, a durable identity, and relationships it can carry when it moves.
Continue reading {Closures, Objects, Actors, and Picos}
Moving Picos from Mesh to Mesh
Software that can’t leave the machine it was born on isn’t really yours. Version 1.7 of the pico engine lets a pico and its subtree move between engines while its relationships keep working, because other picos follow its DID rather than its address. This post describes what moves, why identity is what makes it possible, and what’s still ahead.
Continue reading {Moving Picos from Mesh to Mesh}
Moving My Sensor Network onto Manifold
I moved my working LoRaWAN sensor network onto the new Manifold framework and pointed Home Assistant at it as the interface. The port went smoothly until the OAuth protection on the mesh blocked the inbound webhooks Helium uses to deliver readings. The fix was to let a mesh owner scope access channel by channel, and the pico engine now supports it.
Continue reading {Moving My Sensor Network onto Manifold}
Why Not SPIFFE for Pico Identity?
A pico is arguably just a workload, so why give it a DID instead of using SPIFFE, the standard workload identifier? The answer comes down to whether the identity is meant to last. SPIFFE derives a workload's identity from what it is and where it runs, so it's re-minted per environment; a pico's identity is long-lived and travels with it.
Continue reading {Why Not SPIFFE for Pico Identity?}
Pico-to-Pico Identity Arrives
Version 1.6 of the Pico Engine ships the pico-to-pico identity layer I promised but hadn't built. Every pico now carries two DIDs: a portable did:webvh that says who it is, and a private did:peer for each relationship it forms. This is the piece that lets a pico move between engines and lets two meshes create a relationship without a federation agreement set up in advance.
Continue reading {Pico-to-Pico Identity Arrives}
A Map of the Manifold Environment
A reader asked for a map of the whole Manifold environment and the functional capabilities of each part. I have described this system across three posts, a piece at a time, but never in one picture.
Continue reading {A Map of the Manifold Environment}
Using Home Assistant with Manifold
Manifold is evolving into a proper framework for building meshes of picos, and Home Assistant gives those meshes an interface. A new Home Assistant integration proves out three pieces at once: an OAuth workflow on the pico-engine that lets outside software into the mesh on the owner's terms, a mature interface rather than a custom one, and a pattern that lets specialized communities extend the platform.
Continue reading {Using Home Assistant with Manifold}
Identity for the Pico Engine
Version 1.5 of the Pico Engine finally brings identity into the engine itself: passkeys for humans, and OAuth for external apps and webhooks. Here's the shape of the design, why identity is really three problems and not one, and why I shipped the human and third-party layers before the pico-to-pico layer.
Continue reading {Identity for the Pico Engine}
Manifold API and Sensor Network: Two New Repos
Cleaning up manifold-api as a prerequisite for the spring conversational interface Capstone turned into a complete platform update: Pico Engine 1.0 compatibility, automated bootstrap, centralized notifications, and a Docker-based integration test harness. Once the platform was solid, the old temperature-network had an obvious new home inside Manifold's community framework, so I rewrote it too as an example of how Manifold can be a framework for pico networks.
Continue reading {Manifold API and Sensor Network: Two New Repos}
AI Integration in Picos Starts with Events
Picos already have persistent identity, owned state, and an event-driven architecture—exactly the properties that make a good substrate for AI agents. The integration path starts with a simple webhook and leads somewhere much more interesting: a world where AI works for you, reasoning over data that is stored in your picos rather than on someone else’s platform.
Continue reading {AI Integration in Picos Starts with Events}
Building a Conversational Interface for Manifold with MCP and Picos
GUIs are dead—at least for most user experiences. This post describes a BYU capstone project where five seniors built a conversational interface for Manifold using MCP and picos. The result shows how natural language can replace a GUI entirely, letting users create, tag, and manage digital things through dialogue instead of learning a standard graphical user interface.
Continue reading {Building a Conversational Interface for Manifold with MCP and Picos}
Components for Web Apps
XMLUI brings a fresh, declarative approach to building web interfaces using native, composable components—no heavy frameworks required. It's a promising path toward giving Picos the ability to serve their own UIs again, natively and autonomously.
Continue reading {Components for Web Apps}
dApps Are About Control, Not Blockchains
Decentralized applications, where the identity and application data are both controlled by the person using the app, provide the means of disintermediting companies who leverage their privileged position to work for their own interests and against ours.
Continue reading {dApps Are About Control, Not Blockchains}
Cloudless: Computing at the Edge
New use cases will naturally drive more computing away from centralized cloud platforms to the edge. The future is cloudless.
Continue reading {Cloudless: Computing at the Edge}
Rule-Based Programming and the Internet of Things
Rule-based, actor model systems are a great match for IoT workloads.
Continue reading {Rule-Based Programming and the Internet of Things}
Monitoring Temperatures in a Remote Pump House Using LoraWAN
If you've got a sensor that isn't within range of wifi, then LoraWAN is a good solution. And event-based rules in picos are a convenient way to process the data.
Continue reading {Monitoring Temperatures in a Remote Pump House Using LoraWAN}
The Most Inventive Thing I've Done
I was recently asked to respond in writing to the prompt "What is the most inventive or innovative thing you've done?" I decided to write about picos.
Continue reading {The Most Inventive Thing I've Done}
We Need a Self-Sovereign Model for IoT
The Internet of Things is more like the CompuServe of Things. We need a new, self-sovereign model to protect us from proprietary solutions and unlock IoT's real potential.
Continue reading {We Need a Self-Sovereign Model for IoT}
Easier IoT Deployments with LoraWan and Helium
Connectivity requirements add lots of friction to large-scale IoT deployments. LoRaWAN, and the Helium network, just might be a good, universal solution.
Continue reading {Easier IoT Deployments with LoraWan and Helium}
Picos at the Edge
The future of computing is moving from the cloud to the edge. How can we create a decentralized, general-purpose computing mesh? Picos provide a model for exploration.
Continue reading {Picos at the Edge}
NFTs, Verifiable Credentials, and Picos
The hype over NFTs and collectibles is blinding us to their true usefulness as trustworthy persistent data objects. How do they sit in the landscape with verifiable credentials and picos?
Continue reading {NFTs, Verifiable Credentials, and Picos}
Smart Property
Smart property is much more than the anemic connected things we have now. Smart property imagines a world where every thing participates in digital communities and ecosystems, working through programmable agents under the owners control.
Continue reading {Smart Property}
Ten Reasons to Use Picos for Your Next Decentralized Programming Project
Picos are a programming model for building decentralized applications that provide significant benefits in the form of abstractions that reduce programmer effort. Here are ten eleven reasons you should use picos for your next decentralized application.
Continue reading {Ten Reasons to Use Picos for Your Next Decentralized Programming Project}
Alternatives to the CompuServe of Things
The current model for connected things puts manufacturers inbetween people and their things. That model negatively affects personal freedom, privacy, and society. Alternate models can provide the same benefits of connected devices without the societal and personal costs.
Continue reading {Alternatives to the CompuServe of Things}
Building Decentralized Applications with Pico Networks
Picos make building decentralized applications easy. This blog post shows a heterarchical sensor network can built using picos.
Continue reading {Building Decentralized Applications with Pico Networks}
Persistence, Programming, and Picos
Picos show that image-based development can be done in a manner consistent with the best practices we use today without losing the important benefits it brings.
Continue reading {Persistence, Programming, and Picos}
Announcing Pico Engine 1.0
I'm excited to announce a new, stable, production-ready pico engine. The latest release of the Pico Engine (1.X) provides a more modular design that better supports future enhancements and allows picos to be less dependent on a specific engine for operation.
Continue reading {Announcing Pico Engine 1.0}
Relationships in the Self-Sovereign Internet of Things
DIDComm-capable agents provide a flexible infrastructure for numerous internet of things use cases. This post looks at Alice and her digital relationship with her F-150 truck. She and the truck have relationships and interactions with the people and institutions she engages as she co-owns, lends and sells it. These and other complicated workflows are all supported by a standards-based, open-source, protocol-supporting system for secure, privacy-preserving messaging.
Continue reading {Relationships in the Self-Sovereign Internet of Things}
The Self-Sovereign Internet of Things
Self-sovereign identity offers much more than just better ways to log in. The identity metasystem is really a sophisticated messaging system that is trustworthy, secure, and extensible. While decentralized identifiers and verifiable credentials have much to offer the Internet of Things (IoT), the secure messaging subsystem promises an IoT that goes well beyond those initial scenarios. This post gives and introduction to SSI and IoT. The follow-on post goes deeper into what a true Internet of Things founded on SSI can provide.
Continue reading {The Self-Sovereign Internet of Things}
Self-Sovereign Identity at IIW: We Have Liftoff
Last week was the 28th semi-annual Internet Identity Workshop (IIW). There were 129 session conducted by people from all over the world and about many different aspects of identity. There were technical discussions, standards works, policy debates, and lots of demonstrations. I'll post a link to the Book of Proceedings when it's available so you can read about them yourself.1 One thing that stood out to me is the impact self-sovereign identity is having. There were several dozen sessions on SSI. I was excited to see seven different implementations of Indy Agents that were working together and combined to
Continue reading {Self-Sovereign Identity at IIW: We Have Liftoff}
Secure Pico Channels with DIDs
Decentralized identifiers are a perfect complement to the event channels in picos and provide the means of performing secure messaging between picos with little effort on the developer's part.
Continue reading {Secure Pico Channels with DIDs}
The 10-Year Platform: Shutting Down KRE
The original pico engine, KRE, is no more. But the ideas and capabilities of the platform live on in the new pico engine.
Continue reading {The 10-Year Platform: Shutting Down KRE}
A Mesh for Picos
This post describes some changes we're making to the pico engine to better support a decentralized mesh for running picos.
Continue reading {A Mesh for Picos}
Correlation Identifiers
Correlation identifiers are one of the ideas we talk about in my Distributed Systems class during the Reactive Programming module.
Continue reading {Correlation Identifiers}
Updated Pico Programming Workflow
This page introduces the tool chain in the programming workflow for picos.
Continue reading {Updated Pico Programming Workflow}
Pico Programming Lesson: Modules and External APIs
A new pico lesson is available that shows how to use user-defined actions in modules to wrap an API.
Continue reading {Pico Programming Lesson: Modules and External APIs}
The New Pico Engine Is Ready for Use
The new pico engine is nearly feature complete and being used in a wide variety of settings. I'm declaring it ready for use.
Continue reading {The New Pico Engine Is Ready for Use}
Using Picos for BYU's Priority Registration
Picos are a natural way to build microservices. This post presents the results of an experiment we ran to see how the new Pico Engine performs when placed under surge loading that simulates BYU's priority registration.
Continue reading {Using Picos for BYU's Priority Registration}
Sovrin Use Cases: Portable Picos
This article describes a method for using the Sovrin distributed identity ledger to lookup picos by name rather than location. This allows picos to be portable between hosting engines without loss of functionality.
Continue reading {Sovrin Use Cases: Portable Picos}
Pico Labs at Open West
We've built a mockup of a computer closet with temperature sensors and fans to demonstrate how pico structures can be used in the Internet of Things and to experiment with Wrangler, our pico operating system.
Continue reading {Pico Labs at Open West}
A System Ruleset for the Pico Engine
I made a small change to the pico engine recently that has big implications for how we monitor, control, and configure it.
Continue reading {A System Ruleset for the Pico Engine}
Fitbit as Gizmo
The networked devices you purchase aren't products as we've historically understood that term. You're not buying the device, you're buying the service. Fitbit is just a interface to a networked service. Without the service, the device is good for nothing.
Continue reading {Fitbit as Gizmo}
A Pico-Based Platform for ESProto Sensors
Spimes are a wonderful intellectual framework for thinking about the Internet of Things. This blog post shows how spimes can be created using picos and then applied to a sensor platform called ESProto.
Continue reading {A Pico-Based Platform for ESProto Sensors}
Reactive Programming Patterns: Examples from Fuse
Reactive programming requires new programming techniques and methods. This post describes common patterns in asynchronous reactive programming and gives examples from the open-source code base for the Fuse connected car platform. While the examples below are based on the pico platform, they are equally applicable to other Actor-based reactive programming platforms like Akka.
Continue reading {Reactive Programming Patterns: Examples from Fuse}
Rebuilding KRL
I'm reimplmenting KRE, the evaluation engine that makes picos work. Here's the initial plan and a call for (paid) help.
Continue reading {Rebuilding KRL}
Evaluating KRL Declarations
Here's a little project that makes testing KRL expressions easier.
Continue reading {Evaluating KRL Declarations}
Promises and Communities of Things
Promise theory provides a tool for thinking about and structuring the code that implements communities in groups of social things. This blog post discusses some initial thinking about promises and picos.
Continue reading {Promises and Communities of Things}
Reactive Programming with Picos
This is an introduction to picos as a method for doing reactive programming. The article contains many links to other, more detailed articles about specific topics. You can thus consider this an index to a detailed look at how picos work and how they can be programmed.
Continue reading {Reactive Programming with Picos}
Using the Scatter-Gather Pattern to Asynchronously Create Fuse Reports
This post describes how I used the scatter-gather pattern to move from a synchronous process for generating fleet reports to an asynchronous solution, avoiding some failures that were caused by load and short HTTP timeout values. The result is a system that is more reliable and scalable than the previous, request-based synchronous solution.
Continue reading {Using the Scatter-Gather Pattern to Asynchronously Create Fuse Reports}
Asynchronous Boundaries and Back Pressure
Non-blocking back pressume is a useful way to avoid common problems at the asynchronous boundary between autonomous agents.
Continue reading {Asynchronous Boundaries and Back Pressure}
Culture and Trustworthy Spaces
Culture is an important component of self-organizing systems. In this post, I explore this concept as it relates to the Society of Things I described earlier.
Continue reading {Culture and Trustworthy Spaces}
Social Things, Trustworthy Spaces, and the Internet of Things
Social things interacting in trustworthy spaces represent a model for an Internet of Things that is scalable to trillions of devices and still works. This post describes that concept and proposes picos as a platform for building social things.
Continue reading {Social Things, Trustworthy Spaces, and the Internet of Things}
Errors and Error Handling in KRL
A small tutorial on how KRL developers can use error events to monitor applications and find problems.
Continue reading {Errors and Error Handling in KRL}
Picos: Persistent Compute Objects
This brief introduction to picos and the components that make up the pico ecosystem is designed to make clear the high-level concepts necessary for understanding picos and how they are programmed.
Continue reading {Picos: Persistent Compute Objects}
New in Fuse: Notifications
Fuse now supports email and SMS notifications of vehicle alerts including low fuel, low battery, diagnostic trouble codes, and device connectivity.
Continue reading {New in Fuse: Notifications}
What's New With KRL
In The End of Kynetx and a New Beginning, I described the shutdown of Kynetx and said that the code supporting KRL has been assigned to a thing I created called Pico Labs. Here’s a little more color.
Continue reading {What's New With KRL}
The End of Kynetx and a New Beginning
Last week, the Kynetx shareholders, on recommendation from the Board of Directors, voted to dissolve Kynetx. This article is about what comes next. The short answer is a new birth.
Continue reading {The End of Kynetx and a New Beginning}
Fuse as an Experiment in Internet of Things Architectures
O'Reilly Media is hosting a Software Architecture Conference March 17-19 in Boston. This blog post is my proposal.
Continue reading {Fuse as an Experiment in Internet of Things Architectures}
Fuse with Two Owners
I recently did an experiment with supporting multiple owners in Fuse. This post describes how the introduction process works between the current and prospective owners and discusses some design principles that I learned about using subscriptions.
Continue reading {Fuse with Two Owners}
Events, Picos, and Microservices
I spoke at Apistrat 2014 today in Chicago on the Fuse architecture and API. Here are my slides.
Continue reading {Events, Picos, and Microservices}
Fuse as a Microservice Architecture
Microservices provide a powerful pattern for programming picos with KRL. This post describes microservices and shows how we can view rules within the Fuse system as microservices for a vehicle. We give a detailed, technical example of microservice interaction within Fuse and of a specific rule.
Continue reading {Fuse as a Microservice Architecture}
Fuse as a Model of the Vehicle Ecosystem
Fuse has been designed from the ground up to support relationships between the car and everything else in the vehicle ecosystem.
Continue reading {Fuse as a Model of the Vehicle Ecosystem}
Pico Event Evaluation Cycle
Events are processed in KRE using an event loop that decodes the event, makes a schedule, evaluates the respond, and finally assembles a response. This post describes the details of the event evaluation cycle in KRE and how explicit events affect rule schedules.
Continue reading {Pico Event Evaluation Cycle}
Complex Pico Structures: Guard Tours
We've recently been working on a large project that we architected using picos, CloudOS, and the Personal Cloud Application Architecture. I'm pleased with how this turned out and the lessons that we learned.
Continue reading {Complex Pico Structures: Guard Tours}
Test-Driven Development and KRL
We've recently released some initial tools to support test-driven development in KRL. This is a great first step toward a more mature development process for CloudOS.
Continue reading {Test-Driven Development and KRL}
Pico APIs: Events and Queries
A pico's API is not RESTful, rather it follows a pattern we might call Event-Query. KRL provides clear distinction in code for handling events and queries in a segregated manner. This has important implications for developers building picos and designing applications that use them.
Continue reading {Pico APIs: Events and Queries}
Persistent Compute Objects and the Fabric of Cyberspace
Persistent Computer Objects, or picos, give rise to a new way to build internet-based applications to separates app and user data. Users control their own picos and thus the data and processing on them. This presentation describes what picos are, the new programming model they support, and shows Fuse, a sample application built using this new model.
Continue reading {Persistent Compute Objects and the Fabric of Cyberspace}
Fundamental Features of Persistent Compute Objects
Persistent compute objects, or picos, are powerful, general-purpose, online computers that can be used to model people, places, organizations, and concepts. This blog post describes the fundamental features of picos.
Continue reading {Fundamental Features of Persistent Compute Objects}
Sharing in SquareTag: Borrowing my Truck
The introduction pattern allows one cloud to introduce two clouds to each other. This is useful for sharing and delegating and forms the basis for social products in SquareTag.
Continue reading {Sharing in SquareTag: Borrowing my Truck}
CloudOS Services
I took the time recently to update our description of CloudOS services. This is the core of the Kynetx personal cloud platform.
Continue reading {CloudOS Services}
Printing Planetary Gears
3D printing is going to change the way we make, distribute, and use physical goods. This video shows it's not just about glasses. Complex mechanical systems can be printed at will from a design file.
Continue reading {Printing Planetary Gears}
Imagining Trillion Node Networks
The video and slides from my keynote address at OpenWest on May 2, 2013
Continue reading {Imagining Trillion Node Networks}
Pot Holes and Picos
You might not think of a pot hole being part of the Internet of Things, but it should be. Once we start imagining everything being connected, we start to see a world that is vastly different than the one we now know.
Continue reading {Pot Holes and Picos}
Explore Technometria
Popular Topics
- Actor Model
- Agentic AI
- Authentication
- Authorization
- Blogging
- Decentralization
- Event Programming
- Identity
- IIW
- Internet of Things
- IT Conversations
- Javascript
- KRL
- Kynetx
- Picos
- Programming
- Programming Languages
- Reactive Programming
- Reputation
- Sovrin
- Startups
You Might Also Enjoy
- Self-Sovereign Identity References
- Best Food Blog on the Planet
- Live Web Whitepapers
- My Slides
- My Videos
- CTO Breakfast
- Essays
- CIO Whitepapers
My Books
