电竞|投注推荐

                          Posts with keyword: krl


                          Updated Pico Programming Workflow

                          This page introduces the tool chain in the programming workflow for picos.
                          Continue reading...


                          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...


                          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...


                          We're Teaching Programming Wrong

                          Event-based programming is more natural for non-programmers than imperative or object-oriented styles.
                          Continue reading...


                          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...


                          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...


                          Evaluating KRL Declarations

                          Here's a little project that makes testing KRL expressions easier.
                          Continue reading...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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 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...


                          Events, Picos, and Microservices

                          I spoke at Apistrat 2014 today in Chicago on the Fuse architecture and API. Here are my slides.
                          Continue reading...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          Using Dropbox and OAuth 1.0a in KRL

                          Here's a recipe for accessing Dropbox and using OAuth 1.0a in KRL.
                          Continue reading...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          My Conceptual Toaster

                          Conceptual things are a modeling method we need to embrace as we build out the Internet of Things.
                          Continue reading...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          Pagerank for Event Graphs

                          Using an event graph can help us understand relative connectivity in a decentralized network of event-based applications.
                          Continue reading...


                          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...


                          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...


                          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...


                          The Layers and Components in a Cloud OS

                          This diagram shows the organization of components in the personal cloud operating system.
                          Continue reading...


                          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...


                          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 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 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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          Event Channels

                          Event channels provide a means for people to independently manage, permission and respond to online connections.
                          Continue reading...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          Personal Event Networks, Social Products, and Value

                          An introduction to personal event networks, how they work, and why they create value.
                          Continue reading...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          "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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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 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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                          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...


                                                  Go abroad

                                                  image

                                                  Buy a car

                                                  game

                                                  Second-hand housing

                                                  car

                                                  fashion

                                                  Buy a car

                                                  society