(DRAFT) some random thoughts on gnome stuff (dunno how realistic it is): i've been thinking more about the gnome language issue lately. two related issues exist here: the needs of the developers working on the core of gnome (infrastructure), and the needs of the developers working on applications. the most flexibility exists with the application developers whose choices generally affect only themselves. they should be able to use the language of their choice and every effort should be made to make their lives easier (more on that later). the choices infrastructure developers make affect everyone else, so more caution is required. at the same time, requiring infrastructure developers only use C significantly increases the effort necessary to write software and keeps them from taking advantage of higher level language features. therefore a balance must be struck: take every effort to make both groups more productive without tying a large, foreign into gnome's core (note: i don't think anyone is suggesting that mono or java be used for the core of the platform, but i'm trying to suggest that there is a middle ground between staying as things are now, and draggining in mono or java). given all this, my preference is to improve the object system, create a convience layer for infrastructure developers, and take steps to allow application developers to use any language they like. (this is one of havoc's proposed solutions). identifying some requirements: interfaces must be specified with less ambiguity: currently interfaces are largely defined by the C header files. using C, most interfaces tend to be under specified, for example: foo_bar_baz(foo ** arg0, blah_t * arg1, foo_t * flaz); you don't know what the parameters are doing (in, out, or in/out). this creates a problem come time to write bindings for other languages, like python where if arg0 is an out parameter, arg1 is an out parameter, you might find ( arg0, arg1 ) = foo_bar_baz(flaz) since we can pass back multiple values rather than use in/out parameters. an IDL or some other interface definition language would be better suited. binary interfaces should be specified: this just means given an interface definition, we should establish and adhere to a known set of calling conventions so that any language can call into any other language's libraries (one way or another). (this exists de facto, but i believe other issues must be specified). i'm going to make the assumption that we will be using an object oriented system one way or another. i think this is a safe assumption. it should be easy to subclass existing objects: (in order to customize behaviour and create components) the current gobject implementation makes it quite painful to derive an object, (or create an object at all), which significantly reduces the probability that people will actually do it. in many cases functionality which might benefit from being made an object (and possibly reused) is instead created in an ad-hoc to speed development. under the current regime, only advanced users will do it or be able to do it. objects should provide all pertinent metadata: ie function signatures, methods, objects, classes, etc (life cycle issues?) this helps automatically create bindings whether at runtime or compile time objects should require no special effort to provide a component (in or out of process) you should get corba (or whatever) bindings for free when you create the object (this will aid in allowing other languages to use it as well). currently this is a bit painful because C doesn't allow you to abstract away many of the details. one should be able to subclass these imported objects in the language they are imported into (with restrictions most likely) a garbage collector should be provided (as well as a way to get around it). life cycle/memory management issues should be enumerated and provided by metadata so that they can be handled (or at least warned against) the current system can provide (or already does provide) many of these without major changes; the biggest barrier is the fact that C makes it painful to use. consider the case of using corba in which you have to initilize your class's virtual method table and what not manually. the relative lack of use by the community reflects this difficulty. choosing from mono or java is a divisive issue, and both are in my opinion poor choices for infrastructure work. in both cases we tie ourselves to something we cannot control (and it matters because unlike C/C++, there are geniune benfits to having input to .net or java platforms), both require a virtual machine (which don't seem to make provisions for sharing vm's between multiple applications). both also represent a radical departure from what most of us (me) in the community are used to. D seems fits (my biases) well, but currently compiler support is not mature (a gcc front end for it has only recently appeared). the compromise would choose would be a precompiler like gob2 which will allow one to take advantage of the object system easily while retaining C underneath. there could in fact be several different precompilers to suit various tastes. the major issue is that these mini-languages must be documented and versioned. C++ is another possibility, but in my opinion a less desirable one (with no further justification) . ------------------------ With respect to making developers' lives easier, there are several issues that must be attacked. First and foremost we must make sure that doing the default/normal things are dead easy for a developer. secondly we must effectively communicate what is available and how to use it to the developers. finally, we need a test by which we can judge our success. The first two points require us to figure out what developers actually need to do and what technologies they could use to accomplish those things. here's a laundry list of questions a developer might ask, or stuff we should provide, etc: UI: GUI interfaces (make them easy to build to the HIG) Internationalization (how?/why?/where?) Accessibility Storage: when do you use the vfs layer? when should you not? what structured storage is available? when should i use it IPC/Networking: how do i interact with other applications? how do i talk dbus or corba? how do allow my application to be scripted? how do i do DND, how do i do it right? how do i use mime types? how do i access shared bookmarks? how do i use the clipboard App Integration: what does it mean for an application to be well-integrated? how do use the help system and browser? how do i install and remove my application properly? Media: what media services are available? how do i use them? how do i play audio? when should i not use them? (less latency, better performance, etc) most of these things can be done with the platform as is. but it tends to be hard. if we want people to do it (if we want to make it easier for us to do it), we have to make doing it as easy as possible and require little or no effort to implement and get right. for the most part many of these features remain painful to use as a developer. we should provide cookie cutter recipies for putting together applications with minimal effort. underneath, an experienced developer should still have access to all the basic components so that if need be they can customize or create whatever behaviour they need. -------------------------------- how do we know when we're accomplishing what we've set out to? this assessment should be driven by the high level goals: create a coherent and usable desktop for the user create a coherent and usable platform for developers ultimately, all technological choices should be measured against these two goals. these can be further divided substantially; and they must. the easier we understand what our goals are (and by "our" that might not mean the entire "GNOME community", just that group that agrees on them), the more clearly decisions can be made. ------------------------------------ many of these steps (better documentation, standardization, object system extensions, etc) are not controversial and can be done (or begun) today. -------------------------------------- clearly we should all just relax.