Visualizing the Workflow of Developers [VISSOFT2013]Roberto Minelli
We present an approach to visualize the activities of developers within the IDE, implemented in a tool: DFlow. DFlow records all IDE interactions that occur during a development session and visualizes them through a web-based visualization platform.
Slides used at VISSOFT 2013 (http://icsm2013.tue.nl/VISSOFT)
Visualizing the Workflow of Developers [VISSOFT2013]Roberto Minelli
We present an approach to visualize the activities of developers within the IDE, implemented in a tool: DFlow. DFlow records all IDE interactions that occur during a development session and visualizes them through a web-based visualization platform.
Slides used at VISSOFT 2013 (http://icsm2013.tue.nl/VISSOFT)
DFlow - A Platform to Profile Developers
Roberto Minelli and Michele Lanza REVEAL @ Faculty of Informatics
University of Lugano, Switzerland
http://dflow.inf.usi.ch
Slides used for my PhD dissertation defense (13 November 2017).
Thesis: “Interaction-Aware Development Environments enable novel and in-depth analyses of the behavior of software developers and set the ground to provide developers with effective and actionable support for their activities inside the IDE.”
— Roberto Minelli, 2017
Abstract:
Nowadays, software development is largely carried out using Integrated Development Environments, or IDEs. An IDE is a collection of tools and facilities to support the most diverse software engineering activities, such as writing code, debugging, and program comprehension. The fact that they are integrated enables developers to find all the tools needed for the development in the same place. Each activity is composed of many basic events, such as clicking on a menu item in the IDE, opening a new user interface to browse the source code of a method, or adding a new statement in the body of a method. While working, developers generate thousands of these interactions, that we call fine-grained IDE interaction data. In essence, this data captures the behavior of developers inside the IDE, but it is largely neglected by modern development environments. We believe that this data is a valuable source of information that can be leveraged to enable retrospective analyses and to offer novel support to developers.
In this dissertation we propose the concept of "Interaction-Aware Development Environments": IDEs that collect, mine, and leverage the interactions of developers to support and simplify their workflow. We formulate our thesis as follows: Interaction-Aware Development Environments enable novel and in-depth analyses of the behavior of software developers and set the ground to provide developers with effective and actionable support for their activities inside the IDE. For example, by monitoring how developers navigate source code, the IDE could suggest the program entities that are potentially relevant for a particular task.
Our research focuses on three main directions:
1. Modeling and Persisting Interaction Data.
2. Interpreting Interaction Data.
3. Supporting Developers with Interaction Data.
Dissertation Committee:
– Prof. Michele Lanza, Università della Svizzera italiana, Switzerland (Research Advisor)
– Dr. Andrea Mocci, Università della Svizzera italiana, Switzerland (Research Co-Advisor)
– Prof. Matthias Hauswirth, Università della Svizzera italiana, Switzerland (Internal Member)
– Prof. Cesare Pautasso, Università della Svizzera italiana, Switzerland (Internal Member)
– Prof. Serge Demeyer, University of Antwerp, Belgium (External Member)
– Prof. Radu Marinescu, University of Timisoara, Romania (External Member)
Navigate, Understand, Communicate: How Developers Locate Performance BugsSebastian Baltes
Background: Performance bugs can lead to severe issues regarding computation efficiency, power consumption, and user experience. Locating these bugs is a difficult task because developers have to judge for every costly operation whether runtime is consumed necessarily or unnecessarily. Objective: We wanted to investigate how developers, when locating performance bugs, navigate through the code, understand the program, and communicate the detected issues.
Method: We performed a qualitative user study observing twelve developers trying to fix documented performance bugs in two open source projects. The developers worked with a profiling and analysis tool that visually depicts runtime information in a list representation and embedded into the source code view.
Results: We identified typical navigation strategies developers used for pinpointing the bug, for instance, following method calls based on runtime consumption. The integration of visualization and code helped developers to understand the bug. Sketches visualizing data structures and algorithms turned out to be valuable for externalizing and communicating the comprehension process for complex bugs.
Conclusion: Fixing a performance bug is a code comprehension and navigation problem. Flexible navigation features based on executed methods and a close integration of source code and performance information support the process.
Developers use Integrated Development Environments (IDEs) to maintain and evolve software systems. IDEs facilitate development activities such as navigating, reading, understanding, and writing source code. Development activities are composed of many basic events, such as browsing the source code of a method or editing the body of a method. We call these actions “interaction data”. We believe that collecting, processing, and exploiting these interactions at run-time can potentially augment the productivity of developers.
Our goal is to create self-adaptive IDEs: IDEs that collect, mine, and leverage the interactions of developers to better support the developers’ workflow. We envision a development environment that automatically and seamlessly adapts itself to support developers while maintaining and evolving software systems. To reach our goal, we will develop means to reshape the user interface of the IDE, interaction-based recommenders, and integrate live and adaptive visualizations inside the IDE.
As a first step towards our vision, we have developed DFlow, a tool that non-intrusively records all IDE interactions while a developer is programming. At the moment DFlow collects all the interactions between the developer and the IDE, and enables retrospective analysis by means of software visualizations.
Ever wondered about Developer Experience (DevEx) and how it can truly impact your work? Join us for a chat where we break down what DevEx is and why it's relevant for everyone, not just devs. DevsOps and productivity expert Dr. Nicole Forsgren will reveal how DevEx can ignite cultural change and deliver real results in today's rapid software development landscape, backed by the latest research findings. She will share how Microsoft is leveraging a DevEx perspective to drive cultural shifts and enable AI-powered innovations that make expertise available to all teams. It's not just about code; it's about fostering better vibes and achieving outstanding outcomes for all. Don't miss out on this journey into the magic of DevEx.
NDC Sydney 2019 - Microservices for building an IDE – The innards of JetBrain...Maarten Balliauw
Ever wondered how IDE’s are built? In this talk, we’ll skip the marketing bit and dive into the architecture and implementation of JetBrains Rider.
We’ll look at how and why we have built (and open sourced) a reactive protocol, and how the IDE uses a “microservices” architecture to communicate with the debugger, Roslyn, a WPF renderer and even other tools like Unity3D. We’ll explore how things are wired together, both in-process and across those microservices. Let’s geek out!
Guerrilla Usability: Insight on a ShoestringDavid Sturtz
Presented at Iowa Code Camp, May 2010: Iterative and Agile development mean shorter cycles and a desperate need for quick feedback. Luckily, improving the user experience of your software doesn’t require days in a lab. This session will present more than twenty-five tools and techniques for gaining insight into your users’ minds and actions.
Introduction to the User Interface domain for business applications, a pattern based approach to model the UI and code generation techniques to make it possible.
Session for Code Generation 2011
The presentation was given to Rivier Scala / Clojure User Group meeting on 10.6.2013. It is half-baked presentation. Will upload the final version when ready.
The first part is about DSLs in general, complexities in software engineering and abstraction. The seconds part presents an quick overview about DSLs in Scala and touches some of the technologies used for deep embedding.
DFlow - A Platform to Profile Developers
Roberto Minelli and Michele Lanza REVEAL @ Faculty of Informatics
University of Lugano, Switzerland
http://dflow.inf.usi.ch
Slides used for my PhD dissertation defense (13 November 2017).
Thesis: “Interaction-Aware Development Environments enable novel and in-depth analyses of the behavior of software developers and set the ground to provide developers with effective and actionable support for their activities inside the IDE.”
— Roberto Minelli, 2017
Abstract:
Nowadays, software development is largely carried out using Integrated Development Environments, or IDEs. An IDE is a collection of tools and facilities to support the most diverse software engineering activities, such as writing code, debugging, and program comprehension. The fact that they are integrated enables developers to find all the tools needed for the development in the same place. Each activity is composed of many basic events, such as clicking on a menu item in the IDE, opening a new user interface to browse the source code of a method, or adding a new statement in the body of a method. While working, developers generate thousands of these interactions, that we call fine-grained IDE interaction data. In essence, this data captures the behavior of developers inside the IDE, but it is largely neglected by modern development environments. We believe that this data is a valuable source of information that can be leveraged to enable retrospective analyses and to offer novel support to developers.
In this dissertation we propose the concept of "Interaction-Aware Development Environments": IDEs that collect, mine, and leverage the interactions of developers to support and simplify their workflow. We formulate our thesis as follows: Interaction-Aware Development Environments enable novel and in-depth analyses of the behavior of software developers and set the ground to provide developers with effective and actionable support for their activities inside the IDE. For example, by monitoring how developers navigate source code, the IDE could suggest the program entities that are potentially relevant for a particular task.
Our research focuses on three main directions:
1. Modeling and Persisting Interaction Data.
2. Interpreting Interaction Data.
3. Supporting Developers with Interaction Data.
Dissertation Committee:
– Prof. Michele Lanza, Università della Svizzera italiana, Switzerland (Research Advisor)
– Dr. Andrea Mocci, Università della Svizzera italiana, Switzerland (Research Co-Advisor)
– Prof. Matthias Hauswirth, Università della Svizzera italiana, Switzerland (Internal Member)
– Prof. Cesare Pautasso, Università della Svizzera italiana, Switzerland (Internal Member)
– Prof. Serge Demeyer, University of Antwerp, Belgium (External Member)
– Prof. Radu Marinescu, University of Timisoara, Romania (External Member)
Navigate, Understand, Communicate: How Developers Locate Performance BugsSebastian Baltes
Background: Performance bugs can lead to severe issues regarding computation efficiency, power consumption, and user experience. Locating these bugs is a difficult task because developers have to judge for every costly operation whether runtime is consumed necessarily or unnecessarily. Objective: We wanted to investigate how developers, when locating performance bugs, navigate through the code, understand the program, and communicate the detected issues.
Method: We performed a qualitative user study observing twelve developers trying to fix documented performance bugs in two open source projects. The developers worked with a profiling and analysis tool that visually depicts runtime information in a list representation and embedded into the source code view.
Results: We identified typical navigation strategies developers used for pinpointing the bug, for instance, following method calls based on runtime consumption. The integration of visualization and code helped developers to understand the bug. Sketches visualizing data structures and algorithms turned out to be valuable for externalizing and communicating the comprehension process for complex bugs.
Conclusion: Fixing a performance bug is a code comprehension and navigation problem. Flexible navigation features based on executed methods and a close integration of source code and performance information support the process.
Developers use Integrated Development Environments (IDEs) to maintain and evolve software systems. IDEs facilitate development activities such as navigating, reading, understanding, and writing source code. Development activities are composed of many basic events, such as browsing the source code of a method or editing the body of a method. We call these actions “interaction data”. We believe that collecting, processing, and exploiting these interactions at run-time can potentially augment the productivity of developers.
Our goal is to create self-adaptive IDEs: IDEs that collect, mine, and leverage the interactions of developers to better support the developers’ workflow. We envision a development environment that automatically and seamlessly adapts itself to support developers while maintaining and evolving software systems. To reach our goal, we will develop means to reshape the user interface of the IDE, interaction-based recommenders, and integrate live and adaptive visualizations inside the IDE.
As a first step towards our vision, we have developed DFlow, a tool that non-intrusively records all IDE interactions while a developer is programming. At the moment DFlow collects all the interactions between the developer and the IDE, and enables retrospective analysis by means of software visualizations.
Ever wondered about Developer Experience (DevEx) and how it can truly impact your work? Join us for a chat where we break down what DevEx is and why it's relevant for everyone, not just devs. DevsOps and productivity expert Dr. Nicole Forsgren will reveal how DevEx can ignite cultural change and deliver real results in today's rapid software development landscape, backed by the latest research findings. She will share how Microsoft is leveraging a DevEx perspective to drive cultural shifts and enable AI-powered innovations that make expertise available to all teams. It's not just about code; it's about fostering better vibes and achieving outstanding outcomes for all. Don't miss out on this journey into the magic of DevEx.
NDC Sydney 2019 - Microservices for building an IDE – The innards of JetBrain...Maarten Balliauw
Ever wondered how IDE’s are built? In this talk, we’ll skip the marketing bit and dive into the architecture and implementation of JetBrains Rider.
We’ll look at how and why we have built (and open sourced) a reactive protocol, and how the IDE uses a “microservices” architecture to communicate with the debugger, Roslyn, a WPF renderer and even other tools like Unity3D. We’ll explore how things are wired together, both in-process and across those microservices. Let’s geek out!
Guerrilla Usability: Insight on a ShoestringDavid Sturtz
Presented at Iowa Code Camp, May 2010: Iterative and Agile development mean shorter cycles and a desperate need for quick feedback. Luckily, improving the user experience of your software doesn’t require days in a lab. This session will present more than twenty-five tools and techniques for gaining insight into your users’ minds and actions.
Introduction to the User Interface domain for business applications, a pattern based approach to model the UI and code generation techniques to make it possible.
Session for Code Generation 2011
The presentation was given to Rivier Scala / Clojure User Group meeting on 10.6.2013. It is half-baked presentation. Will upload the final version when ready.
The first part is about DSLs in general, complexities in software engineering and abstraction. The seconds part presents an quick overview about DSLs in Scala and touches some of the technologies used for deep embedding.
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
UiPath Test Automation using UiPath Test Suite series, part 4DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 4. In this session, we will cover Test Manager overview along with SAP heatmap.
The UiPath Test Manager overview with SAP heatmap webinar offers a concise yet comprehensive exploration of the role of a Test Manager within SAP environments, coupled with the utilization of heatmaps for effective testing strategies.
Participants will gain insights into the responsibilities, challenges, and best practices associated with test management in SAP projects. Additionally, the webinar delves into the significance of heatmaps as a visual aid for identifying testing priorities, areas of risk, and resource allocation within SAP landscapes. Through this session, attendees can expect to enhance their understanding of test management principles while learning practical approaches to optimize testing processes in SAP environments using heatmap visualization techniques
What will you get from this session?
1. Insights into SAP testing best practices
2. Heatmap utilization for testing
3. Optimization of testing processes
4. Demo
Topics covered:
Execution from the test manager
Orchestrator execution result
Defect reporting
SAP heatmap example with demo
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
Elevating Tactical DDD Patterns Through Object CalisthenicsDorra BARTAGUIZ
After immersing yourself in the blue book and its red counterpart, attending DDD-focused conferences, and applying tactical patterns, you're left with a crucial question: How do I ensure my design is effective? Tactical patterns within Domain-Driven Design (DDD) serve as guiding principles for creating clear and manageable domain models. However, achieving success with these patterns requires additional guidance. Interestingly, we've observed that a set of constraints initially designed for training purposes remarkably aligns with effective pattern implementation, offering a more ‘mechanical’ approach. Let's explore together how Object Calisthenics can elevate the design of your tactical DDD patterns, offering concrete help for those venturing into DDD for the first time!
Accelerate your Kubernetes clusters with Varnish CachingThijs Feryn
A presentation about the usage and availability of Varnish on Kubernetes. This talk explores the capabilities of Varnish caching and shows how to use the Varnish Helm chart to deploy it to Kubernetes.
This presentation was delivered at K8SUG Singapore. See https://feryn.eu/presentations/accelerate-your-kubernetes-clusters-with-varnish-caching-k8sug-singapore-28-2024 for more details.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
When stars align: studies in data quality, knowledge graphs, and machine lear...
Tackling Software Navigation Issues of the Smalltalk IDE
1. Tackling Software Navigation Issues of the Smalltalk IDE David R öthlisberger , Oscar Nierstrasz, Alexandre Bergel and Stéphane Ducasse University of Bern, Switzerland Universidad de Chile, Chile INRIA-Lille Nord Europe, France
2. Navigation of Source Space to gain understanding, to locate the cause of a defect, to implement new features, or to refactor
5. Problem Indicators - Much navigation required to locate broken artifacts. - Many windows opened, many switches between windows - Many source entities visited over and over again Task: Defect correction by 20 different developers during 30 minutes Number of window switches: 38.85 Number of entities revisited: 35.10 (45%) Edit / Navigation ratio 2.85% Number of navigation actions until first edit 52.14 Number of navigation actions between two edits 19.31
6. How to improve software navigation? What is missing in the IDE?
7. Working Sets Runtime Information Distributed Code Window Plague Hidden Dependencies