See also: IRC log
Charlie: Patent Policy?
dsr: As an incubator group we are not creating standards
dsr: we have a more fluid approach
dsr: there is no commitment to make patent disclosures unless we move work into a working group
dsr: let's look at the charter
Charlie: ... reading patent policy
Charlie: Looks like option 3 - the RF policy
dsr: it was weakened to encourage broader participation
Charle: This is the W3C so could there be a charter statement about web architecture principles
Charlie: It should say we are interested in Web Centric approach - a layered UI
dsr: I think that was in the beginning
Charlie: It is more a point of discussion
dsr: My company is looking more at the web architecture
Charlie: we should expect things to run in a loosely coupled, http like, environment
dsr: the idea to have loosely connected teams plays well into this
Charlie: I was looking at reemphasis of this
dsr: Can we assume this is a working assumption of the group
RESOLUTION: It is agreed that we would have loosely coupled layered systems
Charlie: Transformations can get us to a run time point of view
dsr: we should get a better look as we go around the room
fabio: Lot of work in this area - late 80s
Charlie: 3rd generation of work
fabio: how to exploit multiple layers
fabio: Different abstraction layers (task and object, abstract interface, concrete interface)
fabio: this is not only a top down approach
fabio: older proposal for notation representing task models
fabio: concurrent task trees
fabio: set of temporal relations
fabio task allocation
fabio: Concurrent Task Trees (CTT) have become a defacto standard for task modeling
fabio: CTT should be a standard model
Charlie: Is this the human model of tasks
Charlie: tie in with BPMN
Charlie: human processing might be a nice complement
fabio: XForms does not completely solve adaptive description
fabio: XForms have abstract and concrete concepts
Charlie: we wanted this to be a web application spec. initially
Charlie: there are separate applications for RIAs
Charlie: Nothing in xforms relates to the task model
Charlie: in Flex and Silverlight will find similarities
fabio: you can model drag and rop interaction in XForms
dsr: We can collect use cases and do gap analysis on the spec.
fabio: Teresa XML
fabio: we created an authoring tool abstract and concrete
Charie: where is Teresa
fabio: abstract and concrete
fabio: 2 European projects. ServFace model driven service engineering methodology
fabio: illustrating open project model-based incubator framework
fabio: Maria XML
fabio: Maria XML based on Teresa supports abstract data types
fabio: Maria authoring tool
jose: you could do much more than complex transformations
fabio: the source and target are xml documents then you are ok , otherwise ...
fabio: you can generate more powerful approaches but then there is performance
dsr: how easy is important too
dsr: there is a lot of work on transformation languages
jose: transformations between layers of abstraction is a key part
dsr: We would like to open authoring of applications to non-programmers. So, we need easy to use authoring tools
fabio: Maria is at the abstract layer
fabio: Maria would replace Teresa
dsr: lets get back to the various layers later
juan: our group has 20 years of experience
juan: we have experience with multi-modal, haptic, 3d, 2d interfaces
juan: we are in Belgium
juan: we are working with UsiXML consortium
juan: we modeling the UI of the HMI
juan: in a plane cockpit
juan: all information can be downloaded to an image CD
juan: we divide our work for different access
juan: usixml defines a common language
juan: I want to give you the UI transformation model where each layer is described
juan: we are not looking at just the task model but also the business process model
juan: defining roles of each actor, aspects of collaboration
juan: demonstrates gesture-based authoring tool of widgets
juan: the method is 4 layered.
juan: 4 layers for defining the task (abstract, concrete, etc.)
juan: we need some transformation of the UI
juan: we express how to transform form one level to the other ( a graph transformation on each node)
juan: shows example of the methodology
juan: task descriptions, abstract descriptions, concrete UI, and final UI
juan: We have some authoring tools that might help you but not one tool to support the whole process.
juan: GrafiXML allows the user to create multi-language GUI
juan: you cna edit yourself some parts of the XML
You can create a conextModel for Drag/Drop
juan: you can show how can split between different UIs including the mobile phone
jose: Basically all your tools generate code but no runtime
juan: that is correct
juan: we use the CTT notation
jose: Your teresa is only at design time?
fabio: we have tools to generate runtime using the same language
Charlie: the XG should be clear on what W3C is doing for a more flexible runtime across a set of distributed organizaitons
Charlie: business partner may be adding their own UI components
Charlie: to get the W3C language we need pictures of those runtime scenarios
joseph: does one single document define the process
juan: we split the pieces into different repositiories
joseph: does UsiXMl describe all the parts?
joseph: so one UsiXML includes all the design decisions made
joseph: so UsiXML could be an executable language
Jo: [contents of presentation]
Jo: I would like to suggest some work items for the group [as part of my presentation]
Jo: ["service mashups" slide]
Jo: Energy management - available of electricity variable - establishing technology to enhance usability and efficiency
Jo: [Also healthcare, business process, industrial automation]
Jo: Common ground to these and common issues.
Jo: From the lessons learned from the mobile web, we could enhance usability in enterprise-oriented systems.
Jo: [slide "our expectations towards xg results"]
Jo: First want to learn.
Jo: would like to understand better how to combine relevant standards
Jo: [slide: "current work @ siemens"]
Jo: Working on service composition.
Jo: So far using x-forms - but no powerful complete x-forms implementations exist.
Jo: X-Forms also limited for distributed systems.
Jo: We have just started to investigate the semantics behind all of this.
Jo: If all of these services [being composed] bring their own information than this information needs to be aggregated into a single UI.
Jo: Network should be a dynamic topology -- if you bring a new device home, it should find other devices and re-configure itself, so you don't need to be an expert for installation.
Jo: [slide on "proposed work items"]
Jo: We should agree on a common set of use cases. If we don't focus we won't achieve anything.
Jo: From the use cases, it may be sensible to [find] requirements.
Jo: from requirements, we hope to develop to methods and strategies to get some long-term result
Jo: For the report, we should have a compliation of best-practice rules, design patterns, and recommendations for new working group.
Jo: [slide: discussion - mind map]
Jose: We started a long time ago trying to develop a declarative language in order to be adapted to mobile devices
Jose: MyMobileWeb project
Jose: Can support different scenarios. Displaying data as a map or paginating data (for example).
Jose: This adaptation happens at run time.
Jose: You precompile which generates the runtime support that allows at runtime for you to render the UI for different devices.
Jose: This precompliation creates an object model and some code.
Jose: You can't generate code for every device so this happens at runtime.
Jose: Our language was built for the typical mobile web use cases.
Jose: We used CSS properties.
Jose: now (after 3 years) taking into account this experience, we have created a new version of the IDEAL language.
Jose: Necessary to be modular and extensible.
Jose: We have tried to reuse existing things where possible but x-forms didn't give us everything we needed.
Jose: We built it for mobile applications but it could evolve to any modality.
Jose: We have tried to align with DIAL.
Jose: [IDEAL history]
Jose: When you have a UI description language how do you bind to [e.g. Dojo, Yahoo UI, etc...] We should come up with something to bind from the UI language to the final toolkit you use.
Jose: The idea is to allow not only XML data models but also JSON models or whatever model you would like.
Jose: The idea is to have a more advanced language to be able to create more compelling applications.
Jose: Looking at using RDFa to attach more semantics.
Jose: [next slide]
Jose: IDEAL specification suite could be defined around IDEAL. IDEAL is licensed under a creative commons licence.
Jose: We have a working draft published on the web: http://mymobileweb.morfeo-project.org/specs/ideal/
Jose: We are developing an engine behind this which will be open source.
Jose: Adaptation Policies - you need to policies on how layout can change depending on the context, etc...
Jose: context-aware reordering policies - e.g. reorder a table depending on location based on a geolocation API.
Jose: We need simple guidelines on how to translate from the abstract to the concrete.
Jose: [slide on examples]
DKA: What license for the open source implementation?
Jose: Another policy we are trying to explore - have a dual mode - license the technology separately to someone doing something commercial.
Jose: but in general it's GPL.
Charlie Wiecha presents on XML technologies on the client
This could lead to collaboration either with the XForms WG or the Back Plane XG.
Mixing XML and JSON data is really interesting.
b) supporting XForms via additional attributes in HTML
where the goal is to preserve the HTML syntax whilst converging with the XForms architecture.
c) beyond forms with smaller bite sized specs
plus a means to support composition using forms modules.
Charlie: interested in plugging in behavior server-side.
The xforms bind elements can be used within html as empty elements.
We have the full XForms spec running on the client without any need for server-side transclusion.
This is thanks to a script that interprets the DOM tree and supplies the behavior.
This was developed by John Boyer and Mark Birkbeck under an Apache open source element.
This can be thought of as a poor man's XBL.
We support XPath expressions and some schema data types but not yet full schema validation.
We have XML Events and core XForms.
This allows you to choose between compiling down to HTML or to supporting XML technologies via JS run time libraries.
Charlie shows an example
This allows you to interact via voice via launching a VoiceXML component or via launching an ODF-based spreadsheet.
Fabio: the point is that the UI components share the same data-model, right?
Charlie: yes, they share data model via XML events.
We will have conference calls on Monday at 3 PM European Time
ACTION: dsr to create a wiki [recorded in http://www.w3.org/2008/10/24-mbui-minutes.html#action01]
ACTION: dsr to create a wiki [recorded in http://www.w3.org/2008/10/24-mbui-minutes.html#action02]
ACTION: Juan to provide a comparison of task models so far studied by the Academic Community [recorded in http://www.w3.org/2008/10/24-mbui-minutes.html#action03]
ACTION: Fabio to provide CTT materials to be studied by the group [recorded in http://www.w3.org/2008/10/24-mbui-minutes.html#action04]
Roland: What is the relationship of the final user experience?
charlie: looking for a cross-organizational scenario
charlie: the abstract UI comes from one organization, the concrete UI to other scenario, etc
charlie: interoperability is also central
Roland: this things can happen at different times
dsr: there is a lack of standards on this
dsr: we need to explore the interoperability needs
Jo: We would like to go into the use cases
dsr: we need to create the framework for the use cases
Jose: We need a category of use cases, and its comparison to other approchaes and the advantages
Jo: The first 6 months is the analysis phase
Jose: We have not talked about F2F meetings
charlie: A virtual F2F meeting
Fabio: It can be at some event
Fabio: suggests to go to an specific conference in Boston
By default a meeting every six months
If we find a conference or event in Europe that could be potentially attended by members we will consider to meet there
next call: November 10th
ACTION: Sebastian to coordinate collection of use cases [recorded in http://www.w3.org/2008/10/24-mbui-minutes.html#action05]
ACTION: Fabio to provide some material about XForms from the point of view of the abstract UI models coming from the -Academic Commiunity [recorded in http://www.w3.org/2008/10/24-mbui-minutes.html#action06]
dsr: free to invite other people to contribute
dsr: we need to follow the W3C rules, and make expert invitations
dsr: we look it at it further, about the rules for expert invitation
Jose: anyone can contribute via the public mailing list
Jose will help Dave with the chairing
RSSAGent make minutes
RSSAGent, make minutes