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}
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}
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}
Updated Pico Programming Workflow
This page introduces the tool chain in the programming workflow for picos.
Continue reading {Updated Pico Programming Workflow}
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}
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}
We're Teaching Programming Wrong
Event-based programming is more natural for non-programmers than imperative or object-oriented styles.
Continue reading {We're Teaching Programming Wrong}
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}
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}
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}
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}
Rethinking Ruleset Registration in KRL
A ruleset registry has been part of KRL from the start. This proposal would deprecate ruleset registries in favor of simply using URLs.
Continue reading {Rethinking Ruleset Registration in KRL}
Fuse, Kynetx, and Carvoyant
Shon Shah asked about the relationship between Fuse, Kynetx, and Carvoyant on the Fuse Forum. This blog post answers his questions.
Continue reading {Fuse, Kynetx, and Carvoyant}
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}
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}
Extending and Using Fuse
Fuse is the most open, extensible connected-car system available. Extensibility is the key to Fuse giving people better control over their data, being interoperable with a wide variety of services and things, and being able to adapt to future changes.
Continue reading {Extending and Using Fuse}
A Microservice for Healing Subscriptions
Here is a quick little microservice I wrote as a KRL rule to ensure that the vehicle has all the subscriptions it needs and fix them if need be. The simplicity illstrates why a microservices approach holds such promise for more loosely coupled systems.
Continue reading {A Microservice for Healing Subscriptions}
Idempotent Services and Guard Rules
The guard rule pattern provides a way to ensure services are idempotent even when their actions aren't. This post shows how to use guard rules in KRL.
Continue reading {Idempotent Services and Guard Rules}
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}
Automatically Run the KRL Parser When You Commit Code
Running the command line KRL parser is a pain. Better to have a Git hook do it for you.
Continue reading {Automatically Run the KRL Parser When You Commit Code}
Substitutability is an Indispensable Property for the Internet of Things
Substitutability is a key feature of decentralized systems that give people real choice and build trust. The coming Internet of Things will be limited in what it can provide without it.
Continue reading {Substitutability is an Indispensable Property for the Internet of Things}
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}
Using jQuery Mobile and Backbone
I've updated a jQuery Mobile and Backbone.js tutorial I found online to use the latest versions of jQuery Mobile and Backbone.js.
Continue reading {Using jQuery Mobile and Backbone}
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}
Ed Orcutt 1961-2013
Ed Orcutt died on Monday morning of a long illness. Anyone who's come to a Free Lunch Friday or visited Kynetx knows Ed. Anyone who's used a Kynetx product in the last 3 years knows him, at least through his work. Ed was a great friend and an exceptional programmer. We're going to miss him very much. Ed was my principal collaborator and the primary developer of CloudOS, the software layer that powers SquareTag, Fuse, and many other projects and products we've built. Ed designed and programmed the Intentcasting demonstration we built for Swift. He developed the DnB 360
Continue reading {Ed Orcutt 1961-2013}
My Truck Turns On My Office Lights!
I've connected by Fuse device to my office by means of a simple rule. Now my office turns on whenever I pull into the parking lot. This post describes how.
Continue reading {My Truck Turns On My Office Lights! }
Languages Have Power
Programming language choice matters. Languages have the power to push us out of familiar ways of working and into new ways of thinking. But using a language out of the mainstream takes real courage.
Continue reading {Languages Have Power}
Standards, Monopolies, and the Quantified Self
As APIs proliferate, the opportunities for reuse don't multiply nearly as fast because their semantics don't neatly align. Standards could solve this problem, but they're too hard to be practical. We need another way. XDI is aiming to solve this problem in the long term. Rules are a practical answer to this problem today.
Continue reading {Standards, Monopolies, and the Quantified Self}
Updated CloudOS Roadmap
Over the past year we've made substantial progress on building out CloudOS and the underlying engine that makes it run. This post acknowledges that progress as well as laying out future steps we must take.
Continue reading {Updated CloudOS Roadmap}
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}
Facebook for My Stuff
SquareTag is a social product platform. Social products have relationships with owners, manufacturers, and others. Social products promise to make things more useful and reduce the total cost of ownership.
Continue reading {Facebook for My Stuff}
Using Dropbox and OAuth 1.0a in KRL
Here's a recipe for accessing Dropbox and using OAuth 1.0a in KRL.
Continue reading {Using Dropbox and OAuth 1.0a in KRL}
CloudOS Will Be Open Source
Today we're happy to announce that CloudOS will be open source as well. There are still some things we need to get right in the source before we release it (small things like redacting keys). When we do it will be under the GPL license.
Continue reading {CloudOS Will Be Open Source}
Introducing Forever and Personal Cloud Application Architectures
Personal clouds give rise to a brand new application architecture that gives people more control over their data and breaks down data silos to provide greater network effects. We've built an evergreen contact application called Forever that demonstrates this new architecture to developers and provides people with an online contact database that is never stale.
Continue reading {Introducing Forever and Personal Cloud Application Architectures}
Personal Clouds and the Future of the Web
A decentralized, protocol-mediated cloud infrastructure is the best way to create a future Internet that maximizes personal control and individual freedom.
Continue reading {Personal Clouds and the Future of the Web}
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}
Raising Events Asynchronously
Adding the ability to process events asynchronously has huge benefits for performance in an event processing system. With a small change to the code, we've enabled asynchronous events and made the event engine more performant in important situations.
Continue reading {Raising Events Asynchronously}
An API for My Lights
By building an API for my lights, I can hide the implementation details of the various connected lighting systems I own and make the job of controlling them—programming them—easier.
Continue reading {An API for My Lights}
Writing a SquareTag Application
SquareTag is more than a lost and found service because SquareTag is a development platform. You can make SquareTag do anything you want.
Continue reading {Writing a SquareTag Application}
My Conceptual Toaster
Conceptual things are a modeling method we need to embrace as we build out the Internet of Things.
Continue reading {My Conceptual Toaster}
The Internet of My Things Needs the API of Me
Creating the Internet of My Things will require that people gain an online presence: the API of Me. That's what personal clouds are all about.
Continue reading {The Internet of My Things Needs the API of Me}
Using CloudOS From Anywhere
Want to use CloudOS to build your Web application but don't want to learn KRL? I've got a deal for you.
Continue reading {Using CloudOS From Anywhere}
A Programming Model for the CloudOS
The CloudOS and the persistent data objects it runs on depend on a specific programming model. KRL is the only programming language that supports that model right now. This blog post discusses how we could expand the underlying rules engine to support running JavaScript programs on the CloudOS.
Continue reading {A Programming Model for the CloudOS}
Activity Contexts in SquareTag
While knowing my location is a good thing, knowing what I want to do is even better. Until machines become sentient, SquareTags that record activity context is an excellent way to bridge the gap.
Continue reading {Activity Contexts in SquareTag}
Some Benefits of Decentralized Design and Modeling
Some of the problems we face online, like privacy, control, and access to data are solved when we consider decentralized approaches. This blog post discusses several benefits of decentralized design and modeling.
Continue reading {Some Benefits of Decentralized Design and Modeling}
The CloudOS: Connecting Hue Lights and Insteon Controllers
The Internet of Things will provide connections to most of the things around us in our lifetime. Will those connections allow my things to work together on my behalf? Only if they are connected to general-purpose programming environments under my control. This post demonstrates how the CloudOS supports connectivity between two systems from different manufacturers using different protocols.
Continue reading {The CloudOS: Connecting Hue Lights and Insteon Controllers}
Building a Blog with Personal Clouds
Thinking about event-based persistent data objects (PDOs) might be used to build a blog is a useful exercise in understanding how groups of decentralized objects can work together to accomplish a specific purpose.
Continue reading {Building a Blog with Personal Clouds }
Programming the Cloud With Persistent Data Objects
People ask me all the time why I decided to create my own language, KRL, rather than using an existing one. This is my latest thinking on that score.
Continue reading {Programming the Cloud With Persistent Data Objects }
Forgetting to Water the Christmas Tree? How Personal Clouds Saved Christmas
A personal clouds with a cloud-based operating system provides an easy way to take water level signals from an Electric Imp to automatically notify a homeowner via SMS that his Christmas tree needs to be watered.
Continue reading {Forgetting to Water the Christmas Tree? How Personal Clouds Saved Christmas}
When Services Die
What happens when your favorite service dies? Will your data live on? Not if you're dependent on cloud-based services you don't control.
Continue reading {When Services Die }
Hacking the Philips Hue with KRL
Philips Hue is a connected lighting system. No sooner did I see it that I wanted to control my lights from my personal cloud. This blog post is about my initial experiments with controlling Hue using KRL.
Continue reading {Hacking the Philips Hue with KRL }
The Cloud Needs an Operating System
This screencast from a talk I gave at Defrag 2012 describes the reasons why people need an operating system in the cloud. Because it allows you to act as a peer, a CloudOS orchestrates and coordinates online interactions, enables cooperating networks of products and services, supports intention-driven automation, and transforms the way you interact with the world.
Continue reading {The Cloud Needs an Operating System }
Building a Webfinger Client for my Personal Cloud
This post shows how the Webfinger client for the Kynetx CloudOS allows you to link two personal clouds. The post also shows how the client was built.
Continue reading {Building a Webfinger Client for my Personal Cloud }
Using Webfinger to Discover Well-Known ECIs
Webfinger provides a means for doing simple discovery of an event channel identifier (ECI) given a simple, better known account.
Continue reading {Using Webfinger to Discover Well-Known ECIs }
Subscriptions in the CloudOS
The CloudOS service provides a means for one cloud to subscribe to another. This blog post describes the subscription protocol and how it is used.
Continue reading {Subscriptions in the CloudOS }
The Personal Cloud Desktop in Action
Personal clouds are accessed and configured using a cloud-based desktop that can be accessed from any device at any time. This screencast shows the personal cloud desktop in action as two clouds are linked via subscription.
Continue reading {The Personal Cloud Desktop in Action }
Where Does the CloudOS Run?
A while back, I published this diagram to describe the different levels in the implementation of the CloudOS and show the relationship between the construction of a traditional OS and the CloudOS. This is more than an analogy; there is real parallelism. Two open source projects, KRE and XDI, make up the kernel. Anyone can run them. (Note: for now, it's probably easier to just sign up for a free account on the service hosted by Kynetx. At this point the open source projects are not easy to set up—but it is possible. We're actively working on fixing this
Continue reading {Where Does the CloudOS Run? }
Personal Cloud As Personal Assistant
Personal clouds can help remove some of the drudgery of dealing with your insurers and healthcare providers. This turns your personal cloud into a personal assistant that automates many of the mundane tasks we face in the information age.
Continue reading {Personal Cloud As Personal Assistant }
The Roles of Parties in Intentcasting
This blog post lays out the roles of the various parties in an intentcasting scenario. We argue for directories that allow discovery of products by buyers and act on behalf of sellers. In addition, we envision brokers working for the buyer in their personal cloud.
Continue reading {The Roles of Parties in Intentcasting }
Pagerank for Event Graphs
Using an event graph can help us understand relative connectivity in a decentralized network of event-based applications.
Continue reading {Pagerank for Event Graphs }
Controlling the CT-30 Thermostat
With all the work I've done to set up a thermostat under the control of a KRL program, controlling the thermostat from Google calendar is quite simple. This post discusses the rules that make the thermostat work.
Continue reading {Controlling the CT-30 Thermostat }
Talking Back to the Thermostat
The next step in my KRL thermostat experiment is to start sending the thermostat directives. This post describes a project to set the color LED according to the temperature trend.
Continue reading {Talking Back to the Thermostat }
Calculating a Running Average in KRL
Calculating the running average of the data from a series of events in KRL can be tricky unless you let an eventex do the hard work.
Continue reading {Calculating a Running Average in KRL }
The Layers and Components in a Cloud OS
This diagram shows the organization of components in the personal cloud operating system.
Continue reading {The Layers and Components in a Cloud OS }
Services in the Personal Cloud Operating System
The personal cloud operating system will need a set of consistent services. This post begins to flesh out some of the details behind the roadmap I published last week.
Continue reading {Services in the Personal Cloud Operating System }
A Road Map for the Personal Cloud Operating System
Kynetx has build what amounts to a functioning kernel for a cloud OS. But there's more to an OS than the kernel. This post outlines what else is needed to create a fully usable cloud OS.
Continue reading {A Road Map for the Personal Cloud Operating System }
A Kynetx Endpoint for Radio Thermostats
The Internet of Things requires active participants--devices and services that are not just listening, but also talking. I've created a daemon that serves as a framework for linking to multiple connected devices and raising events based on their state.
Continue reading {A Kynetx Endpoint for Radio Thermostats }
A Cosm Module for KRL
I've published a new module that allows KRL rulesets to easily update a Cosm datafeed. This blogpost describes how to use it.
Continue reading {A Cosm Module for KRL }
SquareTag: Making Everything Smart
Making every thing smart isn't science fiction, it's doable now and has startling possibilities to make the world a better place to live. SquareTag links things to personal clouds so they can be smart. When we give everything a virtual existence by means of an identity and a personal cloud, the entire world becomes our user interface.
Continue reading {SquareTag: Making Everything Smart }
Personal Channels
Drummond Reed and I have just release a whitepaper describing how personal clouds can be linked together in a decentralized relationship network to create a sharing architecture that has tremendous power and extraordinary benefits.
Continue reading {Personal Channels }
A Smart Bike
Personal clouds can make every thing, even a bike smart. A smart bike has apps and data, just like a smart phone. What would you like a smart bike to do for you?
Continue reading {A Smart Bike }
Rich Sharing and Personal Channels
Personal channels support rich sharing. Consequently they are extremely flexible and can be used for many purposes. Personal channels provide a messaging system for personal clouds that provides access-controlled, filtered, trustworthy notifications, data exchange, and sharing.
Continue reading {Rich Sharing and Personal Channels }
Federating Personal Clouds
One of the most important aspects of personal clouds, as we envision them, is their ability to federate. Without federation, personal clouds are as interesting as a computer without a network connection. Federation turns personal clouds into automated assistants.
Continue reading {Federating Personal Clouds }
A Programming Model for Personal Clouds
Personal clouds, running a cloud OS, with location-independent, semantically correct access to personal data from around the Web, and running applications that interact with other online services for the owner's benefit promise to usher in a new Web of unprecedented power and convenience.
Continue reading {A Programming Model for Personal Clouds }
Data Abstractions for Richer Cloud Experiences
A Cloud OS (COS) for a personal cloud will need a data abstraction layer analogous to the kinds of data abstraction that a traditional OS provides. Unlike a traditional filesysystem, however, the COS data layer must deal with a multitude of distributed APIs.
Continue reading {Data Abstractions for Richer Cloud Experiences }
The Foundational Role of Identity in a Personal Cloud
If we're to build personal clouds supported by a cloud operating system (COS), then we need to understand the key services that the COS would provide to the user. Operating systems are not monolithic pieces of software, but rather interlocking collections of services. One of the most important things to figure out is how a cloud OS can mediate an integrated experience with respect to authorized access to distributed online resources.
Continue reading {The Foundational Role of Identity in a Personal Cloud }
Personal Clouds Need a Cloud Operating System
If you need an OS for you laptop, your phone, and your tablet, why don't you need one in the cloud? Our current conception of how people use the cloud has significant limitations that could be mitigated with the introduction of a cloud-based operating system that people can look at as their "virtual computer" that's always on, always working.
Continue reading {Personal Clouds Need a Cloud Operating System }
KRL, Data, and Personal Clouds
Personal clouds need access to data. Lots of data. Data from all over. I envision my personal cloud as a general purpose computing platform that is always working for me. As such, it will need access to all sorts of data about me, my schedule, my to do list, and so on. Of course, it's not really the cloud that needs access to the data, but the programs running in it.
Continue reading {KRL, Data, and Personal Clouds }
Protocols and Metaprotocols: What is a Personal Event Network?
The Internet is a creature born of protocol. Protocols are agreements among a set of parties on a sequence of operations and the format of messages that will be used to communicate for a given purpose. Distributed systems depend on protocols to function. Andrew Galloway says 'protocols are the enemy of bureaucracy, of rigid hierarchy, and of centralization.' Through protocols ways overpower and supplant places.
Continue reading {Protocols and Metaprotocols: What is a Personal Event Network? }
Ways Not Places
The Web really isn't a Web at all. We've made links second class citizens and consequently built a system where largely stand-along sites site on the "information superhighway" with a few large directories driving people straight to the centralized place of their choice. There is a better way. One that leads to richer outcomes and more interesting futures. Join me there
Continue reading {Ways Not Places }
Sending Events in Parallel
This code release introduces an action for raising events to personal event networks in parallel. The makes event network federation through subscription practical.
Continue reading {Sending Events in Parallel}
Event Channels
Event channels provide a means for people to independently manage, permission and respond to online connections.
Continue reading {Event Channels }
Sky Event Console
A debugging console makes working with the new Sky event API and debugging KRL rulesets easier. This post shows you how.
Continue reading {Sky Event Console }
On Call TA: Distributed Event Network Federation Through Subscription
Personal event networks can be federated to provide groups with interactive services. By allowing apps to customize the owner's experience, use and manage personal data, and take advantage of shared services, personal event networks provide operating system like services for their owners.
Continue reading {On Call TA: Distributed Event Network Federation Through Subscription }
An Operating System for Your Personal Cloud
A personal event network is like an OS for your personal cloud. You can install apps to customize it for your purpose, it can store and manage your personal data, and it provides generalized services through APIs that any app can take advantage of.
Continue reading {An Operating System for Your Personal Cloud }
Delivering Flowers with a Distributed Event System: Event Subscription in Action
Event subscription creates a powerful system for enabling a completely new kind of interaction between vendors and customers.
Continue reading {Delivering Flowers with a Distributed Event System: Event Subscription in Action }
The Live Web is Live!
I'm very pleased with how my new book, The Live Web, turned out and extremely excited about the ideas in it. I hope you'll read it, comment on it, review it, and try the ideas out. Undoubtedly, the future will turn out different than I've envisioned it, but I think we have an obligation to try to influence the design the emerges.
Continue reading {The Live Web is Live! }
Foursquare and Personal Data in a Personal Event Network
This demonstration shows a personal event network responding to Foursquare checkin events and storing the information about the checkin in a personal data service using a manager application that is loosely coupled and privacy respecting. Pretty cool, huh?
Continue reading {Foursquare and Personal Data in a Personal Event Network }
Static Scoping of Persistents in KRL Modules
I made a scoping mistake in designing modules and it's time for KRL to come clean about that. This post describes the problem and what's changing to fix it.
Continue reading {Static Scoping of Persistents in KRL Modules }
Notifications in Personal Event Networks
Providing event APIs for common services and then supplying rulesets that handle those services make personal event networks more powerful and easier to use. this post describes a notification system for Kynetx personal event networks.
Continue reading {Notifications in Personal Event Networks }
Sky: The New Kynetx Event API
The release of the Sky Event API brings the vision of personal event networks closer to reality on the Kynetx platform. Sky uses saliance data--information saying which rulesets are listening to which events--to determine the rulesets that see any given event.
Continue reading {Sky: The New Kynetx Event API }
The Live Web - Cover
I got the final proof on the cover for my upcoming book The Live Web today. I think it turned out nicely and I'm excited to see the book itself.
Continue reading {The Live Web - Cover }
Human Leverage
Everyone wants leverage. Getting more done with less effort. Accomplishing what needs to be done easily. Personal Event Networks enable dozens of personal digital assistants that enhance your life.
Continue reading {Human Leverage }
Personal Event Networks, Social Products, and Value
An introduction to personal event networks, how they work, and why they create value.
Continue reading {Personal Event Networks, Social Products, and Value }
A Database is Like a Phone that Doesn't Ring
The Evented API specification is a way to get the phones ringing in today's Web APIs. For real-time applications, that's critical.
Continue reading {A Database is Like a Phone that Doesn't Ring }
Semantic Translation in Event Systems
Semantic translation is a type of event abstract that changes one event into another based on the context of the original event. This blog post explains and shows how to do it in KRL.
Continue reading {Semantic Translation in Event Systems }
What Personal Event Networks Do
Personal event networks create a world beyond mobile and social where products are part of your social network.
Continue reading {What Personal Event Networks Do }
Personal Event Networks: Building the Internet of Things
An Internet of Things--social products and services--will have as profound an effect on our lives as the changes of the preceding 15 years. I believe that personalized event-driven programming models are a key part of the architecture that makes them real. Events make active participants of formerly passive APIs and make social products a reality.
Continue reading {Personal Event Networks: Building the Internet of Things }
Help Build Legal Sidewiki
Not many people take the time to understand the terms and conditions of a service they want to use and if they do, they're likely confused and overwhelmed. I'm looking for someone to build a Kynetx browser app that would let legal experts add commentary to these documents to guide users and let them know what they're signing up for.
Continue reading {Help Build Legal Sidewiki }
Using Schema.org Microdata in KRL
Schema.org microdata has been proposed as a way to encoding semantic data in HTML markup. Using semantic data from within KRL allows rules to be more general and loosely coupled. I recently used a jQuery library to gather Schema.org product microdata from a page and forward it to the KRL engine for processing. This blog post explains how I did it.
Continue reading {Using Schema.org Microdata in KRL }
Google Plus Comment Filter
One of the things I dislike about the G+ streams is the way comments are handled. For most people it's OK, but for folks like +Robert Scoble and +Jesse Stay who have tons of followers, they're comments come in fast and furious making it tough to even scroll past their posts to see what's below. I'm used to having things my way, so I wrote a Kynetx app that hides the comments. In their place it puts a link with the number of recent comments. Clicking on the link shows the comments. The link is a toggle, so clicking
Continue reading {Google Plus Comment Filter }
Anonymous eCommerce: Building a Real 4th Party Offer Application with Kynetx
This is a long post. Don't worry, there are plenty of place to stop reading. You can stop at the end of each major section and have a complete picture for a given level of detail. Developers trying to see how to build a 4th party ecommerce application in KRL should read to the end to understand the complete picture. The caption of Peter Steiner's legendary 1993 New Yorker cartoon reads: "On the Internet, nobody knows you're a dog." If you've paid attention to the Internet Identity Workshop logo, you know we use that concept for the conference, although
Continue reading {Anonymous eCommerce: Building a Real 4th Party Offer Application with Kynetx }
Modules in the Cloud
After I wrote my last blog post on "Hover Me - A Social Media Dashboard" I got to thinking about the power of modules and realized that there's a special power that is available from modules that operate in the cloud. First, a little discussion of what Ed's Empire Avenue Module does. Empire Avenue's current API doesn't allow you to look up information by Twitter handle, only by Empire Avenue ID. Ed discovered that you could use the site to do it, so he used Kynetx to essentially do a little screen scaping to get the data and return
Continue reading {Modules in the Cloud }
Hover Me - A Social Media Dashboard
Last December, a developer on the Kynetx platform, Ed Orcutt, released an application that used the Qwerly API to show people the other social networks that Twitter users were on. Called HoverMe, the application pops up a hover card when you put your cursor over a name or picture on Twitter or Facebook like so: The app surprised us all because it got a little press love and took off with over 30,000 installs in just 3 days. Since it's original release, Ed has enhanced HoverMe to add PeerIndex scores and Empire Avenue value. Last week I was sitting
Continue reading {Hover Me - A Social Media Dashboard }
Error Handling in KRL
If you've been following along, you know that KRL, the Kinetic Rule Language, is an event processing language for processing events on behalf of an individual entity (usually a person). Think of it as the People's Complex Event Processing language. For a long time, it's been difficult for KRL developers to handle errors. The language had no mechanism for exceptions and the only hope was to turn on debugging and fix them. Too often, however, we don't want to fix errors so much as handle them. Errors are not always problems in the code--bugs to be fixed--but exceptional conditions
Continue reading {Error Handling in KRL }
Dealing with JSONP in KRL: Using the Flickr API
When I blog I like to put pictures, like the one to the right of this sentence, in the article when I can. My usual method is to use Flickr because I can find good pictures that have creative commons rights that allow me to use them on my blog. The problem is that after I find the picture, I need to create an image tag with the right size source image that links back to the Flickr picture for attribution purposes. Creating the tags to do that by hand is a pain, so I've created a simple Kynetx
Continue reading {Dealing with JSONP in KRL: Using the Flickr API}
The Trends Driving KRL and Kynetx
In my last post, I outlined a few benefits that developers could gain from using KRL. Well and good, but so what? Are those benefits that matter? How do they relate to the other reasons programmers learn new languages like money and opportunity? In this post, I will talk about some of the big trends driving my thinking and informing the decisions around what KRL is and why it enables the abstractions that it does. There are three trends I'd like to examine: The rise of real-time data and the evented Web The rise of personal data and user-centricity
Continue reading {The Trends Driving KRL and Kynetx}
Why KRL?
A lot of people ask me why I invented Kinetic Rule Language (KRL) instead of just using an existing language. There are a lot of answers to that question, but I want to get to some specifics. Tools shape how we think and work. I learned long ago that the best way to think differently about a problem is to create a nomenclature that describes and illuminates the new domain. KRL is a rule-based language that is custom built for the domain of event-based applications that operate on real-time data in the cloud. KRL was designed from the ground
Continue reading {Why KRL?}
Tweeting from KBlog: An Experiment in Loose Coupling
Last week I posted about creating a blog using KRL as an example of an application that used multiple rulesets and has a more complicated event hierarchy than typical KRL applications. I followed that up with a post about making the back button work in the resulting blog as an example of using external JavaScript libraries and emitting raw JavaScript from rules. We even added a new event type (web:hash_change) using JavaScript. You can see the resulting blog here. Another idea I've wanted to explore is how event-driven applications can be extended in a loosely coupled way. The argument
Continue reading {Tweeting from KBlog: An Experiment in Loose Coupling}
KBlog: Making the Back Button Work
Friday, I posted a long blog article that discussed using KRL to create a simple blogging application. the application writes multiple pages, manages a navigation bar, and allows new posts. (Try it here.) One problem with the implementation is that because it paints the entire app in a single page (sometimes called a single page interface or SPI), the back and forward buttons don't work. The problem is that the browser doesn't know there's a new page and put it on the history unless the URL changes. The back and forward buttons are just indexes on the browser history.
Continue reading {KBlog: Making the Back Button Work}
Event Hierarchies: A Blog Written in KRL
I've mentioned several times that I'm writing a book called The Live Web that discusses how events and strong user identity combine to produce new ways of creating Web applications that are significantly different than those in use today. Chapter 12 is about creating event-driven applications that are based on multiple rulesets. At the recent Kynetx Impact developers conference, Ed Orcutt built a blog application using KRL. Actually, he did it twice: once with one ruleset and another time with three. If you're like to read the book in draft form, contact me and I'll invite you to the
Continue reading {Event Hierarchies: A Blog Written in KRL}
Leave the Services Clients to the Services and Build Something Really Interesting
Twitter's Ryan Sarver made news when he posted a message that asked developers to stop developing Twitter clients. There's been a lot of talk about this and certainly, if you're the developer of a Twitter client this isn't good news. Still, it seems like a natural idea to me. The providers of services like Facebook, Twitter, and Foursquare are likely going to be the dominant providers of clients for those services. But clients for a single service are the least interesting clients and provide pretty low value to their users. Where the real value lies, and something the services
Continue reading {Leave the Services Clients to the Services and Build Something Really Interesting}
Come to Impact and Learn About the Future of the Web
In about two weeks on March 22 and 23, Kynetx will be hosting our annual Kynetx Impact conference. You can register for Impact here. We have a great slate of keynote presenters and a great program all about the Live Web. If you're not familiar with the Live Web, listen to Doc Searls descibe it in the following video: The Live Web gets beyong the static architecture of the current Web (yeah, with all it's dynamicism, it's still pretty static). The Live Web promises to give users access to relevant information and services from dozens or even hundreds of
Continue reading {Come to Impact and Learn About the Future of the Web}
Building a PubSubHubBub Endpoint for Kynetx
The Live Web already exists and is exemplified by emerging technologies and concepts such as PubSubHubBub and webhooks. PubSubHubBub (PuSH) is a method for augmenting RSS and Atom feeds that turns the formerly request-response-style interaction of RSS into one that makes calls to subscribers when relevant updates are posted. Webhooks are a simple way to use HTTP to create event notifications . Both of these technologies are raising events, although not in a form directly usable by Kynetx. One approach to using them with KRL would be to write a custom endpoint. Often for special projects, however, it's just
Continue reading {Building a PubSubHubBub Endpoint for Kynetx}
A Completely Connected World Depends on Loosely Coupled Architectures
This article from CNNMoney describes a completely connected world where not just every device, but literally every thing you own "will want to be your friend on the Facebook of things." At the Mobile World Congress in Barcelona, companies like IBM (IBM, Fortune 500), Qualcomm (QCOMM), AT&T (T, Fortune 500) and Ericsson showed off their vision of a not-too-distant future in which every item in your life, from your refrigerator to your fridge magnets, will soon connect to the Internet or communicate other Internet-connected gizmos. Here's how it would work: Electric devices like washing machines, thermostats and televisions will
Continue reading {A Completely Connected World Depends on Loosely Coupled Architectures}
Saying Goodbye to ExpertsExchange! Creating a Personal Block List with Kynetx
Yesterday Google announced a Chrome extension that allows you to create a personal block list of Web site URLs. The idea is to reduce spam in search results by letting users block sites from their personal search results. The extension also sends this information to Google so that they can crowdsource their search spam efforts. But what if you want to do this Firefox or Internet Explorer? Or on Yahoo! or Bing? Kynetx to the rescue! When we saw the Google extension we thought "great idea" but we can do better with KRL. KRL is a language that lets
Continue reading {Saying Goodbye to ExpertsExchange! Creating a Personal Block List with Kynetx}
"Data Incoming!" Event-Based Systems and Self-Determination
A while ago, Steve was helpfully giving me information related to my driving from the passenger seat. I jokingly told him it would be helpful to me if he'd tag his utterances so I'd know what they were. So he started prepending "data incoming!" to the start of his driving tips. So, he'll say something like "Data incoming! There's a car on your left!" Wednesday were driving around Mountain View and he said "Data Incoming! Turn left!" I said "That's not data, it's a command." This is a vital distinction and captures perfectly the difference between request-based system and
Continue reading {"Data Incoming!" Event-Based Systems and Self-Determination}
Contextually Correlating Events: The Power of Emergent Behavior in Loosely Coupled Systems
One of the real powers of event-based programming is the ability to contextually correlate events. That's a pretty dense phrase. I'm writing this blog post to unpack it a little in my mind. Hopefully it will do you some good as well. Single events, like web:pageview, mail:received, or phone:inbound_call can be interesting. We've made money on Kynetx apps that rely exclusively on these kinds of primitive events. In spite of that, we can create even more interesting applications when we start to correlate one event with another. This is analogous to building Web applications. While there are plenty of
Continue reading {Contextually Correlating Events: The Power of Emergent Behavior in Loosely Coupled Systems}
KRL App A Day
Mike Grace, probably the most experienced KRL programmer and without a doubt the most prolific, has been doing a Kynetx App a Day and publishing them on a special blog. When he started we teased hik about doing the Twelve Days of Kynetx, but he's up to 33 now. Most of these are small useful little apps designed to teach a particular feature of KRL or technique for programming in KRL. Here's the list so far: Day 1--Basics and Notify Day 2--Dual Execution Environment part 1 Day 3--Web events and debugging Day 4--Explicit Events Day 5--MD5 and SHA1 hashing
Continue reading {KRL App A Day}
Agent or Endpoint?
Before the New Year, I put up a poll asking what the word "endpoint" meant to people. Overall there were 68 responses. The following table summarizes them: QuestionAnswersPercentage Other answer... 18 \t26.47% \t an entry point for an online service \t13 \t19.12% \t any node on the Internet \t13 \t19.12% \t a node on a communication bus \t11 \t16.18% \t a URL \t8 \t11.76% \t a participant in an event network \t5 \t7.35% While other is the largest category, some of the answers, could be grouped broadly with ones I gave to slightly shift the answers: QuestionAnswersPercentage Other answer...
Continue reading {Agent or Endpoint?}
The Kynetx Rule Language has Modules
KRL (Kynetx Rule Language) started out as a fairly small domain specific language for augmenting Web pages. We integrated with several online services (like geolocation, weather, and so on) to make what we were doing simpler to write. Later, as KRL grew, we added more integrations with Web APIs and services like Twitter. We've increased the abstraction capabilities of the language by adding first-class functions. Lately we've realized that many of the native integrations of external APIs we've done could--and should--be done by developers working in KRL. If only they had a way to encapsulate and share them! Now
Continue reading {The Kynetx Rule Language has Modules}
Building a Programming Layer for the Internet: Audio from Impact
We held our Impact conference for 2010 last April. There were a lot of great talks. Some of them we were able to capture and have published on IT Conversations. If you have yes listened to Steve Spencer, Joe Vito, Steve Gillmor, or Jon Udell, take some time and put them on your playlist. They are great talks with great messages. The audio from my talk from Impact wasn't quite good enough for IT Conversations--there were cutouts in some spots--so we didn't publish it there. I recently got around to cleaning it up and was going to publish it
Continue reading {Building a Programming Layer for the Internet: Audio from Impact }
Language Design Gives Leverage
Last Friday I spoke at the Utah Open Souce Conference on designing and building domain specific languages (DSLs). The slide from my talk are online (PDF). Our experience building KRL served as the catalyst and gave me concrete examples to talk about even though I'd hesitate to call it a DSL anymore. Yesteday, I had an experience which reinforced my enthusiasm for building languages. Writing the post on building event intermediaries, thinking through the patterns, and talking to some of the Kynetx engineers who have the most experience with raising explicit events led to thoughts about how to generalize
Continue reading {Language Design Gives Leverage}
Kynetx and Personal Data Services: Project Neck Pain
One of the technologies that seems to be picking up steam lately is the PDS or personal data service. The PDS goes by other names as well. David Siegel calls it a "personal data locker" in his book Pull. Drummond Reed has determined the right name is personal data service rather than "store." I talked about the problem with the name and enumerated some principles for personal data services after IIW DC. I'm certain that the PDS will be a significant topic of conversation at the upcoming Internet Identity Workshop XI in Mountain View, CA (register here). Why all
Continue reading {Kynetx and Personal Data Services: Project Neck Pain }
KRL Patterns: Building Event Intermediaries
Recently we somewhat quietly added a BIG new feature to KRL: explitic events. Using an explicit event, one rule can raise an event for another rule. Explicit events are raised in the rule postlude like so raise explicit event foo [for ] with fizz = "bazz" and fozz = 4 + x; If the optional for clause isn't given, the event is raised for the current ruleset, otherwise it's raised for the named ruleset. The with clause allows the developer to add event parameters to the explicit event. The right-hand side of the individual bindings in the with clause
Continue reading {KRL Patterns: Building Event Intermediaries }
Static Queries, Dynamic Data: Enabling the Real Time Web
If you're not up on event systems and event programming, no worries. Most programmers aren't. But I'm here to tell you that they're cool, they're accessible, and they're not just for enterprise kinds of problems anymore. Event processing enables the real-time Web. Most of the cool things we want the Web to do will be easier when we no longer rely exclusively on time and request-response based architectures and look to event based architectures to solve more problems. One of the unique things about the Kynetx architecture is that there's no database in the traditional sense. We have a
Continue reading {Static Queries, Dynamic Data: Enabling the Real Time Web}
Beyond the API: The Event Driven Internet
Summary: There's no question that APIs are hot and generating a lot of buzz and excitement. In this article, I'll review why APIs are causing so much excitement, make an argument for why APIs are not enough, and finally propose a model that significantly extends the power of an API: an event-driven view of the Internet. Extending your API with events will make your APIs much more able to compete and make your business more competitive. After reviewing event models, I discuss webhooks as an event model that complements an API strategy and then briefly talk about how Kynetx
Continue reading {Beyond the API: The Event Driven Internet }
Come to Kynetx Developer Day
In the past Kynetx has held two Kynetx Impact conferences, one last fall and one last spring. Kynetx Impact exceeded my expectations both times with lots of people and energy. But holding a conference of that size is, frankly, a lot of work for a small team. Consequently, we've decided to move to an annual schedule with Kynetx Impact, holding the conference once a year in the spring. At the same time, we didn't want to lose the ability to contact and work with developers, so we've created Kynetx Developer Days. The first Kynetx Developer Day will be held
Continue reading {Come to Kynetx Developer Day}
The Kynetx Rule Language: The First Internet Application Platform
A while ago, someone asked, in a comment, "What's KRL?" I realized that while I had lots of snippets that explained KRL and what it could do, there's was no good place to point people who ask that question. Consequently, I put together a white paper that explains, in some technical detail, what KRL is, how it operates, and why we think it's so damn cool. The paper is The Kynetx Rule Language - The First Internet Application Platform (PDF). If that title doesn't pique your interest, maybe a few paragraphs from the intro can: Imagine walking into Borders
Continue reading {The Kynetx Rule Language: The First Internet Application Platform}
Remembering in KRL: Using Entity Variables with Forms
Dan asked a question in the Kynetx Developer Exchange about remembering user entered data in KRL. I gave him a brief outline of the solution but thought an example would be nice. This blog post is the detailed answer to how to gather, remember, and use user-supplied data. The basic idea is to store the data in an entity variable. Trails (a type of persistent variable) are the most appropriate type of entity variable to use. The ruleset pattern has four rules: initialize, send the form, process the form, use the data. The actual ruleset has five because I
Continue reading {Remembering in KRL: Using Entity Variables with Forms}
Using ANTLR and PerlXS to Generate a Parser
As I mentioned earlier, we're anticipating changing out the current Parse::RecDescent based parser in the Kynetx platform with one that will perform better. We've been going down the path of using ANTLR, a modern parser generator that supports multiple target languages. That flexibility was one of the key thing that got us interested in ANTLR. We might want to generate Ruby or Javascript KRL generators at some point. But of course right now we want to generate a Perl parser since that's what the underlying Kynetx Event Service (KES) is written in (it's an Apache module). ANTLR doesn't support
Continue reading {Using ANTLR and PerlXS to Generate a Parser }
Parsing for a Cloud-Based Programming Language
If you follow my blog, you're probably all too aware that Kynetx provides a cloud-based execution engine for a programming language called the Kynetx Rule Language, or KRL. The execution engine is a big, programmable event-loop in the cloud and KRL is the language that is used to program it. As with any language, the first step in executing it is to parse it into an abstract syntax tree. The KRL parser has had it's ups and downs. A while ago, I reported on changing out the HOP parser for Damian Conway's RecDescent (note that the system is written
Continue reading {Parsing for a Cloud-Based Programming Language }
A Big, Programmable Event Loop in the Cloud
An event loop is a message dispatcher. The loop runs, waiting for events, and responding to them. This is how I've come to think of the Kynetx Network Service (KNS): a big, programmable event loop that runs in the cloud. We haven't always thought of KNS as an event loop, we used to think of it as a ruleset evaluation engine. These ruleset evaluations were tied to users visiting a page. We now view that as just one kind of event (a pageview event, to be specific). We also promoted some other events in the system (like Web clicks
Continue reading {A Big, Programmable Event Loop in the Cloud }
Kynetx Code Run I
Saturday was my birthday. About a month ago, I told everyone at Kynetx that what I wanted for my birthday was some cool Kynetx apps. On Thursday at noon, we shut down normal work and everyone broke into teams. They had 24 hours to program an app that would impress their competition. We called this the Kynetx Code Run; it's loosely modeled after Atlassian's FedEx Day. The rules were pretty simple: Teams can consiste of 1, 2, or 3 people. Remote employees are encouraged to be at KWHQ for the event. Apps that can be listed
Continue reading {Kynetx Code Run I}
Getting Quotes and Comments Right
Poor decisions in language design are tough to hide because fixing them is akin to changing the API of your library. You can hide all kinds of sins below the covers, but errors in the syntax and semantics can only be fixed by confessing those sins to the world. Consider this a confession. One of the niggling little details of Kynetx Rule Language has been comment treatment. The parser we user, Parse::RecDescent, does not include a lexer--tokens are specified as regular expressions in productions. That works fine for everything but comments. Because there's no lexer, you can't flag a
Continue reading {Getting Quotes and Comments Right}
Forms, Events, and Dialoging in KRL
As part of the push for Impact, I released a preview functionality of using KRL with Web forms and demonstrated it at the conference. The ability to interact with forms is built on KRL's new event capabilities. In my previous blog post on this, I hinted at primitive events beyond pageview, but didn't go into much detail. In this blog post, I introduce three new primitive events in the web event domain: change, click, and submit. The change event is based on the change event that most browers support. The event fires whenever a form element changes. You set
Continue reading {Forms, Events, and Dialoging in KRL}
Programming the Internet: Reactive Systems, Events, and KRL
Imagine walking into Borders and having your smartphone alert you to the fact that the book you put on your Amazon wish list this morning is available right now and on sale. As another example, think about an application that gathers relevant articles from your RSS and Twitter feeds based on searches you've performed or that are related to an email your received from a friend today. These examples show the power that can be achieved when we start programming the Internet and not just the Web. There's no reason that clients in different domains (like your smartphone and
Continue reading {Programming the Internet: Reactive Systems, Events, and KRL }
The Power of Late Binding
Lately the subject of late binding keeps coming up. In computer science the term refers to runtime resolution of what names mean and includes the concept of dynamic loading. Most of the languages that have gained favor over the last decade like Python and Ruby are late binding languages. Usually these languages also include other runtime resolution features like dynamic types. Raising the topic causes programmers to reach for their crusader sword and shield as they prepare for the religious battle that is sure to follow. Late binding is a big deal in many OO langauges because of the
Continue reading {The Power of Late Binding }
Amazon Products in KRL: A New Distribution Model
The first Web service that Amazon put up, years ago, was the ECommerce API that allowed API access to Amazon's product information. That API has gone through several name changes and is now called the Product Advertising API. Thousands of people have used this API to add data about products--and the opportunity to buy them--to their Web sites. That's the problem, of course. You can use it on your Web site, but you can't conveniently use them in a browser extension to build client-side community apps because your Amazon developer keys would be exposed to the world. The most
Continue reading {Amazon Products in KRL: A New Distribution Model }
Building Fourth Party Apps with Kynetx
Doc Searls uses the term "sewage pump" (I'm paraphrasing) to describe the modern advertising-based economy. Modern society has created the most efficient machine imaginable to push stuff at people whether they want it or not. I gave an example in this blog post about Novatel: they're treating Twitter as a way to push stuff at me instead of as a place to relate to me. A pump pushing sewage at you is a good metaphor for what's wrong with the marketplace we've constructed in the late 20th century. Doc has built the VRM project as a means of exploring
Continue reading {Building Fourth Party Apps with Kynetx}
KRL Supports International Characters
One of the things we often get asked at Kynetx by partners is whether or not KRL will support international characters. The answer is "yes" as shown below: This support extends to reading international characters from data feeds and operations on strings.
Continue reading {KRL Supports International Characters }
Jon Udell to Speak at Spring Kynetx Impact Conference
I'm excited to announce that Jon Udell will be speaking at Kynetx Impact in April. I've known Jon for years--we met though blogging while I was CIO for Utah. He's the perfect person to keynote Impact because he's first and foremost a developer who understands the core nature of the Web. Jon's topic will be (loosely) "why the decentralized architecture of the Web matters." That's a great topic for Impact because what we're trying to help developers do is create applications that leverage that decentralzied architecture rather than trying to figure out ways to get what
Continue reading {Jon Udell to Speak at Spring Kynetx Impact Conference}
Using OAuth to Access Twitter from KRL
The latest build (Build 391) of the Kynetx Rule Language (KRL) includes support for accessing Twitter data intrinsically within the language. Integrating interesting data with KRL is an important part of what makes the language so useful for building cross-site applications that mash-up data and user interactions. But what's really interesting about this release is that we're using OAuth to access the Twitter API and have built primitives into the language for dealing with the Twitter OAuth interaction to save developers from doing it. Not only are we making it easy for developers to write apps that use Twitter,
Continue reading {Using OAuth to Access Twitter from KRL}
UtahPolitics.org All Over the Web: A Kynetx App
Since 2003, I've been running a site called UtahPolitics.org. The site started off as a blog on which I and others posted articles. When I started UtahPolitics.org there was some speculation about my motives. But my motives are simple: create a place I can experiment with new media in an arena that interests me. Last year, in an effort to continue the experiment, I put up a retweeter for UtahPolitics.org that would retweet any tweet from friends of the @utahpolitics account that contained the tag #utpol. When I did that I also morphed the web site--imperfectly--to a site that
Continue reading {UtahPolitics.org All Over the Web: A Kynetx App}
Burtonian Tutorials on the Kynetx Rule Language
Craig Burton has been busy the last few weeks cranking out tutorials on how to use KRL--the Kynetx Rule Langauge--in certain situations. What would a programming language introducation be without a "hello world" example and Craig delivers. The first tutorial anyone ought to watch is Hello World, which gives a video view of the instructions here. After that simple introduction, Craig goes right to the heart of the features that are important for creating useful Kynetx apps. The second tutorial is on External Data. In this tutorial, Craig extends the Hello World tutorial to use an external file as
Continue reading {Burtonian Tutorials on the Kynetx Rule Language}
Looping in KRL
One of the design goals of the Kynetx Rule Language (KRL) is to make it easy to use online data sources to augment the user's experience in the browser. Using interesting data implies some kind of iteration. KRL supports both implicit and explicit looping. Ths article discusses looping in KRL and how looping in a rule language like KRL differs from how you might use it in an imperative language. First, recognize that the ruleset itself is a loop. You should imagine the rulset as a big switch statement inside a loop that is executed over and over again
Continue reading {Looping in KRL}
Build 354: Control Statements in Postludes
This afternoon we releases Build 354 of KNS supporting the addition of a last control statement to postludes. In addition, we also now allow guard conditionals on any statement in a postlude. These are relatively minor additions to KRL in anticipation of some larger features that are coming soon. The use a last statement in a postlude will halt the execution of the ruleset at that rule if it is executed. So, the following statement would halt execution after the current rule if the rule fired: fired { last } This can be useful for rules that initiate action
Continue reading {Build 354: Control Statements in Postludes}
Build 353: Some New Functions for Kynetx Rule Language
We released Build 353 of the Kynetx Rules Engine (KRE) this morning. Actually, I should point out that Wade Billings released it and I watched over his shoulder. This is the first time in the history of Kynetx that someone besides me released KRE code. Yeah!! This is an exciting thing in and of itself. Wade's job is to build a continuous integration environment for Kynetx so that code changes appear in production as quickly as possible. Until then, I've pushed the pain on him to ensure he's properly motivated. The new release adds two new features to KRL:
Continue reading {Build 353: Some New Functions for Kynetx Rule Language}
KNS Build 351: FLWR Comes to KRL
One of the big features missing from KRL as a rule language is a foreach statement that allows looping. Build 351 of KNS (released today) fixes that problem. The thing that kept holding me back was confusion on my part about the best way to add it and how it should work. The problem was that I wanted, thought KRL needed, more than just looping. I wanted full-blown FLWOR statements (foreach, let, where, order by, result). I realized one day on a bike ride that the entire rule ought to be a FLWOR statement and that meant that the
Continue reading {KNS Build 351: FLWR Comes to KRL}
Conditional Expressions and Explicit Logging
This afternoon I released build 329 of Kynetx Network Services (KNS). This build includes two new features for the Kynetx Rule Language (KRL): explicit logging and conditional expressions. Explicit logging allows developers to place information in the ruleset log when a ruleset runs. For example, the following example would place a string with the value of a variable named query in the log if the rule fired: fired { log "query:"+query } Explicit logging is useful for recording information about the rule environment in the logs for later analysis. Conditional expressions allow expressions to take on different values depending
Continue reading {Conditional Expressions and Explicit Logging}
Persistent Variables in KRL: Threading Sites Together
Yesterday I released build 325 of Kynetx Network Services (KNS) which includes a significant addition to the feature set of Kynetx Rule Language (KRL): persistent variables. Persistent variables allow KRL rulesets to store and react to data over multiple visits. This data isn't personally identifying information, but rather the kind of information that makes writing intelligent Web applications easier. Here's an example: an information box placed on a Web site can now have a "don't show this to me again" check box and act accordingly. Persistent variables, or just persistents, will ultimately come in two flavors: Entity variables store
Continue reading {Persistent Variables in KRL: Threading Sites Together}
Why Use the Kynetx Rule Language Instead of Javascript?
Last Friday I blogged about using Kynetx to put my latest tweet on my blog. Joseph Scott asked "Why would this be better than just using Javascript plus the Twitter API to show your last tweet?" The answer is a little longer than I wanted to put in a comment, so here goes. KRL has a number of advantages over Javascript talking to the Twitter API: KRL, the Kynetx Rule Language, provides a closer abstraction to the task than Javascript does as a general purpose language. This is, of course, something that could be subject to debate--if you're already
Continue reading {Why Use the Kynetx Rule Language Instead of Javascript?}
My Last Tweet...Powered by Kynetx
I've had a box on the right-hand side of this blog showing my lastest tweet. Today I realized that it would be better powered by Kynetx. I took a few minutes and wrote one up. You can see it on the right-hand side of this page. To do this, I used the Twitter API to grab my tweets and then replaced an empty div on my page with it. Since Kynetx rules run each time the page is loaded, it's constantly updated. The first step was to declare a datasource to read my tweets: global { datasource tweets I've
Continue reading {My Last Tweet...Powered by Kynetx}
Registration Open for Kynetx Impact Conference
We've opened registration for Kynetx Impact 2009, our developer's conference. You can register here for the event. We've changed the dates to November 18-19th (I previously announced dates in October) to better fit with some other conference schedules. We're charging a small fee to cover food, but if that's problem for you contact me about a scholarship. Doc Searls will give the opening keynote and Craig Burton will give the closing keynote. Here is a list of topics we'll cover: Building Apps with KRL (Kynetx Rule Language) Advanced Rule Writing Introduction to Action & Information Cards Leveraging Data sets
Continue reading {Registration Open for Kynetx Impact Conference}
What are People Tweeting About this Site?
One of the ways that you can use Kynetx rules is to create powerful bookmarklets that modify the current page in some way. In order to demonstrate this, I asked our intern, Jessie Morris, to create a ruleset that displays the last 10 tweets about a Web site. We call this little App "Sweetter." Sam has already built a feature for generating a bookmarket that is tied to a ruleset into Kynetx AppBuilder, our ruleset building tool. So once you've got a ruleset, creating a bookmarklet is as easy as pushing a button. To see it in action, just
Continue reading {What are People Tweeting About this Site?}
Announcing the Kynetx Developers Conference
Kynetx will be holding a developer's conference on October 21-22. The conference will be in Utah, although the exact venue hasn't ben nailed down yet. Some of the topics on the agenda: Building Apps with KRL Advanced Rule Programming Action Cards and Information Cards Data and Rules The KNS API We are also lining up some great keynotes. If you're curious about Kynetx and what we're doing, this will be a great way to immerse yourself for a few hours or a few days in learning about our services and what you can do with them to build applications
Continue reading {Announcing the Kynetx Developers Conference}
You're Gonna Need It
Normally, I subscribe to the "YNGNI" philosophy: You're Not Gonna Need It. The idea is don't over engineer things because you'll likely spend a lot of time on things that never get used. This post is about an exception to that rule that I wish I'd followed. When I started designing KRL, there wasn't much in the way of variable scoping and it didn't really need it. Each rule was a local scope and there were no global variables. Only one ruleset ever operated at a time. Consequently, I took the easy route and instead of designing a proper
Continue reading {You're Gonna Need It}
The Eighth Internet Identity Workshop - IIW2009A
Image by Adriana Lukas via Flickr I can't believe that a week has passed since IIW8 ended. I was planning on writing a wrap-up blog post then and time has just slipped away. When we were planning for this IIW, we were pretty worried about whether people would come and whether we'd get sufficient sponsor support. As it happened, things turned out fine. We had more people than ever--about 180. And while some sponsorships went unsold, overall we had great support for which we're grateful. The workshop itself was one of the best ever. There was a lot of
Continue reading {The Eighth Internet Identity Workshop - IIW2009A}
Context Automation: Slides from Gluecon
I've post my slides from my talk at Gluecon on Wednesday at SlideShare. Context AutomationView more presentations from windley. I haven't had time to do audio for this yet. I hope to at some point.
Continue reading {Context Automation: Slides from Gluecon}
Contrasting Kynetx and Greasemonkey
Kynetx Network Service, or KNS, modifies a user's Web page using Javascript. The ability to customize pages in the browser is a powerful capability, but it goes well beyond that by allowing data from multiple sources, even other Web pages, to be used as part of that customization. Sure we can change change colors, fonts, and layout, but we can also mashup Web sites to produce completely new experiences. Described as I have, KNS is not unlike Greasemonkey, a popular plug-in for Firefox that allows user scripts to modify Web pages. In fact, in a recent post Paul Madsen
Continue reading {Contrasting Kynetx and Greasemonkey}
Posting on code.kynetx.com
As we get ready to launch a limited beta program for developers to use the Kynetx platform, one of the things I wanted to get going was a place to talk about Kynetx code. So we stood up code.kynetx.com. When it's all done, there will be documentation, forums, and examples. I've been making some posts on it even though the template isn't done. So far I've posted: New feature: CSS in Globals Updating the Runtime: Annotated Search Results KRL Templates I've been enjoying writing these because it gives me a chance to write about changes and features in one
Continue reading {Posting on code.kynetx.com}
Designing the Kynetx Rule Language
KRL, the Kynetx Rule Language, is a domain specific language that operates on the Kynetx Network Service (KNS). When I first started building KNS the first priority was getting a rude dog demo working that we could use to start having customer and investor conversations. Consequently, I was less than pure in some of the implementation details. For example, the conditionals in if statements were just single predicates and the declarations in the rule prolog were all one-offs. Later I went back and wrote a complete, generalized expression language that could be used in the conditionals
Continue reading {Designing the Kynetx Rule Language}
More on Context Automation, Privacy, and Kynetx Business Models
Joe Andrieu posted a response to the white paper I released last week. I'm grateful that Joe would take the time necessary to read the paper in depth and offer a long, well-thought out, and helpful set of questions and critique. From his article it's clear to me that Joe understands the problem space well and has a firm grasp on what Kynetx is doing there. Joe raises a number of questions and points that I'd like to respond to. First, Joe asks who the target developers are: Web sites or third party services. Or both? Our primary offering
Continue reading {More on Context Automation, Privacy, and Kynetx Business Models}
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
