Contemporary source control for pharo

•

0 likes•1,710 views

Title: Contemporary source control for Pharo Speaker: Max Leske Wed, August 20, 2:30pm – 3:00pm Video Part1: https://www.youtube.com/watch?v=fa9Zpxyt_no Video Part2: https://www.youtube.com/watch?v=vpag70LmGrY Description Abstract: SVN [1], Mercurial [2] and Git [3] probably are the predominant source control systems used for open source software. Each of these systems brings many tools to the table to visualize meta data, search for versions and content and, most importantly, manage versions and changes to versionable entities. Unfortunately for us, Pharo does not natively support any of these systems which makes access for newcomers harder and inhibits our sharing abilities. In this talk I want to: - show what support for different source control systems can do for us - present the work that is being done on integrating Git into Pharo - discuss how this work will enable the integration of arbitrary source control systems into Pharo - touch upon the future of Monticello and Metacello in Pharo [1] http://subversion.apache.org [2] http://mercurial.selenic.com [3] http://git-scm.com Bio: Max Leske is a master student of University of Bern and working with netstyle.ch

Software

Contemporary source
control for Pharo
This is the talk about Git.
ESUG, 2014-08-10 Max Leske

Overview
background
current state
the future
(Git)
(Git)
(Git)

Revision control systems
Mercurial (2005) Git (2005)
CVS (1990)
Monotone (2003)
RCS (1982)
SVN (2000)
BitKeeper (1999)
SCCS (1972)
Random selection
distributed
centralized

Source control in Squeak
and Pharo
Monticello 2
Monticello
DVS
CVS
RCS
Greatly
exaggerated

“The stupid content tracker from hell”
A bit about Git

Git objects
reference
commit
tree
tree tree
blob blob blob

Git repositories
Synchronization point
(usually)
repository
repository repository
repository
local remote other locals

Git protocols
file protocol file:///path/to/repo.git
/path/to/repo.gi
Git protocol git://server.com/path/to/repo.git
SSH protocol ssh://user@server/path/to/repo.git
user@server.com:path/to/repo.git
HTTP(S) protocol http://server.com/path/to/repo.git
https://server.com/path/to/repo.git

How Monticello works
(in my mind)
.mcz
Cypress
+ Git
Monticello
black hole

Monticello problems
• file instead of objects
• chunk file format
• version tracking / ancestry by filename
• hard to understand

Cypress (FileTree)
meta data
source
package version categorization
commit tree blob

Cypress problems
• moves / renames not tracked
• very deep directory structures
• files instead of objects
• checked out version = only visible version
• hard to merge

Metacello
specification
platform + package versions
fixed loadable unit

Metacello problems
• complex implementation
• hard to maintain for big projects
• very steep learning curve

How Monticello might work
Monticello
arbitrary
backend

Support for arbitrary
backends
Matthias Kleine,
Robert Hirschfeld,
Gilad Bracha
An abstraction for version
control systems
:
https://www.hpi.uni-potsdam.de/hirschfeld/publications/media/
KleineHirschfeldBracha_2012_AnAbstractionForVersionControlSystems_HPI54.pdf

Pharo 2 architecture
Metacello
Monticello
Monticello meta model

Current architecture
Metacello
Monticello
Monticello meta model

Possible future architecture
Metacello
Monticello
Ring
Git adaptor
Git bindings
Git

Possible future architecture
Metacello
Monticello
Ring
Mercurial Git adaptor
adaptor
Mercurial Git bindings
bindings
Mercurial
Git
? adaptor
? bindings
?

Model over matter (mostly)
Versioning model
Git adaptor Mercurial adaptor ? adaptor
commit
tree
blob
reference
changelog
manifest
filelog
tag
onesinglefile™

Why libgit2?
• well documented
• easy to understand
• fast response from community
• Git not required on host
• not maintained by us
• compiled to target platform
• no shell

P2P backend: the good
• resilient
• independent
• don’t care about locality

P2P backend: the bad
• not visible to outsiders
• not searchable from outside
• maintained by the community (super nodes)

Revision meta data in Git
commit
tree
#printOn: - v0

Revision meta data in Git
commit
tree
#printOn: - v0
reference
tree
#printOn: - v1
#printOn: - v2
#printOn: - v3

Revision meta data in Git:
the bad
• not manageable through Git
• need extra tools
• information only available to select few
• overhead (who will look at it)

Revision meta data in Git:
the good
• collect data for research
• fine grained history
• don’t have to look at it if you don’t want to

A bit of a wrap up
• come a long way
• still a long way to go

A bit of a wrap up
• choice of storage backend
• better modularity (changing components)
• use existing solutions
• take load off community

A bit of a wrap up
• Git + abstractions: first step
• access to Git important (not just for revision control)

Acknowledgements
• Esteban Lorenzano
• Martin Dias
• Stéphane Ducasse
• Dale Henrichs
• Camillo Bruni

Git allows for a distributed model where every user has their own local copy of the code and changes are merged to a local master branch, while SVN uses a centralized model where changes are committed to a central repository. Git operations like diff and commit are much faster since they are performed locally without network latency. Git also uses much less storage space than SVN. A key advantage of Git is its powerful branching and merging capabilities.

Git version control

Calloway Green Ltd

Git is a distributed version control system designed to handle large projects with speed and efficiency. It was created by Linus Torvalds for development of the Linux kernel in 2005. Git allows developers to work on non-linear development through rapid branching and merging. Changes are distributed through local clones of the full repository history. Git uses cryptographic authentication to ensure the integrity of commits and detect changes to history.

Git vs. Mercurial

Marian Marinov

Git 101: Force-sensitive to Jedi padawan

James Ford

What is Git? What does it do, how does it work, how does it fit into my workflow? If you've ever wondered about the answers to any of those things, this session is designed for you, my friend. Starting with the assumption of no prior knowledge of Git or even of version control, we'll cover the technology at a theoretical level, its manifestation in your projects in the physical level, and your development workflow at the practical level - by which time you'll be ready to step out into the world, secure in your knowledge of what the heck Git is, and ready to use it in your projects - and you'll marvel at how you ever worked without it.

Kubernetes meetup bangalore december 2017 - v02

Kumar Gaurav

The document summarizes key announcements and discussions from the Kubernetes Meetup in Bangalore on December 16th 2017. Over 4,100 people attended the event where it was announced that CNCF now hosts 14 open source projects and 31 new members joined at the Silver level. Some of the discussions focused on the growing adoption of Kubernetes for building cloud-native applications, new projects being developed for Kubernetes like Metaparticle and Kata Containers, and the rise of serverless architectures and service meshes like Istio. The 2018 Europe Conference for Kubernetes and Cloud Native was also announced.

Beginner walkthrough to git and github

Mahmoud Said

This document provides an introduction to Git and GitHub. It begins with an overview of source control and the history of version control systems like SVN and CVS. It then discusses key concepts of Git like its three-tree architecture, branches and merging, and undoing changes. The document concludes with an introduction to GitHub, how to clone and collaborate on repositories, and some tips on reducing merge conflicts.

Roslyn on GitHub

Immo Landwerth

Workshop on git

Govind Maheswaran

This document provides an overview and introduction to the version control system Git. It begins with information about the workshop organizer Govind Maheswaran and his background. The document then covers what Git is, why it was created, how to get started using basic Git commands, and it provides quotes from Linus Torvalds about creating Git. The document aims to explain key Git concepts like repositories, working copies, and objects in less than three sentences.

Mini-training: Let’s Git It!

Betclic Everest Group Tech Team

Git & GitHub N00bs

YasserElsnbary

This document provides an introduction to Git and GitHub. It begins with an overview of version control and how Git allows recording changes to files over time. It then discusses what GitHub is and how it acts as a remote repository hosting service for Git. The remainder of the document outlines key Git concepts like commits, repositories, cloning, branching and pulling/pushing changes. It also previews demonstrations on creating repositories, forking projects and making pull requests between accounts.

Git_new.pptx

BruceLee275640

This document provides an introduction to Git and GitHub. It begins with an overview of source control and the history of version control systems like SVN and CVS. It then discusses key Git concepts like its three-tree architecture, branches and merging, and undoing changes. The document concludes with an introduction to GitHub, including how to clone repositories, collaborate through pull requests, and link a local Git repository to a remote GitHub repository.

January 2022: Central Iowa Linux Users Group: Git

Andrew Denner

This document provides an overview of the history and features of Git version control software. It discusses earlier version control systems like SCCS and CVS, and how Git was created in 2005 by Linus Torvalds with goals of speed, data integrity, and supporting distributed non-linear workflows. The document outlines some key features of Git like distributed versioning and atomic commits, as well as potential downsides like dealing with large binary files. It also briefly introduces Git LFS as an extension for managing large files outside of the main Git repository.

Whether you should migrate to git

Amit Anand

Git has become very popular due to its good performance and wide plugin support for IDEs. It allows full access to the project history even without an internet connection. Many large companies have migrated to Git due to its open source nature and the popularity of GitHub. While distributed version control has advantages, a centralized server approach may be better for some situations. Migrating to a new version control system requires considering pre-migration and post-migration challenges.

Introduction to git

Ram0603

Embedded Systems: Lecture 10: Introduction to Git & GitHub (Part 1)

Ahmed El-Arabawy

Git presentation to some coworkers some time ago

Rodrigo Urubatan

Git is a distributed version control system created by Linus Torvalds in 2005 to be very fast, support branching and merging easily, and handle Git's workflow of distributed development across multiple repositories. Some key advantages of Git include not requiring a central repository, speed, easy branching and merging, and increased collaboration. However, adoption of Git also presents challenges like learning new concepts and tools, lack of good GUIs, and incompatibility with some SVN workflows.

Introduction to git

Nguyen Van Hung

This document provides an introduction and overview of Git. It begins with a brief history of Git's origins with Linux source code management. It then covers key Git concepts like its distributed version control model, advantages like speed and resilience, and some basic commands. The document demonstrates setting up a sample Git repository and making commits. It also discusses branching, tagging, undoing changes, cleaning up repositories, and using remote repositories.

git presentation

Belal Quamar

Demo

Miracle Anyanwu

This document provides an overview of installing Git and creating a GitHub account, as well as explaining some key concepts about version control with Git and GitHub. It discusses installing Git on Linux, Mac and Windows systems, creating a GitHub account, and what Git and GitHub are. Key Git concepts explained include snapshots, commits, repositories, branches, merging, and what a HEAD means in Git. GitHub is described as a website that hosts Git repositories and adds extra functionality for code collaboration.

Rc094 010d-git 2 - desconocido

Luis Bertel

This document provides an overview and introduction to using the version control system Git. It discusses key Git concepts like distributed version control, cloning repositories, and the typical local and remote workflows. The document covers setting up Git, creating and cloning repositories, editing and committing changes locally, branching, merging, tagging, and working with remote repositories by pushing and pulling changes.

Git(hub) for windows developers

bwullems

Centralized Source Control Systems are so 90’s. Forget Team Foundation Server, Subversion,… Today it’s all about Distributed Source Control systems. Working with many developers on the same project, using lots of branches, managing versions and releases will no longer be a painful experience. Let’s have a (first) look together at GIT and GITHub and how this will simplify your life as a .NET developer.

Git.From thorns to the stars

Strannik_2013

This document provides a summary of Git and its features: Git is a distributed version control system designed by Linus Torvalds for tracking changes in source code during software development. It allows developers to work simultaneously and merge their changes. Key features include rapid branching and merging, distributed development, strong integrity and consistency. Git stores content addressed objects in its database and uses SHA-1 hashes to identify content.

Svn vs mercurial vs github

Vinoth Kannan

Mercurial and Git are both distributed version control systems that allow developers to work offline and synchronize changes later. Some key differences are: - Git has a steeper learning curve due to more commands and concepts, while Mercurial's model is closer to Subversion and easier to migrate to. - Mercurial has cleaner Windows support as an official Python distribution, while Git has stronger Linux heritage and Windows support through third parties. - Git allows discarding old branch data to optimize disk usage, while Mercurial requires keeping all revision history locally at all times. - Both systems effectively support branching and merging, though Git can have irregular performance drops and Mercurial branching is slightly slower. Overall, Mer

Workshop: Identifying concept inventories in agile programming

Contemporary source control for pharo

Recommended

Recommended

More Related Content

Similar to Contemporary source control for pharo

Similar to Contemporary source control for pharo (20)

More from ESUG

More from ESUG (20)

Recently uploaded

Recently uploaded (20)

Contemporary source control for pharo