Yan (Jenny) Liu - Ph.D., Senior ResearcherEmpirical Software Engineering ProgramNational ICT Australiajenny dot liu at nicta dot com dot au

I am a senior researcher in Empirical Software Engineering Program, <html><a href="http://www.nicta.com.au" target="_blank">National ICT Australia Ltd. (NICTA)</a></html>. I joined NICTA in March 2004 as a researcher after I graduated with my PhD degree in Computer Science from Sydney University. My reasearch aims to devising models, tools and architecture frameworks to improve quality and reduce the complexity of however small or large software systems. My research interests fall in the exploration of software architectures which expand across autonomic computing, middleware platforms, component-based software engineering, quality attributes, and software system evaluation: \n*Devising software framework for developing adaptive middleware infrastructure \n*Models and architectures in autonomic computing \n*Analytical modeling and empirical evaluation of middleware quality attributes, particularly performance and reliability\n*Design and implementation of service oriented architecture with component technologies\n*Applying component-based software engineering for embedded system development\n*Model driven software development\n\nI am leading/participating two NICTA funded research projects \n[[Adaptive Server Framework|Adaptive Middleware Platform]]: Models and Extensible Architectures for Adaptive Middleware Platforms \nCAmkES: Component Architecture for microkernel-based Embedded Systems \n\nI also teach at UNSW on software architecture course and supervise students. \n\nFrom March 2001 to April 2004, I studied my phd in <html><a href="http://www.it.usyd.edu.au" target="_blank">School of Information Technologies</a></html> ,University of Sydney. My phd thesis topic is "a framework to predict the performance of component-based applications" under the supervision of Prof. Alan Fekete and Prof. Ian Gorton. My phd study was supported by <html><a href="http://www.usyd.edu.au/fstudent/international/postgrad/costs/iprs.shtml" target="_blank">International Postgradaute Research Scholarship (IPRS)</a></html> from the Australian Department of Education, Science and Training. I graduated in Oct 2004. \n\nPredicting the performance of component-based systems is an engineering approach devised in my Ph.D thesis. It encompasses developing analytic performance models of component-based applications, implementing algorithms (based on queueing theories), devising performance measurement techniques and conducting statistical evaluations of the predicted outcome. This approach is now extended towards the domain of service oritend architecture and autonomic computing for enterprise systems where components and services form the infrastructure of the overall system. After my graduation, a research prototype [[MDAperf|Model Driven Capacity Planning]] was developed in NICTA to automate the performance prediction process with MDA-based UML modeling support. This prototype was implemented as an Eclipse plugin. The core of this approach has been applied to a research project ([[AMP|Adaptive Middleware Platform]]) and a collaration project with two government agencies on evaluating the capacity of an internet-facing integrated service system.\n\nBefore I came to Australia, I studied in Information Science and Technology Institue, Northeastern University in China. I got my bachelor degree of engineering in 1999. I was a postgraduate student major in Computer Science in the same university from August 1999 to Jan 2001. \n\nSee also: [[ publication | Publication ]], [[ research overview | Research Overview ]],[[ research projects | Research Projects ]], [[ research prototype | Research Prototypes ]], [[ professional service | Professional Service ]], [[ public talk | Public Talk ]], [[student supervision |Student Supervision]] and <html><a href="http://cgi.cse.unsw.edu.au/~cs9117/2006s2/" target="_blank">course taught</a></html>.

