tools?
According to the main research question (Question 1) of this Thesis defined at the beginning, the aim of this research was to combine component-based approach and XFormsDB framework in order to create a tool with gentle slope of complexity. The objective was to answer this question by implementing and evaluating the XIDE tool.
In order to create the tool, the extensive research of end user tasks, challenges, expectations and experience with existing tools reported in the publications was conducted. The result of this review is a set of barriers that end users face during Web development process. The tool that can be used by end users for creating Web applications needs to hide these barriers or assist end user in overcoming them. The requirements, designed for the XIDE tool, describe features that a tool should provide to facilitate end user development. Thus, the XIDE requirements are essentially the answer to the second research question (Question 2).
At the same time with research of end user problems, existing solutions for end user Web development were investigated. Both research and commercial area approaches and tools were studied in order to review the state of the art of end user Web development domain. This review presents the answer to the third research question (Question 3).
Based on requirements and results of state of the art review, a user interface design for XIDE was created. Much attention was paid on selecting appropriate interaction style for the system and creating easy-to-use interface. First paper-based mockups were created and taken through
iterative discussion and improving process. Later on, early prototype was evaluated during usability testing round. Analysis of usability testing results showed that in general end users found the approach utilized in XIDE UI usable and they understood the metaphors and concepts of XIDE. The UI of XIDE was improved in order to overcome the problems found during the testing.
Finally all critical requirements were implemented in the XIDE prototype, which was used for evaluation. Current version of XIDE allows to go through all steps of XFormsDB application development: user can create, edit and publish the application.
A sample application use case was designed based on analysis of target end users made in background. This sample application was used to demonstrate how XIDE improves the end user Web development process by providing gentle slope of complexity.
XIDE was also examined with help of Cognitive Dimensions of Notations framework. This usability inspection method allows to evaluate user interface with reference to cognitive and usability aspects. The evaluation did not reveal any major usability problems for end users. However it highlighted some issues to be improved for expert users.
Currently, the XIDE working prototype is running at Aalto University internal server and can be accessed and used by everyone21
. It is planned to use XIDE in other research projects in order to simplify Web development and, on the other hand, test the tool in real life.
XIDE is published as an open source project at Google Code22
. More details about implementation and user manuals can be found from there.
Both theoretical and practical contributions of the research described in this Thesis are going to be published as a conference paper. The work on the publication is in progress now. Paper is going to be submitted to International Conference of Web Engineering (ICWE) 2011.
Z;:;
T&7+(',+$%7"9$7,+#(
Constructive research method was used in this Thesis, so the research produced both practical and theoretical contributions.
Practical contribution of this Thesis is the XIDE tool. The development of XIDE included requirement elicitation, design of XIDE concepts, design of XIDE UI, implementation and evaluation of XIDE. All this tasks, except several technical issues described below, were done by the author of this Thesis.
The work was done in collaboration with other members of Web Services Research Group of Department of Media Technology of Aalto University. The Template Language concept and syntax design was made by Markku Laine with the participation of the author. Implementation of Template Language transformation that was made by Sebastian Monte. Implementation of the components used for XIDE evaluation was done by Markku Laine. There are several theoretical contributions of this Thesis. First, during background study, problems and expectations of end users who try to develop Web applications were investigated. General classification of end user problems proposed by (Ko, Myers, & Aung, 2004) was employed for a specific case of end user Web development with the focus on problems related to component-based development. The contribution of this research is the classified list of barriers faced by end users during Web development. This research result can be utilized by other researchers who aim to create a Web development tool for end users. The second contribution is the investigation of the idea of the combining component-based development and XFormsDB framework that was invented in Web Services Research Group. It was proposed that this approach could provide gentler slope of complexity than available systems for end user Web development. While the general idea was invented earlier, the exact way how these two approaches can be combined is proposed in this Thesis and demonstrated by a mean of implementing the XIDE prototype. The evaluation of XIDE showed that the proposed approach of combining a declarative framework, component-based development and best practices from end user research area is a promising solution and should be further investigated.
Z;>;
U9$9%/(%/#/&%'@(
XIDE development process has reached some valuable results and now it is reasonable to offer it to external people for testing. In order to bring XIDE into real world, there are two major issues to be investigated.
First, the component database should be increased to provide various options for a user. A relevant set of components can be taken from a review of publications about typical
composites and functionalities of Web application, e.g., (Rode & Rosson, 2003), (Ginige, De Silva, & Ginige, 2005). This set can be verified and increased by analyzing information from extensive survey of possible end users. Initial set of components should be developed by XFormsDB experts; the development can be made using XIDE.
Another issue, which is actually combined with the first one, is piloting XIDE with real users. Is can bring a feedback about the usability of the system; also it can give a lot of hints about what kind of components users really need.
Besides testing XIDE in real life, there are also several things to be added into the system. One of them is to add Web 2.0 features to XIDE, as it was mentioned in XIDE requirements. Web 2.0 features provide options for communication and sharing information, which are highly appreciated by users. (Jazayeri, 2007) According to (McAfee, 2006), there are six components that form Web 2.0 paradigm. XIDE already includes some of them, e.g., search engine for components, tags for components and samples, possibility to contribute a component. However, it can be expanded by adding a possibility to comment a component from the database or subscribe to updates for the component.
There are other features, which are not implemented yet, are:
• Sample pages and applications, which users can utilize and build their own applications by extending them.
• Component versioning, which allows to maintain different versions of one component.
• CSS problem. Currently, users should create their CSS files without ability to use UI element name from the main source file (XFormsDB). This problem is caused by XForms processor, which changes element names. So, user has to know how the element will be called after it will be transformed to HTML in order to be able to assign CSS rule for it.
(
W7".7,1%&=@P(
Barr, P., Biddle, R., & Noble, J. (2002). A Taxonomy of User-Interface Metaphors. Victoria University of Wellington, New Zealand, School of Mathematical and Computing Sciences. Citeseer.
Bass, L., Clements, P., & Kazman, R. (2003). Software architecture in practice. Addison- Wesley.
Beletski, O. (2008). End User Mashup Programming Environments.
Benyon, D., Turner, P., & Turner, S. (2005). Designing interactive systems. Addison-Wesley. Boyer, J. (2009 20-October). W3C Standards. Retrieved 2010 16-December from XForms 1.1
: http://www.w3.org/TR/xforms11
Brandt, J., Guo, P., Lewenstein, J., & Klemmer, S. (2008). Opportunistic programming: how rapid ideation and prototyping occur in practice. Proceedings of the 4th international workshop on End-user software engineering, IWEUSE . ACM.
Browser market share, N. A. (2010 15-December). Browser Market Share. Retrieved 2010 15-December from Market share for browsers, operating systems and search engines: http://marketshare.hitslink.com/browser-market-share.aspx?qprid=0
Calabria, T. (2004 02-March). Step Two Designs. Retrieved 2010 15-December from An introduction to personas and how to create them: http://www.steptwo.com.au/papers/kmc_personas/index.html
Cao, J., Riche, Y., Wiedenbeck, S., Burnett, M., & Grigoreanu, V. (2010). End-user mashup programming: through the design lens. Proceedings of the 28th international conference on Human factors in computing systems. ACM.
Clements, P., Garlan, D., Little, R., Nord, R., & Stafford, J. (2003). Documenting software architectures: views and beyond. Proceedings of the 25th International Conference on Software Engineering. IEEE Computer Society.
Costabile, M., Fogli, D., Fresta, G., Mussio, P., & Piccinno, A. (2004). Software Environments for End-User Development and Tailoring. PsychNology Journal .
Costabile, M., Mussio, P., Parasiliti Provenza, L., & Piccinno, A. (2008). End users as unwitting software developers. Proceedings of the 4th international workshop on End- user software engineering, WEUSE'04. ACM.
Crnkovic, G. (2010). Constructive Research and Info-Computational Knowledge Generation.
Model-Based Reasoning in Science and Technology .
Cypher, A., Lau, T., Nichols, J., & Dontcheva, M. (2009). Workshop on end user programming for the web. CHI '09 Proceedings of the 27th international conference extended abstracts on Human factors in computing systems . ACM.
Dagit, J., Lawrance, J., Neumann, C., Burnett, M., Metoyer, R., & Adams, S. (2006). Using cognitive dimensions: advice from the trenches. Journal of Visual Languages & Computing, 17 (4), 302--327.
Douglass, R., Little, M., & Smith, J. (2005). Building online communities with Drupal, phpBB, and WordPress. Apress.
Dubinko, M. (2003). XForms essentials. O'Reilly.
Ennals, R., & Gay, D. (2007). User-friendly functional programming for web mashups.
Proceedings of the 12th ACM SIGPLAN international conference on Functional programming. ACM.
Faulkner, L. (2003). Beyond the five-user assumption: Benefits of increased sample sizes in usability testing. Behavior Research Methods, Instruments, & Computers, 35 (3), 379. Fiala, Z., Hinz, M., Meissner, K., & Wehner, F. (2003). A component-based approach for
adaptive, dynamic web documents. Journal of Web Engineering .
Floyd, I., Jones, M., Rathi, D., & Twidale, M. (2007). Web Mash-ups and Patchwork Prototyping: User-driven technological innovation with Web 2.0 and Open Source Software. Proceedings of the 40th Annual Hawaii International Conference on System Sciences. IEEE Computer Society.
Fraternali, P. (1999). Tools and approaches for developing data-intensive Web applications: a survey. ACM Computing Surveys .
Gaedke, M., & Graef, G. (2001). Development and Evolution of Web-Applications Using the WebComposition Process Model. Web Engineering, Software Engineering and Web Application Development , 58--76.
Gaedke, M., & Rehse, J. (2000). Supporting compositional reuse in component-based Web engineering. Proceedings of the 2000 ACM symposium on Applied computing-Volume 2
(p. 933). ACM.
Gaedke, M., Segor, C., & Gellersen, H. (2000). WCML: paving the way for reuse in object- oriented Web engineering. Proceedings of the 2000 ACM symposium on Applied computing. ACM.
Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1995). Design patterns: elements of reusable object-oriented software. Addison-wesley Reading.
Garrett, J. (2005). Ajax: A New Approach to Web Applications. Nine .
Ginige, A., & Murugesan, S. (2002). Web engineering: An introduction. Multimedia, IEEE . Ginige, J., De Silva, B., & Ginige, A. (2005). Towards end user development of web
applications for SMEs: A component based approach. Web Engineering .
Grammel, L., & Storey, M. (2008). An end user perspective on mashup makers. , Tech. Rep. DCS-324-IR, University of Victoria.
Green, T., & Blackwell, A. (1998). Cognitive dimensions of information artefacts: a tutorial.
BCS HCI Conference.
Green, T., & Petre, M. (1996). Usability Analysis of Visual Programming Environments: A 'Cognitive Dimensions' Framework. Journal of Visual Languages and Computing . Hartmann, B., Doorley, S., & Klemmer, S. (2008). Hacking, mashing, gluing: Understanding
opportunistic design. Pervasive Computing, IEEE .
Hartmann, B., Wu, L., Collins, K., & Klemmer, S. (2007). Programming by a sample: Rapidly prototyping web applications with d. mix. Proceedings of UIST. Citeseer.
Holzinger, A. (2005). Usability engineering methods for software developers.
Communications of the ACM, 48 (1), 71--74.
Honkala, M. (2006). Web User Interaction – A Declarative Approach based on XForms.
Hostetter, M., Kranz, D., Seed, C., Terman, C., & Ward, S. (1997). Curl: A gentle slope language for the web. World wide web journal .
HTML 4.01 Specification. (1999 24-December). Retrieved 2010 16-December from Standards W3C: http://www.w3.org/TR/html401/
Hundhausen, C., Farley, S., & Brown, J. (2009). Can direct manipulation lower the barriers to computer programming and promote transfer of training?: An experimental study. ACM Transactions on Computer-Human Interaction (TOCHI) .
IEEE Standard 1471-2000, 2. (2000). IEEE-Std-1471-2000 Recommended Practice for Architectural Description of Software-Intensive Systems. IEEE, http://standards.ieee.org
Järvinen, P. (2004). On Research Methods. Tampere: Opinpajan kirja.
Jazayeri, M. (2007). Some trends in web application development. Future of Software Engineering, 2007. FOSE'07 , 199--213.
Kelleher, C., & Pausch, R. (2005). Lowering the barriers to programming. ACM Computing Surveys .
Kim, M., Bergman, L., Lau, T., & Notkin, D. (2004). An ethnographic study of copy and paste programming practices in OOPL. Proceedings od 2004 International Symposium on Empirical Software Engineering, 2004. ISESE'04. IEEE.
Klann, M., Paterno, F., & Wulf, V. (2006). Future Perspectives in End-User Development.
End User Development .
Ko, A., Abraham, R., Beckwith, L., Blackwell, A., Burnett, M., Erwig, M., et al. (2009). The State of the Art in End-User Software Engineering. Journal ACM Computing Surveys . Ko, A., Myers, B., & Aung, H. (2004). Six learning barriers in end-user programming
systems. 2004 IEEE Symposium on Visual Languages and Human Centric Computing.
IEEE.
Kuniavsky, M. (2003). Observing the user experience : a practitioner's guide to user research. San Francisco , (Calif.), USA: Morgan Kaufmann Publishers.
Kuuskeri, J., & Mikkonen, T. (2009). Partitioning web applications between the server and the client. Proceedings of the 2009 ACM symposium on Applied Computing. ACM. Laine, M. P. (2010). XFormsDB—An XForms-Based Framework for Simplifying Web
Leff, A., & Rayfield, J. (2001). Web-Application Development Using the Model/View/Controller Design Pattern. Proceedings of the 5th IEEE International Conference on Enterprise Distributed Object Computing. IEEE Computer Society.
Lieberman, H. (2001). Your wish is my command: Programming by example. Morgan Kaufmann.
Lieberman, H., Paterno, F., Klann, M., & Wulf, V. (2006). End-user development: An emerging paradigm. End User Development .
Long, F. (May 2009). Real or Imaginary; The effectiveness of using personas in product design. Dublin: Proceedings of the Irish Ergonomics Society Annual Conference 2009. MacLean, A., Carter, K., Lovstrand, L., & Moran, T. (1990). User-tailorable systems:
pressing the issues with buttons. Proceedings of the SIGCHI conference on Human factors in computing systems: Empowering people. ACM.
Malhotra, A., Melton, J., & Walsh, N. K. (2010 14-December). XQuery 1.0 and XPath 2.0 Functions and Operators (Second Edition). Retrieved 2010 16-December from W3C Standards: http://www.w3.org/TR/xpath-functions/
Mark, R. L., & Nielsen, J. (1994). Usability inspection methods. Wiley New York.
Maximilien, E., Ranabahu, A., & Gomadam, K. (2008). An Online Platform for Web APIs and Service Mashups. IEEE Internet Computing , 32--43.
McAfee, A. (2006). Enterprise 2.0: The dawn of emergent collaboration. MIT Sloan Management Review .
McCreary, D. (2007 14-December). Introducing the XRX Architecture: XForms/REST/XQuery. Retrieved 2010 14-December from Dr. Data Dictionary : http://datadictionary.blogspot.com/2007/12/introducing-xrx-architecture.html
Molich, R., Jeffries, R., & Dumas, J. (2007). Making usability recommendations useful and usable. Journal of Usability Studies , 162--179.
Morch, A., Stevens, G., Won, M., Klann, M., Dittrich, Y., & Wulf, V. (2004). Component- based technologies for end-user development. Communications of the ACM .
Myers, B. (March 1998). A brief history of Human Computer Interaction (Vol. 2). ACM interactions.
Myers, B., & Ko, A. (2009). The past, present and future of programming in HCI. Human- Computer Interaction Consortium (HCIC’09) .
Myers, B., Hudson, S., & Pausch, R. (2000). Past, present, and future of user interface software tools. ACM Transactions on Computer-Human Interaction (TOCHI) .
Myers, B., Ko, A., & Burnett, M. (2006). Invited research overview: end-user programming.
CHI'06 extended abstracts on Human factors in computing systems. ACM.
Myers, B., Pane, J., & Ko, A. (2004). Natural programming languages and environments.
Communications of the ACM .
Nardi, B. (1993). A small matter of programming: perspectives on end user computing. The MIT Press.
Neale, D., & Carroll, J. (1997). The role of metaphors in user interface design. Handbook of human-computer interaction , 441--462.
Newman, M., Lin, J., Hong, J., & Landay, J. (2003). DENIM: An informal web site design tool inspired by observations of practice. Human-Computer Interaction .
Nielsen, J. (2000 19-March). Usability Testing with five users. Retrieved 2010 14-December from Jakob Nielsen's Website: http://www.useit.com/alertbox/20000319.html
North, C., & Shneiderman, B. A Taxonomy of Multiple Window Coordinations. University of Maryland, Human-Computer Interaction Laboratory. 1997: Citeseer.
(2009). Open Source CMS Market Share Report 2009. water&stone and CMSWire.
Pane, J., & Myers, B. (1996). Usability issues in the design of novice programming systems.
Carnegie Mellon University, School of Computer Science. Pittsburgh: Citeseer.
Pohja, M., Honkala, M., Penttinen, M., Vuorimaa, P., & Ervamaa, P. (2007). Web User Interaction. Web Information Systems and Technologies .
ProgrammableWeb - Mashups, APIs, and the Web as Platform. (2010 14-December). Retrieved 2010 14-December from www.programmableweb.com
Ramirez, F., & Wroblewski, L. (2005 10-April). Web Application Solutions: A Designer’s Guide. Retrieved 2010 15-December from LukeW Ideation + Design: http://www.lukew.com/ff/entry.asp?170
Repenning, A., & Ioannidou, A. (2006). What makes end-user development tick? 13 design guidelines. End User Development .
Rode, J., & Rosson, M. (2003). Programming at runtime: requirements and paradigms for nonprogrammer web application development. Proceedings of the 2003 IEEE Symposium on Human Centric Computing Languages and Environments. IEEE Computer Society. Rode, J., Bhardwaj, Y., Perez-Quinones, M., Rosson, M., & Howarth, J. (2005). As easy as
“Click”: End-user web engineering. Web Engineering .
Rode, J., Rosson, M., & Perez-Quinones, M. (2004). End-Users' Mental Models of Concepts Critical to Web Application Development. 2004 IEEE Symposium on Visual Languages and Human Centric Computing. IEEE.
Rode, J., Rosson, M., & Quinones, M. (2006). End user development of web applications.
End User Development .
Rosson, M., Ballin, J., & Nash, H. (2004). Everyday programming: Challenges and opportunities for informal web development. IEEE Symposium on Visual Languages Human-Centric Computing.
Rosson, M., Ballin, J., & Rode, J. (2005). Who, what, and how: A survey of informal and professional web developers. 2005 IEEE Symposium on Visual Languages and Human- Centric Computing.
Rothermel, K., Cook, C., Burnett, M., Schonfeld, J., Green, T., & Rothermel, G. (2000). WYSIWYT testing in the spreadsheet paradigm: An empirical evaluation. Proceedings of the 22nd international conference on Software engineering. IEEE.
Sano, D. (1996). Designing large-scale Web sites: a visual design methodology. John Wiley