Anyway, keynotes and three sessions. The hardware keynote focused on G4, firewire and USB. Nothing surprising came out of it. I think it is still unclear when G4 machines will come out but there is a _ton_ of sessions on AltiVec and actual signup sessions for experience. Throughout the core OS sessions, they are also stressing SMP performance so Apple is definitely wanting to play soon. FireWire and USB are obviously becoming the IO interfaces of choice on the Mac. I still question the lack of FireWire on the new laptops. Sony has some really nice machines with it on already for awhile. Tradeoffs I guess. It also creates a broader market for Newer's firewire card since the new machines and all previous PowerBooks are a target market. The firewire hot swapping is very cool.

PowerBook power savings. I don't think I have seen anyone reporting thus but I bet the huge improvement is strongly motivated by needs of the consumer portable. They stressed power savings through the OS sessions as well. It makes a lot of sense for consumer portable and potential lighter MacOS clients.

Sessions:

* Core OS Overview *

They went through a lot of the layers. Was not extremely detailed but can't expect much from a presentation. Went through the various layers that make up the emerging next generation Apple OS. They are targeting it to support their needs for 10-15 years.

Core OS. Stress processor independent, support multiple application environments (Classic, Carbon, Cocoa, BSD), high performance, flexibility, robustness, ..., everything you want in an OS. They then drilled down to the layers.

Mach 3.0+ (3.0 + OSF/Apple enhancements): Primary purpose is to manage CPU, scheduling, memory protection, and messaging. Apple is really stressing the new scheduling model (primarily the preemptive nature), they want to pump it up to real time interactivity levels. Preemptive is one thing, they also want to make it real time so video, audio, etc. can better be handled. None of the sessions have hinted at a trimmed down version of the MacOS X. Given the push towards real time capabilities, I think they could be very well positioned for the set top market if desired (no signs of this though). Be is trying to push this given their great scheduling abilities. Big changes from the Mach 2.5 kernel include: SMP (not to the 100s of processors, but definitely beyond 1-2), real time facilities (forgot to ask if this would be to the degree of supporting POSIX.4 or something of that nature), untyped IPC/RPC in the kernel (big time optimization), external pager (allows for a lot of flexibility in changing the virtual memory system and how pages are brought in), and overall a more modular design.

IO Kit: DDK out in the fall. Object oriented framework for drivers written in C++. DriverKit in OpenStep and MacOS X Server is written in Objective C. Was not really clear if there were many benefits of moving to C++ other than programmer familiarity (which can be very key). IOKit will offer true plug and play (as opposed to Wintel plug and pray). Apple is really pushing the slogan "it just works". They want the system to just be there and function as expected without the need for any tweaking. Allowing one's grandmother to do anything keeps coming up as a comparison case. IOKit also pushes for dynamic device management. This is becoming more important with FireWire and USB. IOKit is also very modular and will provide a broad suite of base classes to start from. They are working for a revolutionary framework here. I hope it is worth the wait. Am not clear where the new printing framework would fit.

