Postdoctoral Position on Visualizing Multicore Performance – Dublin

Position for postdoctoral HCI researcher on Understanding and Visualizing Multicore Performance

The School of Computer Science and Statistics at Trinity College Dublin (http://www.tcd.ie) is looking for applications for a Post-doctoral research position in the area of HCI and Visualization. The position is part of Lero, the Irish Software Engineering Research Centre, with collaboration from IBM Research.

Whereas previously only a small minority of programmers would deal with parallel programming, the shift towards multi-core has meant that a much wider proportion of programmers will need to produce parallel programs. The successful candidate will work as part of a small team on the ManyCore project, which aims to support this activity through visualizations which help programmers understand and improve the performance of their programs.

Following initial qualitative work (http://www.scss.tcd.ie/ManyCore), a data collection framework is already in place, along with a real-time data visualization framework, and software for supporting experiments. This postdoctoral researcher will thus focus on continuing analysis and design work, coupled with experimental work and associated preparation of publications.

Given the nature of the domain, a strong background in HCI and an interest in programming are essential. Previous experience of
experimental work with visualizations would be desirable.

The researcher will be based in the School of Computer Science and Statistics at Trinity College Dublin. Situated in the centre of Dublin, Trinity College is a 400-year-old University with a large and active research profile in Computer Science.

The post is being offered on a full-time basis for an initial twelve months, with potential to extend the position by a further 9 months subject to satisfactory performance.

To apply, please email your CV and contact details for two references to Gavin.Doherty@tcd.ie, quoting MANYCORE in the subject line. Please use this address for queries also.


Dr. Gavin Doherty,
School of Computer Science and Statistics,
Trinity College Dublin.
Office: O’Reilly Institute LG.19
Tel: +353 1 8963858
Web: http://www.scss.tcd.ie/Gavin.Doherty/

Posted in Positions, Research | Leave a comment

State of the Art of Performance Visualization

This is a guest post by Kate Isaacs, UC Davis, who is one of the authors of the paper presented.

Software visualization for performance is about helping developers find inefficiencies slowing down their code. Performance can have significant affects on the usability, feasibility and cost of running software. At EuroVis 2014, we presented a State-of-The-Art Report (STAR) on performance visualization which I’ll go over below. See here for the full report, slides, and literature website.

Performance is generally measured in terms of time, e.g., time to complete or throughput. Power consumption is another performance measure of interest but there are fewer tools for gathering such data. Since neither can be determined statically, some component of performance data must be gathered during execution (or possibly a simulation there of). This includes calling contexts and state information from the software as well as performance counters like cycles, flops, packets, and cache misses from the hardware. Collecting these data generally falls into one of two formats: Profiles aggregate the data in time, offering low overhead but less detail. Traces record each event separately as it occurs and thus quickly grow in size, so must be limited in scope.

Bar horizontal placement and width indicates time and duration of a function. Bar vertical placement is call stack depth.

Trace visualization showing call stack timeline, by Trümper et al.

We’ve broken down the use of visualization here into three main tasks. First, developers want to gain an overall understanding of what actions the software takes and how it uses resources during execution. Second, developers want help in detecting performance problems — they want to be able to quickly find anomalies, bottlenecks, load imbalance, and misuse of resources. Finally, they want to attribute these problems either to the software itself or some interaction between the software and the system on which it runs. Going beyond line-of-code attribution is a major challenge in helping developers truly understand causes of poor performance.

Though many tools employ visual analytics approaches to meet these tasks, we focused our STAR on the unique visualizations that may be part of these systems or stand alone. We categorized the visualizations by the context they provide to the performance measurements:

The software context is that of the code itself.  Call graphs are a popular sub-context for performance visualization. The need to show time or counter data makes indented trees with attached tables or color on node-link diagrams popular avenues.

Performance data has also been displayed on the code itself. Serial traces, like the one of Trümper et al. above, often focus on displaying the call stack in time or other code information, so they fall in the software context as well.

Call graph drawn as an indented tree, so each row is a unique call path. Data associated with that call path is in the same row of an adjoined table.

Indented tree call graph with tabular attributes, by Lin et al.

Threads and parallel processes are the fundamental units of the tasks context. Visualizing traces is a large area of research in this context, with challenges due to the sheer number of tasks. Representing the interactions between these tasks and their creation and deletion in time adds even more difficulty. Gantt-like representations and node-link diagrams are widely used here.

Each row represents a different processes timelines with bars shown function time and duration. Lines drawn between rows show messages between processors.

Gantt-like per-process timelines with messages overlaid, from Vampir

The system on which software is run is the hardware context. This can be the individual CPU cores or GPUs running the code and their scheduling of instructions, traces of the memory hierarchy usage, and representations of compute nodes and their interconnection network. We also included the operating system in this context, as that is rarely changed by application developers. When possible, natural representations have been used, but scale and complexity of modern architectures has largely removed this option.

Ports are spheroids colored by performance data. Nodes are surrounded by these ports. Network links are shown as lines between ports, colored to show traffic.

Multiprocessor nodes connected in a 2D plane network, from Haynes et al.

The application context is the domain of what is computed by the software. In scientific simulations, this is often a physical domain and in linear algebra libraries this would be the matrices involved. A lot of work has been done in the SciVis community for visualizing the former, but few tools have integrated a mapping of performance data onto those visualizations.

Memory accesses are shown both on the matrices (application context) and on the 1D arrays representing memory and caches (hardware context).

Matrix multiply visualization showing the computing matrices and their memory accesses, from Choudhury et al.

There are several challenges to address in performance visualization, the largest one being scale. Representing growing numbers of parallel operations or multivariate data from counters, function calls, and static context information is a major part of this problem. However, simply managing and compressing the large amount of data that can be collected is also a problem. Another challenge is handling ensembles of data taken from multiple executions, so developers can better determine the effects of their changes. As mentioned before, sophisticated attribution and depictions of complicated architectures are also in demand. These challenges demonstrate the pressing need for innovative performance visualization.

Interested? The first Workshop on Visual Performance Analysis will be held at Supercomputing 2014 — regular and short papers are due July 28th.

Posted in Papers, Research, Summary, Uncategorized | Tagged , , | Leave a comment

VPA 2014 Call for Papers – 1st Workshop on Visual Performance Analysis

1st Workshop on Visual Performance Analysis (VPA)

Held in conjunction with SC14: The International Conference on High Performance Computing, Networking, Storage and Analysis

New Orleans, LA, USA
November 21, 2014

Submission Deadline: July 28, 2014

Over the last decades an incredible amount of resources has been devoted to building ever more powerful supercomputers. However, exploiting the full capabilities of these machines is becoming exponentially more difficult with each new generation of hardware. To help understand and optimize the behavior of massively parallel simulations the performance analysis community has created a wide range of tools and APIs to collect performance data, such as flop counts, network traffic or cache behavior at the largest scale. However, this success has created a new challenge, as the resulting data is far too large and too complex to be analyzed in a straightforward manner. Therefore, new automatic analysis approaches must be developed to allow application developers to intuitively understand the multiple, interdependent effects that their algorithmic choices have on the final performance.

This workshop will bring together researchers and practitioners from the areas of performance analysis, application optimization, visualization, and data analysis and provide a forum to discuss novel ideas on how to improve performance understanding, analysis and optimization through novel techniques in scientific and information visualization.

Workshop Topics

  • Scalable displays of performance data
  • Interactive visualization of performance data
  • Data models to enable data analysis and visualization
  • Graph representation of unstructured performance data
  • Collection and representation of meta data to enable fine grained attribution
  • Message trace visualization
  • Memory and network traffic visualization
  • Representation of hardware architectures

Paper Submission

We solicit two types of papers both covering original and previously unpublished ideas: 8 page regular papers and 4 page short papers. To be considered, your manuscript should be formatted according to the double-column IEEE format for Conference Proceedings (IEEEtran LaTeX Class (template) V1.8 packages and IEEEtran V1.12 BibTeX (bibliography)). Margins and font sizes should not be modified. The templates for “IEEEtran LaTeX Class (template) V1.8 packages and IEEEtran V1.12 BibTeX (bibliography)” can be found at http://www.ieee.org/conferences_events/conferences/publishing/templates.html

All papers must be submitted through Easychair at: https://www.easychair.org/conferences/?conf=vpa14

Logistics

All logistics, including registration, hotel reservations, and visa requests, will be handled by SC14.

Important Dates

  • July 28th: submission deadline for full papers
  • September 15th: notification of acceptance
  • October 6th: final paper and copyrights due

Workshop Organizers

  • Peer-Timo Bremer, Lawrence Livermore National Laboratory
  • Bernd Mohr, Jülich Supercomputing Centre
  • Valerio Pascucci, University of Utah
  • Martin Schulz, Lawrence Livermore National Laboratory

Contact

Program Committee

  • Carlos Scheidegger, AT&T
  • Naoya Maruyama, RIKEN AICS
  • Felix Wolf, German Research School for Simulation Sciences
  • Matthias Mueller, RWTH Aachen University
  • Holger Brunst, ZIH / TU Dresden
  • Joshua Levine, Clemson University
  • Derek Wang, Charlotte Visualization Center, UNCC
  • Todd Gamblin, Lawrence Livermore National Laboratory
  • Hank Childs, University of Oregon
  • Markus Geimer, Jülich Supercomputing Centre
  • Judit Gimenez, Barcelona Supercomputing Center / Universitat Politècnica de Catalunya
  • Remco Chang, Tufts University
Posted in Announcements, Conferences | Tagged , , | Leave a comment

VISSOFT 2014 Call For Papers

Image

http://vissoft.iro.umontreal.ca/

The second IEEE Working Conference on Software Visualization (VISSOFT 2014) builds upon the success of the first edition of VISSOFT in Eindhoven, which in turn followed after six editions of the IEEE International Workshop on Visualizing Software for Understanding and Analysis (VISSOFT) and five editions of the ACM Symposium on Software Visualization (SOFTVIS). In 2014, VISSOFT will again be co-located with ICSME in Victoria, BC, Canada.

Software Visualization is a broad research area encompassing techniques that assist in a range of software engineering activities, such as, specification, design, programming, testing, maintenance, reverse engineering and reengineering. Covered methods contain the development and evaluation of approaches for visually analyzing software and software systems, including their structure, execution behavior, and evolution.

In this conference, we focus on visualization techniques that target aspects of software maintenance and evolution, program comprehension, reverse engineering, and reengineering, i.e., how visualization helps programmers to understand, analyze, and evolve software. We aim to gather tool developers, users and researchers from software engineering, information visualization, and human-computer interaction to discuss theoretical foundations, algorithms, techniques, tools, and applications related to software visualization. We seek theoretical, as well as practical papers on applications, techniques, tools, case studies, and empirical studies.

Topics of interest include, but are not limited to:- Program visualization- Visual software analytics- Network visualizations in software engineering- Visualization of software documentations- Visualization of parallel programs- Visualization-based software in computer science and software engineering education- Visualization of workflow and business processes- Integration of software visualization tools and development environments- Visualization of web services- Visualization of software evolution- Visualization of database schemes- Protocol and log visualization (security, trust)- Graph algorithms for software visualization- Layout algorithms for software visualization- Visual debugging- Software visualization on the internet- Empirical evaluation of software visualization- Visualization to support program comprehension- Visualization to support software testing- Visualization of software repositories- Social media visualization Papers are solicited that present original, unpublished research results and will be rigorously reviewed by an international program committee. In addition to full papers, VISSOFT features a New Ideas or Emerging Results (NIER) track and a tool demo track related to the same list of topics suggested above. All accepted submissions will appear in the conference proceedings and the IEEE Digital Library. Hints for writing Software Visualization research papers are available online (http://www.st.uni-trier.de/~diehl/softvis/org/softvis06/hints.html).

Submission Information

Authors should prepare and electronically submit their papers or abstracts via the EasyChair submission site (https://www.easychair.org/conferences/?conf=vissoft2014). Take care that you provide all required information in EasyChair. At least one author of an accepted paper must attend the conference to present the work. The review process will be single-blind.

All papers must conform, at time of submission, to the IEEE Formatting Guidelines. Make sure that you use this MS Word template (http://www.conference-publishing.com/templates/MSW_USltr_format.doc) and this LaTeX class (http://www.ctan.org/tex-archive/macros/latex/contrib/IEEEtran/IEEEtran.cls updated January 3rd, 2013). Submissions must be in PDF format. Make sure that you are using the correct IEEE style file: the title should be typeset in 24pt font and the body of the paper should be typeset in 10pt font. Latex users: please use \documentclass[conference]{IEEEtran} (without option compsoc or compsocconf).

Submission Types

Technical papers (up to 10 pages): These contributions describe in-depth mature research results in the above-mentioned areas of interest. The submission of a video (up to 5 minutes in length) to accompany the paper is highly encouraged to show interaction possibilities. Authors who wish to submit such video should provide a URL to the video at the end of the abstract input box in EasyChair (not in the submitted paper itself!).

NIER papers (up to 5 pages): The NIER contributions describe work-in-progress and preliminary exciting results. Authors should include open questions and even provocative hypotheses to get early feedback on their research ideas or even support through new research collaborations.

Tool papers (up to 4 pages): Tool contributions describe the design or actual utilization of software visualization tools, with a focus on relevant tool construction aspects or the use of the tool for gaining new insights. Authors should be prepared to demonstrate their tool at the conference.

Challenge paper (up to 4 pages): In the software visualization challenge, authors are to demonstrate the usefulness of their visualization tools on the data provided. The paper should first provide an introduction to the problem, data used, methods and tools used, results and their implications, and conclusions.

Important Dates

Main track (technical papers)

Abstract Submission: May 9, 2014
Paper Submission: May 16, 2014
Author Notification: June 20, 2014
Camera-ready Copies: July 14, 2014

NIER, Tool Demo, and Tool Challenge tracks:

Abstract Submission: June 24, 2014 => extended to July 1
Paper Submission: July 1, 2014 => extended to July 8
Author Notification: July 25, 2014
Camera-ready Copies: August 7, 2014

Organizing Committee

General Chair: Houari Sahraoui (University of Montreal, CA)

Program Co-Chairs: Bonita Sharif (Youngstown State University, US) and Andy Zaidman (Delft University of Technology, NL)

NIER & Tool-Demo Track Co-Chairs: Fabian Beck (University of Stuttgart, DE) and Mircea Lungu (University of Bern, CH)

Publicity & Web Chair: Daniel Limberger (Hasso Plattner Institute, DE)

Posted in Announcements, Conferences | Tagged , , , | Leave a comment

Survey on the Use of Sketches and Diagrams

This is a guest post by Sebastian Baltes, University of Trier. Please consider taking part in his short study (details see below).

Over the last decade, studies have shown that, despite the dominance of source code, sketches and diagrams play a major role in software engineering practice.

The focus of our current research is to expand our knowledge on the use of sketches and diagrams in software engineering practice. We are particularly interested in how these visual artifacts are related to source code. We do not exclusively focus on software developers, but on all “software practitioners” including testers, architects, project managers, but also researchers and consultants.

If you think that you belong to this group of software practitioners, please help us gaining deeper insights into your work practice by participating in our short survey. It just takes five to ten minutes of your valuable time:

http://www.st.uni-trier.de/survey

For more information, don’t hesitate to contact me.
Thanks in advance for your participation!

Posted in Announcements | Tagged , | Leave a comment

Software Visualization Highlights at EuroVis 2013

eurovis13In mid June 2013, the European visualization community spent a hot and, at the same time, refreshing week (both contentwise and weatherwise) in Leipzig meeting for EuroVis 2013. Since the scope of EuroVis is rather broad and covers all kinds of visualization problems, I was surprised to find a couple of works on software visualization there. A feature that connects these works (and even may be one of the current main challenges in information visualization in general) is scalability: software systems are large and complex systems that are difficult to understand. Managing size and complexity becomes a key to success for a software visualization approach.

Hierarchical Organization of Software Systems

A modularization usually structures a software system hierarchically. This hierarchy helps to abstract from the specific source code entities: it reduces the scalability requirements for a visualization technique. However, the levels of abstraction do not necessarily map to the levels of the modularization hierarchy: importance (with respect to a specific task at hand) of hierarchy elements might not be distributed uniformly within one level. Karloff and Shirley address this issue and propose an approach which partly collapses the hierarchy while trying to preserves most of the entropy within the data. Though the approach is not specifically directed at software visualization, it can be applied in this context, for example, as described in their paper, for visualizing webpage visits or directory trees. The paper of Rufiange et al., in contrast, uses the hierarchical modularization to extend NodeTrix (a salable graph visualization approach mixing node-link and matrix elements) to represent compound graphs (a graph plus a hierarchy). As demonstrated in the paper, the extended technique is applicable to show the couplings and the modularization of a software system; hierarchy elements can be collapsed to increase the level of abstraction.

  • Maximum Entropy Summary Trees. Howard Karloff and Kenneth Shirley [pdf] [webpage]
Maximum Entropy Summary Tree; Karloff and Shirley

Maximum Entropy Summary Tree; Karloff and Shirley

  • Tree Matrix: A Hybrid Visualization of Compound GraphsSébastien Rufiange, Michael J. McGuffin, Christopher P. Fuhrman [PDF] [video]
Tree Matrix; Rufiange et al.

Tree Matrix; Rufiange et al.

Performance Visualization

A second focal point was the visualization of software performance. The two visualization approaches presented at EuroVis in particular address the question how to deal with many parallel processes. In the context of high-performance computing, Sigovan et al. propose an animated visualization technique that plots the execution times of function calls on a logarithmic scale; the calls “climb” the scale until they are completed. Discerning multiple parallel processes and function types allows detecting interesting execution patterns. For CUDA programming, Rosen studies the execution of parallel processes based on memory behavior instead of function calls; he employs a family of visualization techniques varying in level of abstraction.

  • Visualizing Large-scale Parallel Communication Traces Using a Particle Animation TechniqueCarmen Sigovan, Chris Muelder, Kwan-Liu Ma [PDF]
  • A Visual Approach to Investigating Shared and Global Memory Behavior of CUDA Kernels. Paul Rosen [PDF]
Posted in Conferences, Papers, Research, Uncategorized | Tagged , , , , | Leave a comment

Software Visualization Highlights at ICPC and ICSE 2013

Last week, the software engineering community met in San Francisco for ICSE 2013 to discuss recent advances in the field. Co-located to this big event, ICPC 2013 provided a forum for discussing specific questions on program comprehension. In this post, I summarize the most interesting papers and talks of the two conference from the perspective of software visualization.

DSC04952

ICPC 2013

ICPC started off with an interesting Keynote by Brad Myers on “Improving Program Comprehension by Answering Questions[slides]. He argued for making the programming experience more natural and presented a list of tools that address different issues in this context. He concluded that developers often have very specific questions for which they need tool support. While the code editor is usually the main view for the developer, visualizations mainly help for effectively navigating the code (which is very important as he pointed out). A further key feature of software engineering tools should be search.

The largest session at ICPC containing four papers was related to visualization, The Role of Visualization in Program Comprehension. Thanks to session chair Andrian Marcus, the session was split into two halfs with separate discussions so that the session did not become too long (ICPC had the mode of doing the main discussion at the end of each session, which usually worked quite well).

Whether a software visualization for requirements comprehension outperforms a textual representation was investigated by Sharafi et al. While the results of their user study are hard to interpret as they are ambivalent pro and contra visualization, the paper is a good example for empirical justification that is certainly required more in the context of software visualization.

  • An Empirical Study on the Efficiency of Graphical vs. Textual Representations in Requirements Comprehension. Zohreh Sharafi, Alessandro Marchetto, Angelo Susi, Giuliano Antoniol, and Yann-Gaël Guéhéneuc

Extending the city metaphor, Kobayashi et al. visualize software clustering results and architectural layers within a given package structure. Using this approach, software architectures can be understood and evaluated.

  • SArF Map: Visualizing Software Architecture from Feature and Layer ViewpointsKenichi Kobayashi, Manabu Kamimura, Keisuke Yano, Koki Kato, and Akihiko Matsuo [PDF]

The two other papers addressed the dynamic runtime behavior of software systems: Trümper et al. introduced a visualization technique to compare stack traces for contrasting multiple runs of a program. This technique helps understanding the effect of a code change or different behavior of a program applied to different data sets.

  • Multiscale Visual Comparison of Execution Traces. Jonas Trümper, Jürgen Döllner, and Alexandru Telea [PDF] [Video]

Quite related to that, Beck et al. target the problem of understanding runtime bottlenecks and propose to integrate miniature visualizations into the source code editor showing the runtime consumption of methods.

  • In Situ Understanding of Performance Bottlenecks through Visually Augmented Code. Fabian Beck, Oliver Moseler, Stephan Diehl, and Günter Daniel Rey [PDF]

Also two short papers report research on visualization methods: an approach for simplifying UML class diagrams and a case study on the integration of the software cities metaphor into IDEs.

  • OnionUML: An Eclipse Plug-In for Visualizing UML Class Diagrams in Onion Graph Notation (Tool Demo). Michael Falcone and Bonita Sharif
  • Manhattan: Supporting Real-Time Visual Team Activity AwarenessMichele Lanza, Marco D’Ambros, Alberto Bacchelli, Lile Hattori, and Francesco Rigotti [PDF]

As the most influential paper from 10 years ago, “An XML-Based Lightweight C++ Fact Extractor” by Michael L. Collard, Huzefa Kagdi, and Jonathan I. Maletic was awarded. It was one of the first works of series of papers on srcML, an XML representation of source code accompanied with many tools. The project was not only successfully applied in many projects in the past, but is still actively maintained and even seriously extended. It is a very interesting technology for anybody doing source code analysis, for instance, visualizing source code or aggregates thereof.

ICSE 2013

Being one of the major software engineering events, ICSE had more than 1000 attendees, lots of parallel sessions, many workshops before and after, and covers nearly every topic related to software development. Maybe two people visiting ICSE may have experienced two largely different conferences.  From my personal perspective, I want to highlight a few papers and talks that have are related to visualization or present interesting user interfaces.

Among the three very interesting keynotes, I particularly liked the one by Tony DeRose from Pixar on “The Connection between Movie Making and Software Development“. He talked about the pitfalls and lessons learned developing the new in-house animation software of Pixar, a project as complex and expensive as producing a new blockbuster movie. While the first two tries failed, only applying the movie making metaphor reusing roles and workflow from that domain brought success. People at Pixar directly knew what to do and had strategies to deal with problems. While this approach is probably not directly generalizable to other (non-movie related) businesses, I think specifically the focus on user interfaces and interaction by using sketches and storyboards can be transferred to other software projects.

While none of the papers at ICSE can be rated as a pure software visualization approach, some papers covered certain visualization aspects. For instance, simple graph visualization methods are used for showing clone dependencies between different spreadsheets. Somewhat more complex graph structures help analyzing the flow of domain knowledge in project teams or the clarification process of requirements.

  • Data Clone Detection and Visualization in Spreadsheets. Felienne Hermans, Ben Sedee, Martin Pinzger, and Arie van Deursen [publisher] [PDF]
  • The Role of Domain Knowledge and Cross-Functional Communication in Socio-Technical Coordination. Daniela Damian, Remko Helms, Irwin Kwan, Sabrina Marczak, and Benjamin Koelewijn [publisher]
  • V:ISSUE:LIZER: Exploring Requirements Clarification in Online Communication over Time. Eric Knauss and Daniela Damian [publisher]

From the user interface point of view, a very interesting approach is to use simple drag-and-drop operations for triggering code refactorings. Quite intuitive interactions are proposed for indicating, for instance, move or extract operations.

  • Drag-and-Drop Refactoring: Intuitive and Efficient Program Transformation. Yun Young Lee, Nicholas Chen, and Ralph E. Johnson [publisher] [PDF]

Further, sketching in the context of software engineering seems to get a wider attention of the community. Two of the following papers present tools embedding digital sketching into software engineering workflow. Further, Socha and Tenenberg describe an experiment for analyzing the sketching behavior of software developers in the wild. Being reported as work in progress, unfortunately results could not be presented so far.

  • Dynamic Injection of Sketching Features into GEF Based Diagram Editors. Andreas Scharf and Till Amma [publisher]
  • Enabling a Classroom Design Studio with a Collaborative Sketch Design Tool. Dastyni Loksa, Nicolas Mangano, Thomas D. LaToza, and André van der Hoek [publisher]
  • Sketching Software in the Wild. David Socha and Josh Tenenberg [publisher]

Related to using sketches in the wild, the same questions arise for using UML in the wild. As extracted from 50 interviews, many developers actually do not use UML in general while others only apply it informally or partial. UML seems to be more en vogue among academics than in industry.

What is More

Last but not least, some impressions from the beautiful city of San Francisco and Hyatt Hotel where the conference took place. While ICPC conference dinner was in a nice restaurant just around the corner, ICSE dinner was on a boat providing the great opportunity to see San Francisco’s skyline by night. What I learned in both occasions is that, no matter how warm the weather has been during the day, San Francisco can be quite chilly in the evenings.

Posted in Conferences, Uncategorized | Tagged , , , , , , | Leave a comment