This document provides an overview of Apache Subversion (SVN), a version control system. It discusses basic SVN concepts like repositories, trunks, tags, and branches. It also covers setting up the SVN environment, including installing SVN, configuring Apache, setting up users and repositories. The document then outlines the typical SVN lifecycle of creating a repository, checking out a working copy, making changes, reviewing changes, resolving conflicts, and committing updates. It provides details on key SVN processes like checking out, making changes, updating, fixing mistakes, and resolving conflicts. Finally, it briefly discusses tags and branching in SVN. The document serves as a tutorial for understanding and using SVN for software version control.
This document provides an introduction to Subversion (SVN), a version control system. It describes key SVN concepts like the repository, trunk, branches, and tags. The trunk contains the main codebase, branches are for experimental work, and tags save stable versions. SVN allows developers to track changes, rollback mistakes, experiment safely without breaking the main code, and collaborate effectively. It works by having a central repository that all developers update and commit their code to. This ensures everyone works from the latest version and changes can be merged automatically. The document outlines best practices like using branches for new features, tagging stable builds, committing with detailed messages, and updating frequently.
This document provides an overview of the key operations in the Subversion (SVN) version control system life cycle. It describes creating a repository, checking out a working copy, updating changes from the repository, performing edits and other changes locally, reviewing pending changes, fixing mistakes by reverting changes, and resolving conflicts when merging changes. The main operations covered are checkout, update, commit, status, diff, revert, and merge.
This document introduces SVN concepts and best practices. It discusses the benefits of version control such as tracking changes, rolling back mistakes, and collaborating on code. It explains how the SVN workflow involves developers checking out code from a central repository, making changes locally, and committing changes back. The document outlines the trunk, branch, and tag file structure and describes branches as experimental code and tags as saved versions. It provides examples of common SVN commands like add, commit, update, and viewing changes. Finally, it offers best practices such as small commits, updating before working, and writing descriptive commit messages.
I made a simple SVN (Subversion) tutorial for my co-workers and just wanted to share it with you. It is based on other lectures and practical experience I had in the past.
Some ideas also come from the GIT world, which is still too far and new for everyone, but which I already love and embrace fully :)
The document provides an overview of using Subversion (SVN) for source code control, including how to set up SVN clients and servers, basic and advanced SVN commands, best practices for usage, and how to install the VisualSVN server software. SVN allows developers to concurrently edit and manage different versions of code through features like revision tracking, merging, branching and locking files during edits. The document recommends using SVN for both individual developers and development teams to avoid issues with shared network drives and provides instructions for getting started with clients like TortoiseSVN and servers like VisualSVN.
The document discusses various topics relating to Subversion (SVN) including basics like checkout, commit, update, status, add, and resolve conflicts. It also covers branching, merging, and best practices. Specifically it provides commands for creating and switching branches, finding the revision number where a feature branch was created, merging a feature branch, and committing the merge. It recommends committing changes per fix/change, keeping commits small, only committing working code, and including the why but not what in commit comments.
What is svn?
how svn works ?
diagram of SVN ?
Merging with SVN ?
Conflict With SVN ?
Checkout and Checkin ,update ,branch , tags ?
what is version control "?
SVN file directory ?
Directories locked in Tags ?
This document provides an introduction to Subversion (SVN), a version control system. It describes key SVN concepts like the repository, trunk, branches, and tags. The trunk contains the main codebase, branches are for experimental work, and tags save stable versions. SVN allows developers to track changes, rollback mistakes, experiment safely without breaking the main code, and collaborate effectively. It works by having a central repository that all developers update and commit their code to. This ensures everyone works from the latest version and changes can be merged automatically. The document outlines best practices like using branches for new features, tagging stable builds, committing with detailed messages, and updating frequently.
This document provides an overview of the key operations in the Subversion (SVN) version control system life cycle. It describes creating a repository, checking out a working copy, updating changes from the repository, performing edits and other changes locally, reviewing pending changes, fixing mistakes by reverting changes, and resolving conflicts when merging changes. The main operations covered are checkout, update, commit, status, diff, revert, and merge.
This document introduces SVN concepts and best practices. It discusses the benefits of version control such as tracking changes, rolling back mistakes, and collaborating on code. It explains how the SVN workflow involves developers checking out code from a central repository, making changes locally, and committing changes back. The document outlines the trunk, branch, and tag file structure and describes branches as experimental code and tags as saved versions. It provides examples of common SVN commands like add, commit, update, and viewing changes. Finally, it offers best practices such as small commits, updating before working, and writing descriptive commit messages.
I made a simple SVN (Subversion) tutorial for my co-workers and just wanted to share it with you. It is based on other lectures and practical experience I had in the past.
Some ideas also come from the GIT world, which is still too far and new for everyone, but which I already love and embrace fully :)
The document provides an overview of using Subversion (SVN) for source code control, including how to set up SVN clients and servers, basic and advanced SVN commands, best practices for usage, and how to install the VisualSVN server software. SVN allows developers to concurrently edit and manage different versions of code through features like revision tracking, merging, branching and locking files during edits. The document recommends using SVN for both individual developers and development teams to avoid issues with shared network drives and provides instructions for getting started with clients like TortoiseSVN and servers like VisualSVN.
The document discusses various topics relating to Subversion (SVN) including basics like checkout, commit, update, status, add, and resolve conflicts. It also covers branching, merging, and best practices. Specifically it provides commands for creating and switching branches, finding the revision number where a feature branch was created, merging a feature branch, and committing the merge. It recommends committing changes per fix/change, keeping commits small, only committing working code, and including the why but not what in commit comments.
What is svn?
how svn works ?
diagram of SVN ?
Merging with SVN ?
Conflict With SVN ?
Checkout and Checkin ,update ,branch , tags ?
what is version control "?
SVN file directory ?
Directories locked in Tags ?
Subversion is a leading open source version control system that provides features for:
- Backing up data and configuration management through atomic commits to a centralized repository.
- Distributed development via easy branching and tagging of project files and revisions.
- Integrations for Windows, Linux, Unix, and web-based access through modules like Apache.
This document provides an overview of version control and Subversion (SVN). It defines version control as the management of changes to documents and files. It discusses why version control is needed, such as for backup, synchronization, tracking changes and owners. It then describes the basic concepts and terminology of SVN like repositories, working copies, revisions, checkouts, checkins and updates. The document also demonstrates the basic SVN workflow and architecture. It concludes with best practices for using SVN.
Largely based on Vishnu Gopal's presentation http://www.slideshare.net/vishnu/basic-source-control-with-subversion
Used for a quick SVN introduction in a Software Engineering course at Massey University.
The document provides information about Subversion, an open source version control system. It describes Subversion repositories and modules, the basic workflow for users including checking out modules and committing changes. It also covers common commands like update, commit, and resolve conflicts. Key aspects of Subversion architecture are explained, including repository access methods and components like the svn client.
Jenkins is an open-source tool for continuous integration that was originally developed as the Hudson project. It allows developers to commit code frequently to a shared repository, where Jenkins will automatically build and test the code. Jenkins is now the leading replacement for Hudson since Oracle stopped maintaining Hudson. It helps teams catch issues early and deliver software more rapidly through continuous integration and deployment.
This document provides an introduction and overview of Jenkins, an open-source automation tool for continuous integration. It discusses that Jenkins is written in Java and uses plugins to enable continuous integration through automation of various DevOps stages. Some key advantages are that it is open-source, easy to install, has many plugins, and is free. The document also covers what continuous integration is, why it is needed to detect problems early, and the different stages of adopting a continuous integration approach.
This document provides instructions on how to use the TortoiseSVN client to interact with a Subversion repository. It describes how to checkout a working copy from the repository, make changes to files, commit changes back to the repository, resolve conflicts, and view the history of changes. It also provides definitions for common Subversion terms like commit, update, merge, and working copy.
This document provides an overview of version control and administration using Subversion (SVN). It discusses SVN concepts like checkout, add, commit, update, tag and branch. It explains how to set up an SVN repository using TortoiseSVN, add and modify files, and take backups and restores of the repository. It also covers hook scripts that can be used for pre-commit validation and post-commit notifications.
Introduction to Subversion and Google Project HostingPhilip Johnson
This document introduces Subversion (SVN) and Google Project Hosting. It describes basic SVN concepts like repositories, working copies, commits, updates and revisions. It explains how SVN uses repository-wide revisions rather than file-based versions. Branches, tags and trunks are organized conventionally in an SVN repository. Google Project Hosting provides a free SVN server and issue tracker for open source projects.
Maven is close to ubiquitous in the world of enterprise Java, and the Maven dependency ecosystem is the de facto industry standard. However, the traditional Maven build and release strategy, based on snapshot versions and carefully planned releases, is difficult to reconcile with modern continuous delivery practices, where any commit that passes a series of quality-control gateways can qualify as a release. How can teams using the standard Maven release process still leverage the benefits of continuous delivery? This presentation discusses strategies that can be used to implement continuous delivery solutions with Maven and demonstrates one such strategy using Maven, Jenkins, and Git.
Automating your build process with Continuous Integration is certainly a great idea, but why stop there? Why not go the whole nine yards and automate the deployment process as well? Staging and production deployments are typically more complicated and more involved than a simple development deployment, but doing them by hand can be time-consuming, tricky and error-prone. Indeed, turning your staging and production deployments into a one-click affair has a lot going for it.
Jenkins is a Continuous Integration (CI) server or tool which is written in Java. It provides Continuous Integration services for software development, which can be started via command line or web application server. Jenkins Pipeline is a suite of plugins which supports implementing and integrating continuous delivery pipelines into Jenkins.
Maven is an open source build automation tool used primarily for Java projects to manage builds, documentation, dependencies, and reports. It uses a project object model (POM) file to manage build configuration and dependencies. Maven has defined build lifecycles consisting of phases that execute plugin goals. It provides standard project layout and dependency management. Maven searches dependencies in local, central, and remote repositories. Build profiles allow customizing builds for different environments. Plugins are used to perform tasks like compiling, testing, packaging, and generating documentation.
Jenkins - Continuous Integration after Hudson, CruiseControl, and home builtMark Waite
This document discusses Jenkins, an open source tool for continuous integration. It describes how Jenkins can help improve productivity by detecting breaks sooner, reporting failures more clearly, and making progress more visible. The document outlines how Jenkins is easy to install, use, and extend with over 300 plugins. It provides examples of using Jenkins for various programming languages and tasks like version control, building, testing, analyzing code quality, and notifications. Finally, it explains how Jenkins can support team development through features like multi-configuration and multi-stage jobs, and swarms to dynamically allocate resources.
This document discusses Jenkins 2.0 and its new "pipeline as code" feature. Pipeline as code allows automation of continuous delivery pipelines by describing the stages in a textual pipeline script stored in version control. This enables pipelines to be more flexible, reusable and survive Jenkins restarts. The document provides examples of pipeline scripts for common tasks like building, testing, archiving artifacts and running in parallel. It also discusses how pipelines can be made more reusable by defining shared library methods.
Jenkins Pipeline uses a master-slave architecture to execute builds across multiple nodes. The Jenkinsfile defines the continuous delivery pipeline using Declarative or Scripted syntax. It contains stages for building, testing, and deploying with steps to define tasks. Maven is used to manage dependencies and build processes. It defines projects using a POM file containing identifiers, dependencies, repositories, plugins, and build configuration.
This document provides best practices for using Subversion (SVN), a version control system. It discusses SVN commands like checkout, add, delete, copy, move, commit, update, and status. It emphasizes checking in changes regularly in distinct commits with clear messages, updating working directories before editing or committing, and using SVN commands instead of shell commands to maintain history. The document also recommends regularly checking the status of working directories and outlines a typical SVN repository structure with trunk for production code and branches and tags for development and snapshots.
This document provides an introduction to version control using Subversion (SVN) and the TortoiseSVN client. It begins with an overview of SVN, describing it as an open source version control system that is popular and free. The document then discusses how to install TortoiseSVN on Windows and describes some basic SVN commands like checkout, update, add, delete and commit. It concludes with an example of how to use TortoiseSVN through its graphical interface to perform version control tasks like checking out a repository, committing changes, updating files and resolving conflicts.
Subversion is a leading open source version control system that provides features for:
- Backing up data and configuration management through atomic commits to a centralized repository.
- Distributed development via easy branching and tagging of project files and revisions.
- Integrations for Windows, Linux, Unix, and web-based access through modules like Apache.
This document provides an overview of version control and Subversion (SVN). It defines version control as the management of changes to documents and files. It discusses why version control is needed, such as for backup, synchronization, tracking changes and owners. It then describes the basic concepts and terminology of SVN like repositories, working copies, revisions, checkouts, checkins and updates. The document also demonstrates the basic SVN workflow and architecture. It concludes with best practices for using SVN.
Largely based on Vishnu Gopal's presentation http://www.slideshare.net/vishnu/basic-source-control-with-subversion
Used for a quick SVN introduction in a Software Engineering course at Massey University.
The document provides information about Subversion, an open source version control system. It describes Subversion repositories and modules, the basic workflow for users including checking out modules and committing changes. It also covers common commands like update, commit, and resolve conflicts. Key aspects of Subversion architecture are explained, including repository access methods and components like the svn client.
Jenkins is an open-source tool for continuous integration that was originally developed as the Hudson project. It allows developers to commit code frequently to a shared repository, where Jenkins will automatically build and test the code. Jenkins is now the leading replacement for Hudson since Oracle stopped maintaining Hudson. It helps teams catch issues early and deliver software more rapidly through continuous integration and deployment.
This document provides an introduction and overview of Jenkins, an open-source automation tool for continuous integration. It discusses that Jenkins is written in Java and uses plugins to enable continuous integration through automation of various DevOps stages. Some key advantages are that it is open-source, easy to install, has many plugins, and is free. The document also covers what continuous integration is, why it is needed to detect problems early, and the different stages of adopting a continuous integration approach.
This document provides instructions on how to use the TortoiseSVN client to interact with a Subversion repository. It describes how to checkout a working copy from the repository, make changes to files, commit changes back to the repository, resolve conflicts, and view the history of changes. It also provides definitions for common Subversion terms like commit, update, merge, and working copy.
This document provides an overview of version control and administration using Subversion (SVN). It discusses SVN concepts like checkout, add, commit, update, tag and branch. It explains how to set up an SVN repository using TortoiseSVN, add and modify files, and take backups and restores of the repository. It also covers hook scripts that can be used for pre-commit validation and post-commit notifications.
Introduction to Subversion and Google Project HostingPhilip Johnson
This document introduces Subversion (SVN) and Google Project Hosting. It describes basic SVN concepts like repositories, working copies, commits, updates and revisions. It explains how SVN uses repository-wide revisions rather than file-based versions. Branches, tags and trunks are organized conventionally in an SVN repository. Google Project Hosting provides a free SVN server and issue tracker for open source projects.
Maven is close to ubiquitous in the world of enterprise Java, and the Maven dependency ecosystem is the de facto industry standard. However, the traditional Maven build and release strategy, based on snapshot versions and carefully planned releases, is difficult to reconcile with modern continuous delivery practices, where any commit that passes a series of quality-control gateways can qualify as a release. How can teams using the standard Maven release process still leverage the benefits of continuous delivery? This presentation discusses strategies that can be used to implement continuous delivery solutions with Maven and demonstrates one such strategy using Maven, Jenkins, and Git.
Automating your build process with Continuous Integration is certainly a great idea, but why stop there? Why not go the whole nine yards and automate the deployment process as well? Staging and production deployments are typically more complicated and more involved than a simple development deployment, but doing them by hand can be time-consuming, tricky and error-prone. Indeed, turning your staging and production deployments into a one-click affair has a lot going for it.
Jenkins is a Continuous Integration (CI) server or tool which is written in Java. It provides Continuous Integration services for software development, which can be started via command line or web application server. Jenkins Pipeline is a suite of plugins which supports implementing and integrating continuous delivery pipelines into Jenkins.
Maven is an open source build automation tool used primarily for Java projects to manage builds, documentation, dependencies, and reports. It uses a project object model (POM) file to manage build configuration and dependencies. Maven has defined build lifecycles consisting of phases that execute plugin goals. It provides standard project layout and dependency management. Maven searches dependencies in local, central, and remote repositories. Build profiles allow customizing builds for different environments. Plugins are used to perform tasks like compiling, testing, packaging, and generating documentation.
Jenkins - Continuous Integration after Hudson, CruiseControl, and home builtMark Waite
This document discusses Jenkins, an open source tool for continuous integration. It describes how Jenkins can help improve productivity by detecting breaks sooner, reporting failures more clearly, and making progress more visible. The document outlines how Jenkins is easy to install, use, and extend with over 300 plugins. It provides examples of using Jenkins for various programming languages and tasks like version control, building, testing, analyzing code quality, and notifications. Finally, it explains how Jenkins can support team development through features like multi-configuration and multi-stage jobs, and swarms to dynamically allocate resources.
This document discusses Jenkins 2.0 and its new "pipeline as code" feature. Pipeline as code allows automation of continuous delivery pipelines by describing the stages in a textual pipeline script stored in version control. This enables pipelines to be more flexible, reusable and survive Jenkins restarts. The document provides examples of pipeline scripts for common tasks like building, testing, archiving artifacts and running in parallel. It also discusses how pipelines can be made more reusable by defining shared library methods.
Jenkins Pipeline uses a master-slave architecture to execute builds across multiple nodes. The Jenkinsfile defines the continuous delivery pipeline using Declarative or Scripted syntax. It contains stages for building, testing, and deploying with steps to define tasks. Maven is used to manage dependencies and build processes. It defines projects using a POM file containing identifiers, dependencies, repositories, plugins, and build configuration.
This document provides best practices for using Subversion (SVN), a version control system. It discusses SVN commands like checkout, add, delete, copy, move, commit, update, and status. It emphasizes checking in changes regularly in distinct commits with clear messages, updating working directories before editing or committing, and using SVN commands instead of shell commands to maintain history. The document also recommends regularly checking the status of working directories and outlines a typical SVN repository structure with trunk for production code and branches and tags for development and snapshots.
This document provides an introduction to version control using Subversion (SVN) and the TortoiseSVN client. It begins with an overview of SVN, describing it as an open source version control system that is popular and free. The document then discusses how to install TortoiseSVN on Windows and describes some basic SVN commands like checkout, update, add, delete and commit. It concludes with an example of how to use TortoiseSVN through its graphical interface to perform version control tasks like checking out a repository, committing changes, updating files and resolving conflicts.
As reformas pombalinas da instrução publica - Laerte Ramos de CarvalhoMAURIZIO MARCHETTI
Este documento discute as reformas educacionais promovidas pelo Marquês de Pombal no século XVIII em Portugal. O autor argumenta que as reformas não foram apenas a expressão da vontade de Pombal, mas sim um esforço de integração de diferentes opiniões. As reformas refletiam uma filosofia política mais ampla e marcavam uma mudança significativa na cultura portuguesa da época.
Nathan Patalano introduces himself and his focus on digital music and computers. He shows off equipment like a Launchpad S for making beats, a Numark mixer II for mixing songs, and uses Ableton Live and Virtual DJ Pro. He also shows a sound board and the inside of a PC which he is knowledgeable about.
This document lists the NAAS (National Academy of Agricultural Sciences) scores of 176 scientific journals from various disciplines including agriculture, biology, chemistry, and physics. The NAAS score is a quantitative measure of the quality and impact of a journal, with higher scores indicating higher quality. Scores ranged from 2.72 to 20, with most scores falling between 6-10. Several high impact journals in the biological sciences like Annual Review of Biochemistry and Genetics scored above 15.
A model of hybrid genetic algorithm particle swarm optimization(hgapso) based...eSAT Publishing House
This document describes a hybrid genetic algorithm-particle swarm optimization (HGAPSO) model for query optimization in web information retrieval. HGAPSO uses genetic algorithms and particle swarm optimization to expand keywords and generate new related keywords to improve search results for users. It represents documents as chromosomes with weights assigned to keywords. The fitness of chromosomes is evaluated using Jaccard coefficient similarity. HGAPSO applies genetic operators like crossover and mutation to generate new populations. It combines the global and local search abilities of genetic algorithms and particle swarm optimization to optimize keyword selection and improve information retrieval over conventional search engines.
A fast atmospheric correction algorithm applied to landsat tm imagesweslyj
This document describes a fast atmospheric correction algorithm for Landsat TM images. The algorithm proceeds in two steps:
1) It calculates ground reflectance for each pixel based on precomputed planetary albedo functions for standard atmospheres, aerosol types, and optical depths.
2) It approximately corrects for the adjacency effect by taking the average reflectance in a neighborhood of pixels and applying weighting functions to differences in reflectance.
http://www.mobileadvertisingeurope.com/ is a leading mobile marketing company in Europe. This company is helping to generate ROI based advertising campaign for little and big enterprise
Efficient data compression of ecg signal using discrete wavelet transformeSAT Publishing House
IJRET : International Journal of Research in Engineering and Technology is an international peer reviewed, online journal published by eSAT Publishing House for the enhancement of research in various disciplines of Engineering and Technology. The aim and scope of the journal is to provide an academic medium and an important reference for the advancement and dissemination of research results that support high-level learning, teaching and research in the fields of Engineering and Technology. We bring together Scientists, Academician, Field Engineers, Scholars and Students of related fields of Engineering and Technology.
IJRET : International Journal of Research in Engineering and Technology is an international peer reviewed, online journal published by eSAT Publishing House for the enhancement of research in various disciplines of Engineering and Technology. The aim and scope of the journal is to provide an academic medium and an important reference for the advancement and dissemination of research results that support high-level learning, teaching and research in the fields of Engineering and Technology. We bring together Scientists, Academician, Field Engineers, Scholars and Students of related fields of Engineering and Technology
పూర్వ విద్యార్థులకు నమస్కారం,
పూర్వ విద్యార్థులందరికి "స్ఫూర్థి సంచిక" అందుబాటులొ ఉందాలనే నేపత్యం తొ మీ అందరికి స్ఫూర్థి సంచిక సంచికను అందుబతులొ ఉంచడం జరిగింది. అందరు దయ చెసి చదివి post ని like మరియు share చెయండి. It should reach our each and every alumni.
Regards
Admin
Geweke Hospitality has been developing and managing hotels in California since 1988. They currently manage a portfolio of six hotels under brands such as Hampton Inn and Suites, Hilton Garden Inn, Homewood Suites by Hilton, and Holiday Inn Express. Headquartered in Lodi, California, Geweke Hospitality has over 25 years of experience developing, owning, and managing hotels in California, consistently outperforming their markets and exceeding owner expectations.
An overview of multiple public, private, hybrid cloud options, including Amazon Web Services (AWS), Google Compute, Vmware vCloud Air, Azure, as well as CSP/MSP based private clouds. We take common use-cases, such as disaster recovery and compare each option. We'll also talk about network fabrics, direct network connectivity, ownership, management, compliance, and accountability.
This document provides an overview and tutorial on using the Apache Subversion (SVN) version control system. It begins with introducing basic SVN concepts like repositories, trunks, tags, branches and working copies. It then describes how to set up the SVN environment, including installing SVN on Linux, configuring Apache as the HTTP server, and creating repositories and user accounts. The rest of the tutorial covers the SVN lifecycle including checkout, commit, update, and resolving conflicts. It also discusses features like tags and branching.
The document provides an overview of agile development using JBoss Seam. It discusses various agile methodologies and technologies that will be presented, including TestNG, Groovy, Hudson, Subversion, Cobertura, DBUnit, and Selenium. It provides descriptions and examples of using these technologies for unit testing, integration testing, and acceptance testing in an agile project.
DevEx aims to improve the developer experience by focusing on tooling, technologies, and documentation within a DevOps environment. This includes adopting integrated toolchains that streamline the development lifecycle through automation and by ensuring tools are well-tested, configurable, and have comprehensive documentation. The goal of DevEx is to create an optimal software production environment by minimizing friction between development, testing, and operations teams through collaboration, shared tools, and improved processes.
This document introduces Subversion (SVN) as a version control system that improves upon CVS. It discusses downloading and using SVN clients like TortoiseSVN, describes how to set up a SVN repository for a project with multiple developers, and provides examples of common SVN commands like checking out files, committing changes, and updating a working copy.
This document provides an overview of DevOps delivery pipelines for beginners. It defines key concepts like source code repositories, build artifacts, environments, and the roles of continuous integration and continuous delivery. The core DevOps principle is an automated software delivery pipeline from code to production. This involves separate build and deploy stages. Common build steps include fetching code, testing, packaging artifacts, and publishing to repositories. Deployment typically includes retrieving artifacts, configuring environments, and validating deployments. Setting up roles, notifications, versioned scripts, and avoiding complex triggers are best practices for enjoying an automated DevOps pipeline.
Presentation 1 open source tools in continuous integration environment v1.0Jasmine Conseil
The document discusses open source tools that can be used in a continuous integration environment. It provides an overview of build tools like Ant and Maven, continuous integration servers, and how tools like Hudson and Archiva can help manage builds, artifacts, and the development process in an agile workflow.
The document discusses the OpenDaylight SDN controller. It provides an overview of OpenDaylight, describing it as an open-source project that promotes Software Defined Networking using technologies like Eclipse, Maven, and OSGi. The document also covers basic hands-on steps for installing and using the OpenDaylight controller, including setting up the environment, writing controller code, using Mininet and the controller's web UI.
Maven is a build tool that can manage a project's build process, dependencies, documentation and reporting. It uses a Project Object Model (POM) file to store build configuration and metadata. Maven has advantages over Ant like built-in functionality for common tasks, cross-project reuse, and support for conditional logic. It works by defining the project with a POM file then running goals bound to default phases like compile, test, package to build the project.
The document discusses version control and the Subversion (SVN) system. It defines what version control is and some key concepts in SVN like checkout, commit, update, and tags. It explains how to set up a new SVN repository from the command line or using TortoiseSVN and Eclipse. It also covers merging changes from branches back into the main trunk.
Microsoft Azure is a cloud computing platform and infrastructure created by Microsoft. It offers a wide range of services, including compute, storage, networking, analytics, and artificial intelligence. Azure is used by businesses of all sizes to build, deploy, and manage applications in the cloud.
Maven is a project management tool that provides conventions for building Java projects, including a standard project structure, dependency management, and lifecycle phases. It simplifies development by standardizing common tasks like compiling, testing, packaging, and deploying. Compared to Ant, Maven takes a more convention-based approach and handles dependencies and lifecycles automatically. The document provides an overview of Maven's key features and how it can help manage Java projects.
Apache Bench is a command line tool used to test the performance and load handling capabilities of HTTP servers. It sends a configurable number of requests with varying concurrency levels to a target URL and analyzes metrics like requests per second, response times, and transfer speeds. The tutorial discusses how to install and use Apache Bench, understand its output, and perform basic and advanced load testing of websites and applications.
Version Uncontrolled - How to Manage Your Version Control (whitepaper)Revelation Technologies
This document discusses best practices for managing version control. It begins by describing the differences between centralized and distributed version control systems like SVN and Git. It then provides examples of common version control commands for creating repositories, committing changes, and branching/merging code. The document recommends adopting a structured workflow like feature branching or the Git flow model to improve collaboration. It stresses the importance of following naming conventions for branches.
This document provides documentation for the ARTIO OB Bridge component, which enables synchronization between Openbravo ERP and Magento. It describes the component's requirements, installation process, administration features, and synchronization processes. The synchronization processes manage the transfer of key business objects like customers, products, orders, and more between the two systems.
The document discusses how to get involved with and contribute to the Open Object community. It covers joining teams to learn, improve documentation, translate materials, develop modules, use version control, track bugs, and promote work. The community uses forums, IRC, mailing lists, blogs, and more to collaborate on the OpenERP/OpenObject project.
This document provides an overview of Maven, a build tool for Java projects. It describes what Maven is, its main features such as dependency management and documentation generation. It also outlines how to install and configure Maven, and explains key Maven concepts like the project object model (POM) file, build lifecycles, phases and goals, and dependencies. The document demonstrates how to define dependencies and repositories in the POM file and use Maven to build projects.
This is an overview of Azure Artifacts and how you can add a fully integrated package management to your continuous integration/continuous delivery (CI/CD) pipelines with a single click. Azure Artifacts allows you to share your code effortlessly by creating and sharing Maven, npm, and NuGet package feeds from public and private sources.
I'm a Flex developer who has been using Subversion (SVN) for version control since 2005. SVN is a centralized version control system where developers can check out files from a central repository, work on them locally, and check in changes. It allows developers to work on the same files simultaneously and merges changes automatically. Popular SVN clients include TortoiseSVN for Windows and Subclipse for Eclipse.
Devops : Automate Your Infrastructure with PuppetEdureka!
"DevOps" denotes a close collaboration and cross-pollination between previous cases i.e, purely the development roles, operations roles and QA roles. As it is necessary for the software to release at an ever-increasing rate, we can see that the old "waterfall" develop-test-release cycle is broken. Devops provides us with consistent software delivery, Faster resolution of complex problems and neatier and crisp feature delivery.
Exploiting Artificial Intelligence for Empowering Researchers and Faculty, In...Dr. Vinod Kumar Kanvaria
Exploiting Artificial Intelligence for Empowering Researchers and Faculty,
International FDP on Fundamentals of Research in Social Sciences
at Integral University, Lucknow, 06.06.2024
By Dr. Vinod Kumar Kanvaria
The simplified electron and muon model, Oscillating Spacetime: The Foundation...RitikBhardwaj56
Discover the Simplified Electron and Muon Model: A New Wave-Based Approach to Understanding Particles delves into a groundbreaking theory that presents electrons and muons as rotating soliton waves within oscillating spacetime. Geared towards students, researchers, and science buffs, this book breaks down complex ideas into simple explanations. It covers topics such as electron waves, temporal dynamics, and the implications of this model on particle physics. With clear illustrations and easy-to-follow explanations, readers will gain a new outlook on the universe's fundamental nature.
This presentation includes basic of PCOS their pathology and treatment and also Ayurveda correlation of PCOS and Ayurvedic line of treatment mentioned in classics.
How to Fix the Import Error in the Odoo 17Celine George
An import error occurs when a program fails to import a module or library, disrupting its execution. In languages like Python, this issue arises when the specified module cannot be found or accessed, hindering the program's functionality. Resolving import errors is crucial for maintaining smooth software operation and uninterrupted development processes.
Executive Directors Chat Leveraging AI for Diversity, Equity, and InclusionTechSoup
Let’s explore the intersection of technology and equity in the final session of our DEI series. Discover how AI tools, like ChatGPT, can be used to support and enhance your nonprofit's DEI initiatives. Participants will gain insights into practical AI applications and get tips for leveraging technology to advance their DEI goals.
it describes the bony anatomy including the femoral head , acetabulum, labrum . also discusses the capsule , ligaments . muscle that act on the hip joint and the range of motion are outlined. factors affecting hip joint stability and weight transmission through the joint are summarized.
Assessment and Planning in Educational technology.pptxKavitha Krishnan
In an education system, it is understood that assessment is only for the students, but on the other hand, the Assessment of teachers is also an important aspect of the education system that ensures teachers are providing high-quality instruction to students. The assessment process can be used to provide feedback and support for professional development, to inform decisions about teacher retention or promotion, or to evaluate teacher effectiveness for accountability purposes.
How to Add Chatter in the odoo 17 ERP ModuleCeline George
In Odoo, the chatter is like a chat tool that helps you work together on records. You can leave notes and track things, making it easier to talk with your team and partners. Inside chatter, all communication history, activity, and changes will be displayed.
2. i
AbouttheTutorial
Apache Subversion which is often abbreviated as SVN, is a software versioning
and revision control system distributed under an open source license. Subversion
was created by CollabNet Inc. in 2000, but now it is developed as a project of
the Apache Software Foundation, and as such is part of a rich community of
developers and users.
This tutorial provides you an understanding on SVN system that is needed to
maintain the current and historical versions of files such as source code, web
pages, and documentations.
Audience
This tutorial is designed for software professionals interested in learning the
concepts of SVN system in simple and easy steps. After completing this tutorial,
you will be gain sufficient exposure to SVN from where you can take yourself to
higher levels of expertise.
Prerequisites
Before proceeding with this tutorial, you should have a basic understanding on
simple terminologies like programming language, source code, documents, etc.
Because using SVN to handle all levels of software projects in your organization,
it will be good if you have a working knowledge of software development and
software testing processes.
Copyright&Disclaimer
Copyright 2014 by Tutorials Point (I) Pvt. Ltd.
All the content and graphics published in this e-book are the property of
Tutorials Point (I) Pvt. Ltd. The user of this e-book is prohibited to reuse, retain,
copy, distribute or republish any contents or a part of contents of this e-book in
any manner without written consent of the publisher.
We strive to update the contents of our website and tutorials as timely and as
precisely as possible, however, the contents may contain inaccuracies or errors.
Tutorials Point (I) Pvt. Ltd. provides no guarantee regarding the accuracy,
timeliness or completeness of our website or its contents including this tutorial.
If you discover any errors on our website or in this tutorial, please notify us at
contact@tutorialspoint.com
3. ii
TableofContents
About the Tutorial .....................................................................................................................................i
Audience....................................................................................................................................................i
Prerequisites..............................................................................................................................................i
Copyright & Disclaimer ..............................................................................................................................i
Table of Contents......................................................................................................................................ii
1. BASIC CONCEPTS...................................................................................................................1
What is Version Control System? ..............................................................................................................1
Version Control Terminologies..................................................................................................................1
2. ENVIRONMENT SETUP...........................................................................................................3
SVN Installation ........................................................................................................................................3
Apache Setup............................................................................................................................................4
User Setup ................................................................................................................................................5
Repository Setup ......................................................................................................................................5
3. LIFE CYCLE.............................................................................................................................8
Create Repository .....................................................................................................................................8
Checkout...................................................................................................................................................8
Update......................................................................................................................................................8
Perform Changes ......................................................................................................................................8
Review Changes........................................................................................................................................9
Fix Mistakes..............................................................................................................................................9
Resolve Conflicts.......................................................................................................................................9
Commit Changes.....................................................................................................................................10
4. CHECKOUT PROCESS ...........................................................................................................11
5. PERFORM CHANGES............................................................................................................13
5. SVN
1
WhatisVersionControlSystem?
Version Control System (VCS) is a software that helps software developers to
work together and maintain a complete history of their work.
Following are the goals of a Version Control System.
Allow developers to work simultaneously.
Do not overwrite each other’s changes.
Maintain history of every version of everything.
A VCS is divided into two categories.
Centralized Version Control System (CVCS), and
Distributed/Decentralized Version Control System (DVCS).
In this tutorial, we will concentrate only on the Centralized Version Control
System and especially Subversion. Subversion falls under centralized version
control system, meaning that it uses central server to store all files and enables
team collaboration.
VersionControlTerminologies
Let us start by discussing some of the terms that we will be using in this tutorial.
Repository: A repository is the heart of any version control system. It is
the central place where developers store all their work. Repository not
only stores files but also the history. Repository is accessed over a
network, acting as a server and version control tool acting as a client.
Clients can connect to the repository, and then they can store/retrieve
their changes to/from repository. By storing changes, a client makes
these changes available to other people and by retrieving changes, a
client takes other people’s changes as a working copy.
Trunk: The trunk is a directory where all the main development happens
and is usually checked out by developers to work on the project.
Tags: The tags directory is used to store named snapshots of the project.
Tag operation allows to give descriptive and memorable names to specific
version in the repository.
For example, LAST_STABLE_CODE_BEFORE_EMAIL_SUPPORT is more
memorable than
1. BASIC CONCEPTS
6. SVN
2
Repository UUID: 7ceef8cb-3799-40dd-a067-c216ec2e5247 and
Revision: 13
Branches: Branch operation is used to create another line of
development. It is useful when you want your development process to
fork off into two different directions. For example, when you release
version 5.0, you might want to create a branch so that development of
6.0 features can be kept separate from 5.0 bug-fixes.
Working copy: Working copy is a snapshot of the repository. The
repository is shared by all the teams, but people do not modify it directly.
Instead each developer checks out the working copy. The working copy is
a private workplace where developers can do their work remaining
isolated from the rest of the team.
Commit changes: Commit is a process of storing changes from private
workplace to central server. After commit, changes are made available to
all the team. Other developers can retrieve these changes by updating
their working copy. Commit is an atomic operation. Either the whole
commit succeeds or it is rolled back. Users never see half finished commit.
7. SVN
3
SVNInstallation
Subversion is a popular open-source version control tool. It is open-source and
available for free over the internet. It comes by default with most of the
GNU/Linux distributions, so it might be already installed on your system. To
check whether it is installed or not use following command.
[jerry@CentOS ~]$ svn --version
If Subversion client is not installed, then command will report error, otherwise it
will display the version of the installed software.
[jerry@CentOS ~]$ svn --version
-bash: svn: command not found
If you are using RPM-based GNU/Linux, then use yum command for installation.
After successful installation, execute the svn --version command.
[jerry@CentOS ~]$ su -
Password:
[root@CentOS ~]# yum install subversion
[jerry@CentOS ~]$ svn --version
svn, version 1.6.11 (r934486)
compiled Jun 23 2012, 00:44:03
And if you are using Debian-based GNU/Linux, then use apt command for
installation.
[jerry@Ubuntu]$ sudo apt-get update
[sudo] password for jerry:
[jerry@Ubuntu]$ sudo apt-get install subversion
[jerry@Ubuntu]$ svn --version
svn, version 1.7.5 (r1336830)
2. ENVIRONMENT SETUP
8. SVN
4
compiled Jun 21 2013, 22:11:49
ApacheSetup
We have seen how to install Subversion client on GNU/Linux. Let us see how to
create a new repository and allow access to the users.
On server we have to install Apache httpd module and svnadmin tool.
[jerry@CentOS ~]$ su -
Password:
[root@CentOS ~]# yum install mod_dav_svn subversion
The mod_dav_svn package allows access to a repository using HTTP, via
Apache httpd server and subversion package installs svnadmin tool.
The subversion reads its configuration from
/etc/httpd/conf.d/subversion.conf file. After adding configuration,
subversion.conf, file looks as follows:
LoadModule dav_svn_module modules/mod_dav_svn.so
LoadModule authz_svn_module modules/mod_authz_svn.so
<Location /svn>
DAV svn
SVNParentPath /var/www/svn
AuthType Basic
AuthName "Authorization Realm"
AuthUserFile /etc/svn-users
Require valid-user
</Location>
Let us create Subversion users and grant them access to the
repository. Htpasswd command is used to create and update the plain-text files
which are used to store usernames and passwords for basic authentication of
HTTP users. '-c' options creates password file, if password file already exists, it is
overwritten. That is why use '-c' option only the first time. '-m' option enables
MD5 encryption for passwords.
9. SVN
5
UserSetup
Let us create user tom.
[root@CentOS ~]# htpasswd -cm /etc/svn-users tom
New password:
Re-type new password:
Adding password for user tom
Let us create user jerry
[root@CentOS ~]# htpasswd -m /etc/svn-users jerry
New password:
Re-type new password:
Adding password for user jerry
[root@CentOS ~]#
Create Subversion parent directory to store all the work
(see/etc/httpd/conf.d/subversion.conf).
[root@CentOS ~]# mkdir /var/www/svn
[root@CentOS ~]# cd /var/www/svn/
RepositorySetup
Create a project repository named project_repo. svnadmin command will create
a new repository and a few other directories inside that to store the metadata.
[root@CentOS svn]# svnadmin create project_repo
[root@CentOS svn]# ls -l project_repo
total 24
drwxr-xr-x. 2 root root 4096 Aug 4 22:30 conf
drwxr-sr-x. 6 root root 4096 Aug 4 22:30 db
-r--r--r--. 1 root root 2 Aug 4 22:30 format
drwxr-xr-x. 2 root root 4096 Aug 4 22:30 hooks
drwxr-xr-x. 2 root root 4096 Aug 4 22:30 locks
-rw-r--r--. 1 root root 229 Aug 4 22:30 README.txt
10. SVN
6
Let us change the user and group ownership of the repository.
[root@CentOS svn]# chown -R apache.apache project_repo/
Check whether SELinux is enabled or not using the SELinux status tool.
[root@CentOS svn]# sestatus
SELinux status: enabled
SELinuxfs mount: /selinux
Current mode: enforcing
Mode from config file: enforcing
Policy version: 24
Policy from config file: targeted
For our server, SELinux is enabled, so we have to change the SELinux security
context.
[root@CentOS svn]# chcon -R -t httpd_sys_content_t
/var/www/svn/project_repo/
To allow commits over HTTP, execute the following command.
[root@CentOS svn]# chcon -R -t httpd_sys_rw_content_t
/var/www/svn/project_repo/
Restart the Apache server and we are done with the configuration of Apache
server.
[root@CentOS svn]# service httpd restart
Stopping httpd: [FAILED]
Starting httpd: httpd: apr_sockaddr_info_get() failed for CentOS
httpd: Could not reliably determine the server's fully qualified domain
name, using 127.0.0.1 for ServerName
[ OK ]
[root@CentOS svn]# service httpd status
httpd (pid 1372) is running...
[root@CentOS svn]#
We have configured the Apache server successfully, now we will configure the
repository. To provide repository access to only authentic users and to use the
default authorization file; append the following lines
to project_repo/conf/svnserve.conf file.
11. SVN
7
anon-access = none
authz-db = authz
Conventionally, every Subversion project has trunk, tags, and
branches directories directly under the project's root directory.
The trunk is a directory where all the main development happens and is usually
checked out by the developers to work on the project.
The tags directory is used to store named snapshots of the project. When
creating a production release, the team will tag the code that goes into the
release.
The branches directory is used when you want to pursue different lines of
development.
Let us create the trunk, tags, and branches directory structure under the project
repository.
[root@CentOS svn]# mkdir /tmp/svn-template
[root@CentOS svn]# mkdir /tmp/svn-template/trunk
[root@CentOS svn]# mkdir /tmp/svn-template/branches
[root@CentOS svn]# mkdir /tmp/svn-template/tags
Now import the directories from /tmp/svn-template to the repository.
[root@CentOS svn]# svn import -m 'Create trunk, branches, tags directory
structure' /tmp/svn-template/
Adding /tmp/svn-template/trunk
Adding /tmp/svn-template/branches
Adding /tmp/svn-template/tags
Committed revision 1.
[root@CentOS svn]#
This is done now! We have successfully created the repository and allowed
access to Tom and Jerry. From now, they can perform all the supported
operations to the repository.
12. SVN
8
The life cycle of a Version Control System is discussed in this chapter. In later
chapters, we will see the Subversion command for each operation.
CreateRepository
The repository is a central place where developers store all their work.
Repository not only stores files, but also the history about changes, which
means it maintains a history of the changes made in the files. The ‘create’
operation is used to create a new repository. Most of the times this operation is
done only once. When you create a new repository, your VCS will expect you to
say something to identify it, such as where you want it to be created, or what
name should be given to the repository.
Checkout
’Checkout’ operation is used to create a working copy from the repository.
Working copy is a private workplace where developers do their changes, and
later on, submit these changes to the repository.
Update
As the name suggests, ‘update’ operation is used to update working copy. This
operation synchronizes the working copy with the repository. As repository is
shared by all the teams, other developers can commit their changes and your
working copy becomes older.
Let us suppose Tom and Jerry are the two developers working on a project. Both
check out the latest version from the repository and start working. At this point,
their working copies are completely synchronized with the
repository. Jerry completes his work very efficiently and commits his changes to
the repository.
Now Tom's working copy is out of date. Update operation will pull Jerry’s latest
changes from the repository and will update Tom's working copy.
PerformChanges
After the checkout, one can do various operations to perform changes. Edit is
the most common operation. One can edit the existing file to add/remove
contents from the file.
3. LIFE CYCLE
13. SVN
9
One can add files/directories. But immediately these files/directories do not
become a part of the repository, instead they are added to the pending change-
list and become a part of the repository after the commit operation.
Similarly one can delete files/directories. Delete operation immediately deletes
file from the working copy, but actual deletion of the file is added to the pending
change-list and changes are made to the repository after the commit operation.
‘Rename’ operation changes the name of the file/directory. ‘Move’ operation is
used to move files/directories from one place to another in a repository tree.
Review Changes
When you check out the working copy or update the working copy, then your
working copy is completely synchronized with the repository. But as you do
changes to your working copy, it becomes newer than the repository. And it is a
good practice to review your changes before the ‘commit’ operation.
‘Status’ operation lists the modifications that have been made to the working
copy. As we have mentioned before, whenever you do changes in the working
copy all these changes become a part of the pending change-list. And the
‘status’ operation is used to see the pending change-list.
‘Status’ operation only provides a list of changes but not the details about them.
One can use diff operation to view the details of the modifications that have
been made to the working copy.
FixMistakes
Let us suppose one has made changes to his working copy, but now, he wants to
throw away these changes. In this situation, ‘revert’ operation will help.
Revert operation reverts the modifications that have been made to the working
copy. It is possible to revert one or more files/directories. Also it is possible to
revert the whole working copy. In this case, the ‘revert’ operation will destroy
the pending change-list and will bring the working copy back to its original state.
ResolveConflicts
Conflicts can occur at the time of merging. ‘Merge’ operation automatically
handles everything that can be done safely. Everything else is considered as
conflict. For example, "hello.c" file was modified in branch and deleted in
another branch. Such a situation requires a person to make the decision. The
‘resolve’ operation is used to help the user figure out things and to inform VCS
about the ways of handling the conflicts.
14. SVN
10
CommitChanges
‘Commit’ operation is used to apply changes from the working copy to the
repository. This operation modifies the repository and other developers can see
these changes by updating their working copy.
Before commit, one has to add files/directories to the pending change-list. This
is the place where changes wait to be committed. With commit, we usually
provide a log message to explain why someone made changes. This log message
becomes a part of the history of the repository. Commit is an atomic operation,
which means either the entire commit succeeds or it is rolled back. Users never
see half-finished commit.
15. SVN
11
Subversion provides the checkout command to check out a working copy from a
repository. Below command will create a new directory in the current working
directory with the name project_repo. Don't bother about the repository URL, as
most of the time, it is already provided by the subversion administrator with
appropriate access.
[tom@CentOS ~]$ svn checkout http://svn.server.com/svn/project_repo --
username=tom
The above command will produce the following result.
A project_repo/trunk
A project_repo/branches
A project_repo/tags
Checked out revision 1.
After every successful checkout operation, the revision number will get printed.
If you want to view more information about the repository, then execute
the info command.
[tom@CentOS trunk]$ pwd
/home/tom/project_repo/trunk
[tom@CentOS trunk]$ svn info
The above command will produce the following result.
Path: .
URL: http://svn.server.com/svn/project_repo/trunk
Repository Root: http://svn.server.com/svn/project_repo
Repository UUID: 7ceef8cb-3799-40dd-a067-c216ec2e5247
Revision: 1
Node Kind: directory
Schedule: normal
Last Changed Author: jerry
Last Changed Rev: 0
4. CHECKOUT PROCESS
17. SVN
13
Jerry checks out the latest version of the repository and starts working on a
project. He creates array.c file inside the trunk directory.
[jerry@CentOS ~]$ cd project_repo/trunk/
[jerry@CentOS trunk]$ cat array.c
The above command will produce the following result.
#include <stdio.h>
#define MAX 16
int main(void)
{
int i, n, arr[MAX];
printf("Enter the total number of elements: ");
scanf("%d", &n);
printf("Enter the elementsn");
for (i = 0; i < n; ++i)
scanf("%d", &arr[i]);
printf("Array has following elementsn");
for (i = 0; i < n; ++i)
printf("|%d| ", arr[i]);
printf("n");
return 0;
5. PERFORM CHANGES
18. SVN
14
}
He wants to test his code before commit.
[jerry@CentOS trunk]$ make array
cc array.c -o array
[jerry@CentOS trunk]$ ./array
Enter the total number of elements: 5
Enter the elements
1
2
3
4
5
Array has following elements
|1| |2| |3| |4| |5|
He compiled and tested his code and everything is working as expected, now it
is time to commit changes.
[jerry@CentOS trunk]$ svn status
? array.c
? array
Subversion is showing ‘?’ in front of filenames because it doesn't know what to
do with these files.
Before commit, Jerry needs to add this file to the pending change-list.
[jerry@CentOS trunk]$ svn add array.c
A array.c
Let us check it with the ‘status’ operation. Subversion shows A before array.c, it
means, the file is successfully added to the pending change-list.
[jerry@CentOS trunk]$ svn status
? array
A array.c
19. SVN
15
To store array.c file to the repository, use the commit command with -m option
followed by commit message. If you omit -m option Subversion will bring up the
text editor where you can type a multi-line message.
[jerry@CentOS trunk]$ svn commit -m "Initial commit"
Adding trunk/array.c
Transmitting file data .
Committed revision 2.
Now array.c file is successfully added to the repository, and the revision number
is incremented by one.
20. SVN
16
Jerry already added array.c file to the repository. Tom also checks out the latest
code and starts working.
[tom@CentOS ~]$ svn co http://svn.server.com/svn/project_repo --
username=tom
Above command will produce the following result.
A project_repo/trunk
A project_repo/trunk/array.c
A project_repo/branches
A project_repo/tags
Checked out revision 2.
But, he found that someone has already added the code. So he is curious about
who did that and he checks the log message to see more details using the
following command:
[tom@CentOS trunk]$ svn log
Above command will produce the following result.
------------------------------------------------------------------------
r2 | jerry | 2013-08-17 20:40:43 +0530 (Sat, 17 Aug 2013) | 1 line
Initial commit
------------------------------------------------------------------------
r1 | jerry | 2013-08-04 23:43:08 +0530 (Sun, 04 Aug 2013) | 1 line
Create trunk, branches, tags directory structure
------------------------------------------------------------------------
When Tom observes Jerry’s code, he immediately notices a bug in that. Jerry
was not checking for array overflow, which could cause serious problems. So
Tom decides to fix this problem. After modification, array.c will look like this.
#include <stdio.h>
6. REVIEW CHANGES
21. SVN
17
#define MAX 16
int main(void)
{
int i, n, arr[MAX];
printf("Enter the total number of elements: ");
scanf("%d", &n);
/* handle array overflow condition */
if (n > MAX) {
fprintf(stderr, "Number of elements must be less than %dn", MAX);
return 1;
}
printf("Enter the elementsn");
for (i = 0; i < n; ++i)
scanf("%d", &arr[i]);
printf("Array has following elementsn");
for (i = 0; i < n; ++i)
printf("|%d| ", arr[i]);
printf("n");
return 0;
}
Tom wants to use the status operation to see the pending change-list.
[tom@CentOS trunk]$ svn status
M array.c
22. SVN
18
array.c file is modified, that's why Subversion shows M letter before file name.
Next Tom compiles and tests his code and it is working fine. Before committing
changes, he wants to double-check it by reviewing the changes that he made.
[tom@CentOS trunk]$ svn diff
Index: array.c
===================================================================
--- array.c (revision 2)
+++ array.c (working copy)
@@ -9,6 +9,11 @@
printf("Enter the total number of elements: ");
scanf("%d", &n);
+ if (n > MAX) {
+ fprintf(stderr, "Number of elements must be less than %dn",
MAX);
+ return 1;
+ }
+
printf("Enter the elementsn");
for (i = 0; i < n; ++i)
Tom has added a few lines in the array.c file, that's why Subversion
shows + sign before new lines. Now he is ready to commit his changes.
[tom@CentOS trunk]$ svn commit -m "Fix array overflow problem"
The above command will produce the following result.
Sending trunk/array.c
Transmitting file data .
Committed revision 3.
Tom's changes are successfully committed to the repository.
23. SVN
19
Jerry had committed the first version of the code. But he thinks that he should
write two functions to accept input and to display array contents. After
modification, array.c looks as follows.
#include <stdio.h>
#define MAX 16
void accept_input(int *arr, int n)
{
int i;
for (i = 0; i < n; ++i)
scanf("%d", &arr[i]);
}
void display(int *arr, int n)
{
int i;
for (i = 0; i < n; ++i)
printf("|%d| ", arr[i]);
printf("n");
}
int main(void)
{
int i, n, arr[MAX];
printf("Enter the total number of elements: ");
7. UPDATE PROCESS
24. SVN
20
scanf("%d", &n);
printf("Enter the elementsn");
accept_input(arr, n);
printf("Array has following elementsn");
display(arr, n);
return 0;
}
Jerry compiles and tests his code and is ready to commit changes. Before that,
he wants to review the changes using the following command.
[jerry@CentOS trunk]$ svn diff
The above command will produce the following result.
Index: array.c
===================================================================
--- array.c (revision 2)
+++ array.c (working copy)
@@ -2,6 +2,24 @@
#define MAX 16
+void accept_input(int *arr, int n)
+{
+ int i;
+
+ for (i = 0; i & n; ++i)
+ scanf("%d", &arr[i]);
+}
+
+void display(int *arr, int n)
+{
25. SVN
21
+ int i;
+
+ for (i = 0; i < n; ++i)
+ printf("|%d| ", arr[i]);
+
+ printf("n");
+}
+
int main(void)
{
int i, n, arr[MAX];
@@ -10,15 +28,10 @@
scanf("%d", &n);
printf("Enter the elementsn");
+ accept_input(arr, n);
- for (i = 0; i < n; ++i)
- scanf("%d", &arr[i]);
-
printf("Array has following elementsn");
- for (i = 0; i < n; ++i)
- printf("|%d| ", arr[i]);
-
- printf("n");
+ display(arr, n);
return 0;
}
For the new added lines, Subversion shows + sign before line and for removed
line it shows -sign. Now, Jerry tries to commit the changes using the following
command:
26. SVN
22
[jerry@CentOS trunk]$ svn commit -m "Add function to accept input and to
display array contents"
The above command will produce the following result.
Sending trunk/array.c
svn: Commit failed (details follow):
svn: File or directory 'array.c' is out of date; try updating
svn: resource out of date; try updating
Subversion is not allowing to commit Jerry's changes, because Tom has already
modified the repository and Jerry's working copy is out of date. To avoid
overwriting each other's changes, Subversion fails this operation. Jerry must
update working copy before committing his changes. So he uses update
command as shown below.
[jerry@CentOS trunk]$ svn update
G array.c
Updated to revision 3.
Subversion is showing the letter G before filename, which means this file has
been merged.
[jerry@CentOS trunk]$ svn diff
The above command will produce the following result.
Index: array.c
===================================================================
--- array.c (revision 3)
+++ array.c (working copy)
@@ -2,6 +2,24 @@
#define MAX 16
+void accept_input(int *arr, int n)
+{
+ int i;
+
+ for (i = 0; i < n; ++i)
27. SVN
23
+ scanf("%d", &arr[i]);
+}
+
+void display(int *arr, int n)
+{
+ int i;
+
+ for (i = 0; i < n; ++i)
+ printf("|%d| ", arr[i]);
+
+ printf("n");
+}
+
int main(void)
{
int i, n, arr[MAX];
@@ -15,15 +33,10 @@
}
printf("Enter the elementsn");
+ accept_input(arr, n);
- for (i = 0; i < n; ++i)
- scanf("%d", &arr[i]);
-
printf("Array has following elementsn");
- for (i = 0; i < n; ++i)
- printf("|%d| ", arr[i]);
-
- printf("n");
+ display(arr, n);
28. SVN
24
return 0;
}
Subversion is showing only Jerry's changes, but array.c file is merged. If you
observe carefully, Subversion is now showing revision number 3. In the previous
output, it was showing revision number 2. Just review who made changes in the
file and for what purpose.
jerry@CentOS trunk]$ svn log
------------------------------------------------------------------------
r3 | tom | 2013-08-18 20:21:50 +0530 (Sun, 18 Aug 2013) | 1 line
Fix array overflow problem
------------------------------------------------------------------------
r2 | jerry | 2013-08-17 20:40:43 +0530 (Sat, 17 Aug 2013) | 1 line
Initial commit
------------------------------------------------------------------------
r1 | jerry | 2013-08-04 23:43:08 +0530 (Sun, 04 Aug 2013) | 1 line
Create trunk, branches, tags directory structure
------------------------------------------------------------------------
Now Jerry's working copy is synchronized with the repository and he can safely
commit his changes.
[jerry@CentOS trunk]$ svn commit -m "Add function to accept input and to
display array contents"
Sending trunk/array.c
Transmitting file data .
Committed revision 4.
29. SVN
25
Suppose Jerry accidently modifies array.c file and he is getting compilation
errors. Now he wants to throw away the changes. In this situation, ‘revert’
operation will help. Revert operation will undo any local changes to a file or
directory and resolve any conflicted states.
[jerry@CentOS trunk]$ svn status
Above command will produce the following result.
M array.c
Let's try to make array as follows:
[jerry@CentOS trunk]$ make array
Above command will produce the following result.
cc array.c -o array
array.c: In function ‘main’:
array.c:26: error: ‘n’ undeclared (first use in this function)
array.c:26: error: (Each undeclared identifier is reported only once
array.c:26: error: for each function it appears in.)
array.c:34: error: ‘arr’ undeclared (first use in this function)
make: *** [array] Error 1
Jerry performs ‘revert’ operation on array.c file.
[jerry@CentOS trunk]$ svn revert array.c
Reverted 'array.c'
[jerry@CentOS trunk]$ svn status
[jerry@CentOS trunk]$
Now compile the code.
[jerry@CentOS trunk]$ make array
cc array.c -o array
8. FIX MISTAKES
30. SVN
26
After the revert operation, his working copy is back to its original state. Revert
operation can revert a single file as well as a complete directory. To revert a
directory, use -R option as shown below.
[jerry@CentOS project_repo]$ pwd
/home/jerry/project_repo
[jerry@CentOS project_repo]$ svn revert -R trunk
Till now, we have seen how to revert changes, which has been made to the
working copy. But what if you want to revert a committed revision! Version
Control System tool doesn't allow to delete history from the repository. We can
only append history. It will happen even if you delete files from the repository.
To undo an old revision, we have to reverse whatever changes were made in the
old revision and then commit a new revision. This is called a reverse merge.
Let us suppose Jerry adds a code for linear search operation. After verification
he commits his changes.
[jerry@CentOS trunk]$ svn diff
Index: array.c
===================================================================
--- array.c (revision 21)
+++ array.c (working copy)
@@ -2,6 +2,16 @@
#define MAX 16
+int linear_search(int *arr, int n, int key)
+{
+ int i;
+
+ for (i = 0; i < n; ++i)
+ if (arr[i] == key)
+ return i;
+ return -1;
+}
+
31. SVN
27
void bubble_sort(int *arr, int n)
{
int i, j, temp, flag = 1;
[jerry@CentOS trunk]$ svn status
? array
M array.c
[jerry@CentOS trunk]$ svn commit -m "Added code for linear search"
Sending trunk/array.c
Transmitting file data .
Committed revision 22.
Jerry is curious about what Tom is doing. So he checks the Subversion log
messages.
[jerry@CentOS trunk]$ svn log
The above command will produce the following result.
------------------------------------------------------------------------
r5 | tom | 2013-08-24 17:15:28 +0530 (Sat, 24 Aug 2013) | 1 line
Add binary search operation
------------------------------------------------------------------------
r4 | jerry | 2013-08-18 20:43:25 +0530 (Sun, 18 Aug 2013) | 1 line
Add function to accept input and to display array contents
After viewing the log messages, Jerry realizes that he did a serious mistake.
Because Tom already implemented binary search operation, which is better than
the linear search; his code is redundant, and now Jerry has to revert his changes
to the previous revision. So, first find the current revision of the repository.
Currently, the repository is at revision 22 and we have to revert it to the
previous revision, i.e. revision 21.
[jerry@CentOS trunk]$ svn up
At revision 22.
32. SVN
28
[jerry@CentOS trunk]$ svn merge -r 22:21 array.c
--- Reverse-merging r22 into 'array.c':
U array.c
[jerry@CentOS trunk]$ svn commit -m "Reverted to revision 21"
Sending trunk/array.c
Transmitting file data .
Committed revision 23.
33. SVN
29
Tom decides to add a README file for their project. So he creates the
README file and adds TODO list into that. After adding this, the file repository is
at revision 6.
[tom@CentOS trunk]$ cat README
/* TODO: Add contents in README file */
[tom@CentOS trunk]$ svn status
? README
[tom@CentOS trunk]$ svn add README
A README
[tom@CentOS trunk]$ svn commit -m "Added README file. Will update it's
content in future."
Adding trunk/README
Transmitting file data .
Committed revision 6.
Jerry checks out the latest code which is at revision 6. And immediately he starts
working. After a few hours, Tom updates the README file and commits his
changes. The modified README will look like this.
[tom@CentOS trunk]$ cat README
* Supported operations:
1) Accept input
2) Display array elements
[tom@CentOS trunk]$ svn status
M README
[tom@CentOS trunk]$ svn commit -m "Added supported operation in README"
9. RESOLVE CONFLICTS
34. SVN
30
Sending trunk/README
Transmitting file data .
Committed revision 7.
Now, the repository is at revision 7 and Jerry's working copy is out of
date. Jerry also updates the README file and tries to commit his changes.
Jerry's README file looks like this.
[jerry@CentOS trunk]$ cat README
* File list
1) array.c Implementation of array operation.
2) README Instructions for user.
[jerry@CentOS trunk]$ svn status
M README
[jerry@CentOS trunk]$ svn commit -m "Updated README"
Sending trunk/README
svn: Commit failed (details follow):
svn: File or directory 'README' is out of date; try updating
svn: resource out of date; try updating
Step1:View Conflicts
Subversion has detected that the README file has changed since last updated.
So, Jerry has to update his working copy.
[jerry@CentOS trunk]$ svn up
Conflict discovered in 'README'.
Select: (p) postpone, (df) diff-full, (e) edit,
(mc) mine-conflict, (tc) theirs-conflict,
(s) show all options:
Subversion is complaining that there is a conflict with the README file, and
Subversion does not know how to solve this. So Jerry chooses the df option to
review the conflict.
35. SVN
31
[jerry@CentOS trunk]$ svn up
Conflict discovered in 'README'.
Select: (p) postpone, (df) diff-full, (e) edit,
(mc) mine-conflict, (tc) theirs-conflict,
(s) show all options: df
--- .svn/text-base/README.svn-base Sat Aug 24 18:07:13 2013
+++ .svn/tmp/README.tmp Sat Aug 24 18:13:03 2013
@@ -1 +1,11 @@
-/* TODO: Add contents in README file */
+<<<<<<< .mine
+* File list
+
+1) array.c Implementation of array operation.
+2) README Instructions for user.
+=======
+* Supported operations:
+
+1) Accept input
+2) Display array elements
+>>>>>>> .r7
Select: (p) postpone, (df) diff-full, (e) edit, (r) resolved,
(mc) mine-conflict, (tc) theirs-conflict,
(s) show all options:
Step2:PostponeConflicts
Next Jerry chooses the postpone(p) options, so that he can resolve the conflict.
Select: (p) postpone, (df) diff-full, (e) edit, (r) resolved,
(mc) mine-conflict, (tc) theirs-conflict,
(s) show all options: p
C README
Updated to revision 7.
Summary of conflicts:
36. SVN
32
Text conflicts: 1
After opening the README in text editor, he realizes that Subversion has
included both Tom's code and his code with conflict markers.
[jerry@CentOS trunk]$ cat README
<<<<<<< .min
* File list
1) array.c Implementation of array operation.
2) README Instructions for user.
=======
* Supported operations:
1) Accept input
2) Display array elements
>>>>>>> .r7
Jerry wants Tom's changes as well as his, so he just removes the lines containing
the conflict markers.
So, the modified README will look like this.
[jerry@CentOS trunk]$ cat README
* File list
1) array.c Implementation of array operation.
2) README Instructions for user.
* Supported operations:
1) Accept input
2) Display array elements
Jerry resolved the conflict and he retries commit.
[jerry@CentOS trunk]$ svn commit -m "Updated README"
svn: Commit failed (details follow):
37. SVN
33
svn: Aborting commit: '/home/jerry/project_repo/trunk/README' remains in
conflict
[jerry@CentOS trunk]$ svn status
? README.r6
? README.r7
? README.mine
C README
Step3:Resolve Conflicts
In the above commit, the letter C indicates that there is a conflict in the README
file. Jerry resolved the conflict but didn't tell Subversion that he had resolved the
conflict. He uses the resolve command to inform Subversion about the conflict
resolution.
[jerry@CentOS trunk]$ svn resolve --accept=working README
Resolved conflicted state of 'README'
[jerry@CentOS trunk]$ svn status
M README
[jerry@CentOS trunk]$ svn commit -m "Updated README"
Sending trunk/README
Transmitting file data .
Committed revision 8.
38. SVN
34
Version Control System supports the tag operation by using that concept that
one can give meaningful name to a specific version of the code. Tag allows to
give descriptive and memorable names to specific version of code. For
example BASIC_ARRAY_OPERATIONS is more memorable than revision 4.
Let us see tag operation with an example. Tom decides to create a tag so that
he can access the code more easily.
[tom@CentOS project_repo]$ svn copy --revision=4 trunk/
tags/basic_array_operations
Above command will produce the following result.
A tags/basic_array_operations/array.c
Updated to revision 4.
A tags/basic_array_operations
Upon successful completion, the new directory will be created inside
the tags directory.
[tom@CentOS project_repo]$ ls -l tags/
total 4
drwxrwxr-x. 3 tom tom 4096 Aug 24 18:18 basic_array_operations
Tom wants to double-check it before commit. Status operation is showing that
the tag operation is successful, so he can safely commit his changes.
[tom@CentOS project_repo]$ svn status
A + tags/basic_array_operations
[tom@CentOS project_repo]$ svn commit -m "Created tag for basic array
operations"
Adding tags/basic_array_operations
Committed revision 5.
10. TAGS
39. SVN
35
Branch operation creates another line of development. It is useful when
someone wants the development process to fork off into two different directions.
Let us suppose you have released a product of version 1.0, you might want to
create new branch so that development of 2.0 can be kept separate from 1.0
bug fixes.
In this section, we will see how to create, traverse and merge branch. Jerry is
not happy because of the conflict, so he decides to create a new private branch.
[jerry@CentOS project_repo]$ ls
branches tags trunk
[jerry@CentOS project_repo]$ svn copy trunk branches/jerry_branch
A branches/jerry_branch
[jerry@CentOS project_repo]$ svn status
A + branches/jerry_branch
[jerry@CentOS project_repo]$ svn commit -m "Jerry's private branch"
Adding branches/jerry_branch
Adding branches/jerry_branch/README
Committed revision 9.
[jerry@CentOS project_repo]$
Now Jerry is working in his private branch. He adds sort operation for the array.
Jerry's modified code looks like this.
[jerry@CentOS project_repo]$ cd branches/jerry_branch/
[jerry@CentOS jerry_branch]$ cat array.c
11. BRANCHING
40. SVN
36
The above command will produce the following result.
#include <stdio.h>
#define MAX 16
void bubble_sort(int *arr, int n)
{
int i, j, temp, flag = 1;
for (i = 1; i < n && flag == 1; ++i) {
flag = 0;
for (j = 0; j < n - i; ++j) {
if (arr[j] > arr[j + 1]) {
flag = 1;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
void accept_input(int *arr, int n)
{
int i;
for (i = 0; i < n; ++i)
scanf("%d", &arr[i]);
}
void display(int *arr, int n)
{
int i;
41. SVN
37
for (i = 0; i < n; ++i)
printf("|%d| ", arr[i]);
printf("n");
}
int main(void)
{
int i, n, key, ret, arr[MAX];
printf("Enter the total number of elements: ");
scanf("%d", &n);
/* Error handling for array overflow */
if (n >MAX) {
fprintf(stderr, "Number of elements must be less than %dn", MAX);
return 1;
}
printf("Enter the elementsn");
accept_input(arr, n);
printf("Array has following elementsn");
display(arr, n);
printf("Sorted data isn");
bubble_sort(arr, n);
display(arr, n);
return 0;
}
42. SVN
38
Jerry compiles and tests his code and is ready to commit his changes.
[jerry@CentOS jerry_branch]$ make array
cc array.c -o array
[jerry@CentOS jerry_branch]$ ./array
The above command will produce the following result.
Enter the total number of elements: 5
Enter the elements
10
-4
2
7
9
Array has following elements
|10| |-4| |2| |7| |9|
Sorted data is
|-4| |2| |7| |9| |10|
[jerry@CentOS jerry_branch]$ svn status
? array
M array.c
[jerry@CentOS jerry_branch]$ svn commit -m "Added sort operation"
Sending jerry_branch/array.c
Transmitting file data .
Committed revision 10.
Meanwhile, over in the trunk, Tom decides to implement search operation. Tom
adds code for search operation and his code looks like this.
[tom@CentOS trunk]$ svn diff
43. SVN
39
The above command will produce the following result.
Index: array.c
===================================================================
--- array.c (revision 10)
+++ array.c (working copy)
@@ -2,6 +2,27 @@
#define MAX 16
+int bin_search(int *arr, int n, int key)
+{
+ int low, high, mid;
+
+ low = 0;
+ high = n - 1;
+ mid = low + (high - low) / 2;
+
+ while (low <= high) {
+ if (arr[mid] == key)
+ return mid;
+ if (arr[mid] > key)
+ high = mid - 1;
+ else
+ low = mid + 1;
+ mid = low + (high - low) / 2;
+ }
+
+ return -1;
+}
+
void accept_input(int *arr, int n)
{
int i;
44. SVN
40
@@ -22,7 +43,7 @@
int main(void)
{
- int i, n, arr[MAX];
+ int i, n, ret, key, arr[MAX];
printf("Enter the total number of elements: ");
scanf("%d", &n);
@@ -39,5 +60,16 @@
printf("Array has following elementsn");
display(arr, n);
+ printf("Enter the element to be searched: ");
+ scanf("%d", &key);
+
+ ret = bin_search(arr, n, key);
+ if (ret < 0) {
+ fprintf(stderr, "%d element not present in arrayn", key);
+ return 1;
+ }
+
+ printf("%d element found at location %dn", key, ret + 1);
+
return 0;
}
After reviewing, he commits his changes.
[tom@CentOS trunk]$ svn status
? array
M array.c
[tom@CentOS trunk]$ svn commit -m "Added search operation"
45. SVN
41
Sending trunk/array.c
Transmitting file data .
Committed revision 11.
But Tom is curious about what Jerry has been doing in his private branch.
[tom@CentOS trunk]$ cd ../branches/
[tom@CentOS branches]$ svn up
A jerry_branch
A jerry_branch/array.c
A jerry_branch/README
[tom@CentOS branches]$ svn log
------------------------------------------------------------------------
r9 | jerry | 2013-08-27 21:56:51 +0530 (Tue, 27 Aug 2013) | 1 line
Added sort operation
------------------------------------------------------------------------
By viewing the Subversion's log message, Tom found that Jerry implemented
‘sort’ operation. Tom implemented search operation using binary search
algorithm, it always expects data in sorted order. But what if the user provides
data in an unsorted order? In that situation, binary search operation will fail. So
he decides to take Jerry's code to sort data before the search operation. So he
asks Subversion to merge code from Jerry's branch into trunk.
[tom@CentOS trunk]$ pwd
/home/tom/project_repo/trunk
[tom@CentOS trunk]$ svn merge ../branches/jerry_branch/
--- Merging r9 through r11 into '.':
U array.c
After merging, array.c will look like this.
[tom@CentOS trunk]$ cat array.c
46. SVN
42
The above command will produce the following result.
#include <stdio.h>
#define MAX 16
void bubble_sort(int *arr, int n)
{
int i, j, temp, flag = 1;
for (i = 1; i < n && flag == 1; ++i) {
flag = 0;
for (j = 0; j < n - i; ++j) {
if (arr[j] > arr[j + 1]) {
flag = 1;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int bin_search(int *arr, int n, int key)
{
int low, high, mid;
low = 0;
high = n - 1;
mid = low + (high - low) / 2;
while (low <= high) {
if (arr[mid] == key)
return mid;
47. SVN
43
if (arr[mid] > key)
high = mid - 1;
else
low = mid + 1;
mid = low + (high - low) / 2;
}
return -1;
}
void accept_input(int *arr, int n)
{
int i;
for (i = 0; i < n; ++i)
scanf("%d", &arr[i]);
}
void display(int *arr, int n)
{
int i;
for (i = 0; i < n; ++i)
printf("|%d| ", arr[i]);
printf("n");
}
int main(void)
{
int i, n, ret, key, arr[MAX];
printf("Enter the total number of elements: ");
48. SVN
44
scanf("%d", &n);
/* Error handling for array overflow */
if (n > MAX) {
fprintf(stderr, "Number of elements must be less than %dn", MAX);
return 1;
}
printf("Enter the elementsn");
accept_input(arr, n);
printf("Array has following elementsn");
display(arr, n);
printf("Sorted data isn");
bubble_sort(arr, n);
display(arr, n);
printf("Enter the element to be searched: ");
scanf("%d", &key);
ret = bin_search(arr, n, key);
if (ret < 0) {
fprintf(stderr, "%d element not present in arrayn", key);
return 1;
}
printf("%d element found at location %dn", key, ret + 1);
return 0;
}
After compilation and testing, Tom commits his changes to the repository.
49. SVN
45
[tom@CentOS trunk]$ make array
cc array.c -o array
[tom@CentOS trunk]$ ./array
Enter the total number of elements: 5
Enter the elements
10
-2
8
15
3
Array has following elements
|10| |-2| |8| |15| |3|
Sorted data is
|-2| |3| |8| |10| |15|
Enter the element to be searched: -2
-2 element found at location 1
[tom@CentOS trunk]$ svn commit -m "Merge changes from Jerry's code"
Sending trunk
Sending trunk/array.c
Transmitting file data .
Committed revision 12.
[tom@CentOS trunk]$