Programmers love science! At least, so they say. Because when it comes to the ‘science’ of developing code, the most used tool is brutal debate. Vim versus emacs, static versus dynamic typing, Java versus C#, this can go on for hours at end. In this session, software engineering professor Felienne Hermans will present the latest research in software engineering that tries to understand and explain what programming methods, languages and tools are best suited for different types of development.
Felienne Hermans presented an overview of her PhD research on analyzing and visualizing spreadsheets. She found that spreadsheets are complex and often lack documentation, leading to errors. To address this, she developed a tool called Breviz that visualizes spreadsheet dependencies and applied methods from software engineering to identify smells. Users found Breviz helpful for understanding spreadsheets. Hermans' work was published in several conferences and aims to bridge the gap between how important spreadsheets are and how well they are treated.
Small, simple and smelly: What we can learn from examining end-user artifacts?Felienne Hermans
We are close to a future in which everyone can and will program. Whether it is some Javascript, some R or an extensive spreadsheet, programming happens everywhere. What do end-users do in the wild? And what can we learn from that as programming language designers?
In this talk Felienne will summarize her research on the topic of end-user testing, error finding and refactoring, as well as presenting a sneak peek into the future of her research as Delft University.
Conference presentations are the moment to share your results, and to connect with researchers about future directions. However, presentations are often created as an afterthought and as a result they are often not as exciting as they could be.
In this slidedeck Felienne Hermans shares hands-on techniques to engage an audience.
The talk covers the entire spectrum of presenting: we start with advice on how to structure a talk and how to incorporate a core message into it. Once we have addressed the right structure for a talk, we will work on adding stories and arcs of tension to your presentation. Finally, to really perform as a presenter, we will talk about how slide design and body language can support your presentation.
Sandro Mancuso - Software Craftmanship @ I T.A.K.E. Unconference 2013, BucharestMozaic Works
1) Software Craftsmanship focuses on producing well-crafted, high-quality software through practices like automated testing, test-driven development, and pair programming.
2) It values not only working software and responding to change, but also steadily adding value and a community of skilled professionals.
3) Being a software craftsman requires continuously improving one's skills through practice and experience over many years to master the craft of software development.
Writing code is easy but writing maintainable code is almost impossible. During this talk I will discuss some of the principles of coding that relates to WordPress but goes beyond that.
The following lessons present the knowledge needed to become proficient in creating, evaluating, comparing, and using quantitative methods for forecasting purposes. Each lesson will introduce a concept or method followed by an example.
The document discusses ways for developers to contribute to open source projects. It recommends starting by learning Git and fixing bugs or documenting features for projects you use. It also suggests answering questions on Stack Overflow and IRC channels. Once comfortable, developers can open source their own projects and accept contributions from others. The document notes maintaining open source projects requires responding promptly to issues but not feeling pressured to fix everything immediately. It also discusses choosing an open source license and signing contributor license agreements.
Felienne Hermans presented an overview of her PhD research on analyzing and visualizing spreadsheets. She found that spreadsheets are complex and often lack documentation, leading to errors. To address this, she developed a tool called Breviz that visualizes spreadsheet dependencies and applied methods from software engineering to identify smells. Users found Breviz helpful for understanding spreadsheets. Hermans' work was published in several conferences and aims to bridge the gap between how important spreadsheets are and how well they are treated.
Small, simple and smelly: What we can learn from examining end-user artifacts?Felienne Hermans
We are close to a future in which everyone can and will program. Whether it is some Javascript, some R or an extensive spreadsheet, programming happens everywhere. What do end-users do in the wild? And what can we learn from that as programming language designers?
In this talk Felienne will summarize her research on the topic of end-user testing, error finding and refactoring, as well as presenting a sneak peek into the future of her research as Delft University.
Conference presentations are the moment to share your results, and to connect with researchers about future directions. However, presentations are often created as an afterthought and as a result they are often not as exciting as they could be.
In this slidedeck Felienne Hermans shares hands-on techniques to engage an audience.
The talk covers the entire spectrum of presenting: we start with advice on how to structure a talk and how to incorporate a core message into it. Once we have addressed the right structure for a talk, we will work on adding stories and arcs of tension to your presentation. Finally, to really perform as a presenter, we will talk about how slide design and body language can support your presentation.
Sandro Mancuso - Software Craftmanship @ I T.A.K.E. Unconference 2013, BucharestMozaic Works
1) Software Craftsmanship focuses on producing well-crafted, high-quality software through practices like automated testing, test-driven development, and pair programming.
2) It values not only working software and responding to change, but also steadily adding value and a community of skilled professionals.
3) Being a software craftsman requires continuously improving one's skills through practice and experience over many years to master the craft of software development.
Writing code is easy but writing maintainable code is almost impossible. During this talk I will discuss some of the principles of coding that relates to WordPress but goes beyond that.
The following lessons present the knowledge needed to become proficient in creating, evaluating, comparing, and using quantitative methods for forecasting purposes. Each lesson will introduce a concept or method followed by an example.
The document discusses ways for developers to contribute to open source projects. It recommends starting by learning Git and fixing bugs or documenting features for projects you use. It also suggests answering questions on Stack Overflow and IRC channels. Once comfortable, developers can open source their own projects and accept contributions from others. The document notes maintaining open source projects requires responding promptly to issues but not feeling pressured to fix everything immediately. It also discusses choosing an open source license and signing contributor license agreements.
The document discusses refactoring legacy code for a client project. It describes steps taken to refactor code for searching products and handling file attachments. For searching, the speaker extracted parameters from a method with 21 parameters and 200 lines of code into a builder pattern. For attachments, switch statements were replaced with polymorphism, and file processing logic was extracted from a service into separate classes. The refactoring was done incrementally using test-driven development practices learned at coderetreats. Tests were added to verify changes at each step, and over 30 commits were made. The refactoring provided value to customers while improving code quality and maintainability.
This document discusses Command Query Responsibility Segregation (CQRS). CQRS separates commands and queries in an application by using different models for reading and writing data. This improves separation of concerns and allows for greater scalability. While CQRS requires upfront work to set up the infrastructure, it results in simpler domain models and a complete rebuild of application state is possible through event sourcing. The document provides examples of how to implement CQRS and addresses some common misconceptions.
Workshop from I T.A.K.E. Unconference 2014 on how to lead technical teams.
Topics covered:
- Five duties of technical leaders
- Change management process
- How to communicate effectively
Tom Gilb - Power to the Programmers @ I T.A.K.E. Unconference 2014, BucharestMozaic Works
Tom Gilb, an independent teacher, consultant and writer.
He was a keynote speaker at I T.A.K.E. Unconference 2014 (http://2014.itakeunconf.com/)
He talked about:
- architecture than can be made better by developers
- how one can get quality by designing it in, not by debugging it
- that engineering is defined by multidimensional problem solving.
www.mozaicworks.com
BDD with Cucumber-JVM as presented at I T.A.K.E. Unconference in Bucharest 2014TSundberg
Behaviour Driven Development, BDD, is a way to increase communication between stakeholders in a project and at the same time create executable examples.
Tools needed to build a Continuous delivery pipeline. Most tools are generic and can be used regardless of language, some are specific for Java/JVM.
http://2014.itakeunconf.com/
(IMPROVED VERSION FROM GEECON)
How can we quickly tell what an application is about? How can we quickly tell what it does? How can we distinguish business concepts from architecture clutter? How can we quickly find the code we want to change? How can we instinctively know where to add code for new features? Purely looking at unit tests is either not possible or too painful. Looking at higher-level tests can take a long time and still not give us the answers we need. For years, we have all struggled to design and structure projects that reflect the business domain.
In this talk Sandro will be sharing how he designed the last application he worked on, twisting a few concepts from Domain-Driven Design, properly applying MVC, borrowing concepts from CQRS, and structuring packages in non-conventional ways. Sandro will also be touching on SOLID principles, Agile incremental design, modularisation, and testing. By iteratively modifying the project structure to better model the application requirements, he has come up with a design style that helps developers create maintainable and domain-oriented software.
Erik talboom - TDD as if The Baby Meant it @I T.A.K.E. Unconference 2013, Buc...Mozaic Works
The document discusses test-driven development (TDD) principles and techniques. It outlines an approach to TDD involving writing one failing test at a time, making it pass with just enough code, and refactoring within time limits. Key aspects include pair programming, following the four elements of simple design, and taking "baby steps" with a timer to focus on small, frequent changes.
Sandro Mancuso – Testing and refactoring legacy code @ I T.A.K.E. Unconferenc...Mozaic Works
The document discusses refactoring legacy code for a social networking website for travelers. It describes business requirements where users must be logged in to see content and be friends to see others' trips. When refactoring production code, tests must be added first and refactoring should start from the deepest code branches and move outward. Tests should also be added from the shortest code branches outward. Tips are provided on writing clean, readable code and tests in small, safe increments with frequent commits while embracing changes.
Thesis: Slicing of Java Programs using the Soot Framework (2006) Arvind Devaraj
A Static Slicing Tool for sequential Java programs
Masters thesis at IISc
Specialization topics: Compiler Design / Program Analysis / Pointer analysis / Java program optimization
Slicing is a technique used to identify the program subset that could affect a particular statement of interest called the slicing criterion. Slicing has applications in program understanding, testing, model checking and functionality extraction. For computing a slice, we need to compute dependence information among statements. In object oriented languages, finding dependence information becomes non-trivial because of language features like inheritance, objects, polymorphism, dynamic binding and so forth. We develop a method for computing slices in object oriented programs for application in regression testing. In particular we propose a new method for intraprocedural alias analysis for Java and implement an interprocedural slicing technique using the system dependence graph of Horwitz et al. 1
Simplifying your design with higher-order functionsSamir Talwar
The document discusses simplifying code design through higher-order functions. It notes that behavior can be treated as data and data persists. It also includes a quote about perfection being reached not when you add more but when you remove things.
I T.A.K.E. talk: "When DDD meets FP, good things happen"Cyrille Martraire
Domain-Driven Design (DDD) and Functional Programming (FP) have a lot of good things in common: DDD has borrowed many ideas from the FP community, and both share a common inspiration on established formalisms like maths.
For the software developer, the result is a style of code that mixes the best of DDD, OO and FP. Even in non functional languages like Java or C#, this combined set of practices helps craft simple and powerful code that reads well and that is very easy to test.
In this talk we will have a closer look at some of these ideas, in the context of domain models inspired from real-world projects. From basic FP hygiene like immutability and closure of operations to more mathematical inspirations from abstract algebra like monoids, we will show how all that translates into beautiful code.
WARNING: This may influence your coding style…
This talk was presented on the first day of I T.A.K.E. 2013 at Bucharest http://itakeunconf.com/
The document provides an overview of a content management system (CMS) website project developed using PHP. It includes information on the company developing the project, an introduction to PHP and why it was chosen, how PHP works, what a CMS is and its features. It describes the project scope as providing consistent quality content and services. The technologies used are MySQL, nginx, PHP, JavaScript and a CMS. Software tools include XAMPP, CloudFlare, Google Chrome and Dreamweaver. Screenshots of the home and category pages are also included.
This project includes the features of a database that is adding,deleting,modifying and searching of a required record-are developed using MICROSOFT VISUAL BASIC 6.0 and ORACLE 8.0V
The Good the Bad and the Ugly of Dealing with Smelly Code (ITAKE Unconference)Radu Marinescu
We all have a burning desire to write clean code. Every morning we wake up, look in the mirror, and promise ourselves that today we will follow the principles and best practices learned from Uncle Bob and his disciples. But we live in a cruel environment, surrounded by millions of smelly lines of code, reflections of a stinky design… and these constantly challenge our pure-hearted desire for writing clean code.
In such an environment, the stubbornness to practice daily the writing of clean code is vital.
But is it enough? Can we avoid getting lost in a sea of smelly code and design?
In this talk I will try to persuade you that, in dealing with large-scale systems, craftsmanship must be supported by proper techniques and tools that can help us to quickly understand, assess and improve the sea of smelly design that surrounds us.
I will present a pragmatic approach on how design anti-patterns (e.g. God Class, Feature Envy, Refused Bequest, Shotgun Surgery) can be automatically detected using a set of metrics-based detection rules, by analyzing the history of the system, and by using intriguing software visualizations.
The presentation will also include a live demo of tools that can automate the entire approach to a high-extent. These tools are so robust that they can deal with systems of several million lines of code; but they are also friendly enough to provide you with customized hints that help you deal with each and every case of an “unclean” code.
Computer Science & Information Systems
First attempt to offer a broad view of CS & IS field by comparing and relate its disciplines
Luis Borges Gouveia
November 2013
The document discusses various forms of e-payment systems:
1. Online credit card transactions allow customers to make purchases online using credit cards through a secure connection. Risks include potential disputes and fees for merchants.
2. Digital cash systems allow users to make small online payments by converting funds into digital "coins" through an intermediary like a bank. Coins are spent online and merchants redeem them for funds.
3. Online stored value systems allow users to pre-load funds from a credit card onto an online account, like Ecount, to make purchases from participating merchants through a secure connection.
Electronic payment systems allow customers to make online payments for purchases. There are various types of electronic payment methods, including e-wallets, e-cash, smart cards, and credit cards. E-cash works like real currency with unique serial numbers, while e-wallets store payment information like credit cards. Smart cards can be used for applications such as travel tickets and medical records. Credit cards involve repaying spent amounts later. Payment gateways protect sensitive credit card details during transactions between customers, merchants and payment processors. Electronic payment is growing in India due to technology changes, internet access, and encouragement by the Reserve Bank of India.
This document discusses various data structures in C#, including arrays, lists, queues, stacks, hash tables, and more. It provides code examples and explains the time complexity of common operations for each data structure. Asymptotic analysis and big-O notation are introduced for analyzing how efficiently a data structure handles operations as its size increases.
មេរៀនៈ Data Structure and Algorithm in C/C++Ngeam Soly
This document provides an introduction to a lecture on data structures and algorithms. It discusses the lecturer's contact information and expectations for reading ahead of lectures. It then covers topics that will be discussed in the course, including programs and programming, introduction to programming, crafting programs effectively, what makes a good program, and why data structures and algorithms are important subjects. The document provides an overview of what will be covered in the course.
This document summarizes the internship of Ho Xuan Vinh at Kyoto Institute of Technology aimed at creating a bilingual annotated corpus of Vietnamese-English for machine learning purposes. Vinh experimented with several semantic tagsets, including WordNet, LLOCE, and UCREL, but faced challenges due to the lack of Vietnamese language resources. His goal was to find an effective method for annotating a bilingual corpus to provide training data for natural language processing tasks, but he was unable to validate his annotation approaches due to limitations in the available data and tools.
Inheritance Versus Roles - The In-Depth VersionCurtis Poe
This is the paper to accompany my slides explaining what's wrong with inheritance and how traits (roles) help to solve these issues: http://www.slideshare.net/Ovid/inheritance-versus-roles
The document discusses refactoring legacy code for a client project. It describes steps taken to refactor code for searching products and handling file attachments. For searching, the speaker extracted parameters from a method with 21 parameters and 200 lines of code into a builder pattern. For attachments, switch statements were replaced with polymorphism, and file processing logic was extracted from a service into separate classes. The refactoring was done incrementally using test-driven development practices learned at coderetreats. Tests were added to verify changes at each step, and over 30 commits were made. The refactoring provided value to customers while improving code quality and maintainability.
This document discusses Command Query Responsibility Segregation (CQRS). CQRS separates commands and queries in an application by using different models for reading and writing data. This improves separation of concerns and allows for greater scalability. While CQRS requires upfront work to set up the infrastructure, it results in simpler domain models and a complete rebuild of application state is possible through event sourcing. The document provides examples of how to implement CQRS and addresses some common misconceptions.
Workshop from I T.A.K.E. Unconference 2014 on how to lead technical teams.
Topics covered:
- Five duties of technical leaders
- Change management process
- How to communicate effectively
Tom Gilb - Power to the Programmers @ I T.A.K.E. Unconference 2014, BucharestMozaic Works
Tom Gilb, an independent teacher, consultant and writer.
He was a keynote speaker at I T.A.K.E. Unconference 2014 (http://2014.itakeunconf.com/)
He talked about:
- architecture than can be made better by developers
- how one can get quality by designing it in, not by debugging it
- that engineering is defined by multidimensional problem solving.
www.mozaicworks.com
BDD with Cucumber-JVM as presented at I T.A.K.E. Unconference in Bucharest 2014TSundberg
Behaviour Driven Development, BDD, is a way to increase communication between stakeholders in a project and at the same time create executable examples.
Tools needed to build a Continuous delivery pipeline. Most tools are generic and can be used regardless of language, some are specific for Java/JVM.
http://2014.itakeunconf.com/
(IMPROVED VERSION FROM GEECON)
How can we quickly tell what an application is about? How can we quickly tell what it does? How can we distinguish business concepts from architecture clutter? How can we quickly find the code we want to change? How can we instinctively know where to add code for new features? Purely looking at unit tests is either not possible or too painful. Looking at higher-level tests can take a long time and still not give us the answers we need. For years, we have all struggled to design and structure projects that reflect the business domain.
In this talk Sandro will be sharing how he designed the last application he worked on, twisting a few concepts from Domain-Driven Design, properly applying MVC, borrowing concepts from CQRS, and structuring packages in non-conventional ways. Sandro will also be touching on SOLID principles, Agile incremental design, modularisation, and testing. By iteratively modifying the project structure to better model the application requirements, he has come up with a design style that helps developers create maintainable and domain-oriented software.
Erik talboom - TDD as if The Baby Meant it @I T.A.K.E. Unconference 2013, Buc...Mozaic Works
The document discusses test-driven development (TDD) principles and techniques. It outlines an approach to TDD involving writing one failing test at a time, making it pass with just enough code, and refactoring within time limits. Key aspects include pair programming, following the four elements of simple design, and taking "baby steps" with a timer to focus on small, frequent changes.
Sandro Mancuso – Testing and refactoring legacy code @ I T.A.K.E. Unconferenc...Mozaic Works
The document discusses refactoring legacy code for a social networking website for travelers. It describes business requirements where users must be logged in to see content and be friends to see others' trips. When refactoring production code, tests must be added first and refactoring should start from the deepest code branches and move outward. Tests should also be added from the shortest code branches outward. Tips are provided on writing clean, readable code and tests in small, safe increments with frequent commits while embracing changes.
Thesis: Slicing of Java Programs using the Soot Framework (2006) Arvind Devaraj
A Static Slicing Tool for sequential Java programs
Masters thesis at IISc
Specialization topics: Compiler Design / Program Analysis / Pointer analysis / Java program optimization
Slicing is a technique used to identify the program subset that could affect a particular statement of interest called the slicing criterion. Slicing has applications in program understanding, testing, model checking and functionality extraction. For computing a slice, we need to compute dependence information among statements. In object oriented languages, finding dependence information becomes non-trivial because of language features like inheritance, objects, polymorphism, dynamic binding and so forth. We develop a method for computing slices in object oriented programs for application in regression testing. In particular we propose a new method for intraprocedural alias analysis for Java and implement an interprocedural slicing technique using the system dependence graph of Horwitz et al. 1
Simplifying your design with higher-order functionsSamir Talwar
The document discusses simplifying code design through higher-order functions. It notes that behavior can be treated as data and data persists. It also includes a quote about perfection being reached not when you add more but when you remove things.
I T.A.K.E. talk: "When DDD meets FP, good things happen"Cyrille Martraire
Domain-Driven Design (DDD) and Functional Programming (FP) have a lot of good things in common: DDD has borrowed many ideas from the FP community, and both share a common inspiration on established formalisms like maths.
For the software developer, the result is a style of code that mixes the best of DDD, OO and FP. Even in non functional languages like Java or C#, this combined set of practices helps craft simple and powerful code that reads well and that is very easy to test.
In this talk we will have a closer look at some of these ideas, in the context of domain models inspired from real-world projects. From basic FP hygiene like immutability and closure of operations to more mathematical inspirations from abstract algebra like monoids, we will show how all that translates into beautiful code.
WARNING: This may influence your coding style…
This talk was presented on the first day of I T.A.K.E. 2013 at Bucharest http://itakeunconf.com/
The document provides an overview of a content management system (CMS) website project developed using PHP. It includes information on the company developing the project, an introduction to PHP and why it was chosen, how PHP works, what a CMS is and its features. It describes the project scope as providing consistent quality content and services. The technologies used are MySQL, nginx, PHP, JavaScript and a CMS. Software tools include XAMPP, CloudFlare, Google Chrome and Dreamweaver. Screenshots of the home and category pages are also included.
This project includes the features of a database that is adding,deleting,modifying and searching of a required record-are developed using MICROSOFT VISUAL BASIC 6.0 and ORACLE 8.0V
The Good the Bad and the Ugly of Dealing with Smelly Code (ITAKE Unconference)Radu Marinescu
We all have a burning desire to write clean code. Every morning we wake up, look in the mirror, and promise ourselves that today we will follow the principles and best practices learned from Uncle Bob and his disciples. But we live in a cruel environment, surrounded by millions of smelly lines of code, reflections of a stinky design… and these constantly challenge our pure-hearted desire for writing clean code.
In such an environment, the stubbornness to practice daily the writing of clean code is vital.
But is it enough? Can we avoid getting lost in a sea of smelly code and design?
In this talk I will try to persuade you that, in dealing with large-scale systems, craftsmanship must be supported by proper techniques and tools that can help us to quickly understand, assess and improve the sea of smelly design that surrounds us.
I will present a pragmatic approach on how design anti-patterns (e.g. God Class, Feature Envy, Refused Bequest, Shotgun Surgery) can be automatically detected using a set of metrics-based detection rules, by analyzing the history of the system, and by using intriguing software visualizations.
The presentation will also include a live demo of tools that can automate the entire approach to a high-extent. These tools are so robust that they can deal with systems of several million lines of code; but they are also friendly enough to provide you with customized hints that help you deal with each and every case of an “unclean” code.
Computer Science & Information Systems
First attempt to offer a broad view of CS & IS field by comparing and relate its disciplines
Luis Borges Gouveia
November 2013
The document discusses various forms of e-payment systems:
1. Online credit card transactions allow customers to make purchases online using credit cards through a secure connection. Risks include potential disputes and fees for merchants.
2. Digital cash systems allow users to make small online payments by converting funds into digital "coins" through an intermediary like a bank. Coins are spent online and merchants redeem them for funds.
3. Online stored value systems allow users to pre-load funds from a credit card onto an online account, like Ecount, to make purchases from participating merchants through a secure connection.
Electronic payment systems allow customers to make online payments for purchases. There are various types of electronic payment methods, including e-wallets, e-cash, smart cards, and credit cards. E-cash works like real currency with unique serial numbers, while e-wallets store payment information like credit cards. Smart cards can be used for applications such as travel tickets and medical records. Credit cards involve repaying spent amounts later. Payment gateways protect sensitive credit card details during transactions between customers, merchants and payment processors. Electronic payment is growing in India due to technology changes, internet access, and encouragement by the Reserve Bank of India.
This document discusses various data structures in C#, including arrays, lists, queues, stacks, hash tables, and more. It provides code examples and explains the time complexity of common operations for each data structure. Asymptotic analysis and big-O notation are introduced for analyzing how efficiently a data structure handles operations as its size increases.
មេរៀនៈ Data Structure and Algorithm in C/C++Ngeam Soly
This document provides an introduction to a lecture on data structures and algorithms. It discusses the lecturer's contact information and expectations for reading ahead of lectures. It then covers topics that will be discussed in the course, including programs and programming, introduction to programming, crafting programs effectively, what makes a good program, and why data structures and algorithms are important subjects. The document provides an overview of what will be covered in the course.
This document summarizes the internship of Ho Xuan Vinh at Kyoto Institute of Technology aimed at creating a bilingual annotated corpus of Vietnamese-English for machine learning purposes. Vinh experimented with several semantic tagsets, including WordNet, LLOCE, and UCREL, but faced challenges due to the lack of Vietnamese language resources. His goal was to find an effective method for annotating a bilingual corpus to provide training data for natural language processing tasks, but he was unable to validate his annotation approaches due to limitations in the available data and tools.
Inheritance Versus Roles - The In-Depth VersionCurtis Poe
This is the paper to accompany my slides explaining what's wrong with inheritance and how traits (roles) help to solve these issues: http://www.slideshare.net/Ovid/inheritance-versus-roles
The NLP muppets revolution! @ Data Science London 2019
video: https://skillsmatter.com/skillscasts/13940-a-deep-dive-into-contextual-word-embeddings-and-understanding-what-nlp-models-learn
event: https://www.meetup.com/Data-Science-London/events/261483332/
Word2vec on the italian language: first experimentsVincenzo Lomonaco
Word2vec model and application by Mikolov et al. have attracted a great amount of attention in recent years. The vector representations of words learned by word2vec models have been proven to be able to carry semantic meanings and are useful in various NLP tasks. In this work I try to reproduce the previously obtained results for the English language and to explore the possibility of doing the same for the Italian language.
Gadgets pwn us? A pattern language for CALLLawrie Hunter
The document discusses creating a pattern language for computer-assisted language learning (CALL). It explores the concept of a pattern language as defined by Christopher Alexander and proposes a framework for creating a CALL pattern language in the era of web 2.0. The paper seeks to rework concepts from other fields, like "formal learning design expression" and "task arc," and have participants brainstorm elements to include through graphical challenges. The overall goal is to establish foundational patterns for CALL work.
The document summarizes a working session on software engineering myths held on October 4, 2007 in Paris. The session included discussions of common myths in areas such as complexity, bugs, clones, aspect-oriented programming, and project management. Participants shared and debated myths in small group discussions. Some examples of myths discussed include the ideas that complexity leads to more bugs, clones are always bad, and aspect-oriented programs are inherently easier to maintain. The session aimed to evaluate whether such perceptions are truly myths or if aspects of them have been found to hold true in various studies.
This document summarizes a research paper that explores using multitask prompted training to enable zero-shot task generalization in large language models. The researchers developed a system to convert many natural language tasks into a prompted format. They then fine-tuned a pretrained model on a mixture of these prompted tasks, covering a wide variety of NLP tasks. The model achieved strong zero-shot performance on several benchmark datasets, often outperforming models that were larger in size. Training on more prompts per task consistently improved performance and reduced variability, demonstrating that multitask training can enable better generalization to new tasks without requiring massive scale models.
The document discusses lessons learned from an agile team's experiences improving learning in an agile environment. It describes several practices the team implemented, including open seating to facilitate discussions, pair programming with varied levels of experience, programming on Sundays, brown bag sessions to present various topics, asynchronous discussion lists, blogging, attending and organizing conferences, and building relationships both during and after work. The key lessons are that learning is the base for adapting in agile environments, teaching and sharing knowledge should be mutual, everyone has something to teach, and companies should experiment with different practices to improve learning.
Here are the key points about variable cost:
- Variable cost is a cost that changes in proportion to the amount of goods or services produced. It varies with the level of production or activity.
- Examples of variable costs include direct materials, direct labor, utilities, commissions, etc. These costs change directly with the level of production or sales.
- Fixed costs like rent, insurance, depreciation, etc. remain the same regardless of the level of production in the short run.
- Total variable cost is the sum of all variable costs. It increases as production increases and decreases as production decreases.
- Average variable cost is the total variable cost divided by the quantity produced. It decreases initially as fixed costs
Are you responsible for developing satellite on-board software? Are you the Dutch government and you have to efficiently implement the public benefits law? Are you a healthcare startup, developing companion apps that help patients through a treatment? Are you an insurance company struggling to create new, and evolve existing products quickly to keep up with the market? These are all examples of organisations who have built their own domain-specific programming language to streamline the development of applications that have a non-trivial algorithmic core. All have built their languages with Jetbrains MPS, an open source language development tool optimized for ecosystems of collaborating languages with mixed graphical, textual, tabular and mathematical notations. This talk has four parts. I start by motivating the need for DSLs based on real-world examples, including the ones above. I will then present a few high-level design practices that guide our language development work. Third, I will develop a simple language extension to give you a feel for how MPS works. And finally, I will point you to things you can read to get you started with your own language development practice.
Laure talked about a very hot topic in the community at the moment with the ChatGPT phenomenon: how to supervise a PhD thesis in NLP in the age of Large Language Models (LLMs)?
The document discusses the benefits of using low-fidelity or "lo-fi" prototyping, which involves building prototypes of user interfaces using paper and testing them with real users. Some key benefits are that lo-fi prototyping is very fast, allows designers to iterate and test many ideas early in the design process when changes are less costly, and surfaces issues with a design's core functionality rather than superficial visual aspects. The document provides examples of how lo-fi prototyping was effectively used on a project, spreading an appreciation of usability testing throughout the organization.
Konstantin Knizhnik: static analysis, a view from asidePVS-Studio
The article is an interview with Konstantin Knizhnik taken by Andrey Karpov, "Program Verification Systems" company's worker. In this interview the issues of static code analysis, relevance of solutions made in this sphere and prospects of using static analysis while developing applications are discussed.
Software Citation and a Proposal (NSF workshop at Havard Medical School)James Howison
Presentation at NSF Workshop on Software and Data Citation. Draws from our study of how software is visible in scientific publications (JASIST) and our CSCW paper on BLAST innovation integration.
Three coding experts discuss the importance of readability in code. They emphasize:
1. Code should be written for human readers, with descriptive variable and function names, proper indentation and formatting, and comments explaining purpose not just restating code.
2. Readable code is more likely to be correct and easier to maintain than code written only for computers. Formatting, style, and structure help convey meaning to human readers.
3. Assertions, comments, and documentation help future readers understand code by stating assumptions and intended purpose, not just surface behavior. Readable code supports understanding problem requirements in addition to technical solution.
French machine reading for question answeringAli Kabbadj
This paper proposes to unlock the main barrier to machine reading and comprehension French natural language texts. This open the way to machine to find to a question a precise answer buried in the mass of unstructured French texts. Or to create a universal French chatbot. Deep learning has produced extremely promising results for various tasks in natural language understanding particularly topic classification, sentiment analysis, question answering, and language translation. But to be effective Deep Learning methods need very large training da-tasets. Until now these technics cannot be actually used for French texts Question Answering (Q&A) applications since there was not a large Q&A training dataset. We produced a large (100 000+) French training Dataset for Q&A by translating and adapting the English SQuAD v1.1 Dataset, a GloVe French word and character embed-ding vectors from Wikipedia French Dump. We trained and evaluated of three different Q&A neural network ar-chitectures in French and carried out a French Q&A models with F1 score around 70%.
This is presentation slides of the paper "Attentional Parallel RNNs for Generating Punctuation in Transcribed Speech" in 5th International Conference on Statistical Language and Speech Processing (SLSP 2017)
Abstract
Until very recently, the generation of punctuation marks for automatic speech recognition (ASR) output has been mostly done by looking at the syntactic structure of the recognized utterances. Prosodic cues such as breaks, speech rate, pitch intonation that influence placing of punctuation marks on speech transcripts have been seldom used. We propose a method that uses recurrent neural networks, taking prosodic and lexical information into account in order to predict punctuation marks for raw ASR output. Our experiments show that an attention mechanism over parallel sequences of prosodic cues aligned with transcribed speech improves accuracy of punctuation generation.
Using F# and genetic programming to play computer bridgeFelienne Hermans
This document is a presentation slide deck on using domain-specific languages (DSLs) and genetic programming to develop a computer bridge bidding system in F#. It introduces concepts like defining a DSL for representing bridge hands and bids, using genetic programming to evolve rules for evaluating hands and determining bids, and some tips for effective DSL design like keeping the language simple and leveraging language features.
This talk is about the world's most popular programming language... Java? Python? COBOL?
No... Excel!
Excel somehow hits the sweet spot between being powerful enough to run entire domains like finance and insurance, but also easy enough to attract a huge audience. Why is that?
In this talk we'll explore some of the mechanisms that make spreadsheets so powerful, while implementing a few interesting mathematical problems in spreadsheets. While doing that, you might learn some (functional) programming concepts too, as we'll talk about sorting, dynamic programming and lambdas.
We study all sorts of aspects of programming languages, their ease of use, type system, their level of abstractness, but we feel one aspect is overlooked, how a programming language sounds like when read aloud. Is reading aloud hard? Well, yes. We found that developers cannot pronounce code in a consistent fashion. We had 25 experienced developers read code aloud, and it was a mess, even for simple statements. For example, how to pronounce an assignment statement like x = 5? Is it “x is 5”? Or “set x to 5”? Or “x gets 5”? And what about an equality check? Is it “if x is is 5”? Or “if x is 5”? Or “is x is equal to 5”? What can we learn from reading code aloud? We think programming language designers could learn a lot from hearing their language spoken. For example, if programmers consistently read if x == 5 as “if x is 5”, = or even is might be better keyword. What is the ultimate end game of this idea? We envision programming language designers of the future to prescribe a way that their language sounds, much like languages have style guides. When the sound or ‘phonology’ is defined, it can be practiced, taught and analyzed.
We often say kids should learn programming because it increases their logical reasoning skills. But why do we think that? Is it true? Is it the right motivation even?
This document discusses the results of a study on how code smells impact kids' ability to complete different programming tasks. The study found that:
1) Code smells did significantly impact kids' performance, with kids performing better on programs without smells.
2) However, the type of task mattered - explanation tasks were unaffected by smells, while understanding tasks were more impacted by long methods and modification tasks by duplication.
3) In general, smells had a negative effect on kids' ability to understand, modify, and work with code.
Despite what your boss thinks, programs don't just appear straight out of specifications. But...what if they did?
In this session Felienne will show you how to systematically and step-by-step derive a program from a specification. Functional languages especially are very suited to derive programs for, as they are close to the mathematical notation used for proofs.
You will be surprised to know that you already know and apply many techniques for derivation, like Introduce Parameter as supported by Resharper. Did you know that is actually program derivation technique called generalization?
A board game night with geeks: attacking Quarto ties with SAT solversFelienne Hermans
So this one day, I am playing the board game Quarto (http://en.wikipedia.org/wiki/Quarto_%28board_game%29) with my friend and I wonder, can this game end in a tie, or is there always a winner?
Normal people might have squabbled or shrugged, but not us nerds! We obviously abandoned the game, took our laptops to the local pub and started hacking. In this talk I will explain how I used F# to transform this problem to satisfiability, ran it through an SAT solver to discover if it can indeed end in a tie.
Spreadsheets are often dismissed by developers for not being "proper programming" but that is not true. Since I have shown that spreadsheets are Turing complete, you have no excuse to diss them any longer. In this session, I will implement various algorithms in Excel to show you its power and elegance. After all, spreadsheets are 'live' and functional, so they have everything going for them! Furthermore they are very fit for TDD and rapid prototyping.
Don't fight spreadsheets any longer, but learn to love them.
You are a scientist. You are busy. You want to be on social media but don't know where to start. Then this presentation is for you. Three easy ways to start within 10 minutes.
Spreadsheet testing is important to prevent errors. It involves documenting intentions, checking inputs and assumptions, and looking for differences between values. Tests can be implemented using checks and conditional formatting, and decisions need to be made about where in the spreadsheet to put these tests.
The document discusses using symmetry to solve problems more efficiently. It provides examples of how mathematician Gauss used symmetry to sum the numbers from 1 to 100 with only two operations. It also shows how modeling a problem involving transporting a shepherd, sheep, wolf and cabbage across a river can be simplified by recognizing the symmetrical solutions. The document advocates practicing noticing symmetry in problems to find better solutions and reduce the number of states needing to be considered.
Design and optimization of ion propulsion dronebjmsejournal
Electric propulsion technology is widely used in many kinds of vehicles in recent years, and aircrafts are no exception. Technically, UAVs are electrically propelled but tend to produce a significant amount of noise and vibrations. Ion propulsion technology for drones is a potential solution to this problem. Ion propulsion technology is proven to be feasible in the earth’s atmosphere. The study presented in this article shows the design of EHD thrusters and power supply for ion propulsion drones along with performance optimization of high-voltage power supply for endurance in earth’s atmosphere.
Discover the latest insights on Data Driven Maintenance with our comprehensive webinar presentation. Learn about traditional maintenance challenges, the right approach to utilizing data, and the benefits of adopting a Data Driven Maintenance strategy. Explore real-world examples, industry best practices, and innovative solutions like FMECA and the D3M model. This presentation, led by expert Jules Oudmans, is essential for asset owners looking to optimize their maintenance processes and leverage digital technologies for improved efficiency and performance. Download now to stay ahead in the evolving maintenance landscape.
Batteries -Introduction – Types of Batteries – discharging and charging of battery - characteristics of battery –battery rating- various tests on battery- – Primary battery: silver button cell- Secondary battery :Ni-Cd battery-modern battery: lithium ion battery-maintenance of batteries-choices of batteries for electric vehicle applications.
Fuel Cells: Introduction- importance and classification of fuel cells - description, principle, components, applications of fuel cells: H2-O2 fuel cell, alkaline fuel cell, molten carbonate fuel cell and direct methanol fuel cells.
Software Engineering and Project Management - Introduction, Modeling Concepts...Prakhyath Rai
Introduction, Modeling Concepts and Class Modeling: What is Object orientation? What is OO development? OO Themes; Evidence for usefulness of OO development; OO modeling history. Modeling
as Design technique: Modeling, abstraction, The Three models. Class Modeling: Object and Class Concept, Link and associations concepts, Generalization and Inheritance, A sample class model, Navigation of class models, and UML diagrams
Building the Analysis Models: Requirement Analysis, Analysis Model Approaches, Data modeling Concepts, Object Oriented Analysis, Scenario-Based Modeling, Flow-Oriented Modeling, class Based Modeling, Creating a Behavioral Model.
Advanced control scheme of doubly fed induction generator for wind turbine us...IJECEIAES
This paper describes a speed control device for generating electrical energy on an electricity network based on the doubly fed induction generator (DFIG) used for wind power conversion systems. At first, a double-fed induction generator model was constructed. A control law is formulated to govern the flow of energy between the stator of a DFIG and the energy network using three types of controllers: proportional integral (PI), sliding mode controller (SMC) and second order sliding mode controller (SOSMC). Their different results in terms of power reference tracking, reaction to unexpected speed fluctuations, sensitivity to perturbations, and resilience against machine parameter alterations are compared. MATLAB/Simulink was used to conduct the simulations for the preceding study. Multiple simulations have shown very satisfying results, and the investigations demonstrate the efficacy and power-enhancing capabilities of the suggested control system.
Rainfall intensity duration frequency curve statistical analysis and modeling...bijceesjournal
Using data from 41 years in Patna’ India’ the study’s goal is to analyze the trends of how often it rains on a weekly, seasonal, and annual basis (1981−2020). First, utilizing the intensity-duration-frequency (IDF) curve and the relationship by statistically analyzing rainfall’ the historical rainfall data set for Patna’ India’ during a 41 year period (1981−2020), was evaluated for its quality. Changes in the hydrologic cycle as a result of increased greenhouse gas emissions are expected to induce variations in the intensity, length, and frequency of precipitation events. One strategy to lessen vulnerability is to quantify probable changes and adapt to them. Techniques such as log-normal, normal, and Gumbel are used (EV-I). Distributions were created with durations of 1, 2, 3, 6, and 24 h and return times of 2, 5, 10, 25, and 100 years. There were also mathematical correlations discovered between rainfall and recurrence interval.
Findings: Based on findings, the Gumbel approach produced the highest intensity values, whereas the other approaches produced values that were close to each other. The data indicates that 461.9 mm of rain fell during the monsoon season’s 301st week. However, it was found that the 29th week had the greatest average rainfall, 92.6 mm. With 952.6 mm on average, the monsoon season saw the highest rainfall. Calculations revealed that the yearly rainfall averaged 1171.1 mm. Using Weibull’s method, the study was subsequently expanded to examine rainfall distribution at different recurrence intervals of 2, 5, 10, and 25 years. Rainfall and recurrence interval mathematical correlations were also developed. Further regression analysis revealed that short wave irrigation, wind direction, wind speed, pressure, relative humidity, and temperature all had a substantial influence on rainfall.
Originality and value: The results of the rainfall IDF curves can provide useful information to policymakers in making appropriate decisions in managing and minimizing floods in the study area.
Applications of artificial Intelligence in Mechanical Engineering.pdfAtif Razi
Historically, mechanical engineering has relied heavily on human expertise and empirical methods to solve complex problems. With the introduction of computer-aided design (CAD) and finite element analysis (FEA), the field took its first steps towards digitization. These tools allowed engineers to simulate and analyze mechanical systems with greater accuracy and efficiency. However, the sheer volume of data generated by modern engineering systems and the increasing complexity of these systems have necessitated more advanced analytical tools, paving the way for AI.
AI offers the capability to process vast amounts of data, identify patterns, and make predictions with a level of speed and accuracy unattainable by traditional methods. This has profound implications for mechanical engineering, enabling more efficient design processes, predictive maintenance strategies, and optimized manufacturing operations. AI-driven tools can learn from historical data, adapt to new information, and continuously improve their performance, making them invaluable in tackling the multifaceted challenges of modern mechanical engineering.
artificial intelligence and data science contents.pptxGauravCar
What is artificial intelligence? Artificial intelligence is the ability of a computer or computer-controlled robot to perform tasks that are commonly associated with the intellectual processes characteristic of humans, such as the ability to reason.
› ...
Artificial intelligence (AI) | Definitio
Embedded machine learning-based road conditions and driving behavior monitoringIJECEIAES
Car accident rates have increased in recent years, resulting in losses in human lives, properties, and other financial costs. An embedded machine learning-based system is developed to address this critical issue. The system can monitor road conditions, detect driving patterns, and identify aggressive driving behaviors. The system is based on neural networks trained on a comprehensive dataset of driving events, driving styles, and road conditions. The system effectively detects potential risks and helps mitigate the frequency and impact of accidents. The primary goal is to ensure the safety of drivers and vehicles. Collecting data involved gathering information on three key road events: normal street and normal drive, speed bumps, circular yellow speed bumps, and three aggressive driving actions: sudden start, sudden stop, and sudden entry. The gathered data is processed and analyzed using a machine learning system designed for limited power and memory devices. The developed system resulted in 91.9% accuracy, 93.6% precision, and 92% recall. The achieved inference time on an Arduino Nano 33 BLE Sense with a 32-bit CPU running at 64 MHz is 34 ms and requires 2.6 kB peak RAM and 139.9 kB program flash memory, making it suitable for resource-constrained embedded systems.
9. You get
interpreted >>
compiled
JavaScript 4
ever!
Pure is the
only true path
C++ is for real
coders
PHP sucks
Pascal is very
elegant
You’d expect computer scientists to
somewhat respectfully debate this.
Unfortunately, reality is more like
this.
11. But, some people are trying! In this
slidedeck I’ll highlight some of the
interesting results those people
have found so far.
12. Researchers at Berkeley have
conducted a very exptensive
survey on programming language
factors.
http://www.eecs.berkeley.edu/~lmeyerov/projects/socioplt/
viz/index.html
13. Researchers at Berkeley have
conducted a very extensive survey
on programming language factors.
They collected 13.000 (!)
responses, and their entire dataset
is explorable online
http://www.eecs.berkeley.edu/~lmeyerov/projects/socioplt/
viz/index.html
14. They founds loads of interesting
facts, I really encourage you to
have a look at their OOPSLA ‘13
paper (Empirical Analysis of
Programming Language Adoption)
My favorite is this graph, factors
for choosing a particular language.
http://www.eecs.berkeley.edu/~lmeyerov/projects/socioplt/
viz/index.html
15. They founds loads of interesting
facts, I really encourage you to
have a look at their OOPSLA ‘13
paper (Empirical Analysis of
Programming Language Adoption)
My favorite is this graph, factors
for choosing a particular language.
Notice that the first factor that has
something to do with the language
is on the 6th place.
http://www.eecs.berkeley.edu/~lmeyerov/projects/socioplt/
viz/index.html
16. They founds loads of interesting
facts, I really encourage you to
have a look at their OOPSLA ‘13
paper (Empirical Analysis of
Programming Language Adoption)
My favorite is this graph, factors
for choosing a particular language.
Notice that the first factor that has
something to do with the language
is on the 6th place.
Two other languages are on the 8th
and 12th place.
http://www.eecs.berkeley.edu/~lmeyerov/projects/socioplt/
viz/index.html
17. What correlates most
with enjoyment?
Meyerovich and Rabkin also
looked into what makes
programmers happy.
Want to guess?
18. Meyerovich and Rabkin also
looked into what makes
programmers happy.
Want to guess?
It’s expressiveness. That correlates
with enjoyment most.
19. Could we measure it?
Meyerovich and Rabkin also
looked into what makes
programmers happy.
Want to guess?
It’s expressiveness. That correlates
with enjoyment most.
So what language is most
expressive? Is there a way to
measure this?
20. Danny Berkholz, researcher at RedMonk came up with a way to do this.
He compared commit sizes of different projects (from Ohloh, covering 7.5
million project-months)
His assumption is that a commit has more or less the same ‘value’ in
terms of functionality over different languages.
http://redmonk.com/dberkholz/2013/03/25/programming-languages-ranked-by-expressiveness/
21. In the graph, the thick line indicates the median, the box represents 25
and 75% of the values and the lines 10 and 90%.
http://redmonk.com/dberkholz/2013/03/25/programming-languages-ranked-by-expressiveness/
22.
23. In the graph, the thick line indicates the median, the box represents 25
and 75% of the values and the lines 10 and 90%.
Let’s have a look at what language goes where!
http://redmonk.com/dberkholz/2013/03/25/programming-languages-ranked-by-expressiveness/
24. Loads of interesting things to see here. For instance, all the popular
languages (in red) are on the low end of expressiveness. This somehow
corroborates Meyerovich findings: while programmers enjoy
expressiveness, it seems not to be a factor for picking a language.
25. Loads of interesting things to see here. For instance, all the popular
languages (in red) are on the low end of expressiveness. This somehow
corroborates Meyerovich findings: while programmers enjoy
expressiveness, it seems not to be a factor for picking a language.
Interesting is also the huge difference between CoffeeScipt and
JavaScript, while this might be due to the fact that CoffeeScript is young
and commits are thus quite ‘clean’.
26. Loads of interesting things to see here. For instance, all the popular
languages (in red) are on the low end of expressiveness. This somehow
corroborates Meyerovich findings: while programmers enjoy
expressiveness, it seems not to be a factor for picking a language.
Interesting is also the huge difference between CoffeeScipt and
JavaScript, while this might be due to the fact that CoffeeScript is young
and commits are thus quite ‘clean’.
Finally, unsurprising, functional (Haskell, F#, Lisps) = expressiveness.
32. Stefan Hanenberg
Static versus
dynamic, does it
really matter?
Let’s experiment!
Stefan Hanenberg tried to measure
whether static typing has any
benefits over dynamic typing.
33. Two groups
Stefan Hanenberg tried to measure
whether static typing has any
benefits over dynamic typing.
He divided a group of students into
two groups, one with a type system
and one without, and had them
perform small maintainability
tasks.
Let’s summarize his results... Star
Wars style!
34. On the left, we have the lover of
dynamically typed stuff. He has gone
through some ‘type casts’ in his life
and he is sick of it!
On the right is his static opponent.
Let’s see how this turns out.
35. But what about
type casting?
One of the arguments that dynamic
proponents have, is that type casting is
annoying and time consuming.
Hanenberg’s experiment showed:
36. It does not really
matter
But what about
type casting?
One of the arguments that dynamic
proponents have, is that type casting is
annoying and time consuming.
Hanenberg’s experiment showed:
It does not really matter. For programs
over 10 LOC, you are not slower if you
have to do type casting.
37. I’m sure I can fix
type errors just as
quickly
38. I’m sure I can fix
type errors just as
quickly
Not even close
39. I’m sure I can fix
type errors just as
quickly
Not even close
The differences are HUGE!
Blue bar = Groovy, Green = Java
Vertical axis = time
40. I’m sure I can fix
type errors just as
quickly
Not even close
The differences are HUGE!
Blue bar = Groovy, Green = Java
Vertical axis = time
In some cases, the run-time errors
occurred at the same line where the
compiler found a type error.
49. Walter Tichy
Let’s tackle another one!
Walter Tichy wanted to know
whether design patterns really help
development.
He started small, with a group of
students, testing whether giving
them info on design patterns
helped understandability.
50. Again two
groups, but
different
Let’s tackle another one!
Walter Tichy wanted to know
whether design patterns really help
development.
He started small, with a group of
students, testing whether giving
them info on design patterns
helped understandability.
Again, students were divided into
two groups, but setup was a bit
different.
51. There were two programs used (PH
and AOT) and some students got
with the version documentation
first and without second.
On different programs obviously,
otherwise the students would know
the patterns were there in the
second test.
Prechelt et al, 2002. Two controlled experiments assessing
the usefulness of design pattern documentation in
program maintenance. TSE 28(6): 595-606
52. The results clearly show that knowing a pattern is there, helps
performing maintenance tasks.
However, it was not entirely fair to measure time, as not all solutions
were correct. If you look at the best solutions, you see a clear difference
in favor of the documented version. Ticky updated the study design in
the next version, where only correct solutions were taken into account.
53. Again two
groups, but
again
different
The results clearly show that knowing a pattern is there, helps
performing maintenance tasks.
However, it was not entirely fair to measure time, as not all solutions
were correct. If you look at the best solutions, you see a clear difference
in favor of the documented version. Ticky updated the study design in
the next version, where only correct solutions were taken into account.
54. In this next version, professionals were used instead of students.
Furthermore, the setup was different. The same experiment was done
twice, first without participants knowing patterns. Then, they did a
course and after that again they did a test.
56. Again, results showed that version with patterns tuned out to be easier to
modify.
For some patterns though (like Observer) the differences in pre- and
posttest were really big. For these patterns, the course made a big
difference. In other words: patterns only help if you understand them.
59. Long term
memory
Short term
memory
The human memory works a bit like a computer. Long term memory can
save stuff for a long time, but it is slow. Short term memory is quick, but
can only retain about 7 items.
Using patterns, you only use 1 slot “this is an observer pattern” rather
than multiple for “this class is notified when something happens in this
other class”
"The Magical Number Seven, Plus or Minus Two: Some Limits on Our Capacity for Processing Information“, George Miller,
1956
63. Appearently, the law is not so
universal, we know that code
reviews are hard to do right for
larger pieces of software.
64. Not
impressed?
Appearently, the law is not so
universal, we know that code
reviews are hard to do right for
larger pieces of software.
Yeah, a tweet is not exactly
science. Don’t worry, I have some
proof too.
65. Researcher at Microsoft research
published a study in which they
connected the number of bugs in
the release of Vista (gathered
through bug report) with
organizational metrics, like the
number of people that worked on a
particular binary.
Nagappan et al, 2008. The Influence of Organizational
Structure On Software Quality: An Empirical Case Study,
ICSE 2008
66. They found that the opposite of
Linus’ law is true. The more people
work on a piece of code, the more
error-prone it is!
Nagappan et al, 2008. The Influence of Organizational
Structure On Software Quality: An Empirical Case Study,
ICSE 2008
More
touchers ->
more bugs
67. More tied to
bugs than
any code
metric
They found that the opposite of
Linus’ law is true. The more people
work on a piece of code, the more
error-prone it is!
These, and other, organizational
big are more tied to quality than
any other code metric!
Nagappan et al, 2008. The Influence of Organizational
Structure On Software Quality: An Empirical Case Study,
ICSE 2008
68. They found that the opposite of
Linus’ law is true. The more people
work on a piece of code, the more
error-prone it is!
These, and other, organizational
big are more tied to quality than
any other code metric!
This means that if you want to
predict future defects, the best you
can do is look at the company!
Might be me, but I think that is
surprising.
Nagappan et al, 2008. The Influence of Organizational
Structure On Software Quality: An Empirical Case Study,
ICSE 2008
69. Putting the science
in computer science
Felienne
Delft University of
Technology
That’s it! I hope you got a sense for
the usefullness of software
engineering research in practice.
If you want to keep up, follow my
blog where I regularly blog about
the newest SE research.
Notas do Editor
Static type system really helped in finding errors. Often