Apple pushes its own development environment Xcode to use new interface techniques. Objective-C gets Garbage Collection. 64bit applications will be able to use the same libraries (Cocoa, ...) like the 32bit applications. The whole user interface experience of Mac OS X gets very visual and media rich integrating lots of animation. Some of the ideas might even apply to Microsoft's Vista, which also gets a new user interface technology.
As I have sometimes mentioned, although there are many (generally quite good) Lisp implementations on the Mac right now, none of them has a good Mac integration like MCL used to have in Mac OS 9. With Mac OS X 10.4 there is even more cool infrastructure provided by Apple that waits to be exploited by Lisp environments and by programs written in Lisp. I'll try to collect some ideas - if you have some ideas how to make Lisps cool on the Mac, send them in (joswig@lisp.de). 'Lisp' really means Common Lisp. I'm concentrating here on the Mac OS X related aspects of a Lisp-based development environment.
Here are some ideas for a new Lisp environment on Mac OS X 10.4 (and later):
Objective-C and Cocoa
- Standard Cocoa and Objective-C bindings for Common Lisp. There should be only one cross-implementation interface. Currently the interfaces of OpenMCL and LispWorks are quite different.
- Standard CLIM Cocoa backend. Based on MCL's CLIM.
- Standard Common Lisp high-level bindings for various services in Mac OS X: QuickTime Kit, CoreImage, CoreVideo, Quartz, Webkit, and more. MCL has a nice CLOS-based high-level library for various Carbon functionality. Something like that is needed for the new Cocoa-related libraries.
- Standard Lisp interface to CoreData. CoreData uses SQLite as one of its backends. Lisp programs could make simple data persistent and the data model could be developed with XCode's Data Model Design tool.
- Spotlight plugins for Lisp text and FASL files. Find classes, methods, functions, documentation strings, .. with Spotlight. Spotlight is the standard search/find infrastructure on Mac OS X. Lisp data should be searchable.
- Use Spotlight in the Lisp IDE for live searches into Lisp files, preferences, compiler messages and the documentation.
- Allow persistent 'intelligent folder' searches into the code: all files changed before/after, files written by, files with class/method/function/... definition, files with author, files which reference class/variable/method/function/..., files which contain a certain string ('fix', 'implement', 'to do', ...), classes/functions/methods/variables that ..., ...
- Provide completion based on Spotlight.
- Use Webkit in the Lisp IDE to browse documentation and more. Webkit allows browser views in your application. The new Webkit can even edit HTML - somehow.
- Make sure that the network streams can be updated, when the physical network connection (Ethernet, Modem, Airport, FireWire, ...) changes. Mac OS X allows you to safely switch networks. This is very common for mobile users. Avoid quiting the application or even rebooting the Mac.
- Make sure that the network streams can be updated, when the network interfaces are changing (add, remove, change IP number, change hostname, ...). Often hostnames and IP numbers are changing. (Note to LispWorks: Make sure that the licensing mechanism can cope with that!)
- Provide a Dashboard widget to search the HyperSpec. The HyperSpec is probably the single most important Common Lisp reference. Dashboards widgets for browsing sources like dictionaries and the Wikipedia are already available.
- Provide a Dashboard widget to search the Lisp documentation.
- Make it possible to use Lisp from Dashboard widgets. Currently widgets are mostly programmed in JavaScript. It could be useful to be able to call Lisp from JavaScript.
- Provide a Dashboard Lisp listener. Something simple to evaluate Lisp expressions and display the results.
- Provide a Dashboard widget for running McCLIM command interpreters. McCLIM has a nice object-oriented command line interpreter. It would fit nicely in a small widget.
- Provide a plugin for Automator to run Lisp code. Automator provides a graphical user interface to combine functionality to scripts. Being able to start a Lisp with a few arguments would be useful.
- Support sending and receiving AppleEvents.
- Make the IDE and applications generated with it scriptable via OSA (AppleScript).
- Let the editor understand Applescript syntax.
- Record Lisp documentation, compiler messages, Lisp messages, source locations, preferences, ... via CoreData in a SQLite database.
- Standard Lisp interface to Interface Builder.
- Export logs (compilation messages, Lisp errors, system transscripts, ...) as RSS feeds.
- Attach metadata from the Lisp IDE to the files created or changed (site, author, default package, base, version, syntax, compilation source, ...).
- Provide small transparent windows showing documentation of symbols under the mouse. Similar to Apple's Command-Control-d functionality.
- 'About this Lisp' should provide information about the running Lisp (threads, memory sizes, site name, version, ...).
- Support Xgrid to spread computation across several machines.
- System-wide hotkey to bring Lisp to the front. Hotkeys to create/rotate Editor, Listener, Inspector, Peek, Filebrowser, Mail, ... windows.
- Provide Lisp project templates (script, command line application, system, Cocoa application, ...) with setup dialogs.
- Provide categorized library (see the Automator user interface) of Lisp code templates (package definition, system definition, new event subclass, play sound, prompt for directory, ...).
- iTunes like browsers with columns for the various meta-data, editors to attach various meta-data (documentation, author, number of times run, created, changed, optimization settings, debug settings, before/after hooks, active/deactivated, ...), hierarchical system/package browsing and an 'online-store' for Lisp code..
- Use the standard Apple installer to install and update the Lisp installation.
- Support for Drag and Drop in various places.
- Text snippets in the editor, text edit dialogs, ... To and from other applications.
- Drag file representations (like in the title of editor windows).
- Dragging a fasl file into a Listener loads it.
- Dragging a Call Frame from a Backtrace onto an Inspector window inspects the Call Frame.
- Dragging a Symbol that is a Class name onto a Class browser shows the Class hierarchy.
- Should not be tied to a certain place in the filesystem. The application should just be a bundle, that can be moved around.
- Find old versions of code and data with Time Machine (10.5).
- Metering Tools
- Automatically updating inspectors, monitoring data changes
- Application history: uptime, runtimes, ...
- Add a file browser as a drawer to the editor window.
- Add a file content overview as a drawer to the editor window.
- Provide Wiki-like linkage in documentation strings and in source code. Recognize hyperlinks.
- Save Lisp files as HTML or PDF. For documentation/publishing purposes.
- Allow pictures, background pictures, diagrams, graphs, buttons, tables, linked frames with text flow in the source code editor. Imagine a 'Pages'-like source code editor. Pages is Apple's new word-processing application. Pages has very beautiful looking templates for common documents, each with several different predefined page types. Predefined styles for various code parts. Why should Lisp source code look boring?
- Remember editor buffers across restarts of the IDE.
- Highlighting of all search matches.
- Ability to run Lisp code on selections (and replace those with the result).
- Persistent Keyboard Macros
- Mark text blocks: sequential, block, fragmented
- Operations apply to: selected region, buffer, file, group of buffers, system
- Menu of marked positions in buffer.
- Search/replace log.
- Compare buffers or files.
- Unlimited backup files.
- Optional recording of keypresses with replay to restore documents.
- Pattern search.
- Support for 64bit addressing and large fixnums.
- Optimize for Altivec engine (available in G4 and G5 processors). Provide Altivec enabled Lisp vector operations.
- Support for Vector engine on Intel processors.
- Support Mac OS X on Intel processors (32bit and 64bit).
- Support for Multiple Processors and native threads (with different priorities).
- Make it possible to save already running Lisp images to the disk (like in MCL or Genera). This boosts productivity.
- Allow delivery of FASLs in directories (like Mac OS X applications). Double-clicking/openning a FASL would run a script that either loads the code into a running Lisp Engine or starts a new one. The directory could also contain other resources (images, sounds, ...).
- Support for applications using Universal Binaries. Universal binaries run natively on Macintosh computers using PowerPC or Intel microprocessors. The Lisp compiler would need to be able to generate both x86 and PowerPC code.
- Native User Interface framework (buttons, fonts, events, images, icons, windows, menus, open/save, undo/redo, ...).
- Add hooks to various functionality (switch to Lisp, switch from Lisp, start compilation, end compilation, full GC start, full GC end, enter sleep mode, wakeup from sleep mode, network changed, start Lisp, quit Lisp, hide Lisp, unhide Lisp, low battery, empty battery, ...).
- Support the media libraries provided by iLife (sound, images, movies, ...). Provide the usual picker to select items from these libraries.
- Use the standard toolbar functionality provided by Mac OS X in the application windows.
- Provide a Dock menu to access the application's windows.
- Adjust to changing network settings on the fly. Useful for TCP/IP servers written in Lisp (like CL-HTTP).
- Adjust to changing screen space/depths on the fly.
- Provide a full-screen mode for applications (like Presentation tools).
- Support Keychain for storing and retrieving passwords.
- Support for AppleEvents. Make the application scriptable and send events to other applications.
- Support transparent windows and windows in different layers (front, back, ...).
- Support for unlimited undo/redo classes.
- Support for clipboards with Lisp data. Put Lisp text with color coding into the Clipboard.
- Support for the service menu (Spotlight searches, Google searches, Open as URL, ...).
- Make it possible to implement 'Services' in Lisp. Other programs then could use these services to manipulate their application objects (text manipulations, evaluate in Lisp, ...).
- Support for drawing graphs, charts and plots.
- Lots of example code organized in categories.
- Instant feedback (search boxes, ...).
- Very visual.
- Lots of drag and drop.
- Direct manipulative.
- Very media rich. Reuse iPhoto, iTunes, ... libraries.
- High quality display and output (Fonts, Icons, Quartz, OpenGL, ...).
- Pro User interface for professional users (like the Pro application suite from Apple).
- Follows Apple's User Interface Guidelines.
- Reuses Apple's highlevel user interface elements.
- Robust. Does not crash.
- Online Wiki for Documentation, FAQ, Tutorials, Code Snippets, Examples, ...
- The wiki should allow registered users to add versioned files/images to the pages. Track downloads.
- Access and edit the Wiki with the IDE (integrated development environment).
- Mailing list for Lisp users on Mac OS X.
- Mac OS X Server based machine for the Lisp community.