POSIX/BSD: POSIX is loosely defined as the API provided to interact with the kernel/low level OS. BSD is the common application framework on top of POSIX. FreeBSD 3 is the BSD Apple is standardizing on. POSIX will provide the system frameworks. Still unclear of how easy it will be to interact with the Mach kernel, given there are some pretty significant interface differences between the two. It appears POSIX/BSD will provide the common process model for the OS. pthreads will be the preferred library for threading, with cthreads (Mach's user level thread implementation) kind of in limbo. BSD will be there for MacOS X but as an optimal interface to the system. Unix will be hidden for the majority of users, and no one will be the wiser.

Also remembered a small note from yesterday's MacOS X Update session. Apple wants to make everything as easy as just driving a folder over with the app or the OS and it just working. Kind of like MS Office but not as scary.

Fie Systems: UFS is the file system of choice for MacOS X Server. It looks like MacOS X will use HFS+ primarily. HFS+ currently has all of the necessary user protection/information needed for a Unix style file system. Design is a VFS (virtual file system) enhanced system. This allows for layering of file systems. For example, someone can write an encryption plug in for the file system to sit inbetween the calls and the actual read/write calls. All the common file system formats will be supported in some manner. UTF-8 (unicode) is there today and they are making sure the international extensions will be trivial.

Networking: Based on BSD 4.4 sockets. Defended choice by pushing the belief open source is better. Open Transport/Streams has components which could not be released. FreeBSD 3 has a lot of developers looking at the network stuff and adding cutting edge code. Apple wants to be able to leverage this current and future code base. Keep pointing to the Networking session on Fri I think to clarify how Open Transport will fit in this new networking world. They have said Carbon will have a pretty robust OT translation layer, requiring _no_ change to work Ot under Carbon. They also mentioned a kernel extensions SDK which will be released probably along with IOKit. Kernel extensions will provide some pretty standard methods of adding functionality to the kernel and other OS systems. Kernel extensions will allow developers to insert modules into the networking stack to gain comparable functionality as the OT streams paradigm.

Above all of this and before the application environment sits what is being referred to as Common Services. These are services supplied to all of the app environments. The best example of this layer is Quartz imaging model.

After, I asked what are the current plans for upgrading MacOS X Server. No comment. It is clear they want to have a common code base across both MacOS X Server and MacOS X at some point. When is up in the air. They hedged at least when MacOS X is released. Darwin will be synched in the fall. Not sure what meaning this has for MacOS X Server. Given the large changes in IOKIt and Mach, there might not be a quick path for upgrading. Given their current model, I am curious if Apple will pursue the MS NT strategy where the server is the exact same as the client but has some bits flipped enabling some server features to be functional. Apple does have very distinct server tools which could basically be bundled with MacOS X to make it a server product. Curious how the market will take all of these distinguishing between clients and servers. Most likely going to confuse on the consumer level.

* QuickTime Interactivity *

I have QuickTime but I really haven't played around with it much. This sessions was very cool. Wired actions got added to QT in version 3.0. 4.0 just improves on the flexibility of multimedia capabilities. People have designed games all in QT. There was a game of break-out written in QT! There were a lot of other games that showed just how flexible QT is. I did not know it was so flexible an environment. When people rumor that QT has almost all of the MacOS toolbox in there, I believe them now. A lot of QT interactive tools were demoed. QT VR has also had a major facelift with 2.2. The quality of rendering is much improved and the workflow process of getting a QT VR image completed has been shortened. More of a show and tell than a dev session. There are definitely some amazing future apps which will revolve around QT.

* WebObjects Java Client *

This was a neat session which went somewhat into detail with the WebObjects frameworks and Java development tools. Some apps were built on the fly during the session that exhibited some pretty advanced feature functionality with minimal programming time.

EOF is the core of WebObjects. It consists of EOInterface (display), EOControl (managing and associating of data), and EOAccess (database plugins, data interfaces). Old OpenStep model approached development layers as:

1. OS
2. Foundation
3. App Kit
4. EOF layers as above

Initial integration with the web changed the model to:

1. OS
2. Foundation
3. EO Access
4. EO Control
5. WebObjects
6. Browser

Moving back to the browser took everyone back around 10 years in the way of interface design. WebObjects wanted to provide an enhanced user experience and a robust developer platform to improve this model. Add Java to the _client_ side

1. JavaVM
2. Foundation
3. JFC (Swing)
4. EODistribution
5. EOControl
6. EOInterface

So WebObjects provides a stack on the client side to interpret and manage a relationship with a WebObjects server (not necessarily needing to be Java oriented). Powerful addition to this model is the EODistribution. It provides methods to get objects over the wire, not just data transfer. The client can receive these objects through the distribution channel and impose some scaled down interface for the received object. This comes in handy if the object has a lot of functionality that should be hidden from the client. The client in its meta information about the object can declare a subset of the methods available to the object that was shipping over the wire.

They went on to give some demos of how Java WebObject clients could be used. It was shown how easy downloading the JFC and foundation classes over the network, and getting a database interacting app running. This fits into the web serving paradigm.

They see the future beyond this. They use the http protocol to communicate between server and client. Ideally, clients will be written as Java applications instead of applets. A very slick database query tool was shown written in Java. Browsing a movie database, the calls were all down remotely, even double clicking on the database item (Star Wars trailer) brought the trailer up on a MacOS client (being served by a WebObjects server). WebObjects has some really powerful abstractions for making some great dynamic applications. Very interesting session.

Day 2 to an end ...

Eric