Transcript of Chris Jones' presentation at the Professional Developers Conference.
March 12, 1996
Chris Jones
Microsoft Corporation
Download Microsoft Word (.DOC) format of this document (zipped, 24.0K). Download the PowerPoint® presentation (zipped, 467K).
CHRIS JONES: Thanks, Tammy. Jim and Paul did a great job about the kinds of technology we're releasing. I want to spend more time about drilling down into exactly how the components fit together, what sets of interfaces you have to support as a component provider to plug into these different objects, [and] what sets of interfaces you have to support to be a contain[er of] these different objects.
John and Paul talked about how we have a vision of the Active Client, and that's a vision of a common framework, and we've all talked a lot for a while about how pages, documents and applications are going to become a single construct. So an HTML document is really quickly becoming an application. And a word application's main view is to actually display a document. And the shell's folder is really crossing that line a lot. It's a document, it's an application, it looks like a page.
So our system is really built around this construct of pages, documents and applications. A single metaphor for browsing through those things, a single way to contain those things. Each of those documents and pages and applications, you really want to have the same level of controls and scripting available so that you, as an application writer or page author, don't have to go and reinvent how controls and scripting work for your particular application. And by having a lot of different containers that support a same standard control interface, there's a huge market for people to write these controls and deliver that value to you so that you and your application can benefit from a control without having to implement the feature yourself.
So standard ways to hook in script-accompanying controls that you want in many diverse documents is a good thing to do. That's part of our Active Client vision. Standard components and services are necessary as well. All these applications are going to need to go and fetch data from the network using URLs. All of these different documents are going to need to hook together and use a standard hyperlinking service. They're all going to want history as a service, direct API. Not everybody wants to go [write] their direct mapping service for DirectX. You want to do that once, have everybody benefit, use it and then have the performance that comes from this positive feedback loop of having multiple users of the same interface.
And finally, we've really stressed home today that COM is the way that you package up components and technology. If you looked at John Ludwig's demo when he showed JavaScript and {Visual Basic® Scripting Edition] VBScript scripting different controls that were built in different development tools like Visual Basic®, Visual C++®, and our Jakarta tool; COM is the way that we have to package up components in a language-independent, tool-independent and platform-independent way, and let you as a provider query a provider for a service without caring about what authoring tool it was built in or how it was distributed to you. Every component we release from now on is going to be a COM object on the client so COM is important for you to understand.
And finally, taking COM and make it go work cross-platform. Norm Meyrowitz talked a little bit about the work we're doing with Macromedia. We're taking COM over to the Macintosh and we're working with other Unix vendors to take it to Unix as well. Again, this thin wrapper that provides a standard binary-compatible interface for how to package technology that runs cross-platform. And then using those services over the Internet in distributed computing.
The demos you've seen today, I'm just going to run through again as I talk about the interfaces. Really talk about integration; how do you integrate with the Web browsing metaphor, how do you integrate with the shell, how can you integrate request applications like the office binder? [For] Active[X™] content, Controls, [and] Scripting, how do I add behavior and create applications on the fly? How do I really activate my application and make it look better, give me more opportunity, give my users more benefit?
And then Active Media, which we'll talk about a lot later today in the breakout, the multimedia breakout. But ActiveVRML, ActiveMovie, the releases we're allowing that will allow to you synchronize audio and video, and the next generation of VRML request behavior and scripting associated with it. Our approach through this has been to make the Web interactive and [our] focus has been on two things, first features for end users so end users look at a page, look at a document and understand that that thing is active, understand that it's live, it interacts with them, has value for them. Or for corporate customers, live to a database, live connections to [a] database, live connections to the data that's there and seamlessly installing those pages and applications and throwing them out as I need [to].
A lot of people have talked about OLE and there's been a lot feedback from us that OLE is too large for some of the uses you want to do, so what we'll do is take OLE and factor it out and reduce the number of interfaces you have to have to be an Active[X] Control. So you can choose to support the full level of OLE if you want to but you can also choose to do the base minimum set, IViewObject, and just go in place without having to go load in the rest of the OLE working set.
The second thing we're going to do is support leading-edge standard. We'll do demonstrations today. We've been working closely with W3C on how to plug in scripts and style sheets and layout. And finally [we'll] deliver these services and support these technology and standards, so you don't have to go write the HTML component; you can use the system service. You don't have to write caching, you can use the system service. No one wants to write services everyone is going to have. You want to focus your energy object-differentiating your application, adding your own branding features and compatibility and letting us do the work of if you're going to have UR resolution service, HTTP, just do that for me. I don't want to have to write it myself.
And last we use these services to build Internet Explorer. So we're not just delivering some components and throwing them over the wall to you and say, "Use this," we're building the Windows® shell, we're building Windows out of these components and that means these components are going to have quality and performance that our development teams are going to be focused on. We are using our own services.
So this architecture overview we've hit on a couple times today. The architecture works, we have containers. Containers are things that contain documents. And these containers add semantics on top of the documents that are relevant to the container. So one example of a container you've seen today is the Windows shell and the Internet Explorer. The semantics that [it] adds is navigation, history, and favorites to all kinds of documents, so documents can use the shared system service. But another example of a container will be the office binder.
And for those of you who have Office 95, you've seen the office binder. The semantics it adds are more about documents and projects and organizing files into a project. So even though the application doesn't understand the semantics of the container, the container can provide its value on top of the application. We'll show some demonstrations of that. I just want to point out that Mosaic hosts documents today, you can go and download them from their Web site. So we're trying to have multi-containered, multi-vendor containers, and we hope that people pick up on containers for document objects. Inside these containers, [we're trying to have] consistent written Active Documents that are written once to a standard set of interfaces and plug into multiple containers. HTML and VRML will be ones that you will see in the system for you to use in the applications. Also today are shipping document applications that you can use: Word, Visio, Micrografx, a bunch of third-party applications that run unchanged, because we provide one single application--and we reused it for the office binder and for the shell and for the Internet Explorer.
Inside Active Documents, hosting ActiveX™ Controls; these are compatible with OLE Controls, the next generation of OLE Controls. And a lot of applications and tools host these today; we'll be providing standard tools you can use, including HTML, VRML, and active VRML. But there are also third-party controls that we'll be demonstrating, including the Macromedia control that you are saw today, [and] Adobe Acrobat has written a control. Visual Basic, there are a number of third-party vendors that have written these controls and they're all engaged in putting them over on top of our new active services.
And a new set of interfaces that we'll be talking about is Active Scripting. And there's never really been a well-defined way to plug in a scripting engine application, we've defined a new way that's how you plug in a scripting engine and we implement two in the Explorer; JavaScript, which is the way we plug JavaScript into our application is through the scripting interface. We'll demonstrate some applications that are nontraditional applications that you might not think of as hosts, but really add some value.
And finally, system services which really are the foundation for everything that we do that are shared between all of these things. URL resolution and data-fetching, hyperlinking history, and favorites are [all] a system service, and code download and security, which I'll talk about briefly and you can go to the breakout session for more detail.
I mentioned COM before. I wanted to have a slide on COM just to again hammer home the point. COM is the way that we are packaging up technology. COM is the way that objects get packaged. It is language- and tool-neutral. And the exciting thing about COM is, once you write to the set of interfaces, you get all this benefit of interoperability that John showed. COM really provides two things for you. The first thing is, it's versionable. So--and it's programmable. The versionable means that I can actually ask a COM object what it does, what interfaces it supports. And it will tell me if it supports the right interface. So COM defines a way for to you ask an object what it is. The second thing COM provides you is a way to ask an object what methods, properties, and events it supports and to source out those events for to you use. Pretty basic stuff, but when you agree upon one standard, you can have a lot of powerful things happen.
Every active component that we're building is a COM object. The way that Active Documents integrate in this is, they all support a standard set of COM interfaces. So in a container, like Internet Explorer, I support the following COM interfaces: I/OKnown, standard, then IOLeContainer, IOLeDocumentSite, and IHLinkFrame. IOLeDocumentSite provides some extended capabilities like printing and additional menu negotiation. And activation. And IHLinkFrame provides [a] way for you to hyperlink and have a hyperlink source for an application. So if I write an application like Acrobat, click out--the container then can navigate to the next document. Active Documents support IOLeObject and IOLeDocument, and [IOLe]HLinkSite. Really sort of the coupling interfaces from the ones supported by the container, how to be contained, how to print, how to merge your menus and toolbars, and how to go and actually call out the hyperlinking, get hyperlink notification back.
And finally, shared underneath those is [another] new network service we're using, called URL moniker. And URL moniker, I'll talk about a little more in detail. But basically, what it is is a packaged-up way to do URL resolution with caching. So I can--I can get bits back asynchronously on our callback. Those of you who are familiar with the IMoniker interface, we've extend it for asynchronous, packaged a component called URL moniker. We're going to talk a little bit about how [this] works. Thomas Reardon is up here to show us how it runs.
TOM REARDON: What do you want to see first?
CHRIS JONES: Microsoft Word running in here.
TOM REARDON: What I've got set up as a favorite is a Word document that I've been working on. And this is a Word document showing newspaper frame. The Word document is a document object.
CHRIS JONES: It's important to note that this is word-unchanged. We integrated that in with the shell, and then you just take the Word application, you drop it in as registered documents, add it to your favorites and it gets launched. What are some of the benefits of doing document object[s]?
TOM REARDON: If you actually compare it to the ActiveX Controls, it's not just about getting screen real estate within a Web page, it's about integrating with the whole application framework. It's been getting on the menus, into the tool bar, cooperating on printing with the application. All of the things that give you integrated application.
CHRIS JONES: So I can change your view options to outline because the Word menus [are] around and you can change it back to normal view.
TOM REARDON: Cool.
CHRIS JONES: Are there other document objects? Word's a Microsoft product.
TOM REARDON: There are plenty. If you come over here, I can show you the Micrografx designer document which you saw in the earlier demo. Aren't you the design expert?
CHRIS JONES: This is the same document that we showed in the Internet add-on shell that Joe was talking about. If you write a--it's going to host inside the interior--it's going to host on the add on as well. The nice thing about designer is I can click and zoom in.
TOM REARDON: Hey.
CHRIS JONES: Hey. And then zoom back out. So show me some document objects running in other containers.
TOM REARDON: The one thing I wanted to bring up here, is that while we've shown document objects as Micrografx designer and Word, IE itself is a document object. And it's important to show that basically Microsoft's eating its own dog food here. Our entire I-83 [IE?] object network is built around this network.
CHRIS JONES: We don't want to throw something over the wall to you, we want to make sure we have what you need in for your applications.
TOM REARDON: This is the exact same graphics designer up front.
CHRIS JONES: Notice how there's a lot of ways for container to add semantic value into office objects. In the office binder case there's all these icons here and it adds project state. It doesn't deal with hyperlinking, it deals with project state. You can make a mail application, you'd write a frame and you can deal with to and from fields and addressing and again let the document itself handle display and editing.
TOM REARDON: It's really neat. This is all live, shipping code. As everyone knows today, I can switch over to the Word document in a different application context here, where people worry about composition of a project.
CHRIS JONES: Cool. So to kind of summarize, just trying to ram home the point that document objects provide for you a way, unlike ActiveX Controls, it's ActiveX Controls plus some additional functionality that lets you do menu and toolbar, to give you the control to decide whether you want to go and implement that for your document. That's great.
TOM REARDON: Thanks.
CHRIS JONES: So if we go back to PowerPoint®, that would be cool. The next thing I want to talk about is ActiveX Controls. Active[X] Controls are these reusable programmable objects. And for those of you familiar with OLE Controls, it is exactly OLE Controls, but with the focus on the Internet and providing Internet services underneath and a focus on refactoring to help you pick the level that you want. So to be an Active[X] Control host, I again implement IOLeContainer. That's the same document I implement to host objects. And IOLeScriptSet I'll talk about later. IOLe script site's[IOLeScriptSite?] an application that allows to you hook in engines. [With] Active[X] Controls, I can implement IViewObject and that's kind of the minimum you'd want to do to implement a control.
It's a pretty lightweight way for you to have a control. If you don't want to have programmability, you don't want to do menu negotiation, you don't want to have additional connections, you just implement IViewObject. But you can also optionally implement IOLeControl and get the functions you need.
Again underneath these is a shared set of services, because controls need to go and get too, and the way it works is, depending on the container that you're in, you can actually--you can actually call out to the container and the container can intercept the call and do its own management of the download. So in Internet Explorer, for example, what I want to do is I want to have the controls ask me for data and then I, as the Internet Explorer container, want to handle how the data gets back and possibly block off different controls or stop the download of ones that are off the page.
If you're in a non-bind host-aware container, like Visual Basic 4 is today because these interfaces weren't around, you can actually call out to the moniker and do the download yourself. Let's see a little bit examples of ActiveX Controls. Go back to Thomas.
TOM REARDON: This thing that Norm showed is pretty neat.
CHRIS JONES: Thomas has been addicted to Webfrog recently. Click there.
TOM REARDON: And "U." Whoa!
CHRIS JONES: Using a tool-like director, which is really designed for designers, Active[X] Controls give you the power and flexibility to create your own run times and sell your authoring tools in. It's really designed for people who want to create that next generation active content. We've created some great stuff in Director as really good animations. Microsoft animations. They have the Microsoft brand.
TOM REARDON: We'll go back and show the Deep Forest a little bit, with sound.
CHRIS JONES: So Director--
TOM REARDON: Deep Forest.
CHRIS JONES: So the director control is using URL moniker services to go and fetch the director file asynchronously over the Internet, and then playing them right off an Internet Explorer, and then the director control has the ability to go and handle the mouse clicks that it uses. Additionally, the director control can now expose methods, properties, and events so that I can add buttons there that stop the movie from playing or start it up again. And I can source events out from the movie as it's playing and trap those in VBScript, which we'll talk about.
TOM REARDON: Here I've moved on to the end compass set of controls, back in the Web page. And the main reason I wanted to come back to this was to show how the whole demo was put together and emphasize the fact that all of it is done using standard HTML, some of the leading edge stuff coming out of W3C right now. Probably you can't really see this, but basically you'll see a tag called the object tag, and it cascades down into these Active[X] Control property files. It's all standard HTML. And it's actually something that other browsers are now starting to support such as NCSA Mosaic, and Hot Java will support the tag for different integrations like Java and--
CHRIS JONES: What's happening here is I have an Active[X] Control that's talking to an Access database, Access 95 out of the box. As the controls get clicked upon, they are multiple upon a page, the clicks sends events and messages up to the other controls updating the picture. These are two buttons that update the picture. Controls, because they expose their methods, properties, and events to other scripting engines and other controls, provide you, the developer, with a lot of rich capability; the more events and properties you expose, the more useful your control is going to be to application builders, to tool users, and to people who are writing Web pages.
So that's pretty cool. And all that stuff ran on Netscape, too, which is really nice. This active plug-in for Netscape really helps us have you write to one interface and host in multiple containers: Delphi, Lotus Notes, Visual C++, Netscape, Internet Explorer. So that's ActiveX Controls. Cool. Let's go back to PowerPoint. We're back.
Finally, talk about Active Scripts. Active Documents and Active[X] Controls may have been familiar to you. So a lot of people have written OLE Controls. Active Scripting's something new. And it ties these active components together. It allows you to take a programmable object, handle events from it, and then source those events and do some interesting calculations to script them together.
So what do I have to do to be an Active Scripting host? Well, as a document, what I need to do is support IOLeScriptSite. It is an interface that basically provides about four methods. You get the script, you hand it off to the scripting engine. The scripting engine does a bunch of parsing and stuff. And then grabs a handle to your container and goes and hooks up the events to all the controls in your container using connection point. Then, as the controls are clicked on, the events get fired out to the scripting engine, which processes the script and fires events back in to the controls in your container.
The message here is two things. One, I/O I/O[IOle?]ScriptSite is pretty easy to implement; the more programmable you make your document, the more powerful scripting can be, the more developers can do with your applications and your controls. If you're an active control writer, what you want to think about is exposing your methods, properties, and events using IDispatch and allowing yourself to have them hooked up using IConnectionPoint. Even though you implement only IObject [it] makes your control more marketable and useful for people.
And finally, Active Scripting engine set of interfaces, IOLeScript, which basically allows the scripting engine to take the script code from a container, have those scripts passed off, compile those scripts down, grab the handle of the container and then go and source events to each of the controls inside the container. And we provide an Active Scripting engine for your use called VBScript, so as soon as you implement an Active Scripting container, you're--you automatically get VBScript as a feature for free. That's pretty cool. And then as other people introduce scripting engines, you can add on their scripting engines for free. Well, they may charge you. So you need to make sure that you implement your scripting interface in an open way and you get all this benefit. So let's go back to the PowerPoint machine. Thomas is, of course, back playing games. And the games are --
TOM REARDON: This is the game I called Microsoft's complete waste of time.
CHRIS JONES: This is a pretty silly game compared to the demos that we've shown. But the interesting thing here is all of these objects on the page are actually sprites that are exposed using automation, so this game engine doesn't have any game intelligence built into it at all. All it does is it understands how to have sprites, how to paint them on the screen and to you to source out events from those screen[s] and source the keyboard event. The way the game is implemented is you actually take VBScript, you write a script, and it handles all the game creation.
So I can go and look at the VBScript source and see how there's a new game and the new game creates these new ship classes, creates the new sprites, so as you're clicking the keyboard, the keyboard event gets fired to VBScript, it handles event and says go create a bullet. It goes and creates a sprite that looks like a bullet, shoots it out. The sprite engine detects collisions, those fire an event and the VBScript code handles what happens when those occur. It's a simple application, but it shows how hugely powerful it is to program your object and expose a rich automation model and then expose yourself to scripting and be a scripting host. Because then you can take a simple sprite engine and turn it into a game. But what about HTML?
TOM REARDON: Well, let me run back over to IE3 and show you some of the VBScript demos that we've pulled together. The first one I want to show you [is] one that's really focused around traditional HTML forms and what would typically be a database application. The pizza demo, where I can go down here and click on a button and have dynamic text show up in a text block and the selection of the pizza show up over here and order through the HTML form.
CHRIS JONES: Cool. So in this case, just like the Active Scripting engine that's the Sprite engine, exposed all these methods, properties, and events, we're taking the form intrinsics of HTML and exposing them as intrinsic objects as well. But these are OLE Controls, but we use the input tag, standard HTML input tag, as people click on that, we source it out to VBScript, it handles those scripts, handles the implementation. I could easily do the same with JavaScript.
TOM REARDON: Instead of just automating traditional form elements, what we've done is building wrappers around all kinds of things in HTML like image maps so in this case you can see that as I mouse over different parts, it actually triggers events that send text down into a text box. This is all straight HTML. So we've even gone and automated the links in our browser. We think it's important for people to be able to handle--on links, and not everybody's going to have [to] go in and do that--could we see the source for that to make sure it's actually working. This is all live code. You're getting all this code on the CD, including that sample page. You'll be getting the Active Scripting host on the CD engine for you to play around [with].Where we get the link, one mouse move and we check for the different rectangles describing the image map. And then send description text out to the different text fields. Pretty rad. So what about this JavaScript stuff?
TOM REARDON: I guess we had some extra time, so we threw together a JavaScript engine that actually plugs into the scripting architecture. And I'll just run over one of the standard JavaScript demos. And this is the notation calculator for post fix. So it's the standard deal. Have fun. Enter.
CHRIS JONES: As opposed to calculators you can't use. Good, I never could use those myself. So we used the Active Scripting interface, we looked at the JavaScript language specification, and we implemented an Active Scripting engine that supports JavaScript and it works in IE. Pretty cool. Thanks. So what is this--where does all this interface stuff get you? The first thing we talked about is delivering an Active Scripting engine that hosts VBScript, cool, reusable component, something you can use and plug into. Second thing is delivering URL resolution services, which I will talk about more in a second. And the third thing, make even the most important is an HTML application that you can use in your applications.
As Thomas mentioned, we took our HTML code, we took it out, made it into an OLE component that you can plug in an Active Document or Control, and you can host that inside your application. So this means that you can go and write your own frame around this HTML component, put your logo on there, brand on there, we don't care. You can go and actually use this HTML component inside a multimedia title as way to go and extend your content out to the Web. We think the HTML implemented once, we're going to continue to rev it and keep it up to speed with the existing standards. And we're going to go work on the W3C on new standards.
The important thing to remember is we're supporting all the existing content. Content out there is not always standard content. It's not the--necessarily the approved W3 extensions--but people want to actually view the content out on the Web, surprisingly. So we go and actually make sure that we can view that stuff. But then work with the W3C and make sure that all the new HTML that we go and support with the W3C proposed and approved HTML standards. Things like object and script and style sheet. Those are the kinds of things that we want to continue to work with committees on 'cause we think that standard's a good thing for all of us.
And lastly again, your application, Thomas can talk a little bit about the kinds of things we do and we'll have some demonstrations of them.
TOM REARDON: Great, Chris. First thing I wanted to show was Atlantic records frames page. It's interesting, because the frames [page] is all implemented as individual document objects within IE3. And you can see it's the standard frames demo.
CHRIS JONES: Did you say the frames were implemented as individual document objects? That means you can take a document object and actually host it inside of a frame, which is pretty cool.
TOM REARDON: Yeah. Look at that, the rendering speed is super fast. The document speeds are surprisingly light.
CHRIS JONES: So this is an existing frames page. This is also on your CD. You can go and take a look at IE and surf the Web, look at frames pages.
TOM REARDON: Let me show you some of the things we're doing, leveraging leading-edge HTML. This is a frames page. And we've gone ahead and leveraged style attributes to take away the 3-D borders on the frames. So now you see that the top--this is three individual frames and the top frame, there's no border between here and here, and I can click through and have the content in this other frame change. And this is the standard form, that was the pizza demo redone as a coffee demo now, and being able to click here and the forms all work. And each frame is, of course, its individual form.
CHRIS JONES: These all work inside a frame, it's just another HTML document inside there. You can actually go and add that behavior.
TOM REARDON: I want to show you some of the really slick things we've done lately. This is a demonstration of floating frames. Rather than limiting frames to a visual model where they're tiled, like that great Windows 1.0 release we did, we've done it now as a floating frame so that frames can appear anywhere in the page. So I can click in here and this is all moving. That's not an Active[X] Control. That's just HTML.
CHRIS JONES: And this you can see we're running out of food for the developers. They kind of put this together at the last minute.
TOM REARDON: I'm going to move to another one. Background colors were allowed on cells, now we allow background images. I can select text in here, I can select text in here. This is a color border and a custom background. Just to kind of emphasize this, if you notice, when I shrink it down like this, the entire thing changes. It really--it's a table. It's not a big GIF. So that actually is really good for low bandwidth connections where you want to add this value, but you don't want to add a big GIF. You can tile it across as we've done here and add a lot of value to your application without taking a lot of download time.
TOM REARDON: We've taken away the 3-D borders on the frames and I can click through and of course it's a real frame set. And now I can move on to another one with a custom color border on it and click among them and I can also go to one where we have a custom graphical border in between all the frames. So an incredible amount of flexibility in the way you compose all the HTML together.
CHRIS JONES: You're seeing a lot of the feedback that we're getting from title vendors throughout as well as the Consumer Division in Microsoft. Where people want the flexibility they have with their authoring tools, they want the rich presentation, inside HTML. So this work combines to try to give that you. Where we're going to be taking HTML along with the W3C. Okay, great, thanks, Thomas.
I'm now going to invite Ken Fowles to give us a free view of what we're doing in terms of international. Ken is our Unicode international expert. And the kinds of thing we've been thinking about is, now that you've got this worldwide connectivity it doesn't do you much good if I see little square blocks every time I go to a Japanese page. I don't understand that. I always find myself ending up in Finland. So I really want to be able to view those pages and we're trying to do some work there to make that easy.
KEN FOWLES: First of all, one of the things that we've done at Microsoft [is] translating to user interface of a product. As John mentioned this morning, we've already shipped Internet Explorer, translated into 22 languages. And that list will continue to expand. But what I would worry a lot more about here in the United States and also in other locations worldwide is what about accessing the contents in other languages so that I don't have to reboot or load a different language or the operating system, to actually be able to go to different character sets from within my browser or my platform. The work that I'm going to show you here is code that's going to start being checked in as soon as I get back up to Redmond.
CHRIS JONES: They missed our check-in deadline.
KEN FOWLES: This is running on standard English Windows 95, standard retail package. And if I go over here, go down to--this is actually logged in live to one of the main daily newspapers in Tokyo, Japan.
CHRIS JONES: So this is standard Windows 95 with Japanese fonts installed, displaying those fonts.
KEN FOWLES: And the other thing I want to emphasize, this is not a bitmap, this is live text. I can redraw, expand, reduce the size of the text. And these are hyperlinks that work. All of this stuff works. And, in fact, if you check the date, this is the current news. It's March 13th in Japan right now because of the dateline.
CHRIS JONES: It's very cool. Very cool. Can I do other character sets, too?
KEN FOWLES: You bet. Let me show you, for example, obviously English is quite easy to get to. You go to view options. Let me move it off to one side. I have another instance of Internet Explorer running now. And what I'm going to do now, this has to load a different table, is I'm going to go to a Web site in Korea. Now, one thing to realize is I'm actually logged in live, so these connections are going to take a little bit of time. There, I've got the window back. If I go here, Cho-Sun, this is the major newspaper in Seoul. I'm simultaneously displaying text in both Korean and Japanese and for that matter, English, on the same machine. (Applause.)
KEN FOWLES: Notice that my frames even work in IE 3.0. This is actually a live frame page in Korea: And again.
CHRIS JONES: So this is really great for multi-national corporations that want to display their stuff. We made a Unicode doing into this and can do the conversion on the fly. Thanks a lot, Ken. That's super. So we're kind of done with demo time, and I actually want to close a little bit talking about media services, network services, a little bit about distributed computing and then about some of the things you can do and the opportunities that you have.
Active media service is taking the knowledge we have in our direct technology, with our multimedia group, applying that knowledge over to the Web, streaming media services, optimized for low bandwidth, supporting the existing content that's out there and then taking the next step to next generation content, adding the next capabilities in terms of synchronization. These are for your application, we'll have a breakout session on that today, we have terrific demos that I didn't have time to squeeze in right here.
The other thing you can do is plug in new formats using this movie architecture, you can plug in your converter for your movie data file, convert your sounds to different things, synchronize your sounds. We'll give you the opportunity to package in at the filtering level if you choose to do that. Speaking of plugging in, there are network services that we provide in the operating system. Gives you the ability to choose where you want to be in the network. So most people who write controls are really going want to be at the URL moniker level. They're going to want to have a URL and a callback and say go figure this out and get my data for me, I don't need anything else.
We provide standard protocols such as HTTP and FTP and Gopher for you to use. Other people are going to want to extend their protocol. You can plug in FOO and everybody will understand that protocol. In addition you can take advantage of our shared caching service that we provide so you don't have to write your own; I can look at information in the cache, suck stuff out of there. It's pretty cool.
And finally, there's a set of applications that you can--that [you] are really going to need to write to Windows Sockets; RealAudio is one, a stock ticker is another one where I want to send packets over UDP and I don't care about getting a whole file back. Windows Sockets and Active[X] Control aren't mutually exclusive. We provide a set of services, you pick the level you want, we think [for] most people, URL moniker is going to be good.
Then there's this technology called Distributed COM [(DCOM)]. And a lot of people ask how does it relate, what is Distributed COM. Just like COM is a way to package up technology, Distributed COM is a way to distribute those packaged components over the network, seamlessly to the client programmer. So if you think how the client architecture works today with COM, a client makes a CoCreateInstance call to create the object. It finds the object on the client and substantiates it and then hands a pointer to the IUnknown, to the client, to the object, and you start working with the object, call the interfaces you want, et cetera. In Distributed COM, the client case is exactly the same. You still make the CoCreateInstance call but DCom goes and remotes that call out to a server independent of your knowledge. So you call it, it does stuff you don't know about, it creates it on the server and hands an interface pointer back to the client, you grab it and start programming that object directly. We'll have some demonstrations of how Distributed COM works. It's a convenient and powerful way to program. You can actually debug your objects and distribute them out remotely. We've got plans to distribute it out over HTTP. So it's our solution for easy object programming over the Internet, over TCP/IP and over networks.
So what about code safety? We've talked a lot about code, about downloading code, about Active[X] Controls, but sometimes Active[X] Controls get a little too active on your hard disk or on your machine, and you don't really want that kind of activity. So what you'd like to do is have some code safety or security just like you have inside a software store today. I go into a software store today, I pick up a box, I take it back to my house, I plug it in and that thing does not format my hard disk because there's brand and association with that. If I have a bad experience with that product I actually can go and say I'm not going to choose to buy that product from that vendor again. There's identity there.
So the risks of code we all know about, there's malicious code, code that's been mucked with as it comes over the wire so the server sends the right code but then on the wire someone changes the code on the fly, adds a virus and it gets to me. So I want to ensure that the code is not tampered with and that it comes from the right authority. So the goals of our code signing are an open industry-wide cross-platform solution. And everyone says who is going to be the certificate authority? We want to have a certificate authority out there that people can use. We'd be happy to be that certificate authority in some cases but some people say Microsoft, certificate authority, bad; we don't like that. So we're going to have a talk on code signing initiatives, but the goals are to have safe downloads of these ActiveX Controls, how the downloading of the rich code that takes advantage of the full platform features of the operating system and does things it needs to do, and also make it a really easy purchasing decision or decision for the user, so they don't have to answer like five questions on a Web page with a control. You just want to run that page and have the system guarantee security.
So we're going to use digital signatures to do this, a standard on top of an executable. The big thing about that is that it doesn't ensure that the code doesn't have viruses or is not going to crash. It ensures identity. It tells you who wrote the code. And depending on if you trust that person or not, you will choose to run the code. It also validates the integrity of the image. It means that the image hasn't been tampered with as it comes across the wire. Like shrink-wrap, you want to have the same feeling of customer satisfaction, the same choice you do walking into a store today. So what's Internet Explorer 3.0 into all this; you talked about components, interface, all this and all that. What is Internet Explorer, what are the components inside of it? First we have a container called IEXPLORE.EXE. So that provides user frame, and SHDOVW.DLL provides for how we host that. On top of that we put our MSHTML.DLL, it's both an Active[X] Control, you can host it inside your applications. And inside MSHTML.DLL we include controls and intrinsics that are only included for images and we will include VRML and ActiveMovie. We also include Active Script, that includes all the scripting services. You can go use that in a different place. That's how we did the VBScript demos we did here, used that VBSCRIPT.DLL, there's also a JavaScript in there. And finally the services, URL moniker we talked about, Gopher support and erl.cache URL is the URL caching services.
The other question people asked is what's the difference between Internet Explorer, the browser and this Windows shell thing and how do they interrelate. What happens in Windows shell is we, whack, replace it with EXPLORER.EXE. The only difference between [what] Joe showed and what Thomas and I showed is the container on top is EXPLORER.EXE. The message for you is you write these Active Documents, Active[X] Controls, you distribute these with your application and when the Windows shell and the update comes along, suddenly you plug into the shell. You don't have to do any work.
Availability: Today we've got a developer's Alpha. Actually the CD will be ready at the end of the conference, Wednesday or Thursday. We'll go on the Internet, get a stability to have broad end user data. Then we think that the Mac and the Win32® product will follow by about a quarter.
So to summarize I'm going to quickly go over these points and then take a couple questions. If you're developer, write an Active[X] Control. Active[X] Controls are the most leveraged way for you to go and deliver technology to people. There's a huge marketplace for OLE Controls today. There's going to be an even bigger marketplace for Active[X] Controls. You've seen a lot of containers up here; [with] the explosion in the Internet we think that will take over. Support high latency networks, make sure you can take data over it. You want to think about how you package your data. You want to substantiate the controls with the packaging you need and then call the container back for the JPEG image. And finally and most importantly expose your objects as a programmable object so other scripting vendors can hook into that. The more programmable your object is, the more powerful it is, the mo[re other] people will deal with it and the more people will buy it.
For applications, write Active Documents. Active Documents: We're hoping there are going to be more active document containers out there. We know we've got three great ones, Internet Explorer, the Windows shell and the office binder. We hope that companies like Lotus note [and] become a document host for the mail products and the scenarios there.
If you're an application, also host controls. Hosting controls is going to be a really good way for you to get progressive JPEG, MPEG, all different sorts of features in your applications for free without you having to write them. And take advantage of scripting and provide a great object model for your application. And all these third-party scripting applications that we hope will come along will be available for people to buy and allow people to plug in your application and script those along. For containers, there's a set of containers you're going to want to host document objects, and the key is host document objects but also provide some interesting semantics and services on top of that to differentiate your container. History. A mail application can provide to and from.
That's a good set of services. The OfficeBinder provides actual project view. That's a good service too. Think about the value you provide, specialize and let the document writers plug their applications inside. And for authoring tools, there are three different levels I want to talk about here. For publishing tools, host controls and scripts and target the W3C approved HTML. There's a tool from SoftQuad called hot metal that actually hosts controls and scripts today. You can see them in the hands-on lab. It's a great way for them to differentiate their tool. It's kind of hard to author and time in HTML manually for those of you who have gone and tried to do that. Encapsulate COM, make it easy for people to use COM objects, make it easy for people to package up their objects as COM objects. And finally for scripting engines, make yourself an OLE script engine that's exposed out there and then go and distribute that engine because people are going to write Active Scripting hosts and you want to make sure you can plug your scripting engine in there.
By conclusion, of course, is write and use ActiveX™ Technolog[ies]. Give us feedback on how it works. We're interested in your feedback. We're on a very fast release cycle. It was just six or seven months ago we released Windows 95. It was just three-and-a-half months ago we released Internet Explorer 2.0 and now we're releasing Internet Explorer 3.0 as a developers's beta. You know we're going to continue to provide with you the interface you need. That's all I have. I'll be happy to take questions.
FROM THE FLOOR: One thing you failed to mention is licensing of ActiveX Controls. Is this something done only on the server that we'll hear about in the future or what are the plans for client?
CHRIS JONES: It's a good question. It's what about licensing these anyway. I don't want to put them on the Web and have them go everywhere and not get my license fees for those controls. We're thinking about how it is you bind a control into the page and have the license stored with the page [store] for a particular author that authors a page, you can run that control with that page. But if you copy the control and put it somewhere else the page that you're putting on doesn't have the key that you need to go and actually instantiate the control.
So we're working through those issues. What's helpful to us is to hear about the scenarios you want to use. Some people want everybody to play a license fee, including the run time. Some only want a license dialog to pop up. So we're working with a team to understand this, to make sure we support licensing well. We agree it's a very important issue and it's one of the places we're going to focus on. Thanks.
FROM THE FLOOR: What kind of tools is Microsoft looking at providing to make OLE COM components easier to build? An example is building OCXes with the V[isual] C 4[.0] tool set.
CHRIS JONES: I think two things. First, you saw us demonstrating ActiveX Controls that were written in Java, in Visual C++ and in Visual Basic. Those were written using our development tools. So you're going to see all of our development tools take these ActiveX Technologies and standards and move those things forward and make it really easy for you to write those. And there's the level that V[isual] C++ has today which is it's real easy to write applications, easy to write a control container, a control. And they're going to go a step further and say it's easy to make a COM object. That's their direction.
FROM THE FLOOR: When we're fine-tuning pages for the Web, we often use view source, and we have that great high end application called Notepad.
CHRIS JONES: Visual Notepad.
FROM THE FLOOR: Are we going to see a Notepad II or something optimized for HTML, maybe a couple simple tools?
CHRIS JONES: We don't have plans for that right now, but we'll take it into account. That's a great idea.
FROM THE FLOOR: Do you have a ship date?
CHRIS JONES: We're not that quick. Yeah.
FROM THE FLOOR: For those of us with existing MFC-based controls, will there be pathways or guidelines so that we can easily move those to ActiveX other than--and to strip out what isn't necessary that we get from MFC?
CHRIS JONES: There are two things I should say about that. The first is all of your controls run today in Internet Explorer; okay? So you don't have to change your control to have it run. There are two things your question revolves around. One is is it going to be easy for me to add you recall URL moniker support, the answer is Bob Muglia will talk about that, our guest will talk about that, but yes, there are plans to add that to MFC. The second is the working set is not what I want it to be. We've seen great improvements in our working set, your are going to continue to see that improvement in performance in working set using these active interfaces.
FROM THE FLOOR: Yes. What about some tools for capturing user information for billing purposes or for marketing purposes, getting users profiled? Is there something that we need to build or is Microsoft going to provide something for that?
CHRIS JONES: So you want me to search the whole hard disk, get the credit-card numbers, e-mail names, send that out to you?
FROM THE FLOOR: No. If there are some--I mean, there are different levels of work going on in different places, but it seems like everybody who wants to sell some service has to get the user to fill out a form, and, you know, get some different levels of details.
CHRIS JONES: So something like a digital ID, where I as a user could fill out a digital ID and submit that to a service and only have to do that once. VeriSign already has some technologies that are like that. We want to make sure there's an open certificate environment in the client that you can install certificates and then get that up.
FROM THE FLOOR: My question has two parts. In the multilingual demo that you had, was that data character sets coming across in Unicode, and the second part is do you have support for the full Chinese character sets or other character sets?
CHRIS JONES: Ken, why don't you take that.
KEN FOWLES: As far as part of the question about was the data stream coming in in Unicode, the answer is no. We take data out of the cache in its existing form for example, shift GIF, whatever. The second half of your question--
FROM THE FLOOR: Oh, do you have a current support for the full Chinese character set?
KEN FOWLES: Yes, we will be building that in. Basically we're supporting anything that [is] supported by Windows 95 or Windows NT.
FROM THE FLOOR: Obviously it's important that the OCX controls work on all different platforms. If we're writing OCX controls that have WinSocks connections in them, will they be able to?
CHRIS JONES: So the question really kind of revolves around what's the level of API support we're going to provide on all the different platforms and how do you get binary compatibility. I guess I would say there are two things. We're looking to migrate these over as COM objects and we will work on the Macintosh platform and the Unix platforms. I'm not sure what form that will take. It could be WinSock is a bad way to get that on the Mac and you want to do something that's different that's customized for the Macintosh. So we're trying to find out what the right interface level is for what level you're on. And then the question goes to tools; okay? What tool do I use, does it have a VM associated with it, a byte code associated with it. V[isual] C++ does not today, Java does today, and we're going to give you a range of choices and you as a developer will pick what you'll do, do I want to run in native code mode and have to compile twice, if I choose to go to the direct level do I write to a different set of interfaces to get the full hardware support. So it's a weird question-answer to your question but we're saying we're going to do the right things on the platform at the right level. It's platform-specific in many cases. We'll try to make it as easy as possible to switch between them. At the active level it's really common platform neutral.
FROM THE FLOOR: What time frame before we're able to do some of those?
CHRIS JONES: Q 3 will be on the Mac. I think when Todd comes up to give his tool talk, I'll have him address it then.
FROM THE FLOOR: A critical mass of my customers have decided to skip over Windows 95 and go to [Windows] NT 3.1 workstation and in my particular industry it takes a while to do things like that. All the nifty environments we're going to get, how much of this works under NT 3.1 and if it doesn't I'm assuming it will work under 4.0.
CHRIS JONES: It works on NT 4.0 the update release and install, it works great. The reason we have a problem is we have shell dependencies so we take advantage of the new shell features to do our doc hosting. I hear your feedback on 3.1. You can't run on NT. So if you get the beta 1 of the release, you can run that today. It works great.
FROM THE FLOOR: So Explorer 3 will not work under 3.1? Is that the bottom line?
CHRIS JONES: If NT 3.1 continues to be the market it does today, we will absolutely s[up]port 3.51.
FROM THE FLOOR: My first question is one of your slides has you delivering 3.1 Internet Explorer which is 16-bit, I suppose. Being a developer using your tools, doing 16-bit and 32-bit is a hassle, and I don't know why you guys are going back and doing 16-bit apps again. Is it your direction is changing or--?
CHRIS JONES: All right. So the question is what about 16-bit apps. Like I was here last year and I heard Win32, and now I hear you're doing Win16. We have customer demand for Win16 clients. So we're going and implementing a great Win16 client like we have a great Macintosh client. Does that mean we think Win32 is less important? No. We think it's super important and we think there's a lot of benefits in the Win32 platform that you won't get on the Win16 because of the services we've put in there. So we have making an investment in 16 bit. You as a developer may choose to make that investment depending on your customer need.
FROM THE FLOOR: Does that mean that V[isual] C++ will allow me to do both 16- and 32-bit with the same tool or do I have to switch between 3.1 and 4.0?
CHRIS JONES: I don't know the answer to that question.
FROM THE FLOOR: My next question is you have your ActiveX Controls tightly coupled into Visual Basic, and obviously you're making Visual Basic programmers rich, and whereas the hard working C++ programmers cheap, and when are you going to have this ActiveX Control incorporated into C++ MFC. On top of that could you share how I could use this to integrate into Microsoft Office suites?
CHRIS JONES: I've been told there's a tools talk--I'm getting cut off. I've been told there's a tools talk later this afternoon. That's a great place to ask that question. In fact I'll have the person address it in their presentation. Is that okay?
FROM THE FLOOR: Okay. Thank you.
CHRIS JONES: I actually have to stop now. I'll be happy to take questions off line over in the corner there. Thanks very much.
Back to table of contents for General Sessions
© 1996 Microsoft Corporation