电竞|投注推荐

                          Posts with keyword: kynetx


                          The 10-Year Platform: Shutting Down KRE

                          The original pico engine, KRE, is no more. But the ideas and capabilities of the platform live on in the new pico engine.
                          Continue reading...


                          The End of Kynetx and a New Beginning

                          Last week, the Kynetx shareholders, on recommendation from the Board of Directors, voted to dissolve Kynetx. This article is about what comes next. The short answer is a new birth.
                          Continue reading...


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


                          Fuse App Launches

                          Two important announcements about Fuse: the apps are available now and we've launched a forum for discussions around Fuse.
                          Continue reading...


                          Fuse Version 1 Candidate Release for 20140815

                          This blog post gives some highlights from the recent release candidate for Fuse version 1.
                          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...


                          What Happens to the Data

                          Metromile offers per-mile car insurance based on an OBD II device that plugs into the car and reports data about how the vehicle is used to the insurance company. This raises questions about where the data goes, how it's used, and who owns it. Even more important, it's a business model that promotes the creation of data silos.
                          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...


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


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


                          Vehicles That Get Better Over Time

                          As software becomes a bigger and bigger part of everything, the rules have changed for manufacturers of durable goods. They will have to adapt to customers who expect things to be updated and fixed automatically. For car manufacturers, this means that if I don't feel like my car has gotten better in some ways, because the software in it has gotten better, you're going to lose me as a customer.
                          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...


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


                          Intention Generation: Fuse and VRM

                          One of the most influential books I've read in the last several years is Doc Searls' Intention Economy. The concept is simple: customer demand is the source of commerce and yet business has done a poor job of finding ways to understand customer intention. Doc's ideas have given rise to a movement called vendor relationship management or VRM. The term is a play off of CRM, and leads to a key idea: customers need tools to manage their interactions with the people who sell them products and services. When I write about social products, I'm writing about one such
                          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...


                          Kynetx Reboot

                          We've had a successful Kickstarter and now we've got a new CEO. Kynetx is ready to take off.
                          Continue reading...


                          Fuse Funds! Thank You and Next Steps

                          Our Kickstarter campaign for Fuse has ended successfully. This was an exhilarating experience. Thanks to everyone who participated.
                          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...


                          Persistent Compute Objects and the Fabric of Cyberspace

                          Persistent Computer Objects, or picos, give rise to a new way to build internet-based applications to separates app and user data. Users control their own picos and thus the data and processing on them. This presentation describes what picos are, the new programming model they support, and shows Fuse, a sample application built using this new model.
                          Continue reading...


                          Fuse and Open APIs

                          Fuse will have an open API from the start, making it a powerful, connected-car platform for developers who want to build applications that need data from the car.
                          Continue reading...


                          How is Fuse Different?

                          Fuse isn't the only connected-car product on the market, but it has several unique features that set it apart from the rest. This post outlines some of those important distinctions.
                          Continue reading...


                          Fuse: Connecting Your Car - Our New Kickstarter Campaign

                          Fuse is a new product that connects your car to the rest of your life. Here's the backstory on what we expect for Fuse and the Kickstarter campaign.
                          Continue reading...


                          My Dryer: A SquareTag Case Study

                          This simple case study of my dryer in SquareTag illustrates the value of social, online products.
                          Continue reading...


                          The Family Fleet Manager

                          As the family fleet manager, I need a little help. SquareTag to the rescue!
                          Continue reading...


                          M2M for People

                          M2M has traditionally been about businesses managing the things they manufacturer, with end users only an after thought. But as the price of connecting things drops, much of what has been done for years in the M2M space, becomes possible for end users too. I call this M2M for People.
                          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...


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


                          IMAP as the Proto Personal Cloud

                          If you have used IMAP to connect an email client to an email server, then you already know the benefits that a personal cloud will provide to you. IMAP and SMTP create an email ecosystem where the user is in control. That's what personal clouds do for other applications.
                          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...


                          Own Your Identity: Important Principles

                          If we are to have agency online, freedom of contract and substitutability are two vitally important principles that we should strive to build into online services.
                          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...


                          Cars, Privacy, and Personal Clouds

                          We don't have to chose between functionality and privacy as more and more of our things get connected. Personal clouds provide an architecture that supports both at the same time.
                          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...


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


                          Introducing SquareTag

                          We're getting ready to launch a product called SquareTag. This post explains what SquareTag is and how it works. If you'd like us to send you a sample SquareTag, let me know your physical address.
                          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...


                          The Digital Asset Grid Session at SIBOS

                          For the last six months Kynetx has been working partnership with several other companies on a project for the Innotribe division of Swift. The project, called the Digital Asset Grid provides a way for banks to become platforms.
                          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...


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


                          Riding the Temple Tour

                          The Temple Tour is a new bike ride we've started at Kynetx. It's a good excuse to get out on a hot June morning.
                          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...


                          Buying a Motorcycle: A VRM Scenario using Personal Clouds

                          I'm interested in understanding how personal clouds and personal channels can be used to bring intentcasting scenarios to life. This post describes a detailed scenario involving a motorcycle purchase that includes three phases: finding the bike to buy, connecting with the seller, and buying the bike.
                          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...


                          Moving Toward a Relationship Network

                          Would you have your electronic bills delivered by Facebook or Twitter? Not likely. You bank won't trust them and neither will you. You need a channel that is designed for banking with the right security, privacy, and legal foundations. A standards-based, decentralized, multi-channel relationship network, however, could easily be used for this purpose because the banks and companies delivering bills could define the nature of the channel. They don't have to wait for Facebook to get around to it and then hope they do it right.
                          Continue reading...


                          Facebook Domination Isn't Inevitable—It's Not Even Likely

                          More people—especially geeks—need to understand that protocols are worth the effort they require. And let's not dodge that; decentralized systems are more work. They are harder to design, harder to build, and harder to bootstrap. But the forcing function, freedom, is powerful and eventually wins out.
                          Continue reading...


                          Unlocking Data Exchange: The Long Tail of Data

                          Much has been made of data lately. And with good reason. Data and the ability to exchange and process it are at the heart of modern society's productivity and prosperity. Data and algorithms are the engines that drive the economy in the 21st century. But data is often onerous to obtain, difficult to trust, and hard to understand. Fixing these problems--making trustworthy, understandable data flow more freely, consistently, and reliably--will provide a wellspring of new ideas and companies to prosecute them.
                          Continue reading...


                          PDS Interoperability

                          For personal data services to really take off, they have to interoperate. Here are some use cases that illustrate what PDS interoperability means.
                          Continue reading...


                          Starting a High Tech Business: Being Startup Compliant

                          If you want to be an entrepreneur, debt is a form of enslavement that you just can't afford.
                          Continue reading...


                          From Personal Computers to Personal Clouds

                          From Personal Computers to Personal Clouds is a whitepaper that explains why the future of personal clouds will be very different from what you have imagined. As more and more of our interactions move online, we increasingly have need of an online place that operates for us. That requires an operating system so that developers have a framework to work within. Operating systems provide a core set of services around identity and data as well as a programming model.
                          Continue reading...


                          Has Social Networking Reached the End of its Cycle?

                          Most of the hot trends on computing seem like more of the same and people start to wonder how all this personal data they're sharing can help improve their lives. Personal clouds and life management platforms offer a revolutionary answer to what's next.
                          Continue reading...


                          The Importance of Protocols

                          Protocol is all around us in the conventions we use everyday to interact with people. Protocol creates a framework within which different agents can interact and accomplish some purpose. Protocol allows me to interact in a store where the checker and I speak different languages. I only need to understand her when we need to depart from the protocol. Inside the protocol, everything is syntactic. Outside the protocol, semantics matter.
                          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...


                          Personal Clouds as General Purpose Computers

                          Personal clouds needn't be complex to set up or manage for them to have significantly more power than the cloud appliances that companies offer people today. We envision systems that are no more complicated than a smartphone that offer the features and benefits described above.
                          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...


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


                          A Web of Things on the Internet of Things

                          Giving me more apps on my phone and more things to manage doesn't appeal to me. But giving me a personal network that automates drudgery and enables things that I couldn't do before does. That's the promise of a personal event network and why I think everyone will want one.
                          Continue reading...


                          APIs That Call You

                          Different standards are required for different types of subscription or push APIs. The Evented API specification for point-to-point or entity-centric APIs.
                          Continue reading...


                          Products as Avatars for a Service

                          Products are becoming mere physical manifestations of the services behind them. This is an important step in creating a world of social products that cooperate on your behalf.
                          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...


                          The Second PC Revolution: Personal Clouds

                          Cloud computing and big data are the mainframe ideas of our time. What happens when there's a personal cloud revolution to match the personal computer revolution?
                          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...


                          App Pushers and Enforcers

                          Lately, I've noticed a phenomenon that is extremely unhealthy, not mention annoying: companies more or less forcing you to use their mobile app instead of their Web site. The truth is that most businesses don't need an app. They just need a Web site that works.
                          Continue reading...


                          The Evented API Specification

                          The Evented API specification provides a standard method for APIs to signal events using any programming language or system that supports HTTP. Signaling events from APIs provides a means for them reach out when something happens instead of waiting for a request.
                          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...


                          A Facebook of Things

                          When we talk about social products and services, the question that naturally arises is: what will be the Facebook of Things look like? Here are my thoughts.
                          Continue reading...


                          Curation in the Small: Personal Event Networks and Getting Things Done

                          As enterprises become more social they will necessarily start to give customers access to information that allows them to curate their own interactions with myriad systems and services. Building systems that use and respond to this information will greatly enhance how we interact with service providers. Personal event networks can play a role in making the interoperability and orchestration of these system scalable and affordable.
                          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...


                          Eric Schmidt's Commerce Fantasy

                          Eric Schmidt's vision of ecommerce in the future lines right up with the anonymous ecommerce application that I wrote last month.
                          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...


                          Install Kynetx for Google Chrome

                          The Kynetx Browser Extension (KBX) is now available for Google Chrome users in the Chrome Web Store. KBX is a universal browser extension that allows you to run Kynetx applications in any browser. There are dozens of Kynetx browser apps available right now and developers are creating more all the time. Because the apps run in the cloud, you get the same behavior from apps whether they're running in Chrome, Firefox, or Safari (IE support is comming soon). What's more, even if you only use one browser, the apps behave uniformly across every computer you own and any app
                          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 Value of Browser Add Ons

                          Today a question about the size of the browser add-on market came up and more specifically, what kinds of things people used browser addons for. I spent a little time at AMO to try and find some answers--at least for Firefox. First the AMO statistics site shows that there are almost 200 million addons in use and that number continues to show healthy growth for the last few months. AMO lists over 5000 add ons. The most popular is Adblock Plus with almost a million weekly downloads. I classified the top 100 addons on AMO according to the following
                          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...


                          Building a Personal Commenting System Using Twitter and Kynetx

                          Earlier today I was talking to Britt Blaser about making the Web friendlier for people who want to organize around political issues. Of course, I immediately imagined a Kynetx application for doing. Doing this as a browser application would have a few advantages: A browser application operates anywhere people wanted to comment and yet still bring the comments together in various, meaningful ways. A browser application can pull information from various contexts and make it available where people are. A browser application would be easily updated as new features were added. What I envision is something that combines the
                          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...


                          Pictures from Kynetx Impact

                          Doc Searls took some great pictures of Kynetx Impact last week and posted them. There are some fun shots in here. I'm disappointed its over and looking forward to next year already. Here's one of me and Craig Burton from Doc's set:
                          Continue reading...


                          Clean Sheets and APIs

                          David Barrett of Expensify just led a session at Kynetx Impact on APIs. His talk was listed as "When APIs go bad. APIs are powerful, but when should you consider not providing an API for your data." He followed Sam Ramji who gave an updated version of his Darwin's Finches talk. The updates are recorded in two recent articles The Building Blocks for a Successful API Strategy and With APIs It's Caveat Structor - Developer Beware. Consequently there was some good discussion and interaction from the audience. David's main point is that building an API isn't free and for
                          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...


                          Starting a High Tech Business: Making Hard Decisions

                          I'm the founder and CTO of Kynetx. This series of articles relates my discoveries and feelings about starting a high-tech business. This is the thirty-first installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! Suppose you had a big tank. It's got water in it. There's a hole in the bottom and a few small pipes delivering water. Unfortunately the pipes are smaller than the hole. Your goal is to never let the tank run dry. You've managed to get by through periodic deliveries of water from an out
                          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...


                          Kynetx is Looking for a Part-Time Programmer

                          If you're a good developer, have always wanted to work on cutting edge stuff in a fun place, and are looking for part-time work, then Kynetx would like to talk to you. If you send me email, leave a comment on this post, or call, you will be ignored. If you come to Free Lunch Friday the day after tomorrow or next week, then you can get to know us and we can get to know you. Please RSVP to the plancast so we know you're coming. This position has the possibility of turning into fulltime employment and what
                          Continue reading...


                          Starting a High Tech Business: Follow Standard Business Practices

                          I'm the founder and CTO of Kynetx. This series of articles relates my discoveries and feelings about starting a high-tech business. This is the thirtieth installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! The other day my wife was telling me about a friend of our's whose ex-husband "lost everything because his partner was embezelling." I hear things like this from time to time. I'm sure you do as well. But there's really no reason for it. Proper financial controls can help keep everyone honest. When we started
                          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...


                          VARs, Clouds, and Silver Linings

                          Hunter Richards has a nice article on the challenges facing value-added resellers with the ongoing move to the cloud. He makes some excellent points about what parts of the VAR business are going away and which are expanding, giving five moves VARs can make to gain a foothold in the new cloud computing market: Specialize Develop competancy in PaaS poducts Make the cloud's efficiency work for you Offer technology-enabled services Promote the cloud to your existing customer base One of the things I like about Hunter's thinking is that he's not focusing, as many do, on the IaaS plays.
                          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...


                          Engineers Do for $1.00 What Any Fool Can Do for $2.00

                          Guest post by Wade Billings, VP Operations, Kynetx When we started Kynetx, we had a very limited IT budget due to fact that the company was bootstrapped with the proceeds of selling the founders Piper Turbo Arrow airplane. From the beginning, Kynetx was built upon the conviction to be initially self funded and very strong beliefs regarding system performance and stability, so from day one, we lived inside a paradox: how do you maintain a high level of reliability, accessibility and stability when you have little in the way of resources or capital to expend. Had we started Kynetx
                          Continue reading...


                          Architectures and Patterns: Hitting the Sweet Spot

                          The Web, indeed the Internet, has a rich tradition of being made from "small pieces, loosely joined" to use David Weinberger's excellent phrase. The beauty of the Web is that it's all built from a handful of relatively simple standards: HTML, a standard for marking up documents with formatting instructions and creating rudimentary user interfaces called "forms," HTTP, a simple request-response protocol for moving resource representations (which might be documents formatted in HTML) from place to place, and URIs, a standard for how resources will be universally reference on the Web Using those simple pieces, the Web has evolved
                          Continue reading...


                          Endpoint: What Does it Mean?

                          I'm trying to determine the effectiveness of a bit of nomenclature. You can help me by taking the following poll: \tWhat does the term "endpoint" mean to you?survey software
                          Continue reading...


                          Streams of Micromessages: Building the Live Web

                          Steve Gillmor recently described a breakfast meeting Micorsoft's Ballmer had with Twitter's Costolo, it's timing, and--more interesting--what it means called breakfast with Twtter. The point of the article is that Microsoft's empire is built on a crumbling foundation that has at it's very base "Outlook." Outlook is vulnerable because it's not real-time. Microsoft's efforts to bring real-time into Outlook have largely failed. Here's Gillmor's words: For all the power and money Ballmer commands at Microsoft, he faces a serious vulnerability at the heart of his Windows/Office stack. In a word: Outlook. If Outlook goes, Office goes. If Office goes,
                          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...


                          Starting a High Tech Business: We Believe...

                          I'm the founder and CTO of Kynetx. This series of articles relates my discoveries and feelings about starting a high-tech business. This is the twenty-ninth installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! A while back I was pointed to this TED video by Simon Sinek on how great leaders inspire action. The talk is marvelous and is well worth watching. The line I like best: "[Martin Luther King] gave the 'I have a dream' speech, not the 'I have a plan' speech." Here's the primary point: Every
                          Continue reading...


                          Podcast: Kaliya Hamlin Interview Me on Personal Data Ecosystems

                          Kaliya interviewed me for her Personal Data Ecosystem podcast series. Here's her description? In this podcast Kaliya talks to Phil Windley who is the CTO and co-founder of Kynetx and co-founded and co-produces the Internet Identity Workshop with Kaliya & Doc Searls. He gives his perspective on the key differentiator between today's social networks and Personal Data Ecosystem the emergence of the personal data store where individuals control their own data. He also covers the event based architecture his company Kynetx is developing and refers to the project neck pain demo. In the podcast he mentions Twillio.
                          Continue reading...


                          Podcast: Ylian Saint-Hilaire on MeshCentral

                          This week Scott and I spoke with Ylian Saint-Hilaire of Intel about his MeshCentral project. While we were talking I just kept thinking how cool it would be to use Kynetx react to the events this system creates. I didn't indulge myself however, that will wait for a future conversation. Here's the description from IT Conversations: MeshCentral, a remote monitoring and management web site, allows a user to connect with home or office devices from anywhere in the world. It requires a special management agent on computers, but once installed, the computers will show up in the My Devices
                          Continue reading...


                          Starting a High Tech Business: Move As a Pack

                          I'm the founder and CTO of Kynetx. This seriesof articles relates my discoveries and feelings about starting a high-tech business. This is the twenty-eighth installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! Yesterday we had a short service degradation at Kynetx caused by a server that kernel paniced. As the incident was in play, I received periodic reports from Wade Billings and Dan McGarry about what steps were being taken to remediate the problem and address customer notification and concerns. Afterwards, I tweeted: The nice thing about working
                          Continue reading...


                          The Real-Time Web

                          Over the last several years, we've witnessed a dramatic shift in how people use the Web. What started as interactive Web applications under the moniker "Web 2.0" has become a firestorm of social applications like Facebook, Twitter, and Foursquare, among others. But underlying these changes is something even more important than the "social" Web: the "real-time" Web. The real-time Web is a radical shift in how people use the Internet: rather than simply viewing static pages, or even interacting with a Web site, the real-time Web uses dynamic streams of information to present contextual, relevant experiences to user. These
                          Continue reading...


                          The Dawn of the Eventernet

                          This is a guest blog post by Dave McNamee The Eventernet is an event architecture overlayed on the Internet, where events are published and applications process those events and take action on behalf of people. This allows for the creation of new value that was not possible under the constraints of the request architecture of the WWW. The World Wide Web In the beginning there was HTTP with its collection of methods. GET, POST, PUT, DELETE, etc. These methods, along with the advent of HTML (and browsers that could render HTML) allowed the World Wide Web to emerge and
                          Continue reading...


                          Essential Characteristics of a Personal Data Store

                          I'm in a session at IIW where personal data stores are being discussed. Drummond Reed and Paul Trevethick are moderating. Someone asked Paul why Facebook isn't a personal data store. Certainly is a store of personal data. Facebook has a rich and powerful mechanism for sharing data with apps. But... They can change the terms any time they like They monetize my data--who owns or controls the transactions Mary Hodder gave a "bank vs bar" analogy. Facebook is a bar, not a bank. There are lots of options and things to do, but no fiduciary responsibility or interoperability. The
                          Continue reading...


                          Starting a High Tech Business: Finding a Market

                          When you're starting a business, you'll hear a lot about product/market fit. Marc Andreesen says: In a great market -- a market with lots of real potential customers -- the market pulls product out of the startup. The market needs to be fulfilled and the market will be fulfilled, by the first viable product that comes along. The product doesn't need to be great; it just has to basically work. And, the market doesn't care how good the team is, as long as the team can produce that viable product. In short, customers are knocking down your door to
                          Continue reading...


                          Voting at API Hack Day: A Kynetx App

                          Sam Curren and Brad Hitze were at API Hack Day yesterday. In a fit of meta hacking, Sam created a voting app that was, at the same time, an app competing in the hackathon and the app recording the votes for who won. The API Hack Day results we computed and communicated in real time using a twitter account from votes made via phone or SMS. Sam's app combined Twilio, Twitter, and a Google spreadsheet. Sam reports that a few people gamed it by provisioning and then dropping telephone numbers, but that's OK. It was still fun. Next time
                          Continue reading...


                          Kynetx Platform Update

                          We've had some changes in the Kynetx platform, KNS, over the last few weeks that I wanted to update people on. First, a few weeks ago, we cut over to a new parser. Yeah, if you're keeping score, this is number 3. The first parser was based on HOP. We replaced that with Damian Conway's Parse::RecDescent as chronicled in a blog post I did in September of 2008. The third (last?) parser is based on the ANTLR parser generator. Cid Dennis did most of the hard work of creating the new Parser and Mark Horstmeier did the Perl integration
                          Continue reading...


                          Events, Webhooks, and the Realtime Web: Kynetx Dev Days

                          At Kynetx we're very bullish on the real-time Web. There are several trends that are leading us inexorably toward better use of real-time data including webhooks, Restful APIs, streaming data from sources like Twitter and Facebook, and Internet identity protocols like OAuth. At Kynetx, we use the term "event-driven" to descibe systems and architectures that make use of these ideas. Kynetx is a system for building event-driven applications that make use of webhooks, APIs, stream data, and user-centric identity. As I said in my post on Static Queries, Dynamic Data: Enabling the Real Time Web, In a traditional database,
                          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...


                          Kynetx DevDay After IIW on November 5

                          Kynetx will be hosting an Impact DevDay on November 5th at the Computer History Museum in Mountain View, CA. This is the Friday after Internet Identity Workshop XI at the same place. Impact DevDay is an all-day, intensive training designed for programmers interested in creating apps that are cross-platform, context-aware, cross-browser and event-driven using the Kynetx Rules Lanaguage (KRL). I've written extensively about KRL and some about why I believe event driven APIs are critical to the Web we all want to build. This is a chance to understand the platform we've built to support this vision and learn
                          Continue reading...


                          Startups in Non-Traditional Places

                          Tim Spaulding who runs LibraryThing, a startup in Portland...Maine asked me on Twitter if I had any thoughts on startups in non-traditional places. The short answer is I've always got thoughts, but I'm not sure how relevant the are. The truth is that while the Wasatch Front isn't Silicon Valley by any stretch, it's got a thriving high-tech community, thousands of software developers working at hundreds of companies, a nascent, but active angel investment community, three strong universities pumping out graduates and ideas, and ahost of support services including legal and PR that understand high-tech business. Just looking at
                          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...


                          Smartphones as the ProtoPDS

                          Last week I had an interesting discussion with Sam Curren where we hit on the notion that the smartphone is a prototype personal data store (PDS). If you think about it, a smartphone--be it Andriod, iPhone, or one of the new Win7 devices--provides a common calendar, a common address book, and common photo library (among other things) with APIs for interacting to all of them. For example, I can change out my calendar app to something like Calvetica (a popular alternate calendar for the iPhone). Doing this doesn't change the underlying calendar data or interfere with any of the
                          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...


                          Starting a High-Tech Business: Hiring Your First Engineer

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the twenty-sixth installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! Allan Carroll asked me a question on LinkedIn that I thought I would answer more publicly: What's most important in hiring the first engineer at a startup and how do you find that person? On one hand, I'm probably not the right guy to answer this question because
                          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 Impact Dev Day this Saturday!

                          Don't forget that the Kynetx Impact Dev Day is this Saturday, Sept. 18th. A full day of intensive training, brainstorming and app-building for developers. And it's FREE! If you haven't signed up yet, make sure you sign up today so we can save you a seat. Can't make it, but want to watch? We'll be streaming the main sessions on the Kynetx Ustream channel. If you are coming, we'll be having an open sign-up for the App Showcase at 4:00. Have a cool app? We want you to see it, so come prepared to show & tell.
                          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...


                          Starting a High Tech Business: The Wind at Your Back

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the twenty-fifth installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! Saturday I rode the ULCER century bike ride for the fourth time. This is a great century that goes around Utah Lake. I look forward to it every year. Every year the ride is a little different. This year, the wind was blowing from the South-South West and
                          Continue reading...


                          Beyond APIs: Declarative References to Data

                          APIs are coming into their own. Gluecon was abuzz with them. I've seen Sam Ramji's talk on Darwin's Finchs and APIs referenced everywhere--and rightly so. One of the problems with RESTful APIs, however, is that every time someone comes up with an API, I have to read the docs and then code, by hand, an interface between that API and my language. For popular APIs libraries are already written to do that. For smaller APIs, I'm on my own. At the Cloud Camp that preceded Gluecon, one of the discussions was about a way to fix that: an API
                          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...


                          Changing the News with Kynetx: Utah Company WILL Revolutionize Internet Use

                          Yesterday Tom Harvey of the Salt Lake Tribune had a great article on Kynetx in the Money section (see Utah company looks to revolutionize Internet use). I loved the article, but what I loved even more was what Casey Holgado (@caseyholgado), one of our summer interns, did with it. Here's the headline for the online article as it appeared: Casey wrote a quick Kynetx app that changed the headline to read like this: This to me embodies the spirit of Kynetx: "the Web, your way." We didn't change the text on the server, of course, only the headline for
                          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...


                          Starting a High Tech Business: Plugging the Fat Pigeon

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the twenty-fourth installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! Some companies are "high-tech" companies. That is, their business model requires building custom technology that differentiates them from their competitors. Others don't differentiate through technology per se, but how they use it. In other words, their business model isn't very dependent upon building intellectual property in the form
                          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...


                          Starting a High Tech Business: The Dark Side of Using a PEO

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the twenty-third installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! At Kynetx we use a professional employee organization (PEO) to reduce the overhead we have with managing all the details surrounding having employees. The way it works is that your employees officially work for the PEO and you "lease" them back. This works very well
                          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...


                          Automatic Negotiation of Contracts Using Context

                          Image by IsraelMFA via Flickr I had some great discussions with Renee Lloyd of Project VRM this week at Kynetx Impact on the subject of legal agreements and context. I don't pretend to understand the legal issues sufficiently well to exilian them here, so I'll just summarize my understanding and let Renee and others correct me where necessary. The problem is that the terms and condition agreements that most Web sites use ubiquitously have some legal issues that make them less than ideal. Moreover people dislike them. Their inflexibility leads to lost business and opportunity. What if we had
                          Continue reading...


                          CTO Breakfast Following Impact

                          Image by windley via Flickr In one of those scheduling goofs that look good 6 months beforehand, but utterly silly up close, I've schedule this month's CTO Breakfast just a day after the Kynetx Impact conference. Not to mention we have 20 people staying over after Impact to talk about personal data exchanges on Thursday. Nevertheless, the CTO Breakfast will happen on Friday morning at 8am in the usual place (Novell cafeteria). You're invited. You don't have to be a CTO, just interested in technology developments. While you're planning your week, please also come to Kynetx Impact on Tuesday
                          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...


                          Apps Make Downloads Cool

                          Image by Getty Images via Daylife Have you ever noticed that many of the things you do in an app on your iPhone, iPad, or Android phone could just as easily be done using just the Web and a browser? My bank, for example, has an iPhone app. They also have a pretty nice Web site. What they don't have is a pretty nice mobile version of their Web site. They put their money into creating an app rather than merely putting a mobile skin on their current system. Many other apps are similar. Why do they do this?
                          Continue reading...


                          10 Reasons You Should Attend Kynetx Impact

                          On April 27-28, we'll hold the second Kynetx Impact conference. The first, last November, was well attended, very fun, and people consistently told us that they learned a lot. Impact isn't just a conference about KRL (Kynetx Rule Language) and the cool things you can do with it--although you'll find plenty of that too--it's a conference about what we think of as the client-side revolution: a whole new way of Web programming that thousands of developers are discovering. So, with that intro, here are ten reasons you should come to Impact: Jon Udell - Jon Udell will be giving
                          Continue reading...


                          Thinking About Cassandra

                          This week on the Technometria podcast, Scott and I interview Jonathan Ellis about the Cassandra Project. Cassandra is an open source distributed database management system used by Facebook, Twitter, and other sites. Cassandra is a distributed database that is designed for extreme scalability. Cassandra is one of the so-called "NOSQL" databases. That's something of a misnomer, because its not specifically SQL that they're lacking--although they are that--but relations. Like Amazon's Dynamo and Google's Bigtable (from which it draws its founding ideas), Cassandra is designed to solve the problems that many modern Web applications have for storing data. That's not
                          Continue reading...


                          Come to Kynetx Impact in April

                          On April 27-28, we'll hold the second Kynetx Impact conference. The first, last November, was well attended, very fun, and people consistently told us that they learned a lot. As I mentioned previously, Jon Udell will be the keynote speaker and I expect it to be a great talk. In addition to Jon's keynote, we'll be talking about client-side Web programming and why it's the next exciting place to work on the Internet. We've got a lot going on in preparation for this spring's Impact. There will be a number of big announcements from Kynetx and our partners about
                          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...


                          Using the .tel TLD for Managing Contacts

                          This week's Technometria podcast is with Henri Asseily, the CTO of Telnic. Telnic is the registry for the .tel top-level domain. The .tel domain is a little different than most domains you might run across. For one, you can't point it at a Web site (although you can get email through it using MX records). The registry controls the A records for the domain and they all point to a contact page. For example, here's my .tel domain: windley.tel. I, of course, control all this data using a Web page that they provide for that purpose. The nifty thing
                          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...


                          Subscription Models are Chic

                          Image via CrunchBase A recent blog post by Dave McClure, the investor in charge of the Founders Fund seed investment program makes the assertion that "subscription models are the new black" and we've lost a decade of innovation by people living off the table scraps of Google's $10B pay-per-click ad system. (Warning: the blog post is pretty raw.) In a seeming non-sequiter, he moves on to talking about passwords. But pay attention, because what he's really doing is talking about friction in subscription models and the friction that they inpose. I think it's interesting that the iPhone app store,
                          Continue reading...


                          CTO Breakfast Tomorrow - Free Pizza Tonight

                          Tomorrow is the CTO Breakfast. I know, kind of late notice, but this one snuck up on me. I've been heads down with a major ope-heart surgery of the Kynetx rules engine. I'll tell you all about it tomorrow at the breakfast--refactoring code provides lots of opportunity for reflection on software development. The breakfast will be held in the usual place (Novell Cafeteria in Provo - map) at 8am. Anyone interested in how information technology is used to build products or run companies. Despite it's name, you don't have to be a CTO to attend--just interested in technology, where
                          Continue reading...


                          Starting a High Tech Business: Do What's Important by Embracing the Urgent

                          Image by Getty Images via Daylife I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the twenty-second installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! Last Saturday I attended the BYU vs Colorado State basketball game and came away with a lesson I hadn't anticipated. When the game first started, things seemed pretty even matched and you'd have had a hard time seeing significant differences between the
                          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...


                          Free Pizza and Kynetx on Wednesday

                          On Wednesday we're going to have a little dev party at Kynetx for anyone who wants to stop by, ask questions, learn how to program in KRL, or just hand out. The Kynetx development team will be there along with other developers who are using KRL. Come by around 5pm and we'll stick around at least until 7, later if people want. Here's the address: 3098 Executive Parkway Suite 280 Lehi, UT 84043 Suite 280 is in the southeast corner of the 2nd floor. Here's a link to a Google map. I hope you'll stop by, check out our
                          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...


                          Come to Kynetx Impact This Week

                          If you're a regular reader of my blog, then you know that we're having a developers conference for Kynetx on this week on November 18-19 in Provo called Kynetx Impact. There's an awesome agenda with some great speakers including Doc Searls, Kim Cameron, and Paul Trevethick. There will also be great food, great people, and a chance to see first hand what we're doing at Kynetx. You can sign up online. Over 110 people are signed up already and we're expecting a standing room only crowd. I'd like for you to come to Impact. Use Windley25 to get 25%
                          Continue reading...


                          We Need More Than a Selector

                          If you glance at Johannes Ernst's latest blog post, Why We Really Don't Need an "Identity Selector", you might think he's speaking out against identity clients, but in reality, he's speaking out against identity "selectors." That is, the idea that the most important, useful feature of such a client is "selecting" an identity. He says: The correct product is not a "selector". It also must be: An identity "de-selector", with which the user can become anonymous again (or perhaps even remove all the information from the site which was conveyed during the "identity selection" phase). The much-desired "single sign
                          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...


                          It's My Browser and I'll Auto-Click if I Want To!

                          A month ago, I posted a piece claiming my right to a purpose-centric web. In it, I stated: I claim the right to mash-up, remix, annotate, augment, and otherwise modify Web content for my purposes in my browser using any tool I choose and I extend to everyone else that same privilege. Not surprisingly, the EFF agrees with me. Not on this exact issue, but in the spirit of the user having the right to control the experience on their own machine. They say: Free file hosting provider MediaFire seems to think that, when you follow
                          Continue reading...


                          Starting a High Tech Business: No Cold Hires

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the twenty-first installment. You may find my efforts instructive. Or you may know a better way--if so, please let me know! In the past two weeks Kynetx has doubled in size. There's lots to do and the resources to make it happen, so getting more people became a priority. Getting the right people became the most important thing Steve and I could do for the long
                          Continue reading...


                          Kynetx Impact Agenda: Register Now!

                          We've finalized the agenda for Kynetx Impact on Nov 18-19 in Provo, UT (register here). I'm pretty excited at the agenda we've managed to put together and the keynote speakers who will be there: Doc Searls and Kim Cameron. I hope you can come. Wednesday Nov. 18 8:30 AM \tBreakfast & Registration 9:00 AM \tKeynote Address: "The Intention Economy: What Happens When Customers Get Real Power,"\tby Doc Searls, Sr. Editor of Linux Journal & author of "The Cluetrain Manifesto." 10:00 AM Keynote Address: "The Forgotten Edge: Building a Purpose-Centric Web," by Dr. Phil Windley, Kynetx Founder & author of the book,
                          Continue reading...


                          UTOSC: Open Source and Utah

                          Last week was the Utah Open Source Conference. This annual event has grown to be a conference that is every bit as enjoyable and informative as and conference I travel to see. There were easily 400 people there. I can't name all the people involed and their "about" page doesn't list their names--it should. These people are performing a great service to the tech community in Utah and we owe them a huge thank you! Kynetx had a table in the exhibitor area and there was a steady stream of visitors. Sam spent much of the day at the
                          Continue reading...


                          New Media Platforms, Building Audience, and the Purpose-Centric Web

                          Last week Seth Godin posted a piece on his blog called The platform vs. the eyeballs. The idea is that in "old media" the medium has control of the customer and "rented" them out to people who wanted to influence them. This is the premise of anyone getting paid for advertising. If you have control of a flow of users, you can charge other people for access to that flow. In essense you're renting out the flow. Seth argues that in "new media" you're not renting an audience, you're building one. Seth calls the thing you use to build
                          Continue reading...


                          You're Invited to Kynetx Impact

                          I've recently been writing about my thoughts on building a purpose-centric web and how SideWiki illuminates the client-centric focus of a purpose-based Web. If you've read through these (yeah, they're long) then you'll know that Kynetx is in the business of helping developers build purpose-centric applications that run in the browser. If that interests you at all, I'd like to invite you to sign up for Kynetx Impact, our conference for bringing together anyone interested in the idea of a purpose-centric Web and building applications for it. Doc Searls will be giving the keynote and I'll be speaking about
                          Continue reading...


                          Claiming My Right to a Purpose-Centric Web: SideWiki

                          Image via CrunchBase Yesterday Google released a small project called SideWiki. SideWiki, enabled by the Google Toolbar, allows people to write commentary about Web pages and see the comments that other have left. The service is opt-in: people can install the toolbar or not and even when it's there, turn SideWiki off if they don't want to see it. But it's not opt-in for a site--you can comment on any page without the permission of the owner. The reaction has been interesting. I've seen tweets from people about how they thought it was wrong for people to be able
                          Continue reading...


                          The Forgotten Edge: Building a Purpose-Centric Web

                          Abstract Since it's inception, the primary metaphor of the Web has been one of location. By framing the Web as a collection of places, we have necessarily caused Web development to focus on servers. But people don't get online to go to a server. They get online to get something done--achieve a purpose. This talk argues that focusing on purpose allows us to build Web applications that more closely align with what people want from the Web. Focusing on purpose will require a move to more intelligent client-side applications. Technological development in the area of Internet identity over 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...


                          Shift Index, Intense Competition, and Continual Innovation

                          Image by Joi via Flickr This morning, I was listening to John Hagel talk to Moira Gunn on IT Conversations. The topic was a recent report he, John Seely Brown, and Lang Davison wrote called the Shift Index (PDF). They spoke about how the Internet and computers are different kinds of technological change than, say, TV. TV wasn't a tool anyone could use. Computers are--and people do. Blogs, twitter, and social networks are examples of that. The result is constant change leading to intense competition. Moira talked about how one of her grad students has a little Web business
                          Continue reading...


                          Kynetx Endpoints and Linux

                          Over the weekend, Travis Hartwell tweeted "I would try out Kynetx, but it appears the required plug-in Azigo is not available for Linux." Alas, It's true that Azigo doesn't support Linux. Still, there are some ways to use Linux to develop and deploy Kynetx apps. In fact, I do all my development on Linux. We call the way that a Kynetx app is deployed an "endpoint." The endpoint is responsible for initiating the call to KNS and mediating the interaction with the client. The details of the execution model are available online. There are several ways that Kynetx apps
                          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...


                          Sweetter in Ubiquity

                          If you're a Ubiquity user, Mike Grace has created a Ubiquity script to run Sweetter. Note that regardless of whether this is running as a bookmarklet or a Ubiquity script, it's still executing KRL in the cloud which delivers Javascript to the browser. All the bookmarklet or Ubiquity script is doing is planting tags to make the call to KNS.
                          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...


                          Sam Rides 1000: Kynetx and Google Docs

                          Sam Curren, who works at Kynetx set a goal to ride his bike 1000 miles this summer. And because he's a geek, he instrumented the whole effort so that we could all follow his efforts. The way he created a dashboard of sorts for his riding using a combination of Google Docs and a Kynetx App. Sam's first task was data collection. He uses a Android-powered G1 for his phone. He installed the My Tracks application to record the data for his ride and then uploaded the data to Google Spreadsheets. Creating his "dashboard" involved using Yahoo!
                          Continue reading...


                          Starting a High Tech Business: Only the Employees Will Care

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the twentieth installment. You may find my efforts instructive. Or you may know a better way--if so, please let me know! Businesses have all sorts of constiuencies: shareholders, customers, employees, and so on. And for one reason or another you might argue which is most important. When you're on a board of directors, for example, you work for the shareholders and, except where required by law, put their needs
                          Continue reading...


                          Context Automation Talk from Gluecon

                          My talk on Context Automation is up on InfoQ now. They've done a nice job with video and slide syncing. In this talk, I discuss the role of digital identity in context automation and web augmentation. I go through an example of building a ruleset in KRL that puts the latest tweet for a search term inside the google search results as part of the talk.
                          Continue reading...


                          Automatically Building, Configuring, and Maintaining Complex Infrastructure

                          I've been heads down for the last few weeks getting a project out the door for a new customer. As I mentioned, this involves creating a virtual appliance. I decided, due to the circumstances of this deployment that the best option was the build an appliance factory that is capable of churning out new virtual machines at will. I'm going to describe how I did that in this post. There are bascially three steps to creating a new image that runs the Kynetx Network Service (KNS): Create a new virtual machine Install packages and Perl libraries,
                          Continue reading...


                          Starting a High Tech Business: Selling the Third Deal

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the nineteenth installment. You may find my efforts instructive. Or you may know a better way--if so, please let me know! I have a theory that the third deal matters more than the first two. Here's why. The first time you sell your product--your first deal--is always exciting. But let's be honest, it could be a fluke. If you beat the bushes long enough you're likely to find someone
                          Continue reading...


                          Kynetx Open House and Demo Day

                          This Friday at 11:30, Kynetx will host an open house and demo lunch. If you'd like to see what we're up to, stop by, eat some pizza, see some demos, and chat. We're especially interested in getting more people developing on our platform, so if you'd like to try it out, we'll have sign up cards for anyone who wants them. We'll be at Kynetx World Headquarters in Thanksgiving Point. This map will give you directions; we're in Suite 275 (metal door). Please RSVP so we know how much pizza to buy.
                          Continue reading...


                          Building a Virtual Appliance: First Steps

                          Image by MrsWoman via Flickr This week I've been working on creating a virtual appliance (VA) version of the Kynetx engine. This is a necessary step for customers who need a version of the Kynetx Rules Engine (KRE) running behind their firewall (think SAS70 compliance, for example). This post documents some of what I discovered. (N.B. Since I'm working with Xen, much of what appears below could be Xen specific; I haven't taken the time to generalize it.) First, and most important, there's no standard definition of what a virtual appliance is or how they are built. There are
                          Continue reading...


                          A Tail of (Disk) Corruption and Eventual Salvation

                          Yesterday I accidentally overwrote the disk image of a running Xen server that represented a machine in production. I didn't notice for two hours because the services on the machine kept going since they didn't need the disk. In fact, the only reason I noticed was because I happened to need to do the same thing again and got the command from the shell command history and noticed the mistake--a one character typo. Recovery from this event required rebuilding the machine. Fortunately, we've been working hard on infrastructure automation and have a set of Puppet recipes for completely building
                          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...


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


                          Starting a High Tech Business: Does Your Mom Use It?

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the eightteenth installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! Yesterday, Steve had an interesting experience which proved one of our claims. We've always said that we were trying to build a Web augmentation service that even our Mom's would use. This is in contrast to, say, Greasemonkey, which is a great tool, but it's decidely aimed at
                          Continue reading...


                          Starting a High Tech Business: Paying Yourself

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the seventeenth installment. You may find my efforts instructive. Or you may know a better way--if so, please let me know! When you start a business you put a lot of yourself into it: time, ideas, and, of course, money for things like servers, supplies, and people. In addition to whatever money you put into the business, you also are spending money just living. Starting a business is not
                          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...


                          Data Leads to Better Parking Decisions

                          The short term lot at Salt Lake City Airport has electronic display boards that tell you how many parking spots are available on each deck. That wasn't always the case. Monday when I was parking to go to RSA, I realized that in the old days my default behavior was to head straight to the top deck because there were always more spots there. The small overhead of driving up to the third deck was far better than driving around the aisle looking for a place to park. Now, with more info, my alrgorithm has changed.
                          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...


                          I'll Send You a Card: Information Cards in the Wild

                          I've been hearing about information cards for the last four years or so. For that entire time, they have been largely theoretical or, at best, used for logging into a blog or something else. I'm out to change that. A few days ago Steve Fulling was on the phone with Paul Trevethick of Parity describing a pilot project we're doing for the Locals Care organization of New Mexico. Steve said "I'll just send you the card; put it in your selector and you'll see the results in Google." That's a pretty interesting statement: "I'll just send you a card."
                          Continue reading...


                          Kynetx on IT Conversations

                          Last week Jon Udell interviewed me on Interviews with Innovators about Kynetx and Contextual Browsing. It was fun to be the one answering questions for a change and Jon asked some good ones. If you've been wondering what Kynetx does, this podcast is a pretty good intro.
                          Continue reading...


                          Starting a High Tech Business: Achieving Q=1

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the sixteenth installment. You may find my efforts instructive. Or you may know a better way----if so, please let me know! In fusion energy research Q is the ratio of fusion power produced in a nuclear fusion reactor to the power required to maintain the plasma in steady state and is called the fusion energy gain factor. When Q=1, the amount of power that the reaction
                          Continue reading...


                          Continuous Deployment

                          This morning Steve gave a presentation on context automation and Kynetx at the Utah Technology Council's CTO P2P forum. The presentation was great and the audience asked a lot of good questions. One thing that came up (I don't even remember why) was the subject of continuous deployment. I decided I'd pull a few URLs out of my head and put them in a blog post for people to mull over. The first URL I think of when I consider continuous deployment is code.flickr.com. If you've never been there, the bottom of the page lists when the last deployment
                          Continue reading...


                          Guy Kawasaki: How to Drive the Competition Crazy

                          Image by Thomas Hawk via Flickr Guy Kawasaki is speaking at the Infopia ecommerce conference in Salt Lake City today. (You might also enjoy reading my notes from the last time Guy was in Utah.) His topic is how to drive the competition crazy. In standard Guy style, he gives his talk as a list of ten things: Find a mighty opposite - find a great enemy who is trying to do something in direct opposition to what you're doing. Portray them in ways that emphasize how you're different. It doesn't have to be a company. It could be
                          Continue reading...


                          Augmentation Gone Wild

                          Joe Andrieu has written a blog post on Netizen Developers wherein he makes this assertion: As netizen developers, we have an obligation not just to do what makes us money, or even what makes users happy, but to build systems that work at Internet scale, when everyone does it. If the systems we build don't work when everyone tries to get into the game, then we are just being selfish, hording value just because we are first-to-market. From joeandrieu.com ? Blog Archive ? Netizen DeveloperReferenced Tue Mar 03 2009 09:07:56 GMT-0700 (MST) He mentions systems like the one we're
                          Continue reading...


                          Context Automation

                          Judith Burton has written a good piece on context automation and what we're doing at Kynetx. She says: When browsing the Internet, each web site encounter throughout the browsing episode is a separate or ad hoc experience. There is no thread or connection from one site to another except in the user's mind. The user must hold the context of the browsing episode outside of each web site encounter. From Context AutomationReferenced Tue Feb 17 2009 09:30:53 GMT-0700 (MST) And then later: To create a context across multiple sites, an abstraction layer may be employed that is capable of
                          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...


                          The Advent of Next Generation Browsing

                          Today I'm releasing the first of a series of white papers on Kynetx and what it's trying to accomplish: The Advent of Next Generation Browsing (PDF). I introduce the problem in the first few paragraphs like so: We are mired in a tangle of architectural legacies that make today's Web browsing experience uncomfortable, confusing, and tiresome for many users. In particular, the lack of Web site independent identity has hampered the ability of the browser to effectively intermediate the Web on the user's behalf. But change is coming and we are about to witness a significant improvement in the
                          Continue reading...


                          Kynetx Demo Day

                          I've had a handful of people ask if they could stop by Kynetx and see what we do. Steve has had similar requests. In an effort to not miss anyone who would like to visit Kynetx and get a demo of our fledgling product, we're hosting a Kynetx Demo Lunch on Friday, Feb 6th at 11:30 at Kynetx World Headquarters in Thanksgiving Point. This map will give you directions and we're in Suite 275 (metal doors). We'll supply the pizza, you bring your curiosity. Please RSVP so we know how much pizza to buy.
                          Continue reading...


                          I'm Going to Gluecon

                          I'm going to be speaking at GlueCon in Denver on May 12-13. The overall theme of the conference is that there is a lot of interesting stuff happening in what we might have thought of as "glue" before--all the code that holds things together. Turns out that there's plenty of value you can add in the glue that makes the resulting mash-up better. Glue is a new conference (the best kind) and is being organized by Eric Norlin, Seth Levine, and Phil Becker. These guys do good conferences. Eric and Phil were the founders of DIDW. More recently Eric's
                          Continue reading...


                          The Kynetx Move to CloudFront

                          Image by chascar via Flickr One of the components of Kynetx Network Service (KNS) is a 30K (compressed) static Javascript library. This is mostly a slightly modified jQuery along with some other components. We set the Expires header so that it is cached in the browser for 24 hours. Even still, it's a significant load on our network bandwidth and, consequently, our budget. When Amazon's CloudFront (CF) was announced, we realized that we could move these kinds of static files to CF as a way to reduce our bandwidth and maybe get a performance improvement. If you aren't familiar
                          Continue reading...


                          Infrastructure Automation Increases Operational Efficiency

                          Last week Jeff Atwood wrote a piece about why throwing hardware at a problem makes sense in some situations. He's careful to avoid the trap of thinking that throwing hardware at a poorly designed program will do more than buy you a little time, but makes a good point: Clearly, hardware is cheap, and programmers are expensive. Whenever you're provided an opportunity to leverage that imbalance, it would be incredibly foolish not to. From Coding Horror: Hardware is Cheap, Programmers are ExpensiveReferenced Sat Dec 27 2008 15:42:36 GMT-0700 (MST) Riffing on that, Gordon Weakliem makes a related and somewhat
                          Continue reading...


                          Azigo's RemindMe Service and Kynetx

                          Yesterday Azigo (Parity) launched it's RemindMe service. RemindMe uses Information Cards to represent relationships that are meaningful to the shopper and then overlays Google and Yahoo! with reminders to indicate when those relationships might be valuable. For example, if you're a AAA member, you get a discount at Hertz. RemindMe will alert you to that fact. The reason I'm jazzed about it is that Kynetx Network Service (KNS) is being used to provide the overlays. In our partnership, Azigo is supplying the cards and selector (including the browser add-on). The add-on calls our service depending on what cards are
                          Continue reading...


                          Javascript Debugging in IE

                          I've spent the last several days immersed in debugging Javascript in Internet Explorer. It's not as bad as it could be. After all, I'm using jQuery and that cuts down on the cross-browser incompatibilities. In it's normal usage, Kynetx Network Services (KNS) compiles our domain specific language, called KRL, into Javascript. Since we test that the Javascript is compatible with multiple browsers, normal rule evaluation is pretty safe. However, like any good DSL, KRL has a way of dropping out of the DSL and into the base system--in this case Javascript. That's when things get dicey.
                          Continue reading...


                          Online Stores Crowded on Black Friday

                          The Business Technology blog at the Wall Street Journal reported last night that several ecommerce merchants experienced slowdowns and in some cases service disruptions due to higher than expected demand. It shouldn't come as a surprise that people are shopping online Friday. This year, retailers have been promoting online sales more heavily than in the past. In the case of Sears.com, the promotions seem to have worked too well: The site was unavailable for many visitors between 10 am and 12:40 pm EST Friday, according to Keynote. (It was also down when we tried to access
                          Continue reading...


                          Kynetx Puppet Update

                          Pat Eyler sent me a note asking if we were still using puppet. In the spirit of trying to leverage my response to him for the widest possible audience, I thought I'd blog the answer. Kynetx has been using Puppet (and a little Capistrano) to automate our infrastructure since this summer. While we haven't gotten everything as automated as we'd like, we're quite a ways down the road and it's making life as a small startup bearable. My ultimate goal is to register a node in the system that delivers Kynetx Network Services (KNS) to the
                          Continue reading...


                          Kynetx Operational Procedures

                          In the spirit of transparency, Kynetx has published our operational procedures and practices online. As we gain more control over our infrastructure automation, we'll also have real-time operational information and statistics. I'd appreciate feedback on what's there. Keep in mind, this isn't out "dream" but rather we're trying to present a true picture of where we're at. We obviously have goals to make this better and have quite a bit of experience in mature operations so we know where we need to be and where we currently fall short. I don't believe that there's anything there that would compromise
                          Continue reading...


                          After the Death of Advertising, Shopper and Merchants Can Start Talking

                          Dave Winer Dave Winer wrote yesterday about the death of online advertising. He says: I've been saying it for as long as people have been building businesses on advertising on the web, it's not a longterm thing. Now we're at the end of the road. Assuming the economy comes back from the recession-depression thing that it's in now, when it does, we will have completely moved on from advertising. The web will still be used for commercial purposes, people will still buy things from Amazon and Amazon-like sites, but they will find information for products as they do now,
                          Continue reading...


                          Startup Hierarchies and Going Lean

                          Here's a few good articles by Eric Ries I ran across today on startups. In A Hierarchy of Pitches, Eric talks about aligning your pitch with what stage your company is in. This is helpful analysis and acknowledges that companies are at--and get funding at--a variety of levels in their maturity. Eric gives ideas about what investor questions are relevant at each level and what slide you have to focus on. If you're getting questions that seem misaligned with where you think you're at, then you should re-evaluate something. In Lean Startups vs Lean Companies Eric defines what it
                          Continue reading...


                          Making Screencasts in OS X

                          I've been creating screencasts to show what Kynetx does for VCs and business development. Using screencasts is a quick, easy way to do a demo that doesn't fail and is self contained. I can email the link to a screencast to someone and they get a good idea what I want them to know. I've been using SnapZPro to record browser sessions and then using iMovie to create the actual movie. SnapZPro works great, but I'm not as impressed with iMovie. Maybe it's just me, but I find it inflexible and hard to use. If you've got suggestions on
                          Continue reading...


                          Start Your Business Now

                          Paul Graham has a new essay on Why to start a startup in a bad economy. Actually, he doesn't necessarily think starting in bad times is better than good times, just that there's nothing special about good times when it comes to starting high-tech businesses. He says that the state of the economy is a rounding error compared to the effects the founders have. The economic situation is apparently so grim that some experts fear we may be in for a stretch as bad as the mid seventies. When Microsoft and Apple were founded. As those examples suggest, a
                          Continue reading...


                          Build an Internet Explorer Plugin for Me, Please

                          I'm looking for someone to build a simple plugin for Internet Explorer. We use the plugin for testing Kynetx. I already have a Firefox version, but need to test against IE as well. If you've got expertise and would like to know more, contact me.
                          Continue reading...


                          Using Puppet and CPAN

                          The code that makes Kynetx work is a couple of custom Apache modules written in Perl. So, configuring machines via puppet, naturally requires ensuring that a set of Perl modules are loaded. For a long time, I was using a private bundle, but I found that was unreliable. For the most part it worked fine, but then sometimes I'd get an error that Perl couldn't find the bundle, even though it was clearly in the path. I didn't want to spend a lot of time debugging it because I figured it was a dead end. Eventually, I've got to
                          Continue reading...


                          Prototype Framework is a Javascript Extension, Not Just a Library

                          I recently ran into a problem with Prototype (the Javascript framework) that exposes a big difference between the design philosophy of Prototype and other frameworks like JQuery. Consider this code: var aryOmnDiv = [ 'header_tracking', 'left_nav_tracking', 'footer', 'homepagecategories', 'subcats', 'bread_crumb', 'subcat_wrapper', 'prod_group_wrapper']; //container divs for(var outside_i in aryOmnDiv) { var divname = aryOmnDiv[outside_i]; var div = $(divname); if(div) { \tvar anchors = div.getElementsByTagName('a'); } } Running this with Prototype installed produces and error that says "getElementsByTagName is not defined." The culprit is that the code is using a for...in loop as a shortcut for looping through the array. The
                          Continue reading...


                          Geolocation and eCommerce

                          This Wall Street Journal article talks about how geolocation data can aid online commerce. I find it interesting because Kynetx takes this data and layers other services on top of it and then makes the whole thing incredibly easy to integrate with any Web site. This story about ACE Hardware is exactly what Kynetx does today: Consider Ace Hardware, a cooperative of more than 4,600 dealer-owned hardware stores that overhauled its Web site in February 2007. Using geolocation software from Digital Element, a unit of Norcross, Va.-based Digital Envoy Inc., Ace now gives Web-site visitors a list of stores
                          Continue reading...


                          Yammering Away About Work

                          A few weeks ago Yammer walked away with top honors at TechCrunch 50. I'd been hearing about it, so last week I went over and signed up. I'm really liking it. Yammer is Twitter for work. The first person to sign up using an email from a particular domain establishes a sandbox for yammers from people in that domain. Since I signed up using my kynetx.com email, Yammer automatically created a domain for Kynetx and made me an administrator. Very low friction. I sent out invites and soon had the whole Kynetx gang yammering away about work. Only people
                          Continue reading...


                          Parsing with Perl

                          The system we're building at Kynetx includes a domain specific language that uses rules to create JavaScript programs that get sent down to the browser. I've documented our decision to use a domain specific langauge and our choice of Perl in other posts. When I started this project, I was reading Mark Dominus' book Higher Order Perl and started using his HOP parser to play around with. One thing led to another an before you know it I had a full blown language parser in HOP without giving much thought as to whether or not I'd made the right
                          Continue reading...


                          P3P and Internet Explorer

                          If your Web service does anything that sets cookies, you'll probably bump up against the fact that Internet Explorer--since version 6--has implemented a fairly strict privacy policy regarding cookies. In a nutshell, if the site does not have the right P3P privacy policy, first-party cookies (i.e. from the site itself) are downgraded to session cookies and not stored in between browser sessions and third party cookies (i.e. from another site) are rejected completely. Here's what to do to solve this problem. P3P, or the Platform for Privacy Preferences is a W3C "protocol allowing websites to declare their intended use
                          Continue reading...


                          Starting a High Tech Business: Sell Before You're Ready

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the fifteenth installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! One of the things that ought to strike fear into any technologist's heart is getting your first customer. You've spent months building a product you hope people will buy and find useful and suddenly someone actually is putting their faith in you and your baby. You're happy, of
                          Continue reading...


                          Anti-Perl Social Engineering

                          Dave Cross has a piece on why corporations hate Perl. He's being a little hyperbolic (as he admits)--not everyone hates Perl, but he's right in noting that there is a backlash against it. He says: I was talking to people from one such company last night. The Powers That Be at this company have announced that Perl is no longer their language of choice for web systems and that over time (probably a lot of time) systems will be rewritten in a combination of Java and PHP. Management have started to refer to Perl-based systems as "legacy" and to
                          Continue reading...


                          The TechCrunch 50 Mosh Pit: Is It Worth It?

                          We were notified that Kynetx will not be one of the TechCrunch 50. Ah well... The rejection notice said this: We are sorry to let you know that your company was not selected as a finalist for the TechCrunch50 conference. As you know, we are only able to select a very, very small percentage of the more than 1,000 outstanding applications we receive. Your company was among a select set of candidates that we considered, and it was a difficult decision driven purely by the limited number of presentation slots. Since we regarded your business so highly, we want
                          Continue reading...


                          Using a Pre-Commit Hook to Check Puppet Syntax

                          The whole idea of Puppet is to put your machine configuration scripts in a versioned repository. This is good because I've found that a syntax error on a manifest not even used by the current machine will stop the puppet updates from running. One error anywhere kills the whole thing everywhere. So, being able to back out of a change is good. We can go one better however and keep people from checking in files that aren't syntactically correct using the pre-commit hook in SVN. If you don't use SVN, your repository probably has something similar. I followed these
                          Continue reading...


                          Puppet Fun

                          I'm continuing to explore the use of puppet for managing systems. I'm convinced that it's the best system for managing large groups of interacting servers and keeping them all in sync. For example, today I was trying to figure out why a cronjob that processes log files wasn't working. Turns out that it was a system issue and there was also a problem with mail aliases, so we weren't even finding out. I create a simple puppet recipe for all our machines that simply ensures crond is running. That's basic and now it's ensured on all our machines. This
                          Continue reading...


                          The 50-50 Rule in Retail: Capturing Customer Conversations

                          Ross Mayfield notes that in an Apple retails store "50% of the space is for retail sales and 50% for service and support." He goes on to contrast that with places like Fry's or Best Buy. I'm always amazed when I go into an Apple store: they're happening places. If you're in retail, visit an Apple store and then go back to your place. Seem kinda quiet and dead. Yeah, I thought so. Ross goes on: What Best Buy is missing is the fact that they provide no after market value add with their retail -- in comparison to
                          Continue reading...


                          Starting a High Tech Business: Speed Pitching

                          I’m starting a new business called Kynetx. As I go through some of the things I do, I’m planning to blog them. The whole series will be here. This is the fourteenth installment. You may find my efforts instructive. Or you may know a better way—if so, please let me know! Most days lately, I've been getting dressed up and talking to people about Kynetx. I'd rather be in jeans writing code, but when you're raising money you're going to dress up more and code less. Raising money is a distraction from running a business and so should be
                          Continue reading...


                          Turning Shoppers Into Customers

                          Someone asked me for a one-paragraph description of Kynetx today. Here's what I sent them: Kynetx is an early stage ecommerce company focused on turning shoppers into customers. We provide online merchants with easy to use tools and services that give them the ability to merchandise in real-time to shoppers according to the shopper's individual context without changing their existing ecommerce toolset. Shoppers get a better shopping experience without sacrificing their privacy. Merchants sell more. The management team includes experienced ecommerce veterans Steve Fulling (CEO) and Phil Windley (CTO) who created the iMALL product strategy that successfully led to
                          Continue reading...


                          Doing CPAN Installs Using Capistrano

                          I've been trying to use Capistrano for application deployment over the last few days, writing rules to do some common tasks, figuring out how it works, etc. One problem I ran into is that I have a private CPAN bundle that I use to ensure a machine has all the right Perl libraries when I deploy to it. The problem is that CPAN is often run interactively and so module writers often assume the user will be present. That means that it stops in the middle and asks questions about skipping tests, etc. I searched for a while to
                          Continue reading...


                          VC Meetings Next Thursday

                          I'm going to be in the Bay Area next Thursday (May 15) with the day free and would love to get a few meetings with venture firms who might be interested in hearing about what we're doing with Kynetx. I don't know many VC's in the Bay area well, so if you wouldn't mind doing an intro to your favorite Bay Area VC, contact me.
                          Continue reading...


                          Starting a High Tech Business: Getting Five Clients

                          I’m starting a new business called Kynetx. As I go through some of the things I do, I’m planning to blog them. The whole series will be here. This is the fourteenth installment. You may find my efforts instructive. Or you may know a better way—if so, please let me know! Most days lately, I've been getting dressed up and talking to people about Kynetx. I'd rather be in jeans writing code, but when you're raising money you're going to dress up more and code less. Raising money is a distraction from running a business and so should be
                          Continue reading...


                          Starting a Small Business: Active Paticipation or Passive Resentment?

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the twelfth installment. You may find my efforts instructive. Or you may know a better way--if so, please let me know! Every business makes a choice, often implicitly or by default, about what kind of relationship they want to have with their customers: will their customers be active participants or passively resentful? We all know business in the latter category. Cell phone companies spring to mind with almost no
                          Continue reading...


                          Starting a High Tech Business: What's Your Story

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the eleventh installment. You may find my efforts instructive. Or you may know a better way--if so, please let me know! When you talk to someone who's starting a business, ask them what they do--you can tell how far along they are by the answer you get. Every business has a story and it takes time to get that story straight. If they stumble around, say "it's hard to
                          Continue reading...


                          On Static Types and Language Choice

                          I caught a little flack in response to my post calling attention to Steve Yegge's recent essay "Portrait of a Noob." In particular Levi thought I was out of line for endorsing something so inflammatory: "People who approach programming differently than I do are insecure n00bs" That's a great attitude for a professor to endorse in a public forum. Steve's rant is nothing more than hot air attempting to justify his personal preferences at the expense of others. It makes you feel good because his preferences are the same as yours. The fact remains, however, that there's no real
                          Continue reading...


                          Starting a High Tech Business: Getting Started

                          I’m starting a new business called Kynetx. As I go through some of the things I do, I’m planning to blog them. The whole series will be here. This is the ninth installment. You may find my efforts instructive. Or you may know a better way—if so, please let me know! Today I got a cold call at my office that essentially went like this: "I read you blog and would like to tell you my business idea and get your opinion on it." I said that I had a few minutes to listen and so the guy launched
                          Continue reading...


                          Starting a High Tech Business: The Rude Dog Demo and Working Code

                          I’m starting a new business called Kynetx. As I go through some of the things I do, I’m planning to blog them. The whole series will be here. This is the eighth installment. You may find my efforts instructive. Or you may know a better way—if so, please let me know! I have a friend who has a way with words and has started his share of high-tech businesses. I asked him his advice on getting started and Dan said "Welp, you gotta get yourself a rude dog demo!" What he meant is that you can't just start a
                          Continue reading...


                          Perl Testing

                          I didn't grow up in an era where testing was as well though of as it is now. When I learned to program, you ran a few tests after the fact and threw it over the wall to the QA department. Not very politically correct in today's software engineering world. As a result, I understand the value of testing and support the idea intellectually, but I don't have the discipline. Recently I was faced with the problem of building code that translated a domain specific language (KRL) back and forth between three different representations: The textual representation is what
                          Continue reading...


                          Kynetx Making Progress

                          I now have evidence that Kynetx is gaining momentum: I got my first call from an Indian "business process outsourcer" today asking if we had any programming work we wanted to outsource. They answer, by the way, is no. While I do believe that there is a role for outsourced programming and many places where it works very well, I don't foresee Kynetx doing much because of how I like to work. I build "two-pizza" teams--a programming team that you can feed lunch to with only two pizzas and I like my programmers close by. I think there is
                          Continue reading...


                          Xen and Multiple Networks

                          Last Friday I asked a question about how to set up a network in Xen with a machine attached between a public and private network, like you might use in a firewall or load balancing situation. I want to be able to mimic real world networking situation in Xen for experimentation and modeling purposes. There were numerous replies and I'm grateful for all the help. In the end, Steve Fulling (he's not as pointy haired as you though) came up with a pretty simple solution. To use virt-install to create a bridged, public machine, you'd do something like this:
                          Continue reading...


                          Xen, VLANs, and Load Balancing

                          I want to create a setup on XEN that has one or more machines load balancing for a number of other machines on a private network. This diagram shows roughly what I'm thinking: The idea is that some machines will be connected to both the public network and the private LAN and other machines will only be connected to the VLAN. This offers some security benefits and reduces the number of public IP numbers I need. The catch is I want to do this all virtually. Does anyone know of the recommended way to do this with XEN? I
                          Continue reading...


                          Starting a High Tech Business: Talent

                          I’m starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the seventh installment. You may find my efforts instructive. Or you may know a better way--if so, please let me know! Yesterday we held the first of what we call Kynetx Jam Sessions at the clubhouse. These are the meetings with some close friends and advisors who are helping us chart the initial course for Kynetx. I expect that as we get funding and ramp up, many of these
                          Continue reading...


                          Starting a High Tech Business: You Need a CTO

                          I'm starting a new business called Kynetx. As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the sixth installment. You may find my efforts instructive. Or you may know a better way----if so, please let me know! People frequently get confused about the differences between CIOs and CTOs and even a lot of techworld business people I know can't really articulate what a CTO does. In many companies, the CTO is the most technical person on the founding team. That might or might not work
                          Continue reading...


                          Enomalism and Xen

                          I'm looking for a management console for Xen (besides the command line). I'd looked into this months and months ago and concluded that when the time came, I'd try Enomalism, but after some initial experiments I'm no longer sure. Any advice? Let me know what you use for managing the Xen hypervisor and why.
                          Continue reading...


                          Starting a High Tech Business: Choosing a Deployment Model

                          I'm starting a new business called Kynetx (nothing to see there yet). As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the fifth installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! Jason Fried at 37Signals has an excellent list of all the reasons they don't sell installable software. That inspired Joel Spolsky to write about gnarly programs. Interestingly, I know people with the exact opposite response as Jason: "Boy, I wish we just sold
                          Continue reading...


                          I'm on YDN Theater

                          While I was at Defrag, I sat down with Jeremy Zawodny for an interview on the Yahoo! Developer Network Theater. You can watch it here: Alternately, you can download it. We talked about a variety of topics, including the idea behind my new startup, Kynetx.
                          Continue reading...


                          Kinetic Energy, Flywheels, and Friction

                          I read this essay on Kinetic Energy, Flywheels, and Friction at A List Apart when it first came out last year. I just reread it. Here's the basic idea: The reason you have a Web site is to get visitors to take some action. In order to induce them to do so, you have to give them enough momentum to get them through the process--with all its attendant friction. There's real power in this. Retail Web sites, for example, are full of friction and rely on their customer's determination to get the product to overcome that friction. Too often
                          Continue reading...


                          Starting a High Tech Business: Commitment

                          I'm starting a new business called Kynetx (nothing to see there yet). As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the fourth installment. You may find my efforts instructive. Or you may know a better way--if so, please let me know! Tuesday night, after Defrag was over, I was at dinner with Andre Durand, the CEO of Ping ID. At one point we were talking about startups, something Andre has a lot of experience in, and he spoke about commitment in a way that
                          Continue reading...


                          Domain Specific Languages

                          Recently, I've been designing a domain specific language for Kynetx, the start-up I'm working on. When you tell someone you're designing a language, the usual reaction is incredulity. "Why would you design your own language?!?!" they say. I'm here to tell you why. First, let me say that I'm a big believer in notation. Using the right notation to describe and think about a problem is a powerful tool--one that we're too eager to give up it seems. People seem to believe that (a) all languages are pretty much the same and (b) the world has enough notations. While
                          Continue reading...


                          Starting a High Tech Business: Get a Clubhouse

                          I'm starting a new business called Kynetx (nothing to see there yet). As I go through some of the things I do, I'm planning to blog them. The whole series will be here. This is the third installment. You may find my efforts instructive. Or you may know a better way---if so, please let me know! One of the things I realized pretty quick after getting serious about a new startup was that you need a clubhouse. It's fine to work from home, meet in coffee shops, and go cheap at first, but eventually you want to get real
                          Continue reading...


                          Starting a High Tech Business: Legal and Banking

                          I'm starting a new business called Kynetx (nothing to see there yet). As I go through some of the things I do, I'm planning to blog them. The whole series will be here. You may find my efforts instructive. Or you may know a better way--if so, please let me know! Obviously one of the things you have to do to start a business is actually set up the legal entity. This is actually easier than it first appears. The first question is what kind of entity to set up. The two basic choices in the US are a
                          Continue reading...


                          Starting a New High-Tech Business: Setting Up Email

                          I'm starting a new business called Kynetx (nothing to see there yet). As I go through some of the things I do, I'm planning to blog them. The whole series will be here. You may find my efforts instructive. Or you may know a better way--if so, please let me know! When you start a new technology company, you're going to be talking to a lot of people. You'll want them to get in touch with you. That means phone and email at the very least. In the early stages you can get away with your Gmail or Yahoo!
                          Continue reading...


                                                  Application Essentials

                                                  news

                                                  game

                                                  entertainment

                                                  Mobile phone

                                                  news

                                                  explore

                                                  news

                                                  news