Wouldn’t it be nice if the phone system was as easy to use as internet services? Why is it so hard to send an SMS from a computer? Why is it nigh-on impossible to get the phone system to alert your e-mail if you get an SMS?
Well, it turns out the telecoms people thought so too, so they invented PARLAY – a set of standard APIs for talking to telephony back-ends. Nice. And then, because the APIs were kinda bizarre and complex (because this is the phone system, after all), they went and invented PARLAY X, a simplified web service layer on top of the plain old Parlay API. Schweet!
Now it turns out the local telephone company Telenor is involved in this. But there isn’t a peep about how to get access to the stuff, or how to get involved. It’s like they don’t actually want anyone to use this stuff.
Netcom has a dead simple HTTP-to-SMS message gateway. Better than nothing, but no way for outsiders to hook into their infrastructure. Disappointing, but at least they’ve priced it reasonably and made it reasonably easy to sign up for.
If we are ever going to get beyond downloadable ring-tones and java games then the services will need to hook back into the IT infrastructure. Parlay gives us the means, but as long as it remains locked in the R&D labs, phone services will continue to be either e-mail or WAP based.
Look at how standard APIs make the net flourish: I posted pictures to my blog from my phone via standard e-mail, through Flickr’s server in the states to my blog’s server. None of the actors here know any details about the others. All happens thanks to standardized APIs.
Telenor and Netcom should be pushing this kinda integrated services to drive more MMS traffic, but it seems to be too hard for them to understand. For example, why not have a personal log where all my incoming and outgoing SMS messages are tracked? Why not the same with MMS? Why not create a blog that is phone addressable (i.e. a person sends an SMS to themselves –> the SMS gets routed to the blog instead of back to themselves).
Bugfix and Source for ScriptUnit.
Now version 0.8
Teardown wasn’t getting called – it is now.
Also added Assert.Error and Assert.IsNotNull and more examples, including a test COM object.
Apparently the USPTO is in such a hurry to issue more patents before someone reforms the whole rotten system that they have stopped reading or checking the patents at all.
METHOD AND SYSTEM FOR INFORMATION EXCHANGE BETWEEN USERS OF DIFFERENT WEB PAGES (claims 1, 2, and 16 in particular) is pretty much identical to my masters project at Stanford Commentor.
The system is part of a general “virtual document” architecture in which–with the help of lightweight distributed meta information–documents are dynamically synthesized from distributed sources depending on the user context and the meta-information which has been attached to them. The meta-information is managed independently of the documents themselves on separate meta-information servers, both in terms of storage and authority.
The COMMENTOR work fed into the W3C Platform for Internet Content Selection (PICS).
I just spent an hour talking about how to gradually introduce commands into our app at work.
Then I read this article, and I can just nod my head in agreement.
The de-coupling of GUI and model is a key part of MVC, but the decoupling of GUI and actions (the C part of MVC) is easily overlooked. SuperOffice started out as a Model-Document app, but we’ve found that the Command pattern is vital as your app grows larger. Without Command objects you end up duplicating the logic throughout the app, along with all the enable/disable state handling logic and bindings to context. Yecch!
As the Pragmatic Programmers say: Don’t Repeat Yourself.
There’s a lot of heat and noise over Microsoft’s changing “Universal” to mean “mostly Universal”. I haven’t got any idea how this affects SuperOffice – I think we’re covered as a Gold Partner, but who can tell.
VSTS will integrate a whole bunch of useful things into the dev environment: bug tracking, source control, project management (task tracking), unit testing, build and deploy scripts. This being a Microsoft product, the whole thing is built around more MS products than you can shake a stick at: SQL Server and Sharepoint Team Services in particular.
So the demos I’ve seen seem spiffy enough, but Sharepoint leaves me cold. It’s too amorphous for me to get a handle on.
What interests me is that the new hooks and integration points in the Visual Studio environment should make building your own bug-track and project-task integration much easier. I think any supplier who doesn’t show up with plugins within the next year will struggle to stay alive. The big question is to what extent will Microsoft publish all the necessary APIs. The Visual Source Safe source-code-control API’s are still licensed only under heavy NDA restrictions. (I suspect this is because they are worried that people will laugh if they see how badly designed they are.)
I hope this stuff opens up – I’d love to have better DevTrack integration from within Visual Studio. Having access to the x-planner task list from within my main programming environment. Being able to check things off without switching tools would be very nice.
I’ve been working on re-doing the security system at SuperOffice for the past couple of months. The first step was to document the state of the existing security system using unit tests. Lots and lots of test. Mindnumbingly boring tests. But they had to be written and checked. (We discovered that the existing security system doesn’t work as well as it should the documentation and the implementation were not equivalent)
Today, my suite of unit tests passed.
All green. Yay!
I’m very happy.
This means that people who upgrade from an old version of the system should not discover anything different after they upgrade. They will be able to see and edit the same things as before.
Now I just have to add all the cool new features to the security system that I wrote down in the spec (back in october), and I’ll be done. Piece of cake.
Also feeling chuffed with myself for pulling two rabbits out of thin air today: created a patch/workaround for a security bug in our web product (it’s gonna be so good to ditch that pile of VB and ASP code) that means we won’t lose a large contract, and also fixed an old bug in our current release that our danish partners were losing sleep over.
Intuitive User Interface design article by Jared Spool.
I’m with Jef Raskin on this – there is no such thing as “intuitive”. There is familiar and unfamiliar. Affordances can make the unfamiliar understandable, but that does not make it intuitive.
Ciphire is an zero, invisible-ui crypto client.
It works by keeping all the certs in a central location. The central certificate store has triple-redundant-backups around the globe, so it should take quite a bit to knock it out. It seems to be a good, solid implementation of the invisible-crypto idea. PGP/GPG can use central stores too, such as the MIT keyserver, so again it’s nothing new, but it’s well implemented.
It also points out that getting crypto that the people will use is equivalent to deploying a global directory of users. Building a global directory turns out to be a hard problem. Using a centralized directory is an easy way to get started (ref Microsoft Passport), but I think in the long run this will need to work with the Liberty Alliance, which is working on distributed identity (another hard problem).
A new and improved site – the WordPress upgrade went fairly smoothly, only took an hour or so to get all the bits in place. The new WordPress looks great – much more polished UI. A lot nicer admin tools – comment spam filtering among other things. Hopefully I’ll be able to get the phone blogging stuff working now (i want to be able to mail entries and photos from my phone)