High-quality code comments assist developers in program comprehension and maintenance tasks, but ensuring their quality is a difficult task.
Quality is a multi-dimensional concept, therefore it requires a multi-perspective analysis.
We analyze code comments from three perspectives, (i) what academic support is there to assess comment quality, (ii) what are developer commenting practices across languages, and (iii) what are developer concerns regarding code comments.
How to Identify Class Comment Types? A Multi-language Approach for Class Com...Pooja Rani
Most software maintenance and evolution tasks require developers to understand the source code of their software systems.
Software developers usually inspect class comments to gain knowledge about program behavior, regardless of the programming language they are using.
Unfortunately,
(i) different programming languages present language-specific code commenting notations and guidelines; and
(ii) the source code of software projects often lacks comments that adequately describe the class behavior, which complicates program comprehension and evolution activities.
To handle these challenges, this paper investigates the different language-specific class commenting practices of three programming languages: Python, Java, and Smalltalk.
In particular, we systematically analyze the similarities and differences of the information types found in class comments of projects developed in these languages.
Our results confirm that our approach can classify frequent class comment information types with high accuracy for the Python, Java, and Smalltalk programming languages.
We believe this work can help in monitoring and assessing the quality and evolution of code comments in different programming languages, and thus support maintenance and evolution tasks.
Code reviews have been conducted since decades in
software projects, with the aim of improving code quality from
many different points of view. During code reviews, developers are supported by checklists, coding standards and, possibly, by various kinds of static analysis tools. This paper investigates whether warnings highlighted by static analysis tools are taken care of during code reviews and, whether there are kinds of warnings that tend to be removed more than others. Results of a study conducted by mining the Gerrit repository of six Java open source projects indicate that the density of warnings only slightly vary after each review. The overall percentage of warnings removed during reviews is slightly higher than what previous studies found for the overall project evolution history. However, when looking (quantitatively and qualitatively) at specific categories of warnings, we found that during code reviews developers focus on certain kinds of problems. For such
categories of warnings the removal percentage tend to be very high—often above 50% and sometimes 100%. Examples of those are warnings in the imports, regular expression, and type resolution categories. In conclusion, while a broad warning detection might produce way too many false positives, enforcing the removal of certain warnings prior to the patch submission could reduce the
amount of effort provided during the code review process.
What Do Developers Discuss about Code Comments?Pooja Rani
Code comments are important for program compre- hension, development, and maintenance tasks. Given the varying standards for code comments, and their unstructured or semi- structured nature, developers get easily confused (especially novice developers) about which convention(s) to follow, or what tools to use while writing code documentation. Thus, they post related questions on external online sources to seek better commenting practices. In this paper, we analyze code comment discussions on online sources such as Stack Overflow (SO) and Quora to shed some light on the questions developers ask about commenting practices. We apply Latent Dirichlet Allocation (LDA) to identify emerging topics concerning code comments. Then we manually analyze a statistically significant sample set of posts to derive a taxonomy that provides an overview of the developer questions about commenting practices.
Our results highlight that on SO nearly 40% of the questions mention how to write or process comments in documentation tools and environments, and nearly 20% of the questions are about potential limitations and possibilities of documentation tools to add automatically and consistently more information in comments. On the other hand, on Quora, developer questions focus more on background information (35% of the questions) or asking opinions (16% of the questions) about code comments. We found that (i) not all aspects of comments are covered in coding style guidelines, e.g., how to add a specific type of information, (ii) developers need support in learning the syntax and format conventions to add various types of information in comments, and (iii) developers are interested in various automated strategies for comments such as detection of bad comments, or verify comment style automatically, but lack tool support to do that.
PDF: https://arxiv.org/abs/2108.07648
Video: https://youtu.be/EUQINZ38ziU
Replication package: https://doi.org/10.5281/zenodo.5044270
Speculative analysis for comment quality assessmentPooja Rani
Previous studies have shown that high-quality code comments assist developers in program comprehension and maintenance tasks. However, the semi-structured nature of comments, unclear conventions for writing good comments, and the lack of quality assessment tools for all aspects of comments make their evaluation and maintenance a non-trivial problem.
To achieve high-quality comments, we need a deeper understanding of code comment characteristics and the practices developers follow. Our preliminary findings show that developers embed various kinds of information in class comments across programming languages. Still, they face problems in locating relevant guidelines to write consistent and informative comments, verifying the adherence of their comments to the guidelines, and evaluating the overall state of comment quality.
To help developers and researchers in building comment quality assessment tools, we provide: (i) an empirically validated taxonomy of comment convention-related questions from various community forums, (ii) an empirically validated taxonomy of comment information types from various programming languages, (iii) a language independent approach to automatically identify the information types, and (iv) a comment quality taxonomy prepared from a systematic literature review.
What do class comments tell us?An investigation of comment evolution and prac...Pooja Rani
Previous studies have characterized code comments in different programming languages. However, very few studies have focused on the analysis of the information embedded in code comments. None of them compared the developer’s practices to write the comments to the standard guidelines and analyzed these characteristics in the Pharo Smalltalk environment. The class commenting practices have their origins in Smalltalk-80, going back 40 years. Smalltalk offers a brief template for entering a comment for newly-created classes. These templates have evolved over the years, particularly in the Pharo environment.
This paper reports the first empirical study investigating commenting practices in Pharo Smalltalk. We quantitatively and qualitatively analyze class comments of the most recent version of Pharo, to investigate the information types of Pharo comments. Finally, we study the adherence of developer commenting practices to the class template over Pharo versions.
The results show a rapid increase in class comments in the initial three Pharo versions, while in subsequent versions developers added comments to both new and old classes, thus maintaining a similar ratio. Additionally, we found that 23 information types are typically embedded in class comments and only seven of them are present in the latest Pharo class comment template. However, the information types proposed by the standard template tend to be present more often than other types of information. Additionally, we find that a substantial proportion of comments follow the writing style of the template in writing these information types, but written and formatted in a non-uniform way. This suggests the need to standardize the commenting guidelines for formatting the text to ensure a consistent style, and to identify the information easily.
Sealed classes: Developers were excited when this new feature was released in JDK15! They have been in use in other programming languages. Now it’s Java’s turn! See: https://xperti.io/blogs/sealed-classes-java-feature/
High-quality code comments assist developers in program comprehension and maintenance tasks, but ensuring their quality is a difficult task.
Quality is a multi-dimensional concept, therefore it requires a multi-perspective analysis.
We analyze code comments from three perspectives, (i) what academic support is there to assess comment quality, (ii) what are developer commenting practices across languages, and (iii) what are developer concerns regarding code comments.
How to Identify Class Comment Types? A Multi-language Approach for Class Com...Pooja Rani
Most software maintenance and evolution tasks require developers to understand the source code of their software systems.
Software developers usually inspect class comments to gain knowledge about program behavior, regardless of the programming language they are using.
Unfortunately,
(i) different programming languages present language-specific code commenting notations and guidelines; and
(ii) the source code of software projects often lacks comments that adequately describe the class behavior, which complicates program comprehension and evolution activities.
To handle these challenges, this paper investigates the different language-specific class commenting practices of three programming languages: Python, Java, and Smalltalk.
In particular, we systematically analyze the similarities and differences of the information types found in class comments of projects developed in these languages.
Our results confirm that our approach can classify frequent class comment information types with high accuracy for the Python, Java, and Smalltalk programming languages.
We believe this work can help in monitoring and assessing the quality and evolution of code comments in different programming languages, and thus support maintenance and evolution tasks.
Code reviews have been conducted since decades in
software projects, with the aim of improving code quality from
many different points of view. During code reviews, developers are supported by checklists, coding standards and, possibly, by various kinds of static analysis tools. This paper investigates whether warnings highlighted by static analysis tools are taken care of during code reviews and, whether there are kinds of warnings that tend to be removed more than others. Results of a study conducted by mining the Gerrit repository of six Java open source projects indicate that the density of warnings only slightly vary after each review. The overall percentage of warnings removed during reviews is slightly higher than what previous studies found for the overall project evolution history. However, when looking (quantitatively and qualitatively) at specific categories of warnings, we found that during code reviews developers focus on certain kinds of problems. For such
categories of warnings the removal percentage tend to be very high—often above 50% and sometimes 100%. Examples of those are warnings in the imports, regular expression, and type resolution categories. In conclusion, while a broad warning detection might produce way too many false positives, enforcing the removal of certain warnings prior to the patch submission could reduce the
amount of effort provided during the code review process.
What Do Developers Discuss about Code Comments?Pooja Rani
Code comments are important for program compre- hension, development, and maintenance tasks. Given the varying standards for code comments, and their unstructured or semi- structured nature, developers get easily confused (especially novice developers) about which convention(s) to follow, or what tools to use while writing code documentation. Thus, they post related questions on external online sources to seek better commenting practices. In this paper, we analyze code comment discussions on online sources such as Stack Overflow (SO) and Quora to shed some light on the questions developers ask about commenting practices. We apply Latent Dirichlet Allocation (LDA) to identify emerging topics concerning code comments. Then we manually analyze a statistically significant sample set of posts to derive a taxonomy that provides an overview of the developer questions about commenting practices.
Our results highlight that on SO nearly 40% of the questions mention how to write or process comments in documentation tools and environments, and nearly 20% of the questions are about potential limitations and possibilities of documentation tools to add automatically and consistently more information in comments. On the other hand, on Quora, developer questions focus more on background information (35% of the questions) or asking opinions (16% of the questions) about code comments. We found that (i) not all aspects of comments are covered in coding style guidelines, e.g., how to add a specific type of information, (ii) developers need support in learning the syntax and format conventions to add various types of information in comments, and (iii) developers are interested in various automated strategies for comments such as detection of bad comments, or verify comment style automatically, but lack tool support to do that.
PDF: https://arxiv.org/abs/2108.07648
Video: https://youtu.be/EUQINZ38ziU
Replication package: https://doi.org/10.5281/zenodo.5044270
Speculative analysis for comment quality assessmentPooja Rani
Previous studies have shown that high-quality code comments assist developers in program comprehension and maintenance tasks. However, the semi-structured nature of comments, unclear conventions for writing good comments, and the lack of quality assessment tools for all aspects of comments make their evaluation and maintenance a non-trivial problem.
To achieve high-quality comments, we need a deeper understanding of code comment characteristics and the practices developers follow. Our preliminary findings show that developers embed various kinds of information in class comments across programming languages. Still, they face problems in locating relevant guidelines to write consistent and informative comments, verifying the adherence of their comments to the guidelines, and evaluating the overall state of comment quality.
To help developers and researchers in building comment quality assessment tools, we provide: (i) an empirically validated taxonomy of comment convention-related questions from various community forums, (ii) an empirically validated taxonomy of comment information types from various programming languages, (iii) a language independent approach to automatically identify the information types, and (iv) a comment quality taxonomy prepared from a systematic literature review.
What do class comments tell us?An investigation of comment evolution and prac...Pooja Rani
Previous studies have characterized code comments in different programming languages. However, very few studies have focused on the analysis of the information embedded in code comments. None of them compared the developer’s practices to write the comments to the standard guidelines and analyzed these characteristics in the Pharo Smalltalk environment. The class commenting practices have their origins in Smalltalk-80, going back 40 years. Smalltalk offers a brief template for entering a comment for newly-created classes. These templates have evolved over the years, particularly in the Pharo environment.
This paper reports the first empirical study investigating commenting practices in Pharo Smalltalk. We quantitatively and qualitatively analyze class comments of the most recent version of Pharo, to investigate the information types of Pharo comments. Finally, we study the adherence of developer commenting practices to the class template over Pharo versions.
The results show a rapid increase in class comments in the initial three Pharo versions, while in subsequent versions developers added comments to both new and old classes, thus maintaining a similar ratio. Additionally, we found that 23 information types are typically embedded in class comments and only seven of them are present in the latest Pharo class comment template. However, the information types proposed by the standard template tend to be present more often than other types of information. Additionally, we find that a substantial proportion of comments follow the writing style of the template in writing these information types, but written and formatted in a non-uniform way. This suggests the need to standardize the commenting guidelines for formatting the text to ensure a consistent style, and to identify the information easily.
Sealed classes: Developers were excited when this new feature was released in JDK15! They have been in use in other programming languages. Now it’s Java’s turn! See: https://xperti.io/blogs/sealed-classes-java-feature/
Documenting Code - Patterns and Anti-patterns - NLPW 2016Søren Lund
How do we document code? A good solution is to create self-explanatory code; this somewhat eliminates the need to document the code. We still need some very basic documentation. Code comments are one form of documentation, that is often misused. This talk is about self-explanatory code, the documentation we need and code comment patterns and anti-patterns.
API Workshop: Deep dive into code samplesTom Johnson
See http://idratherbewriting.com for more details. This was the third slidedeck I used in my presentation. Most of these slides repeat what I presented as a soap! conference webinar in Poland.
How do we document code? A good solution is to create self-explanatory code; this somewhat eliminates the need to document the code. We still need some very basic documentation. Code comments are one form of documentation, that is often misused. This talk is about self-explanatory code, the documentation we need and code comment patterns and anti-patterns.
CMDLets, scripts, functions, methods and modules all make PowerShell sound very complicated however with some simple guidelines you too can become a PowerShell automation Pro!
CommonJS via PINF JavaScript Loader - Introductioncadorn
The PINF JavaScript Loader is one extrapolated interpretation of the CommonJS standards that realizes the dream of portable JavaScript applications composed of libraries from all over the internet today. You don't need to wait for platform implementors to incorporate CommonJS standards. By building on PINF you bring CommonJS with you and in the process build momentum for CommonJS.
Christoph will give us a brief overview of CommonJS and then dive deep into PINF for JavaScript. He will communicate the motivation behind PINF and where it fits into the CommonJS community outlined above. You will walk away with practical advice you can apply immediately to build CommonJS based applications and libraries for production deployment.
This presentation is a part of the COP2271C college level course taught at the Florida Polytechnic University located in Lakeland Florida. The purpose of this course is to introduce Freshmen students to both the process of software development and to the Python language.
The course is one semester in length and meets for 2 hours twice a week. The Instructor is Dr. Jim Anderson.
A video of Dr. Anderson using these slides is available on YouTube at:
https://youtu.be/KcFCcCsn6mM
Java Programming - Java is a general-purpose computer-programming language that is concurrent, class-based, object-oriented, and specifically designed to have as few implementation dependencies as possible.
My presentation at Web2Expo, NYC 2009 - on Building a Successful Developer Community. Included is tips on building your community, your site, SEO tips, free products to help, and more.
Writing code that works and writing code that other people can read and understand are two different skills. And writing code that other people can read and understand became more and more essential skills as the project grows larger, and more people start working on it.
But because it is a skill, you need to train it consciously. It's a lot like writing essays and books. Everybody can write letters and words; many can also connect them in grammatically correct sentences. But not everybody is a J. R. R. R. Tolkien and have their books read by everyone.
An essential part of learning this skill is reading and analyzing other people's code on the one hand. And making other people read your code and give you feedback about it.
The speaker will talk about different methods of how to make programmers better writers and how to work out the skill of writing code that other people will want to read.
APIs at Scale with TypeSpec by Mandy Whaley, MicrosoftNordic APIs
A presentation given by Mandy Whaley, Partner Director of Product, Azure Developer Tools at Microsoft, at our 2024 Austin API Summit, March 12-13.
Session Description:
TypeSpec is a new API description language developed and used by Microsoft to deliver APIs at a massive scale. Learn how Microsoft uses TypeSpec to deliver high quality services to millions of customers and across tens of thousands of API endpoints. We will show how to use this new language and the related IDE tooling to encapsulate common API patterns into reusable components, up-level API descriptions with business-specific metadata and behaviors, connect API guidelines to development time activities, maintain API consistency, and generate custom assets, all while interoperating with the OpenAPI ecosystem.
Documenting Code - Patterns and Anti-patterns - NLPW 2016Søren Lund
How do we document code? A good solution is to create self-explanatory code; this somewhat eliminates the need to document the code. We still need some very basic documentation. Code comments are one form of documentation, that is often misused. This talk is about self-explanatory code, the documentation we need and code comment patterns and anti-patterns.
API Workshop: Deep dive into code samplesTom Johnson
See http://idratherbewriting.com for more details. This was the third slidedeck I used in my presentation. Most of these slides repeat what I presented as a soap! conference webinar in Poland.
How do we document code? A good solution is to create self-explanatory code; this somewhat eliminates the need to document the code. We still need some very basic documentation. Code comments are one form of documentation, that is often misused. This talk is about self-explanatory code, the documentation we need and code comment patterns and anti-patterns.
CMDLets, scripts, functions, methods and modules all make PowerShell sound very complicated however with some simple guidelines you too can become a PowerShell automation Pro!
CommonJS via PINF JavaScript Loader - Introductioncadorn
The PINF JavaScript Loader is one extrapolated interpretation of the CommonJS standards that realizes the dream of portable JavaScript applications composed of libraries from all over the internet today. You don't need to wait for platform implementors to incorporate CommonJS standards. By building on PINF you bring CommonJS with you and in the process build momentum for CommonJS.
Christoph will give us a brief overview of CommonJS and then dive deep into PINF for JavaScript. He will communicate the motivation behind PINF and where it fits into the CommonJS community outlined above. You will walk away with practical advice you can apply immediately to build CommonJS based applications and libraries for production deployment.
This presentation is a part of the COP2271C college level course taught at the Florida Polytechnic University located in Lakeland Florida. The purpose of this course is to introduce Freshmen students to both the process of software development and to the Python language.
The course is one semester in length and meets for 2 hours twice a week. The Instructor is Dr. Jim Anderson.
A video of Dr. Anderson using these slides is available on YouTube at:
https://youtu.be/KcFCcCsn6mM
Java Programming - Java is a general-purpose computer-programming language that is concurrent, class-based, object-oriented, and specifically designed to have as few implementation dependencies as possible.
My presentation at Web2Expo, NYC 2009 - on Building a Successful Developer Community. Included is tips on building your community, your site, SEO tips, free products to help, and more.
Writing code that works and writing code that other people can read and understand are two different skills. And writing code that other people can read and understand became more and more essential skills as the project grows larger, and more people start working on it.
But because it is a skill, you need to train it consciously. It's a lot like writing essays and books. Everybody can write letters and words; many can also connect them in grammatically correct sentences. But not everybody is a J. R. R. R. Tolkien and have their books read by everyone.
An essential part of learning this skill is reading and analyzing other people's code on the one hand. And making other people read your code and give you feedback about it.
The speaker will talk about different methods of how to make programmers better writers and how to work out the skill of writing code that other people will want to read.
APIs at Scale with TypeSpec by Mandy Whaley, MicrosoftNordic APIs
A presentation given by Mandy Whaley, Partner Director of Product, Azure Developer Tools at Microsoft, at our 2024 Austin API Summit, March 12-13.
Session Description:
TypeSpec is a new API description language developed and used by Microsoft to deliver APIs at a massive scale. Learn how Microsoft uses TypeSpec to deliver high quality services to millions of customers and across tens of thousands of API endpoints. We will show how to use this new language and the related IDE tooling to encapsulate common API patterns into reusable components, up-level API descriptions with business-specific metadata and behaviors, connect API guidelines to development time activities, maintain API consistency, and generate custom assets, all while interoperating with the OpenAPI ecosystem.
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
Key Trends Shaping the Future of Infrastructure.pdfCheryl Hung
Keynote at DIGIT West Expo, Glasgow on 29 May 2024.
Cheryl Hung, ochery.com
Sr Director, Infrastructure Ecosystem, Arm.
The key trends across hardware, cloud and open-source; exploring how these areas are likely to mature and develop over the short and long-term, and then considering how organisations can position themselves to adapt and thrive.
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.
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
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
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.
Builder.ai Founder Sachin Dev Duggal's Strategic Approach to Create an Innova...Ramesh Iyer
In today's fast-changing business world, Companies that adapt and embrace new ideas often need help to keep up with the competition. However, fostering a culture of innovation takes much work. It takes vision, leadership and willingness to take risks in the right proportion. Sachin Dev Duggal, co-founder of Builder.ai, has perfected the art of this balance, creating a company culture where creativity and growth are nurtured at each stage.
Leading Change strategies and insights for effective change management pdf 1.pdf
Comment soup with a pinch of types, served in a leaky bowl
1. Comment soup
with a pinch of types,
served in a leaky bowl
Pooja Rani
Manuel Leuenberger
Software Composition Group
Bern, Switzerland
2. !2
A Pinch of Types
The Leaky Bowl
How gradual types can
be useful for migration
A startling encounter
in the VM world
The Comment Soup
How do comments evolve?
How do developers
write comments?
3. How do developers write comments?
How do class comments evolve over time?
What is the impact of template on the comments?
What information is present in class comments?
What is the writing style of developers?
!3
6. !6
Note that to encode a String as Base64, you first
have to encode the characters as bytes using a
character encoder.
See also http://en.wikipedia.org/wiki/Base64
Part of Zinc HTTP Components.
Warning
Link
Dependency
7. !7
Wow! I am the biezer shape 4 4 control points.
Maybe we need roassal3 now with a better system for
bezier lines
Excitement,
Future discussion
8. !8
/**
* Options for connecting through a proxy
*
* Note that not all types may be supported,
depending on
* the platform and compilation options.
*/
Missing Java
documentation
13. How do developers write comments?
How do class comments evolve over time?
What is the impact of template on the comments?
What information is present in class comments?
What is the writing style of developers?
!13
15. Evolution of Class Comments
!15
Pharo versions
#Classes
1 2 3 4 5 6 7
Without comments
With comments
16. How do developers write comments?
How do class comments evolve over time?
What is the impact of template on the comments?
What information is present in class comments?
What is the writing style of developers?
!16
18. !18
Please comment me using the following template inspired by Class Responsibility
Collaborator (CRC) design:
For the Class part: State a one line summary. For example, "I represent a
paragraph of text".
For the Responsibility part: Three sentences about my main responsibilities -
what I do, what I know.
For the Collaborators Part: State my main collaborators and one line about how
I interact with them.
Public API and Key Messages
- message one
- message two
- (for bonus points) how to create instances.
One simple example is simply gorgeous.
Internal Representation and Key Implementation Points.
Implementation Points
Comment markup?
19. !19
I am an abstract class to define an Item use by a tree data source of Fast
table.
Description
-------------------------------------------------
I define the basics methods needed by a FTTreeDataSource.
I use FTTreeItem to manage my elements and I am use by a FTFastTable.
Public API and Key Messages
-------------------------------------------------
- #data. anObject from: aFTTreeDataSource
This is my constructor that is use by FTTreeDataSource and myself
Example
------------------------------------------------
Should not be instanciate.
Internal Representation and Key Implementation Points.
-------------------------------------------------
Instance Variables
dataSource: I am the dataSource that holds this Item.
children: I am a collection of Items calculate by the item. I contains
the chldren of the Item.
Comment markup!
Key Messages
Intent
23. How do developers write comments?
How do class comments evolve over time?
What is the impact of template on the comments?
What information is present in class comments?
What is the writing style of developers?
!23
24. What information is present in class comments?
!24
Intent
Responsibility Collaborators Public API
Example Internal Details Instance Variable
Dependency Reference to external docs
ClarificationExtension Discourse
Coding guideline
Class References
Warnings
LinksSteps
Precondition
License
Suggestions
Observations
Comment Soup
25. What information is present in class comments?
!25
Intent
Responsibility Collaborators Public API
Example Internal Details Instance Variable
Dependency Reference to external docs
ClarificationExtension Discourse
Coding guideline
Class References
Warnings
LinksSteps
Precondition
License
Suggestions
Observations
Template
Inspired
Extra but
frequent
Extra but
rare
26. How do developers write comments?
How do class comments evolve over time?
What is the impact of template on the comments?
What information is present in class comments?
What is the writing style of developers?
!26
27. !27
Comments of length 2-5 lines, have lengthy sentences
Use first person pronouns
Writing style
Different warning words
No formatting standards followed
Inconsistent parentheses
28. – Penelope J. Corfield
“All people are living histories – which is why
History matters”
39. How to write two lines of
code in two months
!11
40. How to write two lines of
code in two months
- (void) pumpRunLoopEventSendAndSignal:(BOOL)signal {
@autoreleasepool {
...
}
}
!12
41. The Bern Experience
• People put effort in commenting classes, not only for new,
but also old classes
• Comment template impacts developers, structure helps
• The ecosystem needs love
• Dynamically typed does not mean no types
• Deeper integration of code transformation tools
!13