April 16, 2008 | Comments: (0)
New Backbase version improves Ajax speed, features
Backbase introduced Enterprise Ajax 4.2 today. According to the company, the new framework version offers developers more technologies, allowing for choices between rich and lightweight Ajax functionality, between CSS and XPath, between JavaScript and tag-based development, between JSON and XML, between native widgets and 3rd party widgets and between online and offline RIAs.
The principal improvements to this version are:
- New hierarchical data binding
- New Data Services module
- Support for lightweight Ajax
- New and improved widgets
- Performance enhancements
A more complete discussion of the new features can be found in Jep Castelein's blog. The offline RIA feature is basically support for Adobe AIR (see sample at left). One of the more ambitious new widgets is a Rich Text Editor.
Speed improvements have been made in all three phases of Ajax operation: load, build, and runtime. The Enterprise Ajax 4.2 product has also been tested against beta 1 of Internet Explorer 8, Opera 9.5 beta, and nightly builds of Safari 3 and Firefox 3.
A Community License for development and deployment on up to 2 server-CPUs is free; this version can be downloaded today. A commercial license is available to businesses needing more CPUs or professional support and software maintenance. A JSF Edition (optimized for Java Server Faces) will be available next month.
Posted by Martin Heller on April 16, 2008 06:30 AM
February 12, 2008 | Comments: (0)
You can't know how much it excites me to hear that Microsoft is designing yet another computer language. Why, what a novel idea! It isn't like there were hundreds of new computer languages designed every year. If that were the case, there would be conferences about the subject. Oh, wait: that's how we first heard about this one, at the Lang .NET conference on the Redmond campus.
But it's a declarative language! Ah, yes: that eliminates maybe half of the languages proposed every year. "Declarative" is an awfully broad term, with multiple meanings. Standard ML is considered declarative, and so are its derivatives OCAML and F#.
Prolog and rule-based AI systems are considered declarative. You declare the rules: the logic engine decides how to run them. SQL queries are declarative: you describe the data you want to see, and the query optimizer figures out how to get it out of the database.
Haskell is considered declarative as well as functional, not to mention that it has monads. Don't ask me to explain monads in the context of functional programming: it's not a short answer. The "Summarizing Proust" contest isn't on today, thank you very much.
Back to declarative languages. XAML is a declarative language for the domain of graphics. It was designed as an extension of XML. It's such an expressive language that Charlie Petzold, arguably one of XAMLs most vocal proponents, built himself a alternative to Microsoft's XAMLPad called XAML Cruncher, so that he could "interactively type XAML code and see the object it creates." In Visual Studio 2008, Microsoft included a bidirectional, split-screen XAML designer, so that you can create XAML by dragging and dropping objects and by typing XAML code, with the ability to freely switch back and forth between the two methods. I freely admit to needing these tools; I can almost never write XAML that will display correctly on the first try.
Watching the Connected Systems Division (CSD) at Microsoft over the years, it has been clear that they have been on a code-reduction path. Why? SOAP was invented by Don Box and others to be an XML-based lingua franca for communication among disparate computer applications and systems. The functional deficiencies of SOAP were addressed by the WS-* series of standards, to give it security, authentication, reliability, and so on.
All of those standards made it harder to write conformant client and server code, raising the complexity by orders of magnitude. CSD engaged in a series of efforts to counter this by raising the level of abstraction for programmers developing connected systems. Web Services Enhancements (WSE) for Microsoft .NET cut the amount of code you needed to write drastically, but not enough for mere mortals.
Windows Communication Foundation (WCF) brought the amount of code down by another order of magnitude or so, partly by using attributes in code and by depending on XML-based configuration files. Attributes are of course one approach to making a language more declarative, and configuration files are another.
Looking at WCF in Visual Studio 2008, it seems like the classes and attributes and design tools are fairly mature, but are still built on top of the general-purpose C# language and the .NET Framework. I wouldn't be at all surprised to hear that the CSD architects decided to try starting over from scratch with a new language that would raise the level of abstraction and reduce the amount of code that needed to be written for a connected application by another order of magnitude. But it's not like nobody else has ever tried that: there's a robust research community working on that kind of problem.
I can guess about the process they're going through, but I can't guess what the outcome will be. It's an emergent experiment, and there are a dozen ways it could go. Nevertheless the criteria are kind of obvious:
High level of abstraction? Check.
Regularity of syntax? Check.
Easy to write? Check.
Easy to read and understand? Check.
Suitable for connection to disparate systems over multiple protocols? Check.
Posted by Martin Heller on February 12, 2008 07:35 AM
January 22, 2008 | Comments: (0)
Oxymoron of the Day: Efficient XML
My title is a bit unfair: "Efficient XML" does sound like a contradiction in terms, but the Efficient XML design chosen to be the basis for the proposed encoding specification by the W3C Efficient XML Interchange (EXI) Working Group is demonstrably efficient both in transmission size and in encoding and decoding speed, at least according to the authors.
The news here is a bit dated: the EXI Working Group (WG) published working drafts of 3 key EXI documents on December 19th:
- Efficient XML Interchange Format 1.0 specification, 2nd draft: includes significant new functionality.
- Efficient XML Interchange Primer: Describes Efficient XML for mere mortals, including useful diagrams and examples
- Efficient XML Interchange Best Practices: Specifies best practices for e.g. maintaining backward compatibility with plain-old-XML, using Efficient XML with XML Digital Signatures, etc.
All three documents can be accessed from the EXI WG page. I would start with the Primer (obviously).
I had a long telephone conversation about this with John Schneider last week. John is both one of the members of the EXI WG, and CEO of AgileDelta Technologies; AgileDelta wrote the winning Efficient XML proposal for the EXI WG based on its own products. This is yet another case of a proprietary product opening up into a standard: I think that's a good thing.
John did a podcast with Jon Udell in October 2006. It's a wide-ranging discussion; if you don't have time for the audio, there's a transcript.
In my conversation with Schneider, he said that Efficient XML is "the data format to end all data formats," and that it was proven to be both the most compact and the least demanding (in terms of CPU for encoding and decoding) of the formats tested by the EXI WG. It has Web service plug-ins for most of the major Web service platforms (for example Apache Axis, BEA, and Microsoft .NET), and by using HTTP content negotiation it can fall back to standard XML when needed.
Efficient XML sounds like just what the doctor ordered for slow Web service connections. But I haven't played with it myself, so I'd bow to superior experience.
Have you evaluated Efficient XML or any of its competitors? Have you built services that use Efficient XML or any of its competitors? Is this a subject you'd like to hear more about?
Posted by Martin Heller on January 22, 2008 01:03 PM
November 12, 2007 | Comments: (0)
I guess I shouldn't be surprised, since Google has been advertising heavily for Java developers with device experience: the much-hyped Google Android Open Handset SDK is basically a Java API. In addition, it supports XML-based layout files, and contains a variety of development tools.
What tools? An emulator, an Eclipse plug-in, a debug monitor, a debug bridge, an asset packaging tool, an interface description language, SQLite, a trace visualizer, a disk image generator, a bytecode translator, and an Ant script creator.
What does "Hello, World!" look like as Android code? Basically this:
public class HelloAndroid extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
TextView tv = new TextView(this);
tv.setText("Hello, Android");
setContentView(tv);
}
}
There are four building blocks to an Android application:
- Activity
- Intent Receiver
- Service
- Content Provider
I'm oversimplifying, but an activity is a screen, and an intent moves from one activity to another. An intent receiver is an event handler. A service is long-lived non-UI code. A content provider is a class that implements a standard set of methods to let other applications store and retrieve the type of data that is handled by that content provider.
For more, read the Android documentation and download the SDK.
Posted by Martin Heller on November 12, 2007 11:33 AM
June 20, 2007 | Comments: (0)
I'm deep into the process of reviewing InfiView, a framework for building interactive and dynamic Web 2.0 maps and diagrams that is implemented on top of Bindows. I'll hold my comments for the review, but I thought you might be interested in the online demos: InfiView™ : Demos / Experience.
The Flight Browser demo (click on the picture at the left) is especially interesting, as it combines a live Google Map with an interactive InfiView annotation layer. Understanding this particular sample from the source code and documentation took some effort, as well as some queries to support, but I think I've got it now.
By the way, don't expect real airline routes from this demo. "The airline routes are drawn using SVG in Firefox and VML in Internet Explorer. Airports are taken from a collection of airport positions. The airline routes are created by randomly connecting pairs of airports."
Posted by Martin Heller on June 20, 2007 06:00 AM
May 14, 2007 | Comments: (0)
In case you missed it, Microsoft resurrected the old XML Notepad last year. The new version, XML Notepad 2007, is a .NET 2.0 application for which source code is available on CodePlex. I find it the application quite useful.
You can find the links to XML Notepad 2007 at the Microsoft XML Developer Center site. In an August 2006 article on MSDN, Chris Lovett, the principal developer of the appllication, discussses its design.
What does it do? According to the author:
XML Notepad 2007 provides a simple intuitive User Interface for browsing and editing XML documents.
Handy features include:
- Tree View synchronized with Node Text View for quick editing of node names and values.
- Incremental search (Ctrl+I) in both tree and text views, so as you type it navigates to matching nodes.
- Cut/copy/paste with full namespace support.
- Drag/drop support for easy manipulation of the tree, even across different instances of XML Notepad and from the file system.
- Infinite undo/redo for all edit operations.
- In place popup multi-line editing of large text node values.
- Configurable fonts and colors via the options dialog.
- Full find/replace dialog with support for regex and XPath.
- Good performance on large XML documents, loading a 3mb document in about one second.
- Instant XML schema validation while you edit with errors and warnings shown in the task list window.
- Intellisense based on expected elements and attributes and enumerated simple type values.
- Support for custom editors for date, dateTime and time datatypes and other types like color.
- Handy nudge tool bar buttons for quick movement of nodes up and down the tree.
- Inplace HTML viewer for processing <?xml-stylesheets instructions.
- Built-in XML Diff tool.
- Support for XInclude.
- Dynamic help from XSD annotations.
- Goto definition to navigate includes and XSD schema information.
What can you learn from the source code? The short summary is how to implement all of the above; I think that the code that processes XML is quite elegant, and a good starting point for people writing other XML processing applications.
On the other hand, don't expect too much: I wasn't able to build the version 465 project I downloaded from CodePlex without errors in my copy of Visual Studio 2005. I wasn't able to bring up the forms in design view, and all the unit tests failed. There has been a new build posted in the last few days; I hope that will fix the problem.
Posted by Martin Heller on May 14, 2007 06:00 AM
May 01, 2007 | Comments: (0)
At Microsoft's MIX07 conference, Yaron Goland gave a talk entitled Opening up Windows Live Data. The description was:
Data wants to be free! So come to this technical deep dive to learn how you can POST/GET/PUT/DELETE your way into Windows Live. We cover how you can ask users for permission to access and then interact with their Windows Live services (e.g. address book, Spaces, etc.).
Interestingly enough, this talk wasn't announced in advance, but was posted at the last minute. Microsoft normally only does that when they don't want to let the cat out of the bag prematurely about a new product or service.
"Data wants to be free!" is of course a takeoff on Stewart Brand's 1984 pronouncement "Information wants to be free" at the first Hacker's Conference. But that isn't really what Yaron was talking about. He was introducing the new Windows Live Data service, which is part of the Windows Live SDK. Microsoft describes this as:
Windows Live Data provides a mechanism by which developers can ask Windows Live users for permission to access the user's Windows Live services and data on the user's behalf. Currently Windows Live Data exposes Windows Live Contacts which is the central address book for all Windows Live services. Access to additional Windows Live services will be added for the upcoming Beta and other future releases.
To ask users for permission to access their data, as described in Requesting Permission to Access Users' Windows Live Data, you basically send the user to a Microsoft page, providing the return address on your site, for example:
<a href="https://ux.cumulus.services.live.com/pgux/default.aspx?rl=https://www.sample.com/permit.aspx&pl=https://www.sample.com/privacy.html&ps=LiveContacts.ReadOnly">
Grant Permission</a>
Then you grab the ResponseCode, DomainAuthenticationToken and OwnerHandle fields from the posted form you get back. If the ResponseCode is "RequestApproved", you can go ahead and use the DomainAuthenticationToken and OwnerHandle to request data.
The OwnerHandle is basically an email address at this point, and it becomes part of the URI for requesting the data. The DomainAuthenticationToken is supplied as a header to the HTTP request. So, for example, you could ask for an address book for user wlddemo@hotmail.com by sending a GET request to:
https://cumulus.services.live.com/wlddemo@hotmail.com/LiveContacts
with C# code like this:
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uri); request.Method = "GET"; request.Headers.Add("Authorization", "DomainAuthToken at=\"" + token + "\""); try { HttpWebResponse response = (HttpWebResponse)request.GetResponse(); //request succeeded, process response ... } catch (WebException ex) { //request failed, handle error ... }
What you'll get back from this request is an XML document, which you can then parse, or connect to a control.
Obviously, there's a lot more: Yaron did talk about POST/GET/PUT/DELETE, not just GET, and the documentation explains two other ways of authenticating. The Windows Live Data documentation goes into detail, and I expect that at some point there will be a sample site.
Posted by Martin Heller on May 1, 2007 02:48 PM
January 24, 2007 | Comments: (0)
As I mentioned on January 10th, I'm going through a stack of AJAX books. The first of the bunch is AJAX: Creating Web Pages with Asynchronous JavaScript and XML, by Edmond Woychowsky (Prentice-Hall, 2006, $44.99, ISBN 0-13-227267-9).
In general, this is a well-written book, with a lot of useful information to present. On the other hand, it's written with an attitude: some will find it refreshing or amusing, and others will find it annoying. I started off in the former camp, and ended up in the latter.
Woychowsky starts by discussing Web pages and their taxonomy, introduces Ajax concepts, explains HTML, XHTML, and CSS, and offers a brief introduction to JavaScript. You can skip all that if you already know the material. Then he offers a chapter that discusses "Ajax Using HTML and JavaScript", which is something quite primitive that wouldn't normally be called Ajax; he does it from the ground up in 46 pages, and manages to throw in MySQL stored procedures. Don't ask.
Then it's off to a whirlwind tour of XML, and then on to 25 pages on XMLHttpRequest, which is a key component of Ajax as we know it. Then, finally, he's ready to talk about traditional Ajax, using XML and XMLHttpRequest. After that, he wants to talks about Ajax using XSLT, because he's a self-described XSLT geek, so he first has to wander off into XPath and XSLT-land; again, skip a couple of chapters if you already know that stuff. Near the end of the journey, we detour to Ruby on Rails, and finally get to its Ajax support; I'm not completely sure why Woychowsky bothered with that particular side trip.
Woychowsky's book is part of Bruce Perens' Open Source Series, so maybe I should cut Woychowsky some slack about the gratuitous slurs against Microsoft in his book. On the other hand, some of them are inaccurate and misleading: for example, when he discusses ATLAS, which was the temporary codename for what is now called ASP.NET AJAX, he wanders off into a rant about "not invented here" syndrome, and then explains that he can't run ATLAS because he doesn't have $549 for Visual Studio 2005 Professional. Excuse me, Edmond: Visual Web Developer 2005 Express Edition is free for the downloading, and works just fine with ASP.NET AJAX.
Woychowsky presents his own home-grown Ajax library in Chapter 12, "Better Living Through Code Reuse." It's not bad at all: you could do a lot worse. And you could easily modify it to your own devices and desires. (The sample code is here, but you'll understand it better if you have the book.)
This is definitely not a book about using commercial Ajax libraries, or even free Ajax libraries, although Woychowsky likes the free Sarissa library and gives it 5 pages. On the other hand, the book is a good foundation for doing Ajax development yourself, and once you know how to do that you can intelligently examine the construction of the Ajax library your management wants you to evaluate, to see if it actually makes sense for your application.
Posted by Martin Heller on January 24, 2007 06:00 AM
TOP STORIES
ADDITIONAL RESOURCES
- Remote Access: Maintain Security and Decrease the Burden on IT
- Beyond AntiVirus: Symantec Endpoint Protection
- What Every Enterprise Needs to Know About VDI
- Monitor the core and troubleshoot the access layer
- Disaster Recovery in Minutes
- Protecting Microsoft(R) Applications
