The document proposes a formalized approach to software version numbering to address current problems. It analyzes why automatic document section numbering cannot be directly applied to software history. The proposed solution extends the section numbering approach formally, allowing version numbers to include arbitrary sets in addition to natural numbers. This addresses issues like inconsistent practices and ambiguous versioning that undermine automation and software quality.
DOAN DuyHai – Cassandra: real world best use-cases and worst anti-patterns - ...NoSQLmatters
This document discusses Cassandra use cases and anti-patterns. It describes queue-like designs, intensive updates on the same column, and designing around a dynamic schema as anti-patterns that can lead to failures. Rate limiting, fraud prevention, and account validation are provided as examples of good use cases. Key-value modeling, clustering, compaction strategies, and time-to-live features are also overviewed.
The document discusses various topics related to GUI Visual Basic 2008 and Microsoft Office Access 2007. It includes sections on Visual Basic, Access 2007 features like tables, queries, forms and reports. It also includes code examples for forms in Visual Basic to manage customer, car and rent data in an Access 2007 database. The code shows how to search, add, update and delete records using buttons and text boxes on the forms.
1.1 introduction to scm - xp and cm are chicken-and-eggSergii Shmarkatiuk
This document discusses the relationship between eXtreme Programming (XP) practices and Software Configuration Management (SCM) tools. It argues that XP practices and SCM tools have a chicken-and-egg type relationship, where neither can truly exist without the other due to their interdependent nature. SCM tools provide version control, build management, and other functions that are essential for evolution of the software product, while XP practices like pair programming, refactoring, and continuous integration describe common development methods. Together, XP practices and SCM tools form the core software engineering practices for effective development.
Continuous integration (CI) is a software engineering practice where developers frequently integrate their work, leading to multiple integrations per day. This approach reduces integration problems and allows teams to develop cohesive software more rapidly. The presentation discusses what CI is, why teams need it, prerequisites like version control and automated testing, typical workflows, tools, and benefits like reduced risks and improved code quality. It also examines problems teams face in implementing CI effectively and potential areas of future research like making CI tools more adaptive and addressing scalability issues.
CS589 paper presentation - What is in unison? A formal specification and refe...Sergii Shmarkatiuk
Overview of the paper "What's in Unison? A Formal Specication and Reference Implementation of a File Synchronizer" by Benjamin C. Pierce Jerome Vouillon presented at Oregon State University for "Domain Specific Languages" class on May 20th 2014. Presentation time: 20 min
This document provides an overview and training plan for merge management. It describes problems that can emerge during merge operations in version control systems and how to mitigate risks and avoid problems related to merging. The training plan includes introductions to concepts like merging, branches, conflicts and how to manage merging. It provides details on common tools and operations involved in merging like diff, patch, branch and how three-way merging works. It also gives examples and demonstrations of merging in practice.
This document provides an overview of continuous integration training goals and plans. The goals are to demonstrate that modern projects cannot succeed without continuous integration and to establish a connection between continuous integration practices and CMMI product integration processes. The training plan covers topics such as what continuous integration is, why it is needed, prerequisites, workflows, tools, and relationships to CMMI processes. It also discusses continuous integration tools and classifications.
This document provides an introduction to version control. It discusses what version control is, the history and evolution of version control systems, different types of version control systems classified by their repository model and concurrency model, and practical considerations for starting to use version control. Key topics covered include centralized and distributed version control, lock-modify-unlock and merge models, and domain vocabulary for common version control tasks and workflows.
DOAN DuyHai – Cassandra: real world best use-cases and worst anti-patterns - ...NoSQLmatters
This document discusses Cassandra use cases and anti-patterns. It describes queue-like designs, intensive updates on the same column, and designing around a dynamic schema as anti-patterns that can lead to failures. Rate limiting, fraud prevention, and account validation are provided as examples of good use cases. Key-value modeling, clustering, compaction strategies, and time-to-live features are also overviewed.
The document discusses various topics related to GUI Visual Basic 2008 and Microsoft Office Access 2007. It includes sections on Visual Basic, Access 2007 features like tables, queries, forms and reports. It also includes code examples for forms in Visual Basic to manage customer, car and rent data in an Access 2007 database. The code shows how to search, add, update and delete records using buttons and text boxes on the forms.
1.1 introduction to scm - xp and cm are chicken-and-eggSergii Shmarkatiuk
This document discusses the relationship between eXtreme Programming (XP) practices and Software Configuration Management (SCM) tools. It argues that XP practices and SCM tools have a chicken-and-egg type relationship, where neither can truly exist without the other due to their interdependent nature. SCM tools provide version control, build management, and other functions that are essential for evolution of the software product, while XP practices like pair programming, refactoring, and continuous integration describe common development methods. Together, XP practices and SCM tools form the core software engineering practices for effective development.
Continuous integration (CI) is a software engineering practice where developers frequently integrate their work, leading to multiple integrations per day. This approach reduces integration problems and allows teams to develop cohesive software more rapidly. The presentation discusses what CI is, why teams need it, prerequisites like version control and automated testing, typical workflows, tools, and benefits like reduced risks and improved code quality. It also examines problems teams face in implementing CI effectively and potential areas of future research like making CI tools more adaptive and addressing scalability issues.
CS589 paper presentation - What is in unison? A formal specification and refe...Sergii Shmarkatiuk
Overview of the paper "What's in Unison? A Formal Specication and Reference Implementation of a File Synchronizer" by Benjamin C. Pierce Jerome Vouillon presented at Oregon State University for "Domain Specific Languages" class on May 20th 2014. Presentation time: 20 min
This document provides an overview and training plan for merge management. It describes problems that can emerge during merge operations in version control systems and how to mitigate risks and avoid problems related to merging. The training plan includes introductions to concepts like merging, branches, conflicts and how to manage merging. It provides details on common tools and operations involved in merging like diff, patch, branch and how three-way merging works. It also gives examples and demonstrations of merging in practice.
This document provides an overview of continuous integration training goals and plans. The goals are to demonstrate that modern projects cannot succeed without continuous integration and to establish a connection between continuous integration practices and CMMI product integration processes. The training plan covers topics such as what continuous integration is, why it is needed, prerequisites, workflows, tools, and relationships to CMMI processes. It also discusses continuous integration tools and classifications.
This document provides an introduction to version control. It discusses what version control is, the history and evolution of version control systems, different types of version control systems classified by their repository model and concurrency model, and practical considerations for starting to use version control. Key topics covered include centralized and distributed version control, lock-modify-unlock and merge models, and domain vocabulary for common version control tasks and workflows.
This document outlines a series of software configuration management trainings covering topics such as introduction to SCM, version control, build and deployment management, continuous integration, agile SCM, and merge management. The trainings will utilize formats like seminars, webinars, workshops, and conferences. Attendees include software engineers, testers, and project managers. The content is organized into 6 modules with examples and demos. Attendance and active participation are required to receive a score. The trainings will be presented in English by lecturer Sergii Shmarkatiuk.
CS 584 - Aligning development tools with the way programmers think about code...Sergii Shmarkatiuk
This presentation reviews a proposed visual tool for generating source code transformations based on the edit-by-example principle. The tool aims to address limitations of existing approaches like regular expressions, IDE search/replace, and AST-based tools by allowing programmers to intuitively create custom transformations through direct manipulation of code representations. An initial prototype was implemented and evaluated via a user study, which provided insights for future iterations. The tool combines textual and graphical elements to naturally fit programmers' mental models of code structure.
The document discusses build and deployment management. It covers why builds and deployments need to be managed, different build types, build phases, and popular build tools like Ant, Maven, Make, and MSBuild. Managing builds is important for large, complex applications to ensure the build process is complete, repeatable, informative, schedulable, and portable. The key difference between a build and deployment is that a build creates installation artifacts while deployment installs the application.
Overview of the paper "Visual Software Evolution Reconstruction" by Marco D'Ambros and Michele Lanza presented at Oregon State University for "Information Visualization" class on May 12th 2014. Presentation time: 15 min
The document discusses agile software configuration management and the connection between agile methodologies and configuration management practices. It presents streamlined diagrams showing how version control, branching, and releases are handled in agile software development. Branching strategies become more complex as the scope expands and parallel development of multiple versions is needed, requiring different branch types including long-running release branches.
Version control is a method for centrally storing files and keeping a record of changes made by developers. It allows tracking who made what changes and when. This allows developers to back up their work, track different versions of files, merge changes from multiple developers, and recover old versions if needed. Centralized version control systems like Subversion store all files in a central repository that developers check files out from and check changes back into. Subversion allows viewing changes between versions, rolling back changes, and recovering old project versions with a single version number across all files.
With the exponential growth of the Internet, inundating text is being generated through articles, blogs, comments, and tweets. For computing systems, text is merely a series of bytes with no meaning. This renders the text obsolete for any further processing.
Multiple methods have been applied to make computers infer word meanings, but none of them was accurate and practical as much as Word2Vec. Word2Vec opened a new horizon for industries that allowed them to apply various Natural Language Processing (NLP) tasks such as machine translation, sentiment analysis, word similarity, text summarization, chat bots ...etc.
This was part of JOSA TechTalks project within Jordan Open Source Association, presented by Wael Farhan.
Successfully Implement Responsive Design Behavior with Adobe Experience ManagerPerficient, Inc.
This document discusses how to manage responsive design behaviors using Adobe Experience Manager. It describes the challenge of displaying content across different devices which may have varying screen sizes and resolutions. The solution presented allows content authors to determine which content is displayed at specific breakpoints and manage the grid layout. It involves building components that use listeners and logic to dynamically handle the display of regions and columns based on the targeted device or screen size. The demonstration shows how authors can control responsive behavior through the new components.
This document provides guidance on analyzing malicious software through a multi-stage process including automated analysis, behavioral analysis, and static and dynamic code analysis. It outlines tips and tools for each stage, with the goal of understanding a malware sample's capabilities and origins to strengthen an organization's security. Key stages involve examining static properties, behavioral interactions, and reversing code using tools like Ghidra and x64dbg.
R is a free software environment for statistical computing and graphics. It provides statistical techniques and is highly extensible. Packages can be installed from repositories like CRAN and BioConductor to expand R's functionality. Basic plots can be created using functions like plot() and hist(). Data can be imported from files and bound together from multiple files into a single data frame.
Data to Insight in a Flash: Introduction to Real-Time Analytics with WSO2 Com...WSO2
In this webinar, Sriskandarajah Suhothayan, technical lead at WSO2, will take a closer look at the following use cases:
Natural language processing capabilities of WSO2 CEP: Introducing basic constructs of the CEP
Analyzing a soccer game in Real time: Explaining how complicated scenarios can be implemented
Geo fencing capabilities of WSO2 CEP: Focusing on the CEP’s virtualization support
As part of their daily work, developers interact with Integrated Development Environments (IDE), generating thousands of events. Together with other aspects of development, this data also captures the modus operandi of the developer, including all the program entities she interacted with during a development session. This "working set" (or context) is leveraged by developers to create and maintain their mental model of the software system at hand. Understanding how developers navigate and interact with source code during a development session is an open question.
We present a novel visual approach to understand how working sets evolve during a development session. The visualization incrementally depicts all the program entities involved in a development session, the intensity of the developer activity on them, and the navigation paths that occurred between them. We visualized about a thousand development sessions, and categorized them according to their visual properties.
A study on improving speaker diarization system = Nghiên cứu phương pháp cải ...Man_Ebook
The document is a master's thesis that explores improving a speaker diarization system by comparing X-Vectors and ECAPA-TDNN embeddings. It includes:
- An introduction outlining the research interest in evaluating these two embedding methods on Vietnamese data sets for speaker verification and diarization tasks.
- Details of the baseline system that uses X-Vector embeddings and the proposed system that replaces it with ECAPA-TDNN embeddings.
- Experiments conducted on private (IPCC_110000, VTR_1350) and public (ZALO_400) data sets to evaluate the systems, along with results showing the proposed system outperforms the baseline.
A study on improving speaker diarization system = Nghiên cứu phương pháp cải ...Man_Ebook
The document is a master's thesis submitted by Tung Lam Nguyen to the Hanoi University of Science and Technology. It studies improving speaker diarization systems by exploring the capabilities of ECAPA-TDNN embeddings versus X-Vector embeddings in a Vietnamese speaker diarization system. The thesis contains experiments evaluating both baseline and proposed systems on speaker verification and speaker diarization tasks using various private and public Vietnamese datasets. The results show that the proposed system using ECAPA-TDNN outperforms the baseline X-Vector system on all tasks and datasets.
Evaluating Cues for Resuming Interrupted Programming TAsksChris Parnin
1) Programmers often forget where they left off after interruptions like lunch breaks due to the large amount of information they must hold in their memory.
2) The researchers conducted a survey of programmers and experiments to evaluate strategies for resuming interrupted tasks. They found that providing cues from the programmer's recent work history was more effective than notes.
3) Specifically, a content timeline view of changed files and a difference-based integrated development environment interface helped programmers resume their tasks faster and with a higher success rate compared to only taking notes.
This document presents the solutions to 4 optimization problems related to software engineering. The problems involve finding the optimal dimensions of boxes, cylindrical structures, and 3D models to minimize costs or pixel usage. Each problem is solved using calculus techniques like taking derivatives and finding critical points to determine maximum or minimum values. The conclusions emphasize how optimization problems are directly applied calculus to calculate extremes of functions subject to conditions.
This document summarizes the author's masters project on developing a document translation system. The system uses a multi-step pipeline including text detection with the CRAFT model, text recognition with STR, text merging, image inpainting with DeepFillV2, and translation via Google Translate API. Details are provided on the models used, data processing, and approach for each step of the pipeline to translate documents while preserving layout and design elements.
Detecting Misleading Headlines in Online News: Hands-on Experiences on Attent...Kunwoo Park
This slide is used for the tutorial in Deep Learning Summer School, held in IBS, Daejeon. Based on the recent effort on detecting misleading headlines through deep neural networks (Yoon et al., AAAI 2019), it explains how RNN and Attention mechanism works for text. Moreover, implementations based on TensorFlow 1.x are introduced.
The document describes EasyEDD, a software for analyzing tomographic electron diffraction data (TEDDI) obtained from synchrotron sources. EasyEDD allows batch processing and visualization of large diffraction data sets. It stores data in a 3D grid format and includes tools for corrections, fitting, visualization and exporting results. The software combines a graphical user interface with algorithms for numerical analysis. Current functionality and future improvements are outlined.
Feature Engineering - Getting most out of data for predictive models - TDC 2017Gabriel Moreira
How should data be preprocessed for use in machine learning algorithms? How to identify the most predictive attributes of a dataset? What features can generate to improve the accuracy of a model?
Feature Engineering is the process of extracting and selecting, from raw data, features that can be used effectively in predictive models. As the quality of the features greatly influences the quality of the results, knowing the main techniques and pitfalls will help you to succeed in the use of machine learning in your projects.
In this talk, we will present methods and techniques that allow us to extract the maximum potential of the features of a dataset, increasing flexibility, simplicity and accuracy of the models. The analysis of the distribution of features and their correlations, the transformation of numeric attributes (such as scaling, normalization, log-based transformation, binning), categorical attributes (such as one-hot encoding, feature hashing, Temporal (date / time), and free-text attributes (text vectorization, topic modeling).
Python, Python, Scikit-learn, and Spark SQL examples will be presented and how to use domain knowledge and intuition to select and generate features relevant to predictive models.
This document presents the Noise Driven Encryption Algorithm (NDEA) for encrypting data at the bit level. It uses noise waves introduced over the bit patterns of plaintext to encrypt it. Windows of prime sized layers are selected from the bit patterns, and noise waves are made to propagate within the windows in concentric circular fashion, encrypting the text. For decryption, the reverse process is followed. The algorithm aims to make decryption complex by introducing randomization in window selection and noise propagation coordinates and intensity. It is claimed to produce unpredictable encrypted text that can be used for encrypting passwords and bank transactions. Pseudocodes for the encryption and decryption algorithms are also provided.
This document outlines a series of software configuration management trainings covering topics such as introduction to SCM, version control, build and deployment management, continuous integration, agile SCM, and merge management. The trainings will utilize formats like seminars, webinars, workshops, and conferences. Attendees include software engineers, testers, and project managers. The content is organized into 6 modules with examples and demos. Attendance and active participation are required to receive a score. The trainings will be presented in English by lecturer Sergii Shmarkatiuk.
CS 584 - Aligning development tools with the way programmers think about code...Sergii Shmarkatiuk
This presentation reviews a proposed visual tool for generating source code transformations based on the edit-by-example principle. The tool aims to address limitations of existing approaches like regular expressions, IDE search/replace, and AST-based tools by allowing programmers to intuitively create custom transformations through direct manipulation of code representations. An initial prototype was implemented and evaluated via a user study, which provided insights for future iterations. The tool combines textual and graphical elements to naturally fit programmers' mental models of code structure.
The document discusses build and deployment management. It covers why builds and deployments need to be managed, different build types, build phases, and popular build tools like Ant, Maven, Make, and MSBuild. Managing builds is important for large, complex applications to ensure the build process is complete, repeatable, informative, schedulable, and portable. The key difference between a build and deployment is that a build creates installation artifacts while deployment installs the application.
Overview of the paper "Visual Software Evolution Reconstruction" by Marco D'Ambros and Michele Lanza presented at Oregon State University for "Information Visualization" class on May 12th 2014. Presentation time: 15 min
The document discusses agile software configuration management and the connection between agile methodologies and configuration management practices. It presents streamlined diagrams showing how version control, branching, and releases are handled in agile software development. Branching strategies become more complex as the scope expands and parallel development of multiple versions is needed, requiring different branch types including long-running release branches.
Version control is a method for centrally storing files and keeping a record of changes made by developers. It allows tracking who made what changes and when. This allows developers to back up their work, track different versions of files, merge changes from multiple developers, and recover old versions if needed. Centralized version control systems like Subversion store all files in a central repository that developers check files out from and check changes back into. Subversion allows viewing changes between versions, rolling back changes, and recovering old project versions with a single version number across all files.
With the exponential growth of the Internet, inundating text is being generated through articles, blogs, comments, and tweets. For computing systems, text is merely a series of bytes with no meaning. This renders the text obsolete for any further processing.
Multiple methods have been applied to make computers infer word meanings, but none of them was accurate and practical as much as Word2Vec. Word2Vec opened a new horizon for industries that allowed them to apply various Natural Language Processing (NLP) tasks such as machine translation, sentiment analysis, word similarity, text summarization, chat bots ...etc.
This was part of JOSA TechTalks project within Jordan Open Source Association, presented by Wael Farhan.
Successfully Implement Responsive Design Behavior with Adobe Experience ManagerPerficient, Inc.
This document discusses how to manage responsive design behaviors using Adobe Experience Manager. It describes the challenge of displaying content across different devices which may have varying screen sizes and resolutions. The solution presented allows content authors to determine which content is displayed at specific breakpoints and manage the grid layout. It involves building components that use listeners and logic to dynamically handle the display of regions and columns based on the targeted device or screen size. The demonstration shows how authors can control responsive behavior through the new components.
This document provides guidance on analyzing malicious software through a multi-stage process including automated analysis, behavioral analysis, and static and dynamic code analysis. It outlines tips and tools for each stage, with the goal of understanding a malware sample's capabilities and origins to strengthen an organization's security. Key stages involve examining static properties, behavioral interactions, and reversing code using tools like Ghidra and x64dbg.
R is a free software environment for statistical computing and graphics. It provides statistical techniques and is highly extensible. Packages can be installed from repositories like CRAN and BioConductor to expand R's functionality. Basic plots can be created using functions like plot() and hist(). Data can be imported from files and bound together from multiple files into a single data frame.
Data to Insight in a Flash: Introduction to Real-Time Analytics with WSO2 Com...WSO2
In this webinar, Sriskandarajah Suhothayan, technical lead at WSO2, will take a closer look at the following use cases:
Natural language processing capabilities of WSO2 CEP: Introducing basic constructs of the CEP
Analyzing a soccer game in Real time: Explaining how complicated scenarios can be implemented
Geo fencing capabilities of WSO2 CEP: Focusing on the CEP’s virtualization support
As part of their daily work, developers interact with Integrated Development Environments (IDE), generating thousands of events. Together with other aspects of development, this data also captures the modus operandi of the developer, including all the program entities she interacted with during a development session. This "working set" (or context) is leveraged by developers to create and maintain their mental model of the software system at hand. Understanding how developers navigate and interact with source code during a development session is an open question.
We present a novel visual approach to understand how working sets evolve during a development session. The visualization incrementally depicts all the program entities involved in a development session, the intensity of the developer activity on them, and the navigation paths that occurred between them. We visualized about a thousand development sessions, and categorized them according to their visual properties.
A study on improving speaker diarization system = Nghiên cứu phương pháp cải ...Man_Ebook
The document is a master's thesis that explores improving a speaker diarization system by comparing X-Vectors and ECAPA-TDNN embeddings. It includes:
- An introduction outlining the research interest in evaluating these two embedding methods on Vietnamese data sets for speaker verification and diarization tasks.
- Details of the baseline system that uses X-Vector embeddings and the proposed system that replaces it with ECAPA-TDNN embeddings.
- Experiments conducted on private (IPCC_110000, VTR_1350) and public (ZALO_400) data sets to evaluate the systems, along with results showing the proposed system outperforms the baseline.
A study on improving speaker diarization system = Nghiên cứu phương pháp cải ...Man_Ebook
The document is a master's thesis submitted by Tung Lam Nguyen to the Hanoi University of Science and Technology. It studies improving speaker diarization systems by exploring the capabilities of ECAPA-TDNN embeddings versus X-Vector embeddings in a Vietnamese speaker diarization system. The thesis contains experiments evaluating both baseline and proposed systems on speaker verification and speaker diarization tasks using various private and public Vietnamese datasets. The results show that the proposed system using ECAPA-TDNN outperforms the baseline X-Vector system on all tasks and datasets.
Evaluating Cues for Resuming Interrupted Programming TAsksChris Parnin
1) Programmers often forget where they left off after interruptions like lunch breaks due to the large amount of information they must hold in their memory.
2) The researchers conducted a survey of programmers and experiments to evaluate strategies for resuming interrupted tasks. They found that providing cues from the programmer's recent work history was more effective than notes.
3) Specifically, a content timeline view of changed files and a difference-based integrated development environment interface helped programmers resume their tasks faster and with a higher success rate compared to only taking notes.
This document presents the solutions to 4 optimization problems related to software engineering. The problems involve finding the optimal dimensions of boxes, cylindrical structures, and 3D models to minimize costs or pixel usage. Each problem is solved using calculus techniques like taking derivatives and finding critical points to determine maximum or minimum values. The conclusions emphasize how optimization problems are directly applied calculus to calculate extremes of functions subject to conditions.
This document summarizes the author's masters project on developing a document translation system. The system uses a multi-step pipeline including text detection with the CRAFT model, text recognition with STR, text merging, image inpainting with DeepFillV2, and translation via Google Translate API. Details are provided on the models used, data processing, and approach for each step of the pipeline to translate documents while preserving layout and design elements.
Detecting Misleading Headlines in Online News: Hands-on Experiences on Attent...Kunwoo Park
This slide is used for the tutorial in Deep Learning Summer School, held in IBS, Daejeon. Based on the recent effort on detecting misleading headlines through deep neural networks (Yoon et al., AAAI 2019), it explains how RNN and Attention mechanism works for text. Moreover, implementations based on TensorFlow 1.x are introduced.
The document describes EasyEDD, a software for analyzing tomographic electron diffraction data (TEDDI) obtained from synchrotron sources. EasyEDD allows batch processing and visualization of large diffraction data sets. It stores data in a 3D grid format and includes tools for corrections, fitting, visualization and exporting results. The software combines a graphical user interface with algorithms for numerical analysis. Current functionality and future improvements are outlined.
Feature Engineering - Getting most out of data for predictive models - TDC 2017Gabriel Moreira
How should data be preprocessed for use in machine learning algorithms? How to identify the most predictive attributes of a dataset? What features can generate to improve the accuracy of a model?
Feature Engineering is the process of extracting and selecting, from raw data, features that can be used effectively in predictive models. As the quality of the features greatly influences the quality of the results, knowing the main techniques and pitfalls will help you to succeed in the use of machine learning in your projects.
In this talk, we will present methods and techniques that allow us to extract the maximum potential of the features of a dataset, increasing flexibility, simplicity and accuracy of the models. The analysis of the distribution of features and their correlations, the transformation of numeric attributes (such as scaling, normalization, log-based transformation, binning), categorical attributes (such as one-hot encoding, feature hashing, Temporal (date / time), and free-text attributes (text vectorization, topic modeling).
Python, Python, Scikit-learn, and Spark SQL examples will be presented and how to use domain knowledge and intuition to select and generate features relevant to predictive models.
This document presents the Noise Driven Encryption Algorithm (NDEA) for encrypting data at the bit level. It uses noise waves introduced over the bit patterns of plaintext to encrypt it. Windows of prime sized layers are selected from the bit patterns, and noise waves are made to propagate within the windows in concentric circular fashion, encrypting the text. For decryption, the reverse process is followed. The algorithm aims to make decryption complex by introducing randomization in window selection and noise propagation coordinates and intensity. It is claimed to produce unpredictable encrypted text that can be used for encrypting passwords and bank transactions. Pseudocodes for the encryption and decryption algorithms are also provided.
Software Architecture Design Recovery through Run-Time Source Code Collaborat...theijes
Interoperability between enterprise legacy systems and contemporary information systems requires more efficient ways to analyze the architecture and design of legacy systems. However, the original source code collaboration design information is dispersed at the implementation level. The analysis of system design architecture therefore becomes a difficult task. In this paper, the authors present a novel approach to efficiently recover and analyze legacy system architecture and design through run-time source code collaboration pattern and role analysis. The extraction of code artifact collaborations and their roles is therefore an important support aspect in legacy software comprehension and architecture design recovery. The authors’ approach consists of two major parts, both of which are supported by their reverse engineering tools. The first part focuses on the dynamic analysis of target legacy systems and the automatic discovery of the legacy system’s architecture. The second part is concentrated on the recovery and study of legacy system design through collaboration pattern and role analysis. The study demonstrates that this novel approach is promising.
Software Architecture Design Recovery through Run-Time Source Code Collaborat...theijes
Interoperability between enterprise legacy systems and contemporary information systems requires more efficient ways to analyze the architecture and design of legacy systems. However, the original source code collaboration design information is dispersed at the implementation level. The analysis of system design architecture therefore becomes a difficult task. In this paper, the authors present a novel approach to efficiently recover and analyze legacy system architecture and design through run-time source code collaboration pattern and role analysis. The extraction of code artifact collaborations and their roles is therefore an important support aspect in legacy software comprehension and architecture design recovery. The authors’ approach consists of two major parts, both of which are supported by their reverse engineering tools. The first part focuses on the dynamic analysis of target legacy systems and the automatic discovery of the legacy system’s architecture. The second part is concentrated on the recovery and study of legacy system design through collaboration pattern and role analysis. The study demonstrates that this novel approach is promising.
Documentation - Element and ElementVectorMichel Alves
This document is a reference manual generated by Doxygen for C++ classes related to modeling elements. It includes:
1. A class index listing the Element, ElementVector, and PredicateSort classes.
2. A file index listing source code files Element.cxx, Element.h, and Sys-Element.cpp.
3. Documentation of the Element and ElementVector classes, including constructors, member functions, and method details. It allows storing and comparing element values.
The reference manual provides documentation on C++ classes and methods for working with elements and element vectors, including storing, comparing, sorting, and accessing element values.
This document provides an introduction to creating a new language for a Service Creation Environment (SCE) using Sixlabs' Generador de Ambientes de Alta Productividad (GAAP). It discusses key concepts for building an SCE like properties, dialogs, entities and functional code. It also covers the tradeoff between productivity and flexibility in entity design. The document then demonstrates creating a new Logo language for an SCE, including defining entities, creating dialogs and generating functional code templates using XSLT.
Similar to Software version numbering - DSL of change (20)
CS519 - Cloud Twin: Native Execution of Android Applications on the Windows P...Sergii Shmarkatiuk
Overview of the paper "Cloud Twin: Native Execution of Android Applications on the Windows Phone" by Holder et al. presented at Oregon State University for "Software Evolution for Mobility" class on Nov 18th 2013. Presentation time: 5 min
Overview of the paper "Cloud Types for Eventual Consistency" by Burckhardt et al. presented at Oregon State University for "Software Evolution for Mobility" class on Oct 10th 2013. Presentation time: 20 min
1.2 introduction to scm - what does version number tell usSergii Shmarkatiuk
This document discusses configuration management and version numbers. It explains that a build takes source code and converts it into artifacts that can run on end-user workstations. Builds are needed to add functionality, improve performance, or implement other requirements. Managing builds is important as applications grow more complex with multiple variants incorporating different property values like version, build type, OS, localization, platform, and maturity. Variants represent the output of a build with a specific set of property values. The version number can incorporate all variant properties to uniquely identify each variant.
"What does it really mean for your system to be available, or how to define w...Fwdays
We will talk about system monitoring from a few different angles. We will start by covering the basics, then discuss SLOs, how to define them, and why understanding the business well is crucial for success in this exercise.
zkStudyClub - LatticeFold: A Lattice-based Folding Scheme and its Application...Alex Pruden
Folding is a recent technique for building efficient recursive SNARKs. Several elegant folding protocols have been proposed, such as Nova, Supernova, Hypernova, Protostar, and others. However, all of them rely on an additively homomorphic commitment scheme based on discrete log, and are therefore not post-quantum secure. In this work we present LatticeFold, the first lattice-based folding protocol based on the Module SIS problem. This folding protocol naturally leads to an efficient recursive lattice-based SNARK and an efficient PCD scheme. LatticeFold supports folding low-degree relations, such as R1CS, as well as high-degree relations, such as CCS. The key challenge is to construct a secure folding protocol that works with the Ajtai commitment scheme. The difficulty, is ensuring that extracted witnesses are low norm through many rounds of folding. We present a novel technique using the sumcheck protocol to ensure that extracted witnesses are always low norm no matter how many rounds of folding are used. Our evaluation of the final proof system suggests that it is as performant as Hypernova, while providing post-quantum security.
Paper Link: https://eprint.iacr.org/2024/257
Must Know Postgres Extension for DBA and Developer during MigrationMydbops
Mydbops Opensource Database Meetup 16
Topic: Must-Know PostgreSQL Extensions for Developers and DBAs During Migration
Speaker: Deepak Mahto, Founder of DataCloudGaze Consulting
Date & Time: 8th June | 10 AM - 1 PM IST
Venue: Bangalore International Centre, Bangalore
Abstract: Discover how PostgreSQL extensions can be your secret weapon! This talk explores how key extensions enhance database capabilities and streamline the migration process for users moving from other relational databases like Oracle.
Key Takeaways:
* Learn about crucial extensions like oracle_fdw, pgtt, and pg_audit that ease migration complexities.
* Gain valuable strategies for implementing these extensions in PostgreSQL to achieve license freedom.
* Discover how these key extensions can empower both developers and DBAs during the migration process.
* Don't miss this chance to gain practical knowledge from an industry expert and stay updated on the latest open-source database trends.
Mydbops Managed Services specializes in taking the pain out of database management while optimizing performance. Since 2015, we have been providing top-notch support and assistance for the top three open-source databases: MySQL, MongoDB, and PostgreSQL.
Our team offers a wide range of services, including assistance, support, consulting, 24/7 operations, and expertise in all relevant technologies. We help organizations improve their database's performance, scalability, efficiency, and availability.
Contact us: info@mydbops.com
Visit: https://www.mydbops.com/
Follow us on LinkedIn: https://in.linkedin.com/company/mydbops
For more details and updates, please follow up the below links.
Meetup Page : https://www.meetup.com/mydbops-databa...
Twitter: https://twitter.com/mydbopsofficial
Blogs: https://www.mydbops.com/blog/
Facebook(Meta): https://www.facebook.com/mydbops/
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/temporal-event-neural-networks-a-more-efficient-alternative-to-the-transformer-a-presentation-from-brainchip/
Chris Jones, Director of Product Management at BrainChip , presents the “Temporal Event Neural Networks: A More Efficient Alternative to the Transformer” tutorial at the May 2024 Embedded Vision Summit.
The expansion of AI services necessitates enhanced computational capabilities on edge devices. Temporal Event Neural Networks (TENNs), developed by BrainChip, represent a novel and highly efficient state-space network. TENNs demonstrate exceptional proficiency in handling multi-dimensional streaming data, facilitating advancements in object detection, action recognition, speech enhancement and language model/sequence generation. Through the utilization of polynomial-based continuous convolutions, TENNs streamline models, expedite training processes and significantly diminish memory requirements, achieving notable reductions of up to 50x in parameters and 5,000x in energy consumption compared to prevailing methodologies like transformers.
Integration with BrainChip’s Akida neuromorphic hardware IP further enhances TENNs’ capabilities, enabling the realization of highly capable, portable and passively cooled edge devices. This presentation delves into the technical innovations underlying TENNs, presents real-world benchmarks, and elucidates how this cutting-edge approach is positioned to revolutionize edge AI across diverse applications.
LF Energy Webinar: Carbon Data Specifications: Mechanisms to Improve Data Acc...DanBrown980551
This LF Energy webinar took place June 20, 2024. It featured:
-Alex Thornton, LF Energy
-Hallie Cramer, Google
-Daniel Roesler, UtilityAPI
-Henry Richardson, WattTime
In response to the urgency and scale required to effectively address climate change, open source solutions offer significant potential for driving innovation and progress. Currently, there is a growing demand for standardization and interoperability in energy data and modeling. Open source standards and specifications within the energy sector can also alleviate challenges associated with data fragmentation, transparency, and accessibility. At the same time, it is crucial to consider privacy and security concerns throughout the development of open source platforms.
This webinar will delve into the motivations behind establishing LF Energy’s Carbon Data Specification Consortium. It will provide an overview of the draft specifications and the ongoing progress made by the respective working groups.
Three primary specifications will be discussed:
-Discovery and client registration, emphasizing transparent processes and secure and private access
-Customer data, centering around customer tariffs, bills, energy usage, and full consumption disclosure
-Power systems data, focusing on grid data, inclusive of transmission and distribution networks, generation, intergrid power flows, and market settlement data
The Department of Veteran Affairs (VA) invited Taylor Paschal, Knowledge & Information Management Consultant at Enterprise Knowledge, to speak at a Knowledge Management Lunch and Learn hosted on June 12, 2024. All Office of Administration staff were invited to attend and received professional development credit for participating in the voluntary event.
The objectives of the Lunch and Learn presentation were to:
- Review what KM ‘is’ and ‘isn’t’
- Understand the value of KM and the benefits of engaging
- Define and reflect on your “what’s in it for me?”
- Share actionable ways you can participate in Knowledge - - Capture & Transfer
Session 1 - Intro to Robotic Process Automation.pdfUiPathCommunity
👉 Check out our full 'Africa Series - Automation Student Developers (EN)' page to register for the full program:
https://bit.ly/Automation_Student_Kickstart
In this session, we shall introduce you to the world of automation, the UiPath Platform, and guide you on how to install and setup UiPath Studio on your Windows PC.
📕 Detailed agenda:
What is RPA? Benefits of RPA?
RPA Applications
The UiPath End-to-End Automation Platform
UiPath Studio CE Installation and Setup
💻 Extra training through UiPath Academy:
Introduction to Automation
UiPath Business Automation Platform
Explore automation development with UiPath Studio
👉 Register here for our upcoming Session 2 on June 20: Introduction to UiPath Studio Fundamentals: https://community.uipath.com/events/details/uipath-lagos-presents-session-2-introduction-to-uipath-studio-fundamentals/
What is an RPA CoE? Session 2 – CoE RolesDianaGray10
In this session, we will review the players involved in the CoE and how each role impacts opportunities.
Topics covered:
• What roles are essential?
• What place in the automation journey does each role play?
Speaker:
Chris Bolin, Senior Intelligent Automation Architect Anika Systems
In the realm of cybersecurity, offensive security practices act as a critical shield. By simulating real-world attacks in a controlled environment, these techniques expose vulnerabilities before malicious actors can exploit them. This proactive approach allows manufacturers to identify and fix weaknesses, significantly enhancing system security.
This presentation delves into the development of a system designed to mimic Galileo's Open Service signal using software-defined radio (SDR) technology. We'll begin with a foundational overview of both Global Navigation Satellite Systems (GNSS) and the intricacies of digital signal processing.
The presentation culminates in a live demonstration. We'll showcase the manipulation of Galileo's Open Service pilot signal, simulating an attack on various software and hardware systems. This practical demonstration serves to highlight the potential consequences of unaddressed vulnerabilities, emphasizing the importance of offensive security practices in safeguarding critical infrastructure.
QA or the Highway - Component Testing: Bridging the gap between frontend appl...zjhamm304
These are the slides for the presentation, "Component Testing: Bridging the gap between frontend applications" that was presented at QA or the Highway 2024 in Columbus, OH by Zachary Hamm.
From Natural Language to Structured Solr Queries using LLMsSease
This talk draws on experimentation to enable AI applications with Solr. One important use case is to use AI for better accessibility and discoverability of the data: while User eXperience techniques, lexical search improvements, and data harmonization can take organizations to a good level of accessibility, a structural (or “cognitive” gap) remains between the data user needs and the data producer constraints.
That is where AI – and most importantly, Natural Language Processing and Large Language Model techniques – could make a difference. This natural language, conversational engine could facilitate access and usage of the data leveraging the semantics of any data source.
The objective of the presentation is to propose a technical approach and a way forward to achieve this goal.
The key concept is to enable users to express their search queries in natural language, which the LLM then enriches, interprets, and translates into structured queries based on the Solr index’s metadata.
This approach leverages the LLM’s ability to understand the nuances of natural language and the structure of documents within Apache Solr.
The LLM acts as an intermediary agent, offering a transparent experience to users automatically and potentially uncovering relevant documents that conventional search methods might overlook. The presentation will include the results of this experimental work, lessons learned, best practices, and the scope of future work that should improve the approach and make it production-ready.
Discover top-tier mobile app development services, offering innovative solutions for iOS and Android. Enhance your business with custom, user-friendly mobile applications.
What is an RPA CoE? Session 1 – CoE VisionDianaGray10
In the first session, we will review the organization's vision and how this has an impact on the COE Structure.
Topics covered:
• The role of a steering committee
• How do the organization’s priorities determine CoE Structure?
Speaker:
Chris Bolin, Senior Intelligent Automation Architect Anika Systems
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor IvaniukFwdays
At this talk we will discuss DDoS protection tools and best practices, discuss network architectures and what AWS has to offer. Also, we will look into one of the largest DDoS attacks on Ukrainian infrastructure that happened in February 2022. We'll see, what techniques helped to keep the web resources available for Ukrainians and how AWS improved DDoS protection for all customers based on Ukraine experience
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...Jason Yip
The typical problem in product engineering is not bad strategy, so much as “no strategy”. This leads to confusion, lack of motivation, and incoherent action. The next time you look for a strategy and find an empty space, instead of waiting for it to be filled, I will show you how to fill it in yourself. If you’re wrong, it forces a correction. If you’re right, it helps create focus. I’ll share how I’ve approached this in the past, both what works and lessons for what didn’t work so well.
The Microsoft 365 Migration Tutorial For Beginner.pptxoperationspcvita
This presentation will help you understand the power of Microsoft 365. However, we have mentioned every productivity app included in Office 365. Additionally, we have suggested the migration situation related to Office 365 and how we can help you.
You can also read: https://www.systoolsgroup.com/updates/office-365-tenant-to-tenant-migration-step-by-step-complete-guide/
High performance Serverless Java on AWS- GoTo Amsterdam 2024Vadym Kazulkin
Java is for many years one of the most popular programming languages, but it used to have hard times in the Serverless community. Java is known for its high cold start times and high memory footprint, comparing to other programming languages like Node.js and Python. In this talk I'll look at the general best practices and techniques we can use to decrease memory consumption, cold start times for Java Serverless development on AWS including GraalVM (Native Image) and AWS own offering SnapStart based on Firecracker microVM snapshot and restore and CRaC (Coordinated Restore at Checkpoint) runtime hooks. I'll also provide a lot of benchmarking on Lambda functions trying out various deployment package sizes, Lambda memory settings, Java compilation options and HTTP (a)synchronous clients and measure their impact on cold and warm start times.
7. Why do we need version
numbers?
• Label unique states of software
applications for future reference
• Introduce continuity for history of
software changes
• Track progress of software development
• Establish dependencies between
modules, libraries, applications, APIs, etc
8. Problem: version numbering is
broken
• Ambiguous. Same version number often
used to refer to different entities (e.g.
builds and branches)
• Unpredictable/inconsistent: 1.0 -> 1.1 -
> 1.2 -> 2.0 -> 2.1 -> 3.1
• Not formalized
• Cannot be used to serve its purpose
(reliable reference, continuity, tracking
progress, establishing dependencies)
9. Problem: version numbering is
broken
Inconsistent version numbering practices:
• Undermine possibilities of development
process automation
• Increase need of communication
• Become one of the causes of poor software
quality
• Cause many problems related to software
maintenance and support
16. It is possible to come up with two
different entities with the same number:
Automatic document sections
numbering cannot be applied to
software history
1.1 1.1.1
1.2 1.2.1 1.2.2 1.2.3
?
1.2.1.1 1.2.1.2
17. It is possible to come up with two
different entities with the same number:
Automatic document sections
numbering cannot be applied to
software history
1.1 1.1.1
1.2 1.2.1 1.2.2 1.2.3
1.2.2
1.2.1.1 1.2.1.2
18. It is possible to come up with two
different entities with the same number:
Automatic document sections
numbering cannot be applied to
software history
1.1 1.1.1
1.2 1.2.1 1.2.2 1.2.3
1.2.3
1.2.1.1 1.2.1.2
19. It is possible to come up with two
different entities with the same number:
Automatic document sections
numbering cannot be applied to
software history
1.1 1.1.1
1.2 1.2.1 1.2.2 1.2.3
1.2.1.1
1.2.1.1 1.2.1.2
20. It is possible to come up with two
different entities with the same number:
Automatic document sections
numbering cannot be applied to
software history
1.1 1.1.1
1.2 1.2.1 1.2.2 1.2.3
1.2.1.2
1.2.1.1 1.2.1.2
21. It is possible to come up with two
different entities with the same number:
Automatic document sections
numbering cannot be applied to
software history
1.1 1.1.1
1.2 1.2.1 1.2.2 1.2.3
1.2.4
1.2.1.1 1.2.1.2
22. It is possible to come up with two
different entities with the same number:
Automatic document sections
numbering cannot be applied to
software history
1.1 1.1.1
1.2 1.2.1 1.2.2 1.2.3
1.2.1.3
1.2.1.1 1.2.1.2
24. There are other problems …
variation
variant
#1 #2 #3 #N…
version Maturity
Platform
OS
Localizatio
n
Build type
…
25. There are other problems …
HTC_Touch_Diamond2_WM6.5_RUU_Topaz_S_HT
C_RUS_2.16.411.2_Radio_Sign_Topaz_61.44
tc.25.32_4.49.25.17_Ship.exe
Real world example:
26. There are other problems …
HTC_Touch_Diamond2_WM6.5_RUU_Topaz_S_HT
C_RUS_2.16.411.2_Radio_Sign_Topaz_61.44
tc.25.32_4.49.25.17_Ship.exe
Real world example:
Where is version?
27. There are other problems …
HTC_Touch_Diamond2_WM6.5_RUU_Topaz_S_HT
C_RUS_2.16.411.2_Radio_Sign_Topaz_61.44
tc.25.32_4.49.25.17_Ship.exe
Real world example:
Where is version?
28. There are other problems …
HTC_Touch_Diamond2_WM6.5_RUU_Topaz_S_HT
C_RUS_2.16.411.2_Radio_Sign_Topaz_61.44
tc.25.32_4.49.25.17_Ship.exe
Real world example:
Where is version?
29. There are other problems …
HTC_Touch_Diamond2_WM6.5_RUU_Topaz_S_HT
C_RUS_2.16.411.2_Radio_Sign_Topaz_61.44
tc.25.32_4.49.25.17_Ship.exe
Real world example:
Where is version?
30. There are other problems …
HTC_Touch_Diamond2_WM6.5_RUU_Topaz_S_HT
C_RUS_2.16.411.2_Radio_Sign_Topaz_61.44
tc.25.32_4.49.25.17_Ship.exe
Real world example:
Where is version?
35. Suggested solution
1. Take “section numbering”
approach
2. Formalize it
3. Show that it is possible to
perform basic operations
using suggested
formalization
4. Extend formalization to
solve problems of software
version numbering
5. Provide mapping from “old
style” to “new style”
approach
38. Formalization of “sections
numbering” approach
Nat
o 0, 1, 2, …
_._ ⊆ Nat × Nat × … × Nat
o 0.1, 1.4, 45.23
o 1.0.0, 45.2.0, 34.89.9
o 3.5.20.11, 2.4.99.85.34.2
…
Num = N1.N2. … .Nk
_<_ ⊆ Num × Num
o 0 < 1, 2 < 9, 3 < 90
o 1.1 < 1.2, 1.3 < 1.5, 4.1 < 6.8
o 2.1.1 < 4.69.78.2 , 2 < 3.8.2.3
…
Section numbering
39. Formalization of “sections
numbering” approach
next : Num -> Nat-> Num
o next 1 {1} -> 2
o next 1.0 1 -> 2.0
o next 1.0 2 -> 1.1
o next 3.4.5.6 3 -> 3.4.6.6
…
NumTree : NumTree (Num NumTree)
nTree = NumTree
nTree =>
o 1
1.1
1.1.1
1.2
1.2.1
1.2.2
1.2.3
Section numbering
43. Extension of “sections numbering”
approach
Nat
o 0, 1, 2, …
_._ ⊆ Nat × Nat × … × Nat
o 0.1, 1.4, 45.23
o 1.0.0, 45.2.0, 34.89.9
o 3.5.20.11, 2.4.99.85.34.2
…
Num = N1.N2. … .Nk
_<_ ⊆ Num × Num
o 0 < 1, 2 < 9, 3 < 90
o 1.1 < 1.2, 1.3 < 1.5, 4.1 < 6.8
o 2.1.1 < 4.69.78.2 , 2 < 3.8.2.3
…
Section numbering
Nat
o 0, 1, 2, …
X : Set
VC ::= Nat
| X
_._ ⊆ VC × VC × … × VC
o 0.1, 1.4, 45.23
o 1.0.0, 45.2.0, 34.89.9
o 3.5.20.11, 2.4.99.85.34.2,
o X , X.X , X.X.X , X.X.X.X , X. … .X
o X.1, X.2, X.3, X.4, … X.n
o X.X.2, X.5.X, 6.X.X, 6.5.X, X.23.10
Num = N1.N2. … .Nk
_<_ ⊆ Num × Num
o 0 < 1, 2 < 9, 3 < 90
o 1.1 < 1.2, 1.3 < 1.5, 4.1 < 6.8
o 2.1.1 < 4.69.78.2 , 2 < 3.8.2.3
o X.0 < X.1
o 1.X.14 < 1.X.25
o 2.3.X < 3.8.X
o X < 0
o 1.X.X < 1.0.X
Version numbering
44. Extension of “sections numbering”
approach
next : Num -> Num -> Num
o next 1 {1} -> 2
o next 1.0 1 -> 2.0
o next 1.0 2 -> 1.1
o next 3.4.5.6 3 -> 3.4.6.6
…
NumTree : NumTree (Num NumTree)
nTree = NumTree
nTree =>
o 1
1.1
1.1.1
1.2
1.2.1
1.2.2
1.2.3
next : Num -> Num
o next 1 -> 2
o next 1.0 -> 1.1
o next 3.4.5.6 -> 3.4.5.7
o next 1.X -> 2.X
o next 3.X.X -> 4.X.X
o next X.6 -> X.7
o next 1.0.X -> 1.1.X
o next 1.X.13 -> 1.X.14
…
NumTree : NumTree (Num NumTree)
nTree = NumTree
nTree =>
o X.X.X
1.X.X
1.0.X
1.1.X
o 1.1.0
o 1.1.1
1.2.X
o 1.2.0
o 1.2.1
o 1.2.2
o 1.2.3
Section numbering Version numbering
45. Extension of “sections numbering”
approach
appendNext : NumTree -> Nat -> NumTree
appendNext vTree 1 =>
o 1
1.1
1.1.1
1.2
1.2.1
1.2.2
1.2.3
o 2
appendNext vTree 2 =>
o 1
1.1
1.1.1
1.2
1.2.1
1.2.2
1.2.3
1.3
Section numbering
appendNext : NumTree -> Nat -> NumTree
appendNext nTree 1 =>
o X.X.X
1.X.X
1.0.X
1.1.X
o 1.1.0
o 1.1.1
1.2.X
o 1.2.0
o 1.2.1
o 1.2.2
o 1.2.3
2.X.X
appendNext nTree 2 =>
o X.X.X
1.X.X
1.0.X
1.1.X
o 1.1.0
o 1.1.1
1.2.X
o 1.2.0
o 1.2.1
o 1.2.2
o 1.2.3
1.3.X
Version numbering
46. Extension of “sections numbering”
approach
Section numbering
appendNext nTree 3 =>
o 1
1.1
1.1.1
1.2
1.2.1
1.2.2
1.2.3
1.2.4
appendNext nTree 3 =>
o X.X.X
1.X.X
1.0.X
1.1.X
o 1.1.0
o 1.1.1
1.2.X
o 1.2.0
o 1.2.1
o 1.2.2
o 1.2.3
o 1.2.4
Version numbering
47. Extension of “sections numbering”
approach
Version numbering
_↓_
o X ↓ 1, X ↓ 2, X ↓ 3, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 0.X , X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
_==_
o X.6.8 == 6.8
o X.1 == 1
o X.X.1 == 1
o X.X.k == k
o X.2.6 == 2.6
o X.1.X == 1.X
o X.X.X = X
o X. … .X = X
…
Copy
Equivalence
49. Extension of “sections numbering”
approach: visual representation
Version numbering
_↓_
o X ↓ 1, X ↓ 2, X ↓ 3, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 0.X , X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
_==_
o X.6.8 == 6.8
o X.1 == 1
o X.X.1 == 1
o X.X.k == k
o X.2.6 == 2.6
o X.1.X == 1.X
o X.X.X = X
o X. … .X = X
…
1 2 3 k…
X
50. Extension of “sections numbering”
approach: visual representation
Version numbering
_↓_
o X ↓ 1, X ↓ 2, X ↓ 3, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
_==_
o X.6.8 == 6.8
o X.1 == 1
o X.X.1 == 1
o X.X.k == k
o X.2.6 == 2.6
o X.1.X == 1.X
o X.X.X = X
o X. … .X = X
…
1 2 3 k…
X
X.X
/1.X
1.0 1.1 1.2
X.1 X.2 X.3 X.k…
1.k…
…
/2.X /m.X
51. Extension of “sections numbering”
approach: visual representation
Version numbering
_↓_
o X ↓ 1, X ↓ 2, X ↓ 3, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
_==_
o X.6.8 == 6.8
o X.1 == 1
o X.X.1 == 1
o X.X.k == k
o X.2.6 == 2.6
o X.1.X == 1.X
o X.X.X = X
o X. … .X = X
…
1 2 3 k…
X
X.X
/1.X
1.0 1.1 1.2
X.1 X.2 X.3 X.k…
1.k…
…
/2.X /m.X
52. Extension of “sections numbering”
approach: visual representation
Version numbering
_↓_
o X ↓ 1, X ↓ 2, X ↓ 3, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
_==_
o X.6.8 == 6.8
o X.1 == 1
o X.X.1 == 1
o X.X.k == k
o X.2.6 == 2.6
o X.1.X == 1.X
o X.X.X = X
o X. … .X = X
…
1 2 3 k…
X
X.X
/1.X
1.0 1.1 1.2
X.1 X.2 X.3 X.k…
1.k…
…
/2.X /m.X
53. Extension of “sections numbering”
approach: visual representation
Version numbering
_↓_
o X ↓ 1, X ↓ 2, X ↓ 3, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
_==_
o X.6.8 == 6.8
o X.1 == 1
o X.X.1 == 1
o X.X.k == k
o X.2.6 == 2.6
o X.1.X == 1.X
o X.X.X = X
o X. … .X = X
…
1 2 3 k…
X
X.X
/1.X
1.0 1.1 1.2
X.1 X.2 X.3 X.k…
1.k…
…
/2.X /m.X
54. Extension of “sections numbering”
approach: visual representation
1.x.x
1.0.x
x.x.x
x.x.1 x.x.2 x.x.3
1.x.0 1.x.1 1.x.k
1.0.0 1.0.1 1.0.k…
…
n.x.x
1.1.x
1.m.x
n.x.0 n.x.1 n.x.k…
…
…
2.x.x
x.x.4 x.x.5 x.x.6 x.x.k…
_↓_
o X ↓ 0, X ↓ 1, X ↓ 2, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
55. Extension of “sections numbering”
approach: visual representation
1.x.x
1.0.x
x.x.x
x.x.1 x.x.2 x.x.3
1.x.0 1.x.1 1.x.k
1.0.0 1.0.1 1.0.k…
…
n.x.x
1.1.x
1.m.x
n.x.0 n.x.1 n.x.k…
…
…
2.x.x
x.x.4 x.x.5 x.x.6 x.x.k…
_↓_
o X ↓ 0, X ↓ 1, X ↓ 2, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
56. Extension of “sections numbering”
approach: visual representation
1.x.x
1.0.x
x.x.x
x.x.1 x.x.2 x.x.3
1.x.0 1.x.1 1.x.k
1.0.0 1.0.1 1.0.k…
…
n.x.x
1.1.x
1.m.x
n.x.0 n.x.1 n.x.k…
…
…
2.x.x
x.x.4 x.x.5 x.x.6 x.x.k…
_↓_
o X ↓ 0, X ↓ 1, X ↓ 2, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
57. Extension of “sections numbering”
approach: visual representation
1.x.x
1.0.x
x.x.x
x.x.1 x.x.2 x.x.3
1.x.0 1.x.1 1.x.k
1.0.0 1.0.1 1.0.k…
…
n.x.x
1.1.x
1.m.x
n.x.0 n.x.1 n.x.k…
…
…
2.x.x
x.x.4 x.x.5 x.x.6 x.x.k…
_↓_
o X ↓ 0, X ↓ 1, X ↓ 2, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
58. Extension of “sections numbering”
approach: visual representation
1.x.x
1.0.x
x.x.x
x.x.1 x.x.2 x.x.3
1.x.0 1.x.1 1.x.k
1.0.0 1.0.1 1.0.k…
…
n.x.x
1.1.x
1.m.x
n.x.0 n.x.1 n.x.k…
…
…
2.x.x
x.x.4 x.x.5 x.x.6 x.x.k…
_↓_
o X ↓ 0, X ↓ 1, X ↓ 2, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
59. Extension of “sections numbering”
approach: visual representation
1.x.x
1.0.x
x.x.x
x.x.1 x.x.2 x.x.3
1.x.0 1.x.1 1.x.k
1.0.0 1.0.1 1.0.k…
…
n.x.x
1.1.x
1.m.x
n.x.0 n.x.1 n.x.k…
…
…
2.x.x
x.x.4 x.x.5 x.x.6 x.x.k…
1 2 k…
x
3 4 5 6
== == == == == == ==
_==_
o X.6.8 == 6.8
o X.1 == 1
o X.X.1 == 1
o X.X.k == k
o X.2.6 == 2.6
o X.1.X == 1.X
o X.X.X = X
o X. … .X = X
60. Extension of “sections numbering”
approach: visual representation
x.x.x
x.x.x
x.x.x
x.x.x
x.x.x
x.x.x
…
x.x.x
_↓_
o X ↓ 0, X ↓ 1, X ↓ 2, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
x.x.x
x.x.x
x.x.x
…
_==_
o X.6.8 == 6.8
o X.1 == 1
o X.X.1 == 1
o X.X.k == k
o X.2.6 == 2.6
o X.1.X == 1.X
o X.X.X = X
o X. … .X = X
61. Extension of “sections numbering”
approach: visual representation
x.x
x.x
x.x
x.x
x.x
x.x
…
x.x
_↓_
o X ↓ 0, X ↓ 1, X ↓ 2, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
x.x
x.x
x.x
…
_==_
o X.6.8 == 6.8
o X.1 == 1
o X.X.1 == 1
o X.X.k == k
o X.2.6 == 2.6
o X.1.X == 1.X
o X.X.X = X
o X. … .X = X
62. Extension of “sections numbering”
approach: visual representation
x
x
x
x
x
x
…
x
_↓_
o X ↓ 0, X ↓ 1, X ↓ 2, … X ↓ k
o X.X ↓ X.1 , X.X ↓ X.2 , … , X.X ↓ X.k
o X.X ↓ 1.X , X.X ↓ 2.X , … , X.X ↓ m.X
o 1.X ↓ 1.0 , 1.X ↓ 1.1 , 1.X ↓ 1.2 , … , 1.X ↓ 1.k
o X.X.X ↓ 1.X.X , X.X.X ↓ 2.X.X, … , X.X.X ↓ n.X.X
o 1.X.X ↓ 1.0.X , 1.X.X ↓ 1.1.X, … , 1.X.X ↓ 1.m.X
o 1.X.X ↓ 1.X.0 , 1.X.X ↓ 1.X.1, … , 1.X.X ↓ 1.X.k
o 1.0.X ↓ 1.0.0 , 1.0.X ↓ 1.0.1, … , 1.0.X ↓ 1.0.k
o X.X.X ↓ X.X.X , X.X ↓ X.X , X ↓ X
…
x
x
x
…
_==_
o X.6.8 == 6.8
o X.1 == 1
o X.X.1 == 1
o X.X.k == k
o X.2.6 == 2.6
o X.1.X == 1.X
o X.X.X = X
o X. … .X = X
73. x
x
x
x
Revisions: 1, 2, 3, … , 2131, …
Mapping from “old style” to “new
style”
x
x
x
x
x
x
x
8 10
1
7
2 3 5
2.1 2.2
1.1 1.2 1.3 1.4
1.3.2.1
x
9
1.3.2.2
4
1.3.1.1
6
1.3.1.2
74. Semantics of version
numbering
1.0.x
1.x.x
x.1.x x.2.x
x.x.x
1.0.x
1.x.x
x.x.x
1.0.x
1.1.x
2.x.x
x.x.x
1.x.x
1.0.x
1.1.x
1.x.x
x.x.x
x
x
x
x
There are many
different ways to
decompose the same
history of versions.
Which one should we
choose?
We need to learn
about semantics of
76. Semantics of “old” version
numbering
[major].[minor].[build]
1.2.3
ITERATIONS
ARCHITECTURE
CONCEPTS
PORTING
MARKETING
BUILD
PATCH
http://semver.org/
77. Semantics of “new” version
numbering
x.x.x
N.M.K
mutable
immutable
Creation of
immutable
artifact
compatible
incompatible
Definition of
compatibility
scope
all changes
Fixed set of
features
Feature freeze
81. Mapping from “old style” to “new
style”
1.0.x
1.x.x
x.1.x x.2.x
x.x.x
1.0.x
1.x.x
x.x.x
1.0.x
1.1.x
2.x.x
x.x.x
1.x.x
1.0.x
1.1.x
1.x.x
x.x.x
x
x
x
x
?
?
?
?
?
82. Mapping from “old style” to “new
style”
• Way of versions history decomposition depends on
WHY certain versions were created:
• Purpose of tagging, branching, etc
• Actual content of tag, branch, etc
• It is difficult to refactor existing history of versions
because of insufficient information about purpose and
content of certain artifacts.
• It is easier to follow rules of version numbering
semantics at early stages of software projects.
• It is even more easy to follow rules if there is a special
tool that helps with version numbering.
88. Hierarchy of version numbers
x.x
x.KM.x
M.K
x
K
x.x.x
x.x.KN.x.x
N.M.K
x.M.x
x.M.KN.M.x N.x.K
X.X.X ↓ X.M.X
X.X.X ↓ N.X.X
X.X.X ↓ X.X.K
N.X.X ↓ N.M.X
N.X.X ↓ N.X.K
X.M.X ↓ X.M.K
N.M.X ↓ N.M.K
X.X ↓ M.X
X.X ↓ X.K
M.X ↓ M.K
M.X ↓ M.K
X ↓ K
It is possible to establish hierarchy of version
numbers using copy operation:
102. Conclusion
• Version != variation
• Versions and variations are complementary and always go
side by side in software development
• Necessity of software configuration management practices
arises because of high variability of software
• Both formalized version numbering and variations can help
to understand nature of changes better
• If formalized, versions can provide context for variations
and choices of alternative implementations
• Proper version numbering must be introduced into software
projects as early as possible to avoid problems with version
numbering.
• Formalized version numbering and variations are stepping
stone for better software tools.