[[Jenny's bookshelf|http://www.librarything.com/catalog.php?view=jpll]]

Type the text for ' Links on the Web '

Type the text for ' Professional Service '

Type the text for ' Public Talk '

!Journal Publication\n# Gorton, I., Liu, Y. and Trivedi, N., A Lightweight and Extensible Architecture for Adaptive Server Applications, accepted to Journal of Software Practice and Experience, July 2007.\n#Liu, Y., Zhu, L., Gorton, I., Model Driven Capacity Planning: Models and Tools, invited submission to Journal of Computer Resource Management, November, 2006.\n#Zhu, L., Bui, N. B., Liu, Y. and Gorton, I., MDABench : Customized Benchmark Generation using MDA, invited paper for the special issue of Journal of Systems and Software on Software Architecture Section.\n#Kuz, I., Liu, Y., Gorton, I., Gernot, H., CAmkES: A component model for secure microkernel-based embedded systems, Journal of Systems and Software, In Press, Corrected Proof, Available online 13 October 2006, DOI= http://dx.doi.org/10.1016/j.jss.2006.08.039 \n#Liu, Y., Fekete, A., Gorton, I., Design Level Performance Prediction of Component-Based Applications, IEEE Transactions on Software Engineering, vol. 31, no.11, pp. 928-941, November, 2005. http://doi.ieeecomputersociety.org/10.1109/TSE.2005.127\n#Chen, S.,Liu, Y.,Gorton, I., Liu, A., Performance Prediction of Component-based Systems, Elsevier Journal of Systems and Software, vol 74, no. 1, Jan 2005, p.35-43. http://dx.doi.org/10.1016/j.jss.2003.05.005 \n\n!Peer Reivewed Conference/Workshop Paper\n#Liu, Y., Zhu, L., Bass, L., Gorton, I., and Staples, M., Non-Functional Property Driven Service Governance: Performance Implications, in Non Functional Properties and Service Level Agreements in Service Oriented Computing Workshop (NFPSLA-SOC'07) at the 5th International Conference on Service Oriented Computing (ICSOC 2007 ), 2007.\n#Liu, Y., Zhu, L. and Gorton, I., Performance Assessment for e-Government Services: An Experience Report, accepted by The 10th International ACM SIGSOFT Symposium on Component-Based Software Engineering (CBSE), Boston, July 9-11, 2007.\n#Kuz, I., Liu, Y., Extending the Capabilities of Component Models for Embedded Systems, accepted by Third International Conference on the Quality of Software-Architectures (QoSA), Boston, July 12-13, 2007.\n#Liu, Y., Gorton, I., and Zhu, L. Performance Prediction of Service Oriented Applications based on an Enterprise Service Bus, in 31st IEEE Annual International Computer Software and Applications Conference (COMPSAC), Beijing China, 2007. (acceptance rate: 18%) \n#Liu, Y., Gorton, I., Implementing Adaptive Performance Management in Server Applications, accepted by ICSE 2007 workshop on Software Engineering for Adaptive and Self-managing Systems (SEAMS), 2007. \n#Zhu, L., Liu, Y., Bui, N.B., Gorton, I., Revel8or: Model Driven Capacity Planning Tool Suite, accepted as formal demo paper of the 29th International Conference on Software Engineering 2007, (21% acceptance rate ) \n#Liu, Y., Gorton, I., Le, V. K., A Configurable Event Correlation Architecture for Adaptive J2EE Applications, accepted by Annual Australian Software Engineering Conference (ASWEC), 2007, (40% acceptance rate out of 100+ submissions). ''Invited to Journal of Software and Systems as one of the best papers. ''\n#Bui, N.B., Zhu, L., Gorton, I., Liu, Y., Model Based Approach for Benchmark Generation Using Domain Specific Language, accepted by Annual Australian Software Engineering Conference 2007, (40% acceptance rate out of 100+ submissions) \n#Liu, Y. 2006. Enabling adaptation of J2EE applications using components, web services and aspects. In Proceedings of the 5th Workshop on Adaptive and Reflective Middleware (ARM '06) (Melbourne, Australia, November 27 - December 01, 2006). ARM '06, vol. 190. ACM Press, New York, NY, 9. http://doi.acm.org/10.1145/1175855.1175864 \n#Gorton, I., Liu, Y, Trivedi, N., An Extensible, Lightweight Architecture for Adaptive J2EE Applications, accepted by International Workshop of Software Engineering and Middleware (SEM), Nov 2006. \n#Liu, Y., Zhu, L., Gorton, I., Model Driven Capacity Planning: Models and Tools, Annual Conference of Computer Management Group Australia, September 2006. (best first time CMGA paper award) \n#Liu, Y., Gorton, I., Le, V.K., A Configurable Event Correlation Architecture for Adaptive J2EE Applications, Posters of the 2006 DOA (Distributed Objects and Applications) International Conference, Lecture Notes in Computer Science, Volume 4277/2006, 2006. http://dx.doi.org/10.1007/11915034_11 \n#Liu, Y., Gorton, I., Bass, L, Hoang, C., Abanmi, S., MEMS: A Method for Evaluating Middleware Architectures, Second International Conference on the Quality of Software Architectures (QoSA 2006), June 27-29, 2006, Sweden. Lecture Notes in Computer Science, Volume 4214/2006, 2006. http://dx.doi.org/10.1007/11921998_6 \n#Zhu, L., Gorton, I., Liu, Y., and Bui, N. B. 2006. Model driven benchmark generation for web services. In Proceedings of the 2006 international Workshop on Service-Oriented Software Engineering (Shanghai, China, May 27 - 28, 2006). SOSE '06. ACM Press, New York, NY, 33-39. http://doi.acm.org/10.1145/1138486.1138494 \n#Zhu, L., Liu, Y., Gorton, I., and Bui, N. B., Customized Benchmark Generation using MDA, accepted at the 5th IEEE/IFIP Working Conference on Software Architecture, Pittsburgh, PA, USA, November 2005. (Selected as Best Papers) (30% acceptance rate ) \n#Zhu, L., Liu, Y., Gorton, I. and Bui, N. B., MDABench: A Tool for Customized Benchmark Generation using MDA, OOPSLA 2005 Conference Companion, San Diego, USA, October 2005, ACM Press, p. 171-172.http://doi.acm.org/10.1145/1094855.1094919 \n#Liu, Y. and Gorton, I., Performance Prediction of J2EE Applications using Messaging Protocols, International SIGSOFT Symposium on Component-based Software Engineering (CBSE), St Louis, USA, May 2005,Lecture Notes in Computer Science, p.1-16. (25% acceptance rate), http://dx.doi.org/10.1007/11424529_1 \n#Liu, Y., and Gorton, I., An Empirical Evaluation of Architectural Alternatives for J2EE and Web Services, Proceedings 11th Asia-Pacific Software Engineering Conference (APSEC), Korea, Nov 2004, IEEE Computer Society, p. 10-17. (40% acceptance rate). http://doi.ieeecomputersociety.org/10.1109/APSEC.2004.25 \n#Liu, Y. and Gorton, I., Accuracy of Performance Prediction for EJB Applications: A Statistical Analysis, International Workshop on Software Engineering and Middleware (SEM), Linz, Austria, Sep 2004, Lecture Notes in Computer Science, p.185-198. (27% acceptance rate ) http://dx.doi.org/10.1007/11407386_14 \n#Liu, Y., Fekete, A. and Gorton, I., Predicting The Performance of Middleware-based Applications at the Design Level, ACM Proceedings of the Fourth International Workshop on Software and Performance (WOSP), Oracle Conference Center, Redwood City, California, USA, Jan 2004, ACM Press, p.166-170. (26% acceptance rate) http://doi.acm.org/10.1145/974044.974071\n#Liu, Y., Gorton, I., Liu, A. and Chen, S., Evaluating the scalability of Enterprise JavaBeans Technology, Proceedings 9th Asia-Pacific Software Engineering Conference (APSEC), Gold Goast, Australia, Dec 2002, IEEE Computer Society, p.74-83. (45% acceptance rate) http://doi.ieeecomputersociety.org/10.1109/APSEC.2002.1182977\n#Liu, Y., Performance and Scalability Measurement of COTS EJB Technology, Proceedings of 4th Symposium on Computer Architecture and High Performance Computing (SBAC-PAD) , Victoria, Brazil, Oct 2002, IEEE Computer Society, p. 212-219. (34% acceptance rate) http://doi.ieeecomputersociety.org/10.1109/CAHPC.2002.1180778\n# Chen, S., Gorton, I., Liu, A. and Liu, Y., Performance Prediction of COTS Component-based Enterprise Applications, 5th ICSE Workshop on Component-Based Software Engineering (CBSE), USA, May 2002. (25% acceptance rate)\n#Liu, Y., Gorton, I., Liu, A., Jiang, N. and Chen, S., Design a Test Suite for Empirically-based Middleware Performance Prediction, Proceedings of the 14th International Conference on Tools Pacific: Objects for internet, mobile and embedded application (TOOLS), Feb 2002, Australian Computer Society, p.123-130. (55% acceptance rate) http://portal.acm.org/ft_gateway.cfm?id=564110&type=pdf&coll=GUIDE&dl=GUIDE&CFID=60878872&CFTOKEN=17500581\n\n!Book Chapters\n#Liu, Y., Aspect Oriented Architectures, in Essential Software Architecture, I. Gorton, Ed., 2005 \n\n!Awards\n#Liu, Y., Zhu, L., Gorton, I., Model Driven Capacity Planning: Models and Tools, Annual Conference of Computer Management Group Australia, September 2006. (best first time CMGA paper award) \n#Zhu, L., Liu, Y., Gorton, I., and Bui, N. B., Customized Benchmark Generation using MDA, accepted at the 5th IEEE/IFIP Working Conference on Software Architecture, Pittsburgh, PA, USA, November 2005. (Selected as Best Papers)\n

In March 2004, I joined NICTA Empirical Software Engineering program as a researcher working in the area of software architecture. In the last three years, I have expended my research into new areas and increased the research capabilities. My research development can be summarized into three stages, growing from formal Ph.D. training, to enhanced research capability with new research outcomes produced, and then proving of research impact through industrial trial of technologies developed, and now at the stage of proposing new long term research projects. The development roadmap of my research is shown in Figure [Research Structure].\n\nMy phd topics is within the area of performance analysis and modelling. The thesis was developing a framework to predict the performance of middleware-based distributed applications.\n\nThrough my work in NICTA, I have been continuously exploiting my core knowledge and skills to do high quality research work and expend in to new research areas, including autonomic computing, model driven development, and performance assessment of service architecture. I also broaden my research domain towards cross-disciplinary area of component-based software engineering for embedded systems, in which my expertise is synergistic. \n\nThe incarnation of my research achievement is through the outputs of NICTA projects I lead, investigate and participate. Each research topic I am working on has a research project associated with it and they are all driven by main NICTA research disciplines. I perform the role of leading research direction and technical development on two NICTA projects, one collaborating project with two government agencies, and one collaborating project with a defence organization in the last three years. \n\nMy research aims at challenging research issues and having impact, thus my research activities balance the scientific contribution and the engineering effort. In term of the research methodology, I have been developing my research method in a synergistic manner and establish hierarchical research linkages from different projects I am involved in. This means each fundamental research produces outputs that either promote to establish new collaborating research projects with industry or enable the technologies developed from my research to be applied to solve real-world problems. \n\nI have developed analytical models (based on queueing theory) and software architecture evaluation methods, which are published as peer-reviewed papers at various international conferences and journals, including IEEE Transactions on Software Engineering (TSE), Journal of Software and Systems (JSS), International Conference of Software Engineering (ICSE), International Conference International Symposium Component-based Software Engineering (CBSE) and International Working Conference on Software Architecture (WICSA). The research prototyes on model-driven capacity planning have been demonstrated at OOPSLA, ICSE and Computer Management Group Conference Australia. \n\nI also heavily contribute to the development and implementation of the research prototypes/tools produced from the research. \n\nI have presented my research at various events including local and international conferences. I have delivered seminars to industry audience such as at NICTA Breakfast seminar. I commit to professional services as reviewers, PC members and workshop organizers at local and international conferences and workshops, including WICSA, ASWEC, HICSS, Middleware and COMPSAC.\n\n[img[ASF Architecture Overview|http://www.cse.unsw.edu.au/~yliu/index-images/ResearchStructure.png]]\n/%[img[ASF Architecture Overview|file:///D:/RESEARCH/AmericaTrip2007/WebConstruct/ResearchStructure.png]]%/\n

In the last three years, I have been working on the following research projects. A number of research prototypes have been produced and the research outputs have been applied to solve real-world problems through collabrations. My current projects include:\n\n* [[Design by composition of embedded systems]]\n* [[Managing critical services of software intensive systems]]\n* [[Ehancing adaptive capability for mobile applications]]\n* [[Model Driven Capacity Planning]]\n* Evaluation of software-intensive systems\n\n

My research in NICTA has produced several software and prototypes through the collabration with other researchers and research students. These include\n* [[MDAperf|Model Driven Capacity Planning]], produced from Model Driven Capacity Planning research collabrated with Dr Liming Zhu, Prof. Ian Gorton and Mr. Peter Huang.\n* [[MDABench/DSLBench|Model Driven Capacity Planning]], collabrated with Dr Liming Zhu, Ms Betty Bui. and Prof. Ian Gorton.\n* [[Adaptive Server Framework|Adaptive Middleware Platform]], collaborated with Prof. Ian Gorton and Mr. Vinh Khanh Le.\n** Research Demo Video: Developing Mobile Applications using Adaptive Web Services http://www.cse.unsw.edu.au/~yliu/asf-demo/MobileApplications.avi\n** Research Demo Slide: Developing Mobile Applications using Adaptive Web Services http://www.cse.unsw.edu.au/~yliu/asf-demo/nicta-amp-tech-demo.pdf

[[something in mind|http://artpad.art.com/gallery/?j8m6zu1d92eg]]\n[[Magpine|http://artpad.art.com/gallery/?j3ay9316ue04]]\n[[Peaceful bay|http://artpad.art.com/gallery/?j8lwgr1hnkko]]\n\n\n\n

http://softperformance.blogspot.com/ \n\nWorking with my heart and passion is the happiness that I pursue. It is fun to write down emotional or even irrelevant thoughts when I fight with those cold and concrete symbols and numbers. \n

''Models and Extensible Architecture for Adaptive Middleware Platforms (AMP) is a NICTA research project that I have been participating/leading in the last three years. This project aims to develop novel middleware technology that augments existing standards-based application server technologies with adaptive capability.''\n\n!!Project Summary\nServer applications such as J2EE applications and Web services augmented with behavioural adaptation logic can react to environmental changes, creating self-managing server applications with improved quality of service at runtime. However, developing adaptive server applications is challenging due to the complexity of the underlying server technologies and highly dynamic application environments. One delivery from this project is a novel architecture framework associated with analysis models and mechanisms, the Adaptive Server Framework (ASF) to facilitate the development of adaptive behaviour for server applications. ASF provides a clear separation between the implementation of adaptive behavior and the business logic of the server application. This means a server application can be extended with programmable adaptive features through the definition and implementation of control components defined in ASF. This is an ongoing research.\n\n!!Background and Motivation\nServer applications augmented with behavioural adaptation logic can react to environmental changes, creating self-managing server applications with improved quality of service at runtime. However, developing adaptive server applications is challenging due to the complexity of the underlying server technologies and highly dynamic application environments. This project produces novel architecture framework associated with analysis models and mechisms, the Adaptive Server Framework (ASF) to facilitate the development of adaptive behaviour for server applications. ASF provides a clear separation between the implementation of adaptive behavior and the business logic of the server application. This means a server application can be extended with programmable adaptive features through the definition and implementation of control components defined in ASF. \n\n!!Architecture Overview\nThe fundamental design principle of ASF is to separate the implementation of adaptive behavior from the server application business logic. This means the adaptation should be encapsulated into components external to the application implementation. Hence the goal of ASF is to provide infrastructure components and services to facilitate the construction of behavioral adaptation. This is achieved by creating a component model for developing adaptive control components, and providing associated services that support the deployment of adaptive components with J2EE application servers. \n\nFigure [ASF Architecture Overview] depicts an overview of how ASF interacts with applications and the underlying application server platform. ASF defines a component architecture for implementing dynamic, adaptive control, such as managing the lifecycle of control components and coordinating their communications. Adaptive logic implemented using ASF components runs in an adaptive engine. ASF components interact with the application server, monitor the runtime environment, analyze collected data, and change the application’s behavior by adapting the response or setting the server’s configuration to fulfill the business goals. In this way, ASF helps developers to focus on the design and implementation of adaptive logic and insulates them from the complexities of the underlying J2EE platform. \n\n[img[ASF Architecture Overview|http://www.cse.unsw.edu.au/~yliu/index-images/ASFArch-small.png]]\n/%[img[ASF Architecture Overview|file:///D:/RESEARCH/AmericaTrip2007/WebConstruct/ASFArch-small.png]]%/\n\n!!Layered Architecture\n\nTo fulfill the goals of ASF, its various components and services are designed as reusable from application to application. We divide the ASF infrastructure into three layers to address the reusability of its components and services. ASF executes above the middleware layer, and the current implementation runs on top of exisiting middleware platforms such as application servers, messaging servers and service buses, as shown in Figure [TechnologyOverview.png].\n* Adaptive component layer: this layer supports a component model that defines the control components and interactions needed to implement adaptive behaviors. The control components collect data on the application server’s environment, tune the server configuration and/or change its behavior through management layer interfaces. \n* Service layer: ASF acts as a container of control components for adaptive behaviors. In order to manage these components, ASF provides a default implementation of useful services, such as lifecycle management, concurrent execution of ASF components, security management, and so on. This service layer also provides infrastructure support for reusable ASF components services including wrappers for Web services, event correlation and security management, and policy management. For example, policies are application-defined, but the mechanisms for checking and enforcing polices provided by the policy management subsystem are generic, and therefore they can be reused as infrastructure services. By separating these general services into a specific layer, the tasks of developing adaptive behavior using ASF control components can be further simplified.\n* Management layer: ASF control components are executed on top of the management layer. The management layer includes utilities and mechanisms that can be used to monitor the runtime behavior of the application and the underlying platform, and reconfigure the application settings. Our goal is to build adaptive server applications without requiring changes to or specialized services from the underlying middleware. This is achieved by utilizing standard-based management protocols to collect status information and reconfigure an application server. For example, the JMX (Java Management Extensions) based management architecture is leveraged in our current implementation of ASF. Most Java-based application servers utilize JMX to both implement internal server management and provide APIs for hosted applications to retrieve and set the state of the application server configuration. \n\nThe adaptive component layer, the service layer and the management layer together form the platform that augments applications with adaptation. The application is not aware of the existence of the adaptive components, thus achieving our aim of separation of concerns. \n\n[img[ASF Architecture Overview|http://www.cse.unsw.edu.au/~yliu/index-images/TechnologyOverview-small.png]]\n/%[img[ASF Architecture Overview|file:///D:/RESEARCH/AmericaTrip2007/WebConstruct/TechnologyOverview-small.png]]%/\n\n!!An Illustrating Example: Implementing Adaptive Performance Management in Server Applications \nApplication servers provide a standardized service layer to support the development and deployment of distributed, server-side applications. Application server technologies such as J2EE and .NET can be used to build server applications that support various levels of quality-of-service, making them a suitable platform for high performance and reliable software systems. However, such systems remain challenging to construct as they usually operate in dynamic environments with rapidly fluctuating user loads and resource levels, and unpredictable system faults.\n\nApplication server technologies enable administrators to tune application performance in response to functional and environmental changes that occur after application deployment. Such responses are made by adjusting configuration parameters, such as the server thread pool size, transaction time-out duration, and the maximum number of concurrent connections. However, deciding on the ‘best’ parameters settings is notoriously difficult, and must be performed through observation and experimentation every time an environmental change occurs. This results in on-going, high administrative overheads and costs for managing the system. \n\nA solution is to apply autonomic computing technologies to automate the performance management at runtime. Autonomic computing encompasses a grand vision of creating computer systems with properties of self-configuration, self-healing, self-optimization and self-protection. In the realm of autonomic computing, application servers are an autonomic element that interacts, regulates and adapts its behavior in response to a wide range of changing environmental circumstances under administrative policies. \n\nPerformance and scalability are critical quality attributes within the scope of self-optimization and self-configuration. However, common performance engineering approaches usually do not aim to automate performance management at the run-time, but focus on building performance models from software artifacts. Few efforts have addressed the issue of efficiently acquiring and reasoning with dynamic performance data during execution. In order to enable performance optimization of server applications at runtime, applications need to be extended with adaptive behavior implemented using autonomic computing technologies. \n\nFollowing autonomic computing principles, adaptive behaviors for performance optimization of server applications utilize a control loop to constantly monitor the system and identify and handle events according to defined policies. This however creates new development and management challenges for application designers, namely: \n\n* Construction of predictive models: given inputs that characterize the current execution environment, models must be solved to produce optimal parameter settings for controlling various aspects of application configuration and behavior.\n* Separation of concerns: application business logic should be completely separated from the adaptive control logic for performance management. This promotes ease-of-change to the business logic, and supports a clear division of labor between application developers and adaptive control logic developers. \n* Overhead: Environmental changes can occur rapidly, and hence responses, in terms of behavior adaptation, should occur with low latency. This indicates the necessities of extra control loops to manage the resource consumption caused by adaptation so that it does not adversely affect overall application performance.\n\nWe consider the adaptivity in terms of optimizing the performance at runtime. The behaviour to fulfill performance goals is implemented by adaptive control logic. The control logic implements a performance model that, given inputs to characterize the current execution environment, solves the model to produce optimal parameter settings for controlling various aspects of application configuration and behavior.\n\nWe consider the adaptivity in terms of optimizing the performance at runtime. The behaviour to fulfill performance goals is implemented by adaptive control logic. The control logic implements a performance model that, given inputs to characterize the current execution environment, solves the model to produce optimal parameter settings for controlling various aspects of application configuration and behavior.\n\n[img[The Approach|http://www.cse.unsw.edu.au/~yliu/index-images/TheApproach.png]]\n/%[img[The Approach|file:///D:/RESEARCH/AmericaTrip2007/WebConstruct/TheApproach.png]]%/\n\nThere are three aspects to consider when devising a performance model for adaptive behavior of server applications:\n\n1. Convert descriptions of performance goals into quantitative and measurable metrics. These measures become the target outputs of the performance analysis. \n2. Determine the impact of adaptive behaviors to the server applications. Issues include how to model the performance related behavior of adaptive components and their interactions, especially for interactions with the underlying server infrastructure.\n3. Calibrate application specific factors such as parameters into the performance models and populate their values. For example, tuning the thread pool size of J2EE application servers is a generic self-configuration strategy for all applications running on an application server, however, optimal cache size tuning is only needed for applications that actually cache data at the application server layer.\n\nThe above approach gives a strategy for devising models for online performance analysis using performance engineering techniques. The approach categorizes dynamic environmental variables to three groups, namely, application specific control parameters, server configuration parameters, and resource constraints parameters.\n\n[img[Construction of Models|http://www.cse.unsw.edu.au/~yliu/index-images/ConstructionOfModels.png]]\n/%[img[Construction of Models|file:///D:/RESEARCH/AmericaTrip2007/WebConstruct/ConstructionOfModels.png]]%/\n\nASF components and services provide the infrastructure support for realizing adaptation strategies by constructing control loops. An example for adaptive image application server optimized for its overall throughput and response time was developed. For details, please refer to our paper \n* Liu, Y., Gorton, I., Implementing Adaptive Performance Management in Server Applications, accepted by ICSE 2007 workshop on Software Engineering for Adaptive and Self-managing Systems (SEAMS), 2007.\n\n\n[img[Construction of Models|http://www.cse.unsw.edu.au/~yliu/index-images/ASFControlLoops.png]]\n/%[img[Construction of Models|file:///D:/RESEARCH/AmericaTrip2007/WebConstruct/ASFControlLoops.png]]%/\n\n\nSee also: <html><a href="http://nicta.com.au/research/projects/models_and_extensible_architecture_for_adaptive_middleware_platforms" target="_blank">NICTA AMP Project Overview</a></html>

<<option chkGenerateAnRssFeed>> GenerateAnRssFeed\n<<option chkOpenInNewWindow>> OpenLinksInNewWindow\n<<option chkSaveEmptyTemplate>> SaveEmptyTemplate\n<<option chkToggleLinks>> Clicking on links to tiddlers that are already open causes them to close\n^^(override with Control or other modifier key)^^\n<<option chkHttpReadOnly>> HideEditingFeatures when viewed over HTTP\n<<option chkForceMinorUpdate>> Treat edits as MinorChanges by preserving date and time\n^^(override with Shift key when clicking 'done' or by pressing Ctrl-Shift-Enter^^\n<<option chkConfirmDelete>> ConfirmBeforeDeleting\nMaximum number of lines in a tiddler edit box: <<option txtMaxEditRows>>\nFolder name for backup files: <<option txtBackupFolder>>\n<<option chkInsertTabs>> Use tab key to insert tab characters instead of jumping to next field

I am interested in topics towards \n\n!!Performance Evaluation Mehtods and Tools \n*Performance evaluation of alternative architectures of .Net applications, including .Net transaction control, data access, synchronous and asynchnronous communication, .Net web services and .Net remoting.\n*Quality management of integrated services in SOA\n*Performance evaluation of Enterprise Service Bus\n*Model driven performance prediction toolkit with IDE extension \n*Comparing .Net 3.0, Java EE and Ruby on Rail for Web 2.0 development\n*Simulating SOA based Loan Application using .Net 3.0 and Biztalk Server\n!!Adaptive Middleware Systems \n*Customized benchmark generation on .Net platform. \n*Model driven development of adaptive middleware based systems \n*Monitoring and Debugging of adaptive middleware runtime \n*Web portals of adaptive middleware managemnt\n*Adaptive Service Composition by Middleware Support\n!!Software Architecture for Embedded Systems\n*Introducing annotation to embedded system development\n*Component architecture to support non-functional requirements of embedded systems\n*Eclipse plugins of model-driven development for embedded systems \n*Extending unit test framework for component communications of embedded systems\n \nI am also co-supervising Master by research and PhD theses. The following projects are available particularly for PhD and Master by Research study.\n*''Automating Design and Deployment of Adaptive Integrated Systems in SOA'' \n*''Managing Sensor Network Quality using Adaptive Control Protocol''\n*''Policy-based Quality Management of Data Intensive Applications''\n\nEnqueries of potential master and phd topics on the above areas and of my research interests are welcome.

__C__omponent __A__rchitecture for __m__icro__k__ernel-based __E__mbedded __S__ystems is a NICTA research project that I have been participating/leading in the last three years. This project aims to create a quick catalogue solution for embedded systems. Creating new component technology will increase the reliability of embedded systems and decrease the cost. \nSee also: <html><a href="http://squiz-atp.it.nicta.com.au/research/projects/component_architectures_for_microkernel-based_embedded_systems" target="_blank">CAmkES overview</a></html>\n\n

[[ About Me ]]

!! Introduction and Motivation\nEmbedded systems are pervasive and ubiquitous. Devices (such as appliances, vehicles, instruments, etc.) increasingly contain more embedded software components. The world market for embedded software is expected to grow from about $1.6 billion in 2004 to $3.5 billion by 2009, at an average annual growth rate (AAGR) of 16% . The increasing tendency in embedded system development is to shift functionality and complexity away from hardware and into software. This is mainly due to economic and technical reasons: embedded systems need to be cheap, light and small. Overall costs can be reduced by shifting functionality to software. In addition, software solutions are clearly more easily changed than hardware solutions.\n\nEmbedded systems have a number of unique properties and requirements that have a direct impact on the methods and tools used for their software development. These include\n* Heterogeneity. Embedded systems are very domain specific and as such are highly heterogeneous in terms of the hardware and software components used. For example, the embedded software for automotive systems has different features and requirements to that for mobile applications. \n* Complexity. Embedded systems often have stricter requirements for many properties than enterprise systems do, including timeliness, liveness, safety, reliability and low resource consumption, such as power and memory. \n* Flexibility. Economically, embedded systems need to have flexible development methods with tool support to reduce time-to-market and to improve maintenance.\n* Communication. Embedded systems are being increasingly applied in pervasive computing, tending to form networked systems that require unobtrusive communication. For example the communication of sensors and actuators in sensor networks falls in this category. \n* Advanced management. Because of their limited resources, decentralized control and alternative energy sources (such as light, vibration and walking), embedded systems are often required to provided adaptive behaviours such as self configuration and self management according to changes in their environment. \n\nThese properties and requirements have greatly increased the difficulty of embedded systems development and in particular of those activities relating to system design, verification and maintenance. The current state of practice shows that the methods, tools and techniques used within industry are mostly generic and not specifically targeted for the embedded systems domain. Furthermore, many important non-functional requirements such as memory usage, power consumption and timing are not widely addressed owing to the lack of tool support.\n\nThese problems have been recognized by the research community, and advanced software engineering technologies have been proposed as solutions. Component-based software development (CBSD) provides promising solutions to these problems by composing systems from independent, well-defined building blocks. CBSD shifts the development emphasis from programming software to composing software systems. It brings with it obvious benefits for embedded systems such as reusability, maintainability, and a reduction of software complexity, which leads to improved productivity.\n\nCAmkES (Component Architecture for microkernel-based Embedded Systems) is an architecture that we have developed as part of a NICTA RMCC project to enable the component-based development of embedded systems. Specifically, CAmkES targets embedded systems based on the L4 microkernel. Since microkernels are light on resource requirements, provide good protection between applications and OS components, and make for a suitably small trusted computing base, they are a highly suitable base upon which to build reliable and trustworthy embedded systems. The CAmkES project was started in December 2004 as a joint project between the ESE and ERTOS programs. With a project duration of 26 months the project is scheduled to be completed at the end of July 2007. The outcomes of CAmkES include a core component architecture, dynamic component extensions and associated development tools (ADL compiler and image loader). This component architecture focused on providing flexibility without sacrificing performance or increasing memory footprint, both very important non-functional requirements for embedded system software. \n\nHowever, numerous other requirements and challenges of embedded systems, such as those discussed above, are not addressed by the original architecture. Also CAmkES provides only the basic tool support required for a component-based software development lifecycle. Adding further tool support at various stages of the development lifecycle would improve embedded system development even further. Applying component-based development in the embedded system domain also introduces several new concepts and challenges. \n* Must fulfil the real-time requirements present in many embedded systems,\n* Should provide flexibility for component design and implementation. For example, it should allow components to be parameterised and configured, it should allow various ways of connecting components together, and it should allow components to make as few assumptions as possible about their environment. \n* Should support a variety of computational models (or architectural styles), including event-based models, dataflow models, etc.\n* Require testing and validation support in the integration phase of embedded systems\n\nConsidering these challenges of complexity, component-based embedded software development necessitates the abstraction of the system requirements and properties of features, functionalities and qualities; and mapping the abstraction to the programmable platforms and runtime environment that support it. This is the essence of model driven software development (MDD), of which the primary artefacts of development are models as opposed to programs. Models provide abstractions of physical systems that allow engineers to reason about their systems by ignoring extraneous details while focusing on relevant ones. For example, a UML design is a model consisting of a visualization of programming code and a formal specification of a system’s behaviour. Model-driven software development is centred on the use of models. It is a software engineering approach that aims to reduce the complexity and improve quality of software systems by constructing software systems through models and associated modelling technologies. For example, generating programming code from UML notations is just one of the applications of MDD at the design and implementation stage. In MDD, models can be used in many ways, including to:\n* predict system quality;\n* reason about specific properties when aspects of the system are changed;\n* communicate key system characteristics to various stakeholders.\n\nA synergistic engineering approach is to combine CBSD with MDD. This is an emerging research topic with a focus on generating code and deployment descriptors of embedded systems from models in design artefacts. One of the great software engineering challenges in integrating MDD and CBSE is to support non-functional requirements of embedded systems. Models are actually of broader use than simply as design artefacts. For instance, models can be used to represent component structure; or models can be analytical models of particular properties of an embedded system. We consider the concepts of models in a broader context in that they can guide the design, the runtime management, the deployment and the validation of component-based embedded software. Based on the above, and given the fact that CAmkES has already established a solid infrastructure for component-based development of embedded systems, ''the aims of this project are to develop the next generation of CAmkES, which includes capabilities for model-oriented development and support for arbitrary non-functional requirements. This is realized by devising a comprehensive, principled model-oriented development framework for embedded systems with an associated suite of software tools. This framework supports the management of non-functional requirements of embedded systems by reasoning about models of the systems at different levels of abstraction''. \n\n!! Research Objectives\nThe project will have the following specific objectives:\n1. To develop a comprehensive suite of modeling techniques and an associated implementation tailored to the design of embedded systems with declarable non-functional requirements (NFRs). In particular,\n*To enrich the semantics of the core CAmkES component model to allow specification of NFRs.\n*To develop annotations for each non-functional property (NFP) relevant to the NFRs.\n*To develop techniques and tools to automate the transformation from design models to generated code.\n*To develop a testing framework associated with components specified in the design models to reduce the engineering effort of developing test cases from scratch. \n\n2. To develop a model representation that can be accessed and manipulated at runtime. This will be associated with CAmkES extension components that will support querying and modification of the runtime model and that will reflect such changes on the running system. A further objective will be the development of runtime support for ensuring that components with NFP annotations will actually provide the appropriate properties.\n3. To develop a framework for integrating models developed from different perspectives and at different levels. For example, the design models represent the structure of the embedded application, and this structure information can be used as a basis for a runtime model that reflects the status of components and their connections.\n4. To investigate suitable approaches for specifying model semantics and checking models for consistency. This can lead to the development of mechanisms that can transform design models to inputs for formal verification. Models with annotations for NFPs are particularly interesting candidates for such transformation.\n\nCrucially, the resulting comprehensive software framework must have the following general characteristics:\n• Maintain Separation of Concerns: The management behavior of non-functional requirements behavior must be expressed separately from the main application business logic.\n• Deployment/Development Scalability: Solutions should scale down to small-scale applications, and scale up to large networked deployments.\n• Resource efficient management: The overhead introduced by constructing, manipulating and maintaining models should be optimized such that it does not adversely affect the quality of the resulting embedded systems.\n\nMore specifically, the creation of a model-oriented development capability for CAmkES presents the following scientific challenges:\n1. The invention of design runtime models that, given inputs of NFRs that characterize the current execution environment, can be manipulated and reasoned to produce optimal parameter settings for controlling various aspects of application configuration and behavior.\n2. The invention of new extensible software architectures to provide flexible component communication, runtime monitoring, feedback mechanisms, all with minimal overhead. \n3. The invention of mechanisms to transform and integrate models. It is these three scientific challenges that this project will address.\n\n!! Status\nI am currently heavily working on CAmkES project, and this research activity leads to the vision for a long term research . A strategic plan and a proposal in details of a large research project is under development. \n

Advances in wireless networking combined with increasing small-scale wireless devices have led to the vision of ‘being connected anywhere and anytime’. Many rich features have been introduced to mobile applications, so that users can easily access web-based applications through their mobile devices just like desk-top based web applications. However, mobile devices still have the constraints over display resolution, power consumption, and computing capacity such as processors and memories. There is the demand that wireless and embedded computing devices should be equipped with powerful computation and communication services in a ubiquitous and pervasive world. These trends actually demand the services being able to handle requests in an ever changing dynamic environment, according to the users’ situation, such as network connection status (wether it is fast and stable or very slow and unstable), display screen (size and resolution), power consumption (whether the remaining power can sustain during the period that the request for the web application being processed) and etc. \n\nA promising solution is leveraging the adaptive capability of web platforms according to the user’s situation, so that the servers that host web platforms can compute the response and make proactive adaptation before it is sent back to the client application running on mobile devices. For example, a large image may not be displayed on small screen of mobile phones. By degrading the quality of images from 100% to 75%, the size of the image can be significant reduced and thus may be displayed properly without users being aware of the difference of image quality in term of human being’s visual conception. \n\nAs web platforms are normally hosted by more powerful computing capacities, computation of adaptation can be more efficiently handled at the server side than plugging in extra software components to the mobile devices. This also presents a good separation of concern and modifiability especially under evolution: updating of mobile devices will not affect the availability of this adaptive service feature, as the adaptation is deployed and maintained at the server side. This can enrich the user experience of mobile applications with better quality of services. \n\nThis project aims to devise generic and extensible web platform, with architectural mechanisms, techniques and models to enrich user experience of mobile applications through server side adaptation. This give rise to the following research issues:\n* Non-instrument of the adaptation logic through monitoring, analysing and executing on the web platform, such as web application containers, and service engines. \n* Optimize communication between the mobile application and the web platform when transferring adaptation management related data\n* Devise models for analysing the data on the fly and determine the execution plan for adaptation \n\nIt is these three scientific challenges that this project will address. \n \nThe outcomes will be a generic adaptive web platform that augments existing web server technologies. This platform will be used by application developers as the foundation architectural platform for building a myriad of adaptive mobile application behaviours for creating reusable monitoring and adaptive model components that exploit the foundation architecture. \n\nThis choice is motivated by two factors:\n* Our experience in developing adaptive middleware infrastructure through the NICTA research project Models and Extensible Architecture for Adaptive Middleware Platform , has convinced us about the benefit of the approach regarding the practical usage and efficiency of the resulting systems. \n* We have well established research records in combing model-based approach with server infrastructure to develop adaptive software platforms. A research prototype of a mobile Web service-based application using Xda O2, ASP.Net and Axis 2 has already been implemented. \n\nOur application domain is voluntarily broad since we aim at offering generic solutions. One specific application is displaying rich context such as tabs, RSS feeds, images on mobile devices, by providing adaptive display of customized tabs with optimized layouts and views according to the display characteristics of a mobile device. \n

[[ About Me ]]\n[[ My Linkedin Profile | http://www.linkedin.com/in/yjennyliu ]]\n[[ Research Overview ]]\n[[ Research Projects ]]\n[[ Research Prototypes ]]\n[[ Publication ]]\n[[Student Supervision]]\n[[Available Project Topics]]\n[[ Books I Read ]]\n[[ Scratch I Draw ]]\n[[ Software Performance Space ]]\n

Evolution of middleware and distributed system technologies have led to the emergency of service-oriented system architectures to deal with the ever increasing complexity and demanding requirements of Internet-based systems. Service architectures are primarily designed for realizing complex business process over the internet. A service is an instance of a configured software system, which can be composed with other services to offer a new system. The process specifying the composition must not only define the functional behaviour of the process, but also the non-functional properties in terms of end-to-end interactions with the composed services, especially by exploiting middleware infrastructure support. The critical business values of the Internet-based services depend on the service architecture. Dependability, performance, together with around-the-clock availability, reliability, and security are the most common indicators of QoS on the Internet. Enforcing quality of composite software services remains one of the most challenging issues for service oriented systems, especially for supporting various non-functional properties of end-to-end interactions of composed services. \n\nAdvances in wireless networking combined with increasing small-scale wireless devices have led to the vision of ‘being connected anywhere and anytime’, which further complicated the challenges. Wireless and embedded computing devices are increasingly being equipped with powerful computation and communication services in a ubiquitous and pervasive world. These trends actually demand the services being able to handle requests in an ever changing dynamic environment, for example according to the users’ situation. \n\nWhile a number of middleware technologies are already commercially available for deploying base infrastructures for supporting the service development vision, the management of service-oriented system is still raises numerous scientific and technical challenges due to the specifics of Web services. In addition to traditional requirements for distributed software systems like dependability, performance and reliability, the service oriented system shall deal with: mobility of users, increasing heterogeneity in platforms, networks and software infrastructures, varying application and user requirements, diverse context of services, and exploiting knowledge about the environment. Above requirements reveal the highly dynamic characteristics of service oriented systems, which shall be accommodated by the overall service infrastructure with the support of adaptive middleware infrastructure underpinning the computing of services. Specially, the service infrastructure is required to comprehensively offer the following features:\n* Service delivery is capable of continuously adapting to the highly changing situation in the combined software-centric and user-centric context. \n* Adaptation shall be transparent to the business process definition and deployment, so that the complexity of managing end-to-end services can be reduced through the automation of service management to guarantee reliability and performance, as apposed to putting increasing burden on them for mastering the increasing complexity of technologies.\n\nThis project addresses the above two issues, investigating methods, tools and middleware architectures to assist the management of critical end-to-end services. Our approach relies on next generation adaptive middleware infrastructure which combines models, data and derived knowledge:\n\n* Automation of service oriented system management based on adaptive middleware technologies, encompassing design through development to production and capturing service monitoring, evaluation and evolution.\n* Guarantee the non-functional properties especially reliability and high performance of end-to-end interactions with composed services, coupling models, data and derived knowledge. \n\nParticularly, this project covers the research challenges that connects research issues under two NICTA research themes: Managing Complexity in the vision o f introducing the adaptive capability to the resulting service oriented systems, and Embedded Systems by encompassing its user-centric context equipped with small scale wireless and embedded computing devices. \n\nThis choice is motivated by two factors:\n* Our experience in developing adaptive middleware infrastructure through the NICTA RMCC project AMP, has convinced us about the benefit of the approach regarding the practical usage and efficiency of the resulting systems. \n* We have well established research records in combing model-based and model-driven approach to the design and evaluation of large scale enterprise systems. The methods and technologies have already been applied to solve real world problems thorough collaboration projects with government agencies.\n* We have the synergetic expertise in ESE for interdisciplinary research areas in software architecture, middleware, web services, business process and embedded system.\n\n\nOur application domain is voluntarily broad since we aim at offering generic solutions. However, we examine our results for specific applications as part of the validation of our research results we undertake through prototype implementation and industrial trial. Applications that we consider in particular include demonstrators developed for\n* Enhancing the adaptive capability for enterprise service bus\n* Composing adaptive middleware for managing reliability and performance of integrated web services\n* Enriching the features of mobile applications through remote server side adaptation\n* Exploiting machine learning techniques for efficient adaptation development.\n\nThis project leverages the software framework produced from [[Adaptive Middleware Platform]]. It also has strong connections with other research, especially projects in NICTA including CAmkES and machine learning for identifying rules. It is compliant to these projects on the fact that it targets the underlying infrastructure to provide better support for higher level business process management and address the resulting embedded systems out of CAmkES in a pervasive computing world. \n\n

<<closeAll>><<permaview>><<newTiddler>><<newJournal 'DD MMM YYYY'>><<saveChanges>><<slider chkSliderOptionsPanel OptionsPanel 'options »' 'Change TiddlyWiki advanced options'>>

Designing complex multi-tier applications that must meet strict performance requirements is a challenging software engineering problem. Ideally, the application\narchitect could derive accurate performance predictions early in the project life-cycle, leveraging initial application design-level models and a description of the\ntarget software and hardware platforms. To this end, a capacity planning tool suite for component-based application is produced. The tool adheres to the model driven development paradigm and supports benchmarking and performance prediction for J2EE, .Net and Web services platforms. The suite is composed of three different tools: MDAPerf, MDABench and DSLBench. \n* MDAPerf allows annotation of design diagrams and derives performance analysis models.\n* MDABench allows a customized benchmark application to be modeled in the UML 2.0 Testing Profile and automatically generates a deployable application, with measurement automatically conducted. \n* DSLBench allows the same benchmark modeling and generation to be conducted using a simple performance engineering domain specific language. DSLBench integrates with Visual Studio and reuses its load testing infrastructure. \n\nThe tool suite can assist capacity planning across platforms in an automated fashion. These prototypes have been demonstrated at various NICTA public events and conference venues including OOPSLA and ICSE. These prototypes were implemented by NICTA research students and the research is supervised by my colleagues and myself. \n\n[img[Revel8tor Overview|http://www.cse.unsw.edu.au/~yliu/index-images/Revel8tor-small.png]]\n/%[img[Revel8tor Overview|file:///D:/RESEARCH/AmericaTrip2007/WebConstruct/Revel8tor-small.png]]%/\n

\n<div id='header' class='header'>\n<div class='headerShadow'>\n<span class='searchBar' macro='search'></span>\n<span class='siteTitle' refresh='content' tiddler='SiteTitle'></span> \n<span class='siteSubtitle' refresh='content' tiddler='SiteSubtitle'></span>\n</div>\n\n</div>\n<div id='mainMenu'>\n<span refresh='content' tiddler='MainMenu'></span>\n<span id='noticeBoard' refresh='content' tiddler='NoticeBoard'></span>\n\n</div>\n<div id='sidebar'>\n<div id='sidebarOptions' refresh='content' tiddler='MochaSideBarOptions'></div>\n<div id='sidebarTabs' refresh='content' force='true' tiddler='SideBarTabs'></div>\n</div>\n<div id='displayArea'>\n<div id='messageArea'></div>\n<div id='tiddlerDisplay'></div>\n</div>\n<div id='contentFooter' refresh='content' tiddler='contentFooter'></div>\n

Ph.D., Senior Researcher\nEmpirical Software Engineering Program\nNational ICT Australia\njenny dot liu at nicta dot com dot au

Yan (Jenny) Liu

http://www.tiddlywiki.com/

I am very glad that in the coming year 2008, two TOR scholars will join our research group for 10 weeks to explore and experience research. \nMy CSE topic list can be found [[here|http://www.cse.unsw.edu.au/db/thesis/mytopics/JYL.html]]. \n\nI have supervised many student projects in the last four years. \n\n#Adi Christian Iskandar ,Jul 2004 - Jun 2005,Thesis,Performance Evaluation of .Net Application\n#Ngoc Bao Bui,Dec 2004 - Feb 2005,TOR (co-supervision),MDA-based Automated Benchmark Generation\n#Ngoc Bao Bui,Feb 2005 - Nov 2005,Thesis (co-supervision),MDA-based Automated Benchmark Generation\n#Sid Sheng,Feb 2005 - Nov 2005,Thesis,Performance Evaluation of .Net .Net Architectures: Implementing Asynchronous Stock-Online.Net\n#Pramod Murali ,Feb 2005 - Nov 2005,Thesis,Performance Evaluations of .NET Architectures: Comparing Different Transaction Controls\n#Peter Huang ,Feb 2005 - Nov 2005,Thesis,IDE Integration of Performance Prediction of Component-based Systems\n#Vinh Khanh Le,Dec 2005 - Feb 2006,TOR,An Event Correlation Engine for Adaptive Server Framework\n#Cuong Hoang,Dec 2005 - Feb 2006,TOR,Security for Grid-based applications\n#Fahad Al-Hajeri,July 2005 - Jun 2006,Master Project,Porting the Adaptive Server Framework on COTS Weblogic Server\n#Vinh Khanh Le,Feb 2006 - Nov 2006,Thesis,An Event Correlation Service for Adaptive Server Applications \n#Ronny Handoko Arsie,Feb 2006 - Nov 2006,Thesis,Performance Modeling of Enterprise Applications on Service Bus\n#Billy Johari,Feb 2006 - Nov 2006,Thesis,Performance Modeling of Enterprise Applications on Service Bus\n#Alex Chen,Feb 2006 - Nov 2006,Thesis,Performance evaluation of architectural alternatives of .NET Applications\n#Gia Hieu Dinh,Dec 2006 - Feb 2007,TOR,Enabling Mobile Access to Adaptive Services and Portals\n#Gia Hieu Dinh,Feb 2007 - Nov 2007,Thesis,Enabling Mobile Access to Adaptive Services and Portals\n#Nhuan Luong Mach,Feb 2007 - Nov 2007,Thesis,The model and architecture of adaptive components on ADO.Net\n#Eugene Paperny,Feb 2007 - Nov 2007,Thesis,Architecture of Adaptive Components on ASP.Net\n#Simon Truong,Feb 2007 - Nov 2007,Thesis,The Architecture of Adaptive Components in .Net 3.0 (WCF)\n#Raymond Chiu,Feb 2007 - Nov 2007,Thesis,Enhance the Adaptivity of Integrated Services in SOA\n#Anna Mary Lyons,Dec 2007 - Feb 2008,TOR,Model Driven Development for Real-time Embedded Applications\n#Min'an Tan,Dec 2007 - Feb 2008,TOR,Policy Driven Adaptive Web Service Management Framework\n#Andy Wu Shu Yan ,Jul 2007 - Jun 2008,Thesis,Developing A Service Oriented Architecture Based on OSGI framework for Vine Yard Network Architecture\n#Alex Zhu ,Jul 2007 - Jun 2008,Thesis,Developing A Service Oriented Architecture Based on OSGI framework for Vine Yard Network Architecture\n#Ngoc Bao Bui,July 2006 - present,PhD Project (co-supervision),Composing Web Services Using Non-functional Properties: A Model Driven Approach\n\n

/*{{{*/\n/*Mocha TiddlyWiki Theme*/\n/*Version 1.0*/\n/*Design and CSS originally by Anthonyy, ported to TiddlyWiki by Saq Imtiaz.*/\n/*}}}*/\n/*{{{*/\n #contentWrapper{\nmargin: 0 3.4em;\n\n font-family: Lucida Grande, Tahoma, Arial, Helvetica, sans-serif; /* Lucida Grande for the Macs, Tahoma for the PCs */\nfont-size: 11px;\n line-height: 1.6em;\n color: #666;\n}\n\n.header {\n background: #fff; \n padding-top: 10px;\n clear: both;\n\nborder-bottom: 4px solid #948979;\n}\n\n.headerShadow { padding: 2.6em 0em 0.5em 0em; }\n\n.siteTitle {\n font-family: 'Trebuchet MS' sans-serif;\n font-weight: bold;\n font-size: 32px;\n color: #CC6633;\n margin-bottom: 30px;\n background-color: #FFF;\n}\n\n.siteTitle a{color:#CC6633; border-bottom:1px dotted #cc6633;}\n\n.siteSubtitle {\n font-size: 1.0em;\n display: block;\n margin: .5em 3em; color: #999999;\n}\n\n#mainMenu {\nposition:relative;\nfloat:left;\nmargin-bottom:1em;\ndisplay:inline;\ntext-align:left;\npadding: 2em 0.5em 0.5em 0em;\nwidth:13em;\nfont-size:1em;\n}\n\n#sidebar{\nposition:relative;\nfloat:right;\nmargin-bottom:1em;\npadding-top:2em;\ndisplay:inline;\n\n}\n\n#displayArea {\n margin: 0em 17em 0em 15em;\n}\n\n.tagClear {clear:none;}\n\n#contentFooter {background:#575352; color:#BFB6B3; clear: both; padding: 0.5em 1em;}\n\n \n #contentFooter a {\n color: #BFB6B3;\n border-bottom: 1px dotted #BFB6B3;\n }\n \n #contentFooter a:hover {\n color: #FFFFFF;\n background-color:#575352;\n }\n\n a,#sidebarOptions .sliderPanel a{\n color:#CC6714;\n text-decoration: none;\n }\n\n a:hover,#sidebarOptions .sliderPanel a:hover {\n color:#CC6714;\n background-color: #F5F5F5; \n }\n\n.viewer .button, .editorFooter .button{\n color: #666;\n border: 1px solid #CC6714;\n}\n\n.viewer .button:hover, \n.editorFooter .button:hover{\n color: #fff;\n background: #CC6714;\n border-color: #CC6714;\n}\n\n.viewer .button:active, .viewer .highlight,.editorFooter .button:active, .editorFooter .highlight{color:#fff; background:#575352;border-color:#575352;}\n\n\n #mainMenu a {\n display: block;\n padding: 5px;\n border-bottom: 1px solid #CCC;\n }\n\n #mainMenu a:link, #navlist a:visited {\n color:#CC6714;\n text-decoration: none;\n }\n \n #mainMenu a:hover {\n background: #000000 url(arrow.gif) 96% 50% no-repeat;\n background-color: #F5F5F5;\n color:#CC6714;\n }\n\n#mainMenu br {display:none;}\n\n#sidebarOptions a {\n color:#999;\n text-decoration: none;\n }\n\n#sidebarOptions a:hover {\n color:#4F4B45;\n background-color: #F5F5F5;border:1px solid #fff;\n }\n\n#sidebarOptions {line-height:1.4em;}\n\n .tiddler {\n padding-bottom: 40px;\n border-bottom: 1px solid #DDDDDD; \n }\n.title {color:#CC6633;}\n.subtitle, .subtitle a { color: #999999; font-size: 1.0em;margin:0.2em;}\n.shadow .title{color:#948979;}\n\n.selected .toolbar a {color:#999999;}\n.selected .toolbar a:hover {color:#4F4B45; background:transparent;border:1px solid #fff;}\n\n.toolbar .button:hover, .toolbar .highlight, .toolbar .marked, .toolbar a.button:active{color:#4F4B45; background:transparent;border:1px solid #fff;}\n\n .listLink,#sidebarTabs .tabContents {line-height:1.5em;}\n .listTitle {color:#888;}\n\n#sidebarTabs .tabContents {background:#fff;}\n#sidebarTabs .tabContents .tiddlyLink, #sidebarTabs .tabContents .button{color:#999;}\n#sidebarTabs .tabContents .tiddlyLink:hover,#sidebarTabs .tabContents .button:hover{color:#4F4B45;background:#fff}\n\n#sidebarTabs .tabContents .button:hover, #sidebarTabs .tabContents .highlight, #sidebarTabs .tabContents .marked, #sidebarTabs .tabContents a.button:active{color:#4F4B45;background:#fff}\n\n.tabSelected{color:#fff; background:#948979;}\n\n.tabUnselected {\n background: #ccc;\n}\n\n .tabSelected, .tabSelected:hover {\n color: #fff;\n background: #948979;\n border: solid 1px #948979;\npadding-bottom:1px;\n}\n\n .tabUnselected {\n color: #999;\n background: #eee;\n border: solid 1px #ccc;\npadding-bottom:1px;\n}\n\n#sidebarTabs .tabUnselected { border-bottom: none;padding-bottom:3px;}\n#sidebarTabs .tabSelected{padding-bottom:3px;}\n\n\n#sidebarTabs .tabUnselected:hover { border-bottom: none;padding-bottom:3px;color:#4F4B45}\n\n#sidebarOptions .sliderPanel {\n background: #fff; border:none;\n font-size: .9em;\n}\n#sidebarOptions .sliderPanel a {font-weight:normal;}\n#sidebarOptions .sliderPanel input {border:1px solid #999;}\n\n.viewer blockquote {\n border-left: 3px solid #948979;\n}\n\n.viewer table {\n border: 2px solid [[ColorPalette::TertiaryDark]];\n}\n\n.viewer th, thead td {\n background: #948979;\n border: 1px solid #948979;\n color: #fff;\n}\n.viewer pre {\n border: 1px solid #948979;\n background: #f5f5f5;\n}\n\n.viewer code {\n color: #2F2A29;\n}\n\n.viewer hr {\n border-top: dashed 1px #948979;\n}\n\n.editor input {\n border: 1px solid #948979;\n}\n\n.editor textarea {\n border: 1px solid #948979;\n}\n\n.popup {\n background: #948979;\n border: 1px solid #948979;\n}\n\n.popup li.disabled {\n color: #000;\n}\n\n.popup li a, .popup li a:visited {\n color: #eee;\n border: none;\n}\n\n.popup li a:hover {\n background: #575352;\n color: #fff;\n border: none;\n}\n\n.tagging, .tagged {\n border: 1px solid #eee;\n background-color: #F7F7F7;\n}\n\n.selected .tagging, .selected .tagged {\n background-color: #eee;\n border: 1px solid #BFBAB3;\n}\n\n .tagging .listTitle, .tagged .listTitle {\n color: #bbb;\n}\n\n.selected .tagging .listTitle, .selected .tagged .listTitle {\n color: #666; \n}\n\n.tagging .button, .tagged .button {\n color:#aaa;\n}\n.selected .tagging .button, .selected .tagged .button {\n color:#4F4B45;\n}\n\n.highlight, .marked {background:transparent; color:#111; border:none; text-decoration:underline;}\n\n.tagging .button:hover, .tagged .button:hover, .tagging .button:active, .tagged .button:active {\n border: none; background:transparent; text-decoration:underline; color:#000;\n}\n\nh1,h2,h3,h4,h5 { color: #666; background: transparent; padding-bottom:2px; font-family: Arial, Helvetica, sans-serif; }\nh1 {font-size:18px;}\nh2 {font-size:16px;}\nh3 {font-size: 14px;}\n\n#messageArea {\n border: 4px solid #948979;\n background: #f5f5f5;\n color: #999;\n font-size:90%;\n}\n\n#messageArea a:hover { background:#f5f5f5;}\n\n#messageArea .button{\n color: #666;\n border: 1px solid #CC6714;\n}\n\n#messageArea .button:hover {\n color: #fff;\n background: #948979;\n border-color: #948979;\n}\n\n\n* html .viewer pre {\n margin-left: 0em;\n}\n\n* html .editor textarea, * html .editor input {\n width: 98%;\n}\n\n.searchBar {float:right;font-size: 1.0em;}\n.searchBar .button {color:#999;display:block;}\n.searchBar .button:hover {border:1px solid #fff;color:#4F4B45;}\n.searchBar input { \n background-color: #FFF;\n color: #999999;\n border: 1px solid #CCC; margin-right:3px;\n}\n\n#sidebarOptions .button:active, #sidebarOptions .highlight {background:#F5F5F5;}\n\n*html #contentFooter { padding:0.25em 1em 0.5em 1em;}\n\n#noticeBoard {font-size: 0.9em; color:#999; position:relative;display:block;background:#fff; clear: both; margin-right:0.5em; margin-top:60px; padding:5px; border-bottom: 1px dotted #CCC; border-top: 1px dotted #CCC;}\n#mainMenu #noticeBoard a,#mainMenu #noticeBoard .tiddlyLink {display:inline;border:none;padding:5px 2px;color:#DF9153 }\n#noticeBoard a:hover {border:none;} \n\n#noticeBoard br {display:inline;}\n\n#mainMenu #noticeBoard .button{\n color: #666;\n border: 1px solid #DF9153;padding:2px;\n}\n\n#mainMenu #noticeBoard .button:hover{\n color: #fff;\n background: #DF9153;\n border-color: #DF9153;\n}\n/*}}}*/

[[Nicholas Allen's Indigo Blog | http://blogs.msdn.com/drnick/default.aspx]]\n[[Software Engineering Institute|http://www.sei.cmu.edu/]]

\n//{{{\n//This ensures that the footer sticks to the bottom of the screen when there are no tiddlers open. If that is not desirable, it can be deleted.\nfunction setFooter() {\n if (document.getElementById && document.getElementById("contentFooter") ) {\n var windowHeight=findWindowHeight();\n if (windowHeight>0) {\n var contentHeight= document.getElementById('mainMenu').offsetHeight + document.getElementById("header").offsetHeight + document.getElementById("contentFooter").offsetHeight;\n var menu= document.getElementById('mainMenu');\n if (windowHeight-(contentHeight)>=0) {\n menu.style.position='relative';\n menu.style.marginBottom=(windowHeight-(contentHeight))+'px';\n }\n else {\n menu.style.position='';\n menu.style.marginBottom='';\n }\n }\n }\n}\nwindow.onresize = function() {\n setFooter();\n}\n\nStory.prototype.refreshTiddler_footerhack=Story.prototype.refreshTiddler;\nStory.prototype.refreshTiddler = function (title,template,force)\n{ \nvar theTiddler = Story.prototype.refreshTiddler_footerhack.apply(this,arguments);\nsetFooter();\n return theTiddler;}\n\n//}}}

version.extensions.sliceGrid= {major: 1, minor: 0, revision: 0, date: new Date(2007,9,18)};\n\nconfig.macros.sliceGrid= {\n sizeSliceName: "TiddlerSize", // shadow slice used for retrieving and showing tiddler size as a grid column\n noSlicesMsg: "\sn|~SliceGrid: there are no slices to display|\sn",\n handler:\n function(place,macroName,params) {\n this.slicesRE=/(?:^\s|\ss*[\s'\s/]*~?(\sw+)\s:?[\s'\s/]*\ss*\s|\ss*(.*?)\ss*\s|$)/gm;\n this.wikify=false; // wiki-syntax in slices\n this.edit=false; // 'click-to-edit' feature\n this.verbose=false; // debugging/performance feedback messages\n this.alltiddlers=false; // rows for all tiddlers (even if no slices)\n this.inline=false; // slice value in cell (instead of mouseover)\n this.headers=false; // column headers\n this.cliplength=0; // limit inline display text length (0=no limit)\n this.slices=[]; // slices to show (columns)\n var tablewidth="auto"; // default CSS for table width\n var p=params.shift();\n while (p) {\n if (p.substr(0,6).toUpperCase()=="WIDTH:")\n tablewidth=p.substr(6);\n else if (p.substr(0,5).toUpperCase()=="TAGS:") {\n if (p.substr(5,1)=="@") { // get tags from tiddler\n var tid=store.getTiddler(p.substr(6));\n if (p.substr(6)=="here") {\n var here=story.findContainingTiddler(place);\n if (here) var tid=store.getTiddler(here.getAttribute("tiddler"));\n }\n if (tid) var tags=tid.tags;\n }\n else if (p.substr(5,1)=="+") { // get tags from tiddler contents\n var tid=store.getTiddler(p.substr(6));\n if (p.substr(6)=="here") {\n var here=story.findContainingTiddler(place);\n if (here) var tid=store.getTiddler(here.getAttribute("tiddler"));\n }\n if (tid)\n { var tags=tid.text.readBracketedList(); }\n }\n else var tags=p.substr(5).readBracketedList();\n }\n else if (p.substr(0,7).toUpperCase()=="SLICES:") {\n if (p.substr(7,1)=="@") { // get slices from tiddler\n var tid=p.substr(8);\n var tiddler=store.getTiddler(tid);\n if (tid=="here") {\n var here=story.findContainingTiddler(place);\n if (here) var tiddler=store.getTiddler(here.getAttribute("tiddler"));\n }\n if (tiddler) {\n var slices=tiddler.getSlices(tiddler.title); for (var s in slices) this.slices.push(s);\n }\n }\n else if (p.substr(7,1)=="+") { // get slices from tiddler contents\n var tid=p.substr(8);\n var tiddler=store.getTiddler(tid);\n if (tid=="here") {\n var here=story.findContainingTiddler(place);\n if (here) var tiddler=store.getTiddler(here.getAttribute("tiddler"));\n }\n if (tiddler)\n { this.slices=tiddler.text.readBracketedList(); }\n }\n else this.slices=p.substr(7).readBracketedList();\n }\n else switch (p.toUpperCase()) {\n case "EDIT":\n this.edit=true && !readOnly; break; // no editing allowed if readOnly mode\n case "WIKIFY":\n this.wikify=true; break;\n case "VERBOSE":\n this.verbose=true; break;\n case "ALL":\n this.alltiddlers=true; break;\n case "INLINE":\n this.inline=true; this.headers=true; break; // default to show headers with inline grid\n default:\n if (!isNaN(p)) { this.cliplength=p; break; }\n else displayMessage("unrecognized parameter: "+p);\n }\n p=params.shift();\n }\n // get rows and columns\n var rows=[]; var cols=[]; var total=0;\n var tiddlers=store.getTiddlers("title","excludeLists"); // get all tiddlers (except hidden ones)\n if (tags && tags.length) for (t=0;t<tiddlers.length;t++) // filter out tiddlers with no matching tags\n if (!tiddlers[t].tags.containsAny(tags)) { tiddlers.splice(t,1); t--; } // remove non-matching tiddler\n for (i=0; i<tiddlers.length; i++) {\n var slices=this.getSlices(tiddlers[i].title);\n var count=0; for (var s in slices) { cols.pushUnique(s); count++; total++;}\n if (count || this.alltiddlers) rows.push(tiddlers[i].title); // only show rows for tiddlers with slices\n }\n if (!cols.length) { wikify(this.noSlicesMsg,place); return; }\n if (this.verbose) displayMessage("Found %0 slices using %1 slice names in %2 tiddlers".format([total, cols.length,rows.length]));\n\n // get optional list of slices to show\n if (this.slices.length) var cols=this.slices;\n\n // generate HTML table\n var out="";\n out+="<html><table cellpadding='0' cellspacing='0' style='border:0;border-collapse:collapse;width:"+tablewidth+"'>";\n // column headings\n out+="<tr style='border:0;'><td style='text-align:right;border:0'>";\n out+="<a href='javascript:;' style='font-size:80%;'";\n out+=" title='show all column headings'";\n out+=" onclick='return config.macros.sliceGrid.toggleAllColumns(this,event,"+(this.headers?"true":"false")+")'>";\n out+=this.headers?"<<<":">>>";\n out+="</a>";\n out+="</td>";\n for (var i=0;i<cols.length;i++) {\n out+="<td style='text-align:center;cursor:pointer;border:0;padding-left:2px;padding-right:2px;' ";\n out+=" title='show/hide column heading' ";\n out+=" onclick='return config.macros.sliceGrid.toggleColumn(this,event)'>";\n out+="<span style='display:"+(this.headers?"block":"none")+"'>"+cols[i]+"</span>";\n out+="</td>";\n }\n out+="</tr>";\n for (var i=0;i<rows.length;i++) {\n var tiddlersrc=rows[i].replace(/"/g,""");\n out +="<tr style='border:0'>";\n // row heading\n out +="<td style='text-align:right;border:0;padding-right:2px;white-space:nowrap;"+(this.inline?'width:1%':'')+";'>";\n out +="<a href='javascript:;' tid=\s""+tiddlersrc+"\s" onclick='story.displayTiddler(this,this.getAttribute(\s"tid\s"));return false'>"+tiddlersrc+"</a>";\n out +="</td>";\n var slices=this.getSlices(rows[i]);\n for (var j=0;j<cols.length;j++) {\n var val=slices[cols[j]]; if (!val) val="";\n var bgcolor=val.length?"#999":"transparent";\n var content=" ";\n if (val.length && this.inline) {\n content=val.htmlEncode();\n if (this.cliplength) content=val.substr(0,this.cliplength)+(val.length>this.cliplength?"...":"");\n bgcolor="transparent";\n }\n out+="<td style='background-color:"+bgcolor+";border:1px solid;"+(!this.inline?'width:1em;':'');\n if (this.inline && cols[j]==this.sizeSliceName) out+="text-align:right !important;"; // right align tiddler size pseudo-slice\n out+="'"; \n if (this.edit && !(cols[j]==this.sizeSliceName)) { // add edit-in-place, except for tiddler size pseudo-slice\n var onclick="return config.macros.sliceGrid.editSlice(this,event,this.getAttribute(\s"tid\s"),\s""+cols[j]+"\s","+(this.inline?"true":"false")+")";\n out+=" tid=\s""+tiddlersrc+"\s" onclick='"+onclick+"'";\n }\n out+=" title=\s""+tiddlersrc+"::"+cols[j]+(!this.inline?("="+val):"")+"\s"";\n out+="><span class='slicegrid_content'>"+content+"</span></td>";\n }\n out+="</tr>";\n }\n out+="</table>";\n out+="</html>";\n var span=createTiddlyElement(place,"span")\n span.innerHTML=out;\n if (this.wikify) {\n // find all TD's in table and replace span content with wikified elements\n var tds=span.getElementsByTagName("td");\n for (var t=0; t<tds.length; t++) {\n var content=tds[t].firstChild;\n if (!hasClass(content,"slicegrid_content")) continue;\n var txt=getPlainText(content);\n removeChildren(content);\n wikify(txt,content);\n }\n }\n },\n toggleAllColumns:\n function(here,event,defOpen) {\n if (here.expanded==undefined) here.expanded=defOpen;\n var ex=here.expanded=!here.expanded; \n here.innerHTML=ex?"<<<":">>>";\n here.title=ex?'hide all column headings':'show all column headings';\n var cells=here.parentNode.parentNode.getElementsByTagName("td");\n for (i=1; i<cells.length; i++) cells[i].firstChild.style.display=ex?"inline":"none";\n event.cancelBubble = true;\n if (event.stopPropagation) event.stopPropagation();\n return(false);\n },\n toggleColumn:\n function(here,event) {\n here.firstChild.style.display=(here.firstChild.style.display=="none")?"inline":"none";\n event.cancelBubble = true;\n if (event.stopPropagation) event.stopPropagation();\n return(false);\n },\n editSlice:\n function(here,event,tid,slice,inline) {\n // replace prompt box with edit field that is displayed until onBlur\n if (here.editing) return false; // already editing... don't re-init\n\n var onkeyup='if (event.keyCode==13)'; // SAVE and END\n onkeyup+=' { config.macros.sliceGrid.setSlice(this.getAttribute(\s"tid\s"),"'+slice+'",this.value); this.blur(); }';\n onkeyup+='else if (event.keyCode==27)'; // END without saving\n onkeyup+=' { this.blur(); }';\n\n var onblur="var tid=this.getAttribute(\s"tid\s"); var slice=\s""+slice+"\s"; var currval=config.macros.sliceGrid.getSlice(tid,slice); ";\n onblur+="if (this.value!=currval && confirm(tid+\s"::\s"+slice+\s" has changed... save value?\s"))";\n onblur+=" { config.macros.sliceGrid.setSlice(tid,slice,this.value); currval=this.value; }";\n onblur+="var target=this.parentNode;";\n onblur+="target.editing=false;";\n onblur+="target.style.backgroundColor=target.getAttribute(\s"savedColor\s");";\n onblur+="target.style.padding=target.getAttribute(\s"savedPadding\s");";\n onblur+="target.style.width=target.getAttribute(\s"savedWidth\s");";\n onblur+="if (config.macros.sliceGrid.wikify) { removeChildren(target); wikify(currval,target); }";\n onblur+="else target.innerHTML="+(inline?'currval':'\s" \s"')+";";\n\n var style="font-size:1em;font-family:inherit;width:95%;margin:0px;padding:1px 0px 1px 3px;border:0;";\n var title=tid+"::"+slice+" (ENTER=submit, ESC=cancel)";\n\n here.setAttribute("savedWidth",here.style.width); if (!inline) here.style.width="99%";\n here.setAttribute("savedPadding",here.style.padding); here.style.padding="0px"; \n here.setAttribute("savedColor",here.style.backgroundColor); here.style.backgroundColor="#fff";\n here.innerHTML="<input type='text' tid=\s""+tid.replace(/"/g,"&#x22")+"\s" onkeyup='"+onkeyup+"' onblur='"+onblur+"' style='"+style+"' title='"+title+"'>";\n here.firstChild.value=config.macros.sliceGrid.getSlice(tid,slice); // avoids conflicts with nested quoting in HTML\n here.firstChild.focus();\n here.firstChild.select();\n here.editing=true;\n\n event.cancelBubble = true; if (event.stopPropagation) event.stopPropagation(); return(false);\n },\n getSlice:\n function(tid,slice) {\n var slices=config.macros.sliceGrid.getSlices(tid);\n return slices[slice]?slices[slice]:"";\n },\n getSlices:\n function(tid) {\n var slices = {};\n var text = store.getTiddlerText(tid,"");\n slices[this.sizeSliceName]=text.length.toString(); // 'shadow slice' for displaying tiddler size\n this.slicesRE.lastIndex = 0;\n do {\n var m = this.slicesRE.exec(text);\n if (m) { if (m[1]) slices[m[1]] = m[2]; else slices[m[3]] = m[4]; }\n } while(m);\n return slices;\n },\n setSlice:\n function(tid,slice,val) {\n var oldval=this.getSlice(tid,slice);\n if (val==oldval) return false; // value is unchanged... do nothing\n // find slice within tiddler text\n var tiddler=store.getTiddler(tid);\n this.slicesRE.lastIndex = 0;\n var lastIndex=0;\n do {\n var m=this.slicesRE.exec(tiddler.text);\n if (m && (m[1]==slice||m[3]==slice)) break;\n if (m) lastIndex=this.slicesRE.lastIndex;\n } while(m);\n if (m) { // if matching slice was found\n if (oldval.length) { // replace old value with new value\n var pos=RegExp.lastMatch.indexOf(oldval);\n var newSlice=RegExp.lastMatch.substr(0,pos)+val+RegExp.lastMatch.substr(pos+oldval.length);\n } else // insert new value into empty slice\n var newSlice=RegExp.lastMatch.substr(0,RegExp.lastMatch.length-1)+val+"|";\n var newText=RegExp.leftContext+newSlice+RegExp.rightContext;\n } else { // create new slice following last slice (or at start of tiddler if no slices)\n var newSlice="|"+slice+"|"+val+"|\sn";\n var newText=newSlice+tiddler.text\n if (lastIndex) var newText=tiddler.text.substr(0,lastIndex+1)+newSlice+tiddler.text.substr(lastIndex+1);\n }\n // write tiddler contents\n var user=config.options.txtUserName; var mod=new Date();\n if (config.options.chkForceMinorUpdate)\n { var user=tiddler.modifier; var mod=tiddler.modified; }\n store.saveTiddler(tid,tid,newText,user,mod,tiddler.tags,tiddler.fields);\n displayMessage(tid+"::"+slice+" has been "+(m?"updated":"created"));\n return(false);\n }\n};