Image via Wikipedia

People use Twitter for lots of different purposes. I use Twitter to keep up with friends, find new things on the 'Net that I wouldn't otherwise see, and to tell others what I'm thinking. Another word for that final purpose is "influence." To a certain extent almost everyone on Twitter is trying to use it to influence something--some more blatantly than others.

If you've been on Twitter for any time you'll notice that people have different behaviors with respect to their avatars. Some put them up and never change them. Some put up their own face. Others put up pictures of their family, logos, or even book covers or favorite brands. Some people change their avatars frequently and some have had the same avatar since they set up their account.

As an aside, when you pick an avatar, something recognizable is nice, but not necessary--I'll pattern match eventually even if I can't tell what it is. Also, one of my pet peeves is people who use pictures that are looking to their own left. Most Twitter clients put the picture on the left of the text and the picture ought to look at the text, not off to the side. If you're using a face, pick pictures that are facing to their right and make the face big enough to be recognizable.

I understand the desire to use the avatar in Twitter for personal expression. But if influence is part of your motive for using Twitter, then changing your avatar frequently is a bad idea. Here's why.

One measure of influence on Twitter is the number of followers. To refine that we might use an algorithm that determines who your followers are and their influence--kind of like Google page rank, but for tweeple. Certainly there are sites that do that sort of thing. But the ultimate measure of influence is how often your tweets are read. No way to measure that, as far as I know. But there is a way to increase the probability: pick an avatar you like and stick with it.

I subscribe to almost 700 people on Twitter. That means that my Tweetstream is in constant motion with new stuff on it all the time. As i scan it, your avatar is one of the clues I use to determine whether to read a particular tweet or not. I read every tweet that some people make; others I read only occassionaly. My primary clue is the avatar. More than once I've missed people because they decided to express themselves and change their avatar.

Obviously you can change your avatar if you like. But if you're trying to express yourself, leave your avatar alone and write a well thought out 140 characters. That will get across much more forcefully than anything else you can do and the probability I'll see it and read it will go up because you'll be familiar to me as I scan the tweetstream.

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 to say that relational databases aren't useful, but they come with certain problems like the fact that they're difficult to scale. If all you need is key-value storage, then you're suffering that pain for functionality you're not even using.

At Kynetx, for example, our core engine needs to be able to grab persistant data about a ruleset evalation regardless of which machine it's running on to avoid the need to pin sessions to particular machines--something made more difficult by the fact that interactions may stretch over days. We don't need a relational store--we can get by just fine with key-value storage for this application.

Right now we're using memcachedb (note that that's not memcached). Memcachedb is very fast and uses the memcache API, so it's easy to talk to from just about any language. But the fact that it's based on BerkeleyDB means that it doesn't scale particularly well--essentially the same was as relational databases with a master-slave architecture.

I'm hoping to switch out what we're doing now with Cassandra sometime soon to get the distribution and scalability. There's still some research to do, but I'm looking forward to it.

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 the programming platform, including a big upgrade to how KRL processes events and fires rules that will significantly increase it's power and the applications that you can write with it.

We'll be holding Kynetx Impact at the Larry H. Miller center at Salt Lake Community College. In addition to great talks and new ideas, we'll have some great food. I just visited the caterer last week for a tasting and was very impressed. I think it's worth coming to Impact just for the food!

I'm offering a discount code for 33% off the normal $150 price to readers of my blog. Just use the code "pjw33". Please take a minute and sign up now. I guarantee you won't be disappointed in Kynetx Impact.

This week on the Technometria podcast, Scott and I talk to David Siegel, the author of The Power of Pull. David talked to me one or two times quite a while back about identity as he was researching this book, but I didn't really know what the book was about or why he cared about identity. In appreciation, he sent me a copy of the book when it came out and I left it sitting on my desk for a number of weeks before I picked it up. When I did, I was blown away.

I'm certain that the podcast won't do justice to the material in the book--you have to read it for the full impact--but maybe it will give you and idea of why this is such an important work.

For years, we've heard about the semantic web and mostly it's been a bunch of talk about RDF, ontologies, and so on. David's talking about the semantic web, but he does it by telling us how our lives will change when data is portable and systems can manage it without constant interaction with us. These changes--and they're inevitable--will change everything from health to commerce to how we play golf. What struck me as I've read the book was the shear ubiquity of the impact.

The title, Pull, comes from the central idea of the book that more and more people will pull things to them, rather than being at the receiving end of a push. I wrote about what that will mean to commerce in a blog post called Building Fourth Party Apps with Kynetx where I borrowed Doc Searls metaphor of the sewage pump as an apt descriptor for the current regime.

When I think of the changes that the Internet has caused in the last 15 years, I'm amazed, but I also realize that we're just getting a good start. There are myriad changes yet to happen and David has done a great job in this book of laying out what the next set of changes are likely to be, why they'll happen, and what it will mean for individuals and businesses.

The bottom line: this is the most interesting tech book I've read in a long time. I bought eight copies and spread them around the office because I wanted everyone at Kynetx to read it. You should read it too.

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 recent build of KRL changes that by making the Amazon Product Advertising API (PAA) available as a library. That means that it's possible to use Kynetx to build client-side applications that use the PAA without exposing your developer tokens. That opens up a whole host of possible uses for Amazon product information that were difficult to achieve before.

Here's a video that shows this at work:

Of course, to create client-side applications that people will install and use requires more than just pumping more product at them. The KRL integration of PAA includes the ability to access all the user-generated reviews, product information, photos, and other product data that would allow a developer to create a first-rate experience that adds real value for people who download and use their apps.

KRL makes using PAA easy. To get started, you simple put your Amazon developer secrets and associate ID in the meta block of your application:

meta {
  key amazon {
    "token"        : "absjj99a9ad9ad8799",
    "secret_key"   : "absjj99a9ad9ad8799abs79999a9ad9ad8799",
    "associate_id" :  "windleyofente-20"
  }
}

These are stored securely in the cloud and not divulged to users of the application.

The KRL Amazon library has two primary methods: ItemSearch and ItemLookup. With ItemSearch the search index is a parameter and additional parameters depend on the particular index. ItemLookup takes an Amazon product ID (ASIN) as it's primary parameter. Here's an example:

amazon:item_lookup({"ItemId" : "B00008OE6I",
                "response_group" : "ItemIds" })

The response is returned as JSON so that you can use JSONPath to pick it apart and use it. Here's a piece of the response to the previous query:

"Item" : {
            "OfferSummary" : {
               "LowestUsedPrice" : {
                  "Amount" : "3999",
                  "CurrencyCode" : "USD",
                  "FormattedPrice" : "$39.99"
               },
               "TotalRefurbished" : {},
               "TotalUsed" : "8",
               "TotalCollectible" : {},
               "TotalNew" : {}
            },
            "ASIN" : "B00008OE6I"
         }

Here's a video showing a little more about how this is done and giving a working example.

You can install the example that we used for the first video or just view the source code using the app detail page in the Apps Directory. Here's the documentation for the Amazon library.

The Amazon integration with KRL allows Amazon developers to build client-side application that use Amazon product data without exposing the Amazon developer credentials--something that's been hard in the past. KRL is designed to make using online data like Amazon or Twitter easy and quick. We'll be annnouncing some other major data and service integrations over the next few weeks as we gear up for Kynetx Impact in April. Come join us.

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 is how it's stored. There's no database behind this, rather the data is all stored in the DNS records for the domain. For example, the system uses NAPTR records (yeah, I didn't know what they were either before this) to store the

pjw:Downloads pjw$ dig windley.tel -tNAPTR
;; ANSWER SECTION:
windley.tel. 60 IN NAPTR 100 100 "u" "E2U+web:http" "!^.*$!http://www.windley.com!" .
windley.tel. 60 IN NAPTR 100 101 "u" "E2U+web:http" "!^.*$!http://xri.net/=windley!" .
windley.tel. 60 IN NAPTR 100 103 "u" "E2U+x-voice:skype" "!^.*$!skype:windley!" .
windley.tel. 60 IN NAPTR 100 102 "u" "E2U+voice:tel+x-work" "!^.*$!tel:+18016494601!" .

You can see that some of the data in the page is available in these records. The textual data is in the TXT records:

pjw:Downloads pjw$ dig windley.tel -tTXT
;; ANSWER SECTION:
windley.tel. 59	IN TXT ".tlb" "1" "100" "100" "Technometria
windley.tel. 59	IN TXT ".tlb" "1" "100" "101" "Contact form"
windley.tel. 59	IN TXT ".tlb" "1" "100" "102" "Phone number at Kynetx"
windley.tel. 59	IN TXT ".tlb" "1" "100" "103" "My Skype address"

Note that the numbers in the text records are being used to link this data to the data in the NAPTR records.

This is pretty cool because it means that anything that can speak DNS (pretty much everything) could have programmatic access to this data. If you can make DNS queries, you can grab my contact data.

The system allows for me to create profiles and then make different profiles available based on where I am and what I'm doing. I could update my telephone number, preferred method of contact, and so on just by choosing a different profile. Eventually this would be done automatically for you depending on various events in your life. This is where Kynetx comes in, but that's the subject of another post once.

On Saturday, I blogged about a bill before the Utah Senate that would allow law enforcement to use administrative subpoenas to get data about you from your ISP when they suspected you of crimes against children. This would be done without a warrant and without any real oversight (as currently drafted).

This morning Rep. Brad Daw is testifying about his bill before the Senate Edcuation Committee (yeah, it's confusing). @sausagegrinder (a Daily Herald reporter) tweeted that Daw said:

Daw: 4th amend doesn't apply to his bill. The subpoenas would be for information owned by a company, not property of suspect

That's an interesting position. Forget the bill itself. Just consider the question of when information about you belongs to you, when it belongs to someone else, and when it belongs to multiple parties.

If we take the position, as Daw apparently does, the data in the ISP records about you, your address, you billing information, and other transactional data (although by his admission in an unlinkable Facebook exchange not the content of the transactions themselves) belongs to the ISP and not to you, where do we draw the line on what data about you belongs to you...at least in part?

What about your health data? Yeah, I know about HIPAA, but forget that--we're trying to suss out principles, not the law. Would you consider all the information about your doctor visits, the tests you took, the payments you made (or didn't) to be data in which you had no privacy interest? Even if the actual content of the tests and medical procedures was not included, there's a lot of private data to be had in the meta data about our activities. In fact, give me just your meta data and I can probably construct a pretty interesting picture about you.

I submit that any data about me, held by another party is usually jointly owned and that I have an interest in what happens to it. And by extension, that interest means that it is data that is protected by the fourth amendment from unwarranted government prying and snooping. Daw is playing fast and loose with this for the convenience of his bill and ignoring the larger consequences to our freedoms if such a mentality is not resisted.

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 better ways of building markets for the 21st century. Something I hadn't considered until I was going through David Siegel's book Pull is that "pull" is the right metaphor for this new marketplace and it's precisely why Doc's metaphor of a sewage pump rings so true.

David's book is about the Semantic Web and the use of data standards to enable you to "pull" the information, services, and products to you. An example from the book that really hit home for me is this: in 2010 if you order a package from Amazon, you have to give an address where it will be delivered. Wouldn't it be better if instead, you just gave Amazon an identifier and then the package would find you at the place you wanted it to go--even if that's the hotel you're currently staying at? In essence, you pull the package to you with online data. This isn't a pipe dream, but a perfectly reasonable way to think about how the world ought to work--and one that's doable now from a technical standpoint.

Doc uses different language to describe this same idea when he talks demand leading supply. The pump is all about supply leading demand. The key idea that both Doc and David would agree on here is that "If demand leads supply..., customers need to be the points of integration for their own data." More on that later.

The Four Party System

In an effort to further define VRM, Doc has introduced the notion of "fourth-party services." He says:

Among numbered parties the best-known one today is the third party. Wikipedia currently defines a third party this way (at least for the computer industry):

• Third-party developer, hardware or software developer not directly tied to the primary product that a consumer is using
• Third-party software component, reusable software component developed to be either freely distributed or sold by an entity other than the original vendor of the development platform

In general, a third party works on the vendor's side of the marketplace. However, the vendor is not generally called the "first party" (except in the game business, as Wikipedia says here). In fact, the most common use of the term "first party" in business is with insurance, where the term refers to the insured. (The insurer is the second party.)

From » VRM and the Four Party System ProjectVRM
Referenced Fri Feb 26 2010 11:04:37 GMT-0700 (MST)

So, if third-party services are merchant driven, it stands to reason that the customer-drive services that represent them would be the fourth party. Here's a picture of these four parties:

The little horseshoe magnet looking things are called rel buttons are meant to represent customers or merchants (left and right in the above diagram) who want to relate to each other.

Fourth-party services, be theysimple or sophisticated will act as brokers that work on the user's behalf to manage their interaction with vendors of various products and services. Without such automated agents, no one would want to take on the work that would be necessary otherwise to manage the dozens of relationships each of us has with vendors. But with them magic happens.

Building 4th Party Apps

Doc and David are both thinking about very general solutions to this problem as well they should. My job, as the CTO for Kynetx, however, is slightly different. I'm trying to build things for our customers and make them work now. The Kynetx platform has always been aimed at creating client-side Web applications that help users achieve a purpose. That's a pretty good working definition of "fourth-party" in my book. The platform is designed to allow developers to use data in context to create interesting Web applications. Moreover, our corporate philosophy has been consistently in favor of respecting user rights to control data.

With that backdrop, I've thought long and hard about how Kynetx could be used in service of VRM and--by David's definition--the semantic web. I'll use this schematic to help explain my latest thinking:

To keep this simple, I'm going to avoid going down every "or they could do..." fork in the tree. There are lots of them. Here's the flow:

1. The user visits a merchant. This could be online or in person (imagine the app running on their phone and using location in context).
2. At the same time any fourth party apps that they've installed (denoted by the fourth-party rel-button) are invoked as long as they are relevant to the current activity.
3. KNS (the Kynetx Network Service) executes the rules associated with the presented apps. We're going to presume for sake of this example that those apps need personal data to work on the user's behalf and such access has not been previously granted.
4. KNS requests the required user information from the personal data store (PDS).
5. The user is asked to authorized such access and grants it.
6. The PDS requests the data from various sources as necessary and returns it to KNS. Note that as envisioned here, the PDS acts more like a virtual directory than an actual repository, although that's not a strict requirement.
7. KNS executes any relevant merchant rules (determined by the app, current context, and the data retrieved in step 6) to determine how they want to relate. Merchant rules are denoted by the third-party rel-button in the diagram. This may be specific offers, discounts, special service levels, etc. I'm calling this "the deal" for lack of a better word.
8. Finally the results are presented to the user's client.

A key feature of the scenario shown in the figure is the privacy wall (in red). That's there to reinforce the fact that in this model the user's data is never given to the merchant. The merchant's rules act against it, but they never see it. For fourth-party apps to work, users will need assurance that their data is being treated in a way that respects privacy. They will also need to trust the agents working on their behalf.

A few other points to note:

• Kynetx has no access to user data except as authorized by the user. The user is entirely in control of the experience and what data is used.
• The merchant rules could exists in a standard rule format like RuleML and be stored in any repository so long as they were discoverable.
• The same holds for user data. There's no need for it to be in a single place as long as it's in standard formats, is discoverable, and has a clear, unambiguous meaning. David calls this same concept the personal data locker and it is central to the whole idea of the semantic web, pull, and VRM.
• As envisioned the merchant rules, users data, and user apps are all orthogonal to each other. This isn't a single application, but a platform where fourth-party apps can be built using whatever user data and merchant rules are available.
• Successful fourth-party apps won't just be ways to get offers to customers but manage the relationship between merchants and users in sophisticated ways. They could, for example store receipts, initiate and mediate support issues, manage returns, and so on.
• In this demo, we're using OAuth to enable user control of the data in the PDS but that's really a stand-in for other more versatile standards that are forthcoming like UMA and R-Cards.
• The scenario above focuses on one interaction where the app and the merchant rules could conduct a complete, complex negotiation on the user and merchant's behalf. Keep in mind, however, that the key is the relationship and that is bigger than a singleton deal or negotiation and might include support and service functions, ratings, and so on. Successful fourth-party apps will be seen by users as trusted agents, not merely a way to get a good deal on a single transaction.

A key difference between this model and a traditional ad network is the idea of "pull." Ads are not being pushed (note that successful pushing requires "tracking" and "targeting" users--niether is being done here). Rather more holistic information about what I'm calling "deals" is being pulled to the user based on their purpose and intent.

I have a working demo of all of this right now that uses a PDS that has access to a user's Amazon wish lists as an example of intent data and Acxiom-held data as an example of personal data--all under user control. Getting from demo to production is more a legal and business matter, not a technical one. We're working on that too. I plan to share this demo and the ideas and techniques behind it at the Kynetx Impact conference in April and at IIW X in May.

The inclusion of intent data in the demo is important because data that signals user intent or purpose is much more useful in creating compelling fourth-party apps than mere facts like gender or household size that leave the app to infer intent. Guessing will become less necessary because users will have convenient, private means of sharing intent. In this model, attention gives way to intention just as purpose gives way to location.

Some might complain that there's too much dependence on KNS or that KNS is closed. That's not technically true: Kynetx is proprietary, not closed. Still, if that bothers you, give me the standards and we'll use them. We're all about building support for standard data sources and formats into the system. As I mentioned above, I'm open to supporting rules expressed in RuleML or some other standard format. And, of course, no one is imagining that KNS would be the only system doing this. This is just our contribution to making the idea of VRM and fourth-party services real.

We invite your participation. Signup for a free developer account. Register for Impact where you can listen to Jon Udell's keynote and discuss these ideas with us. We're happy to listen, resolve issues, and make this work.

Image via Wikipedia

Utah House Bill 150 is a bad bill that will give government too much power to invade your privacy without a warrant. The bill has passed the house and it now awaiting action in the Senate. Read this post, read the bill, and then take a minute to contact your senator and express your hope that they will vote against it. If you don't know who your senator is, you can find out here.

HB150 would allow law enforcement agencies in Utah to use an "administrative subpoena" to ask for the records of people suspected of committing crimes against children from Internet Service Providers (ISPs) without a warrant. This may sound fine as long as the people are really engaged in suspicious activity, but there's no check to ensure that's the case. That's why warrants exist. They force law enforcement to convince another party (i.e. the judge) that they really do have reasonable suspicion.

I'm all for getting tough on crime and catching bad guys who are exploiting children, but I'm not prepared to give up my 4th amendment rights to make it happen. Good conservatives should be on the side of protecting individual rights and liberties, not handing more power to the state, no matter how noble the cause may sound.

Take a minutes, send your senator a note, and ask them to vote no on HB150.

Image by Old Shoe Woman via Flickr

I'm a pretty happy MiFi owner, but I've had a problem with my battery and would like to buy a new one. They're not easy to find, so I was plesantly surprised to find that Novatel (the maker of the MiFi) had a Twitter account: @MyLifeMyWayMiFi. I followed and when I saw some activity, replied to @MyLifeMyWayMiFi asking where spare batteries could be purchased. Nothing. I tried a few more time when I saw activity and have never received any kind of reply. It's clear that Novatel is using it's Twitter account to simply push more advertising at me.

Maybe its working for Novatel, but I think they're missing the real value of using Twitter: two way communication with their customers and opportunities to build relationships. I like my MiFi a lot and I'm a fan. I want to know what they're doing, so in that respect the Twitter account is working. But there's more there.

If I had a relationship with Novatel through Twitter (because they answered my question, for example), I'd be more likely to recommend it to my friends. I'd also be more likely to forgive them missteps. As it is, it's just another piece of the gigantic sewage pump that the industrial age has constructed to push more stuff at me.

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.

This week's Technometria podcast is with designer Thomas Petersen on the topic of data overload and design. Late last year he wrote a blog post called Slaves of the Feed that talked about a problem almost all of us face: too much information. It was the start, rather than the end, of a conversation and so seemed a good jumping off spot for a podcast. Thomas has a designer's take on the problem and we ended up talking about design in a more general sense. I enjoyed it.

Image via Wikipedia

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 they want done in spite of it. The client-centric, rather than server-centric, nature of Kynetx applications is all about embracing decentralization.

In addition to Jon, I'll be speaking and so will Craig Burton. We're working on an awesome agenda and I'll publish that soon. In addition to some mind blowing keynotes that challenge the way you've thought about programming the Web, we'll also be going over the latest developments in KRL.

If you're wondering if you ought to come to Impact, I'd give you this rubric: If you're a Web programmer who's wanted to get beyond the confines of the server and create applications that work anywhere, Impact is for you. Applications built using KRL go beyond a single location and let you work whereever information has the most meaning for your users. As an example, here's an application I wrote that mashes up Twitter with a dozen Web sites to carry the Twitter discussion to them.

People who came to Impact in November will tell you that even if you're not sure you're going to use Kynetx to build your application, the ideas at Impact are of a different stripe than those of a traditional Web development conference. Come participate in the discussion and be part of the client-side revolution.

The spring Kynetx Impact conference will be held April 27-28 in Salt Lake City. The normal price of admittance is $150, but if you ise the code "FOK2010" you'll get 30% off.

This Thursday is the CTO breakfast. We'll start at 8am in the Novell cafeteria. See the link for maps and calendars. I hope you can join us.

The CTO Breakfast is open to anyone interested in high-tech businesses and products. It is a free-form discussion of topic. If you've got something that you're interested in, come prepared to talk about it.

Future CTO Breakfast times can be found on the CTO Breakfast Google calendar. The CTO breakfast for March will be help on March 26th in conjunction with Podcamp SLC. Details to come.

The latest build of the Kynetx Rule Language (KRL) provides a significant upgrade in capability with the addition of functions. We've also added some new array operators that take advantage of functions to make using arrays easier.

KRL supports functions as first-class objects in the expression language. KRL supports only anonymous functions, but they can be given names by binding them to a variable in a declaration. Here's an example:

pre {
  add5 = function(x) {
           x + 5
         };
}

Functions are evaluated statically (e.g. the environment they are defined in, not the environment they are executed in determines the binding of free-variables) and can be recursive. Here's an example of a recursive function in KRL:

pre {
  fact = function(n) {
            (n <= 0) => 1
                      | n * fact(n-1)
         }
}

Functions are declared using the keyword function and contain optional declarations followed by a single expression that returns the result of the function when executed. To see this, consider the following example which uses Newton's method to calculate square roots (taken from Section 1.1.8 of Structure and Interpretation of Computer Programs):

sqrt = function(x) {
    average = function(x,y) { (x + y) / 2 };
    good_enough = function(guess, x) {
       v = (guess * guess) - x;
       v < 0.01 && v > -0.01
    };
    improve = function(guess, x) {
       average(guess, (x / guess))
    }
    sqrt_iter = function(guess, x) {
       good_enough(guess, x) => guess
                              | sqrt_iter(improve(guess,x), x)
    };
    sqrt_iter(1.0, x)
}

Functions can return functions as values and functions can be passed as the arguments to other functions and operators in KRL. The following example defined a generalized summation function that sums the numbers from a to b incrementing using inc and applying the function f to each term:

sum = function(f, a, next, b) {
  (a > b) => 0
           | f(a) + sum(f, next(a), inc, b)
};
inc = function(x) { x + 1 };
cube = function(x) { x * x * x };
sum_cubes = function(a, b) {
  sum(cube, a, inc, b)
}

We could define a function that creates incrementor functions. When given a number, it returns a function that increments by that value:

inc_generator = function(n) { function(x){ x + n } };
inc = inc_generator(1);
inc_by_2 = inc_generator(2);
inc_by_25 = inc_generator(25);

Being able to write functions adds significant power. More so with some of the other languages changes we have in mind for the next few months.

Weve also added several new array operators in recent builds. Most notably, array references now work as follows:

a = [1,4,3,6,5];
b = a[1]

This would bind the value 4 to the variable b. Note that array references only work for arrays of one-dimension, so c[1][2] is not allowed (presuming c is an array of arrays).

In addition, there are a number of new operators available for arrays. The following array operators are now available (in addition to length which has been previously available):

• sort - sorts the array. With no argument, sorting is done in ascending order. The argument "reverse" causes sorting to happen in descending order. The argument can also be a function that takes two argument and returns a boolean value which will be used as the comparison function for the sort.
• filter - filters an array, producing a new array. The operator takes a function argument that takes a single parameter and returns a boolean value. The return array contains elements for which the function returns true.
• map - modfies an array from mapping a function to each member of the array. The operator takes a function argument that takes a single parameter and returns any value. The array returned from map is the result of applying the function to each member of the original array in turn, collecting the results into a new array.
• head - returns the first element of an array without modifying the array.
• tail - returns an array that is identical to the orginal array except without the first member.

You could use these like so:

pre {
  f = function(x) { x < 4 };
  g = function(y) { y * 2 };
  a = [1,4,3,6,5];

  b = a.sort(); // returns [1,3,4,5,6]
  c = a.filter(f); // returns [1,3]
  d = a.head(); // d has the value 1
  e = a.map(g); // e has the value [2,8,6,12,10]
}

Operators are fairly easy to add and handy to have, so if you have ideas for other operators, on arrays, strings, and so on, just let us know.