background preloader

Tv's cobweb: Git for Computer Scientists

Tv's cobweb: Git for Computer Scientists
Abstract Quick introduction to git internals for people who are not scared by words like Directed Acyclic Graph. Storage In simplified form, git object storage is "just" a DAG of objects, with a handful of different types of objects. blob: The simplest object, just a bunch of bytes. tree: Directories are represented by tree object. When a node points to another node in the DAG, it depends on the other node: it cannot exist without it. commit: A commit refers to a tree that represents the state of the files at the time of the commit. refs: References, or heads or branches, are like post-it notes slapped on a node in the DAG. git commit adds a node to the DAG and moves the post-it note for current branch to this new node. The HEAD ref is special in that it actually points to another ref. remote refs: Remote references are post-it notes of a different color. tag: A tag is both a node in the DAG and a post-it note (of yet another color). History This is the simplest repository.

Why might git log not show history for a moved file, and what can I do about it Preface Git is a version control Swiss army knife. A reliable versatile multipurpose revision control tool whose extraordinary flexibility makes it tricky to learn, let alone master. As Arthur C. Clarke observed, any sufficiently advanced technology is indistinguishable from magic. This is a great way to approach Git: newbies can ignore its inner workings and view Git as a gizmo that can amaze friends and infuriate enemies with its wondrous abilities. Rather than go into details, we provide rough instructions for particular effects. I’m humbled that so many people have worked on translations of these pages. Dustin Sallings, Alberto Bertogli, James Cameron, Douglas Livingstone, Michael Budde, Richard Albury, Tarmigan, Derek Mahar, Frode Aannevik, Keith Rarick, Andy Somerville, Ralf Recker, Øyvind A. François Marier maintains the Debian package originally created by Daniel Baumann. My gratitude goes to many others for your support and praise. or from one of the mirrors:

The Places frecency algorithm - MDC Frecency is a score given to each unique URI in Places, encompassing bookmarks, history and tags. This score is determined by the amount of revisitation, the type of those visits, how recent they were, and whether the URI was bookmarked or tagged. The word "frecency" itself is a combination of the words "frequency" and "recency." The default frecency value for all valid entries is -1. The frecency calculation process Example This is an example of a frecency calculation for a URI that is bookmarked and has been visited twice recently (once yesterday, and once last week by clicking a link), and two other times more than 90 days ago: Notes The number of sampled visits is min(10 most recent visits pref, total visit counts). Developer notes There are various development notes you can read about Places that may offer additional insights: History The initial algorithm design was by Mike Connor and Seth Spitzer.

Chapter 3. Cloning Around Chapter 3. Cloning Around In older version control systems, checkout is the standard operation to get files. You retrieve a bunch of files in a particular saved state. In Git and other distributed version control systems, cloning is the standard operation. I can tolerate making tarballs or using rsync for backups and basic syncing. Initialize a Git repository and commit your files on one machine. $ git clone other.computer:/path/to/files to create a second copy of the files and Git repository. $ git commit -a $ git pull other.computer:/path/to/files HEAD will pull in the state of the files on the other computer into the one you’re working on. Initialize a Git repository for your files: $ git init $ git add . $ git commit -m "Initial commit" On the central server, initialize a bare repository in some directory: $ mkdir proj.git $ cd proj.git $ git --bare init $ touch proj.git/git-daemon-export-ok Start the Git daemon if necessary: $ git daemon --detach # it may already be running $ git commit -a

Git User's Manual (for version 1.5.3 or newer) This chapter covers internal details of the Git implementation which probably only Git developers need to understand. A birds-eye view of Git’s source code It is not always easy for new developers to find their way through Git’s source code. This section gives you a little guidance to show where to start. A good place to start is with the contents of the initial commit, with: $ git checkout e83c5163 The initial revision lays the foundation for almost everything Git has today, but is small enough to read in one sitting. Note that terminology has changed since that revision. Also, we do not call it "cache" any more, but rather "index"; however, the file is still called cache.h. If you grasp the ideas in that initial commit, you should check out a more recent version and skim cache.h, object.h and commit.h. In the early days, Git (in the tradition of UNIX) was a bunch of programs which were extremely simple, and which you used in scripts, piping the output of one into another. Now, for the meat:

A successful Git branching model » nvie.com Note of reflection (March 5, 2020)This model was conceived in 2010, now more than 10 years ago, and not very long after Git itself came into being. In those 10 years, git-flow (the branching model laid out in this article) has become hugely popular in many a software team to the point where people have started treating it like a standard of sorts — but unfortunately also as a dogma or panacea.During those 10 years, Git itself has taken the world by a storm, and the most popular type of software that is being developed with Git is shifting more towards web apps — at least in my filter bubble. Web apps are typically continuously delivered, not rolled back, and you don't have to support multiple versions of the software running in the wild.This is not the class of software that I had in mind when I wrote the blog post 10 years ago. Why git? For a thorough discussion on the pros and cons of Git compared to centralized source code control systems, see the web. The main branches ¶ develop

Understanding Git Conceptually Introduction This is a tutorial on the Git version control system. Git is quickly becoming one of the most popular version control systems in use. There are plenty of tutorials on Git already. How is this one different? A Story When I first started using Git, I read plenty of tutorials, as well as the user manual. After a few months, I started to understand those under-the-hood concepts. Understanding Git The conclusion I draw from this is that you can only really use Git if you understand how Git works. Half of the existing resources on Git, unfortunately, take just that approach: they walk you through which commands to run when, and expect that you should do fine if you just mimic those commands. This tutorial, then, will take a conceptual approach to Git. Go on to the next page: Repositories

appscript nco sourceforge This file documents NCO, a collection of utilities to manipulate and analyze netCDF files. Copyright © 1995–2014 Charlie Zender This is the first edition of the NCO User Guide, and is consistent with version 2 of texinfo.tex. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. The original author of this software, Charlie Zender, wants to improve it with the help of your suggestions, improvements, bug-reports, and patches. Table of Contents The netCDF Operators, or NCO, are a suite of programs known as operators. This documentation is for NCO version 4.4.3. Enjoy, Charlie Zender Foreword NCO is the result of software needs that arose while I worked on projects funded by NCAR, NASA, and ARM. Charlie Zender May 1997 Boulder, Colorado Summary 1 Introduction 1.1 Availability

Related: