Tag Archives: Subversion


Git – A New Training

Git continues to encroach upon the space of existing version control systems. More and more development projects are opting for Git over the likes of CVS and Subversion. But Git is not an easy system to handle.

You’ll need someone to give you a nice, gentle introduction. I’ve long since elbowed out all other version control systems in favour of using this colourfully-named version control system exclusively. If you like, I’ll come along and be the one to give you that gentle introduction.

Git is a powerful, distributed version control system that is particular well-suited for large development projects that include numerous parallel development branches. The Linux Kernel developers use it for heaven’s sake, a project with thousands of contributors. Last I checked, Linux recently went beyond 15 million lines of code. Nevertheless, Git is just at home servicing more humbly-sized projects too.

I ordinarily cover the following core topics:

Introduction to Git

  • History and philopsophy
  • Centralised vs. distributed architecture
  • Local vs. remote operations
  • Comparisons to other VCSs (e.g. CVS, Subversion)

Installation (Windows and Linux)

  • Installing the core software
  • Installing GUI tools (e.g. TortoiseGit)

Basic Operations

  • Initialising
  • Cloning
  • Configuring
  • File tracking and statuses
  • Staging
  • Committing
  • Maintaining an ignore list
  • Tagging

Repository History

  • Viewing the log
  • Viewing diffs
  • Customising log output
  • Rewriting recent history (undoing)

Labels and Specifiers

  • Data structure of a Git repository
  • Revision specifiers
  • Branches
  • Visualing labels and specifiers

Working in Branches

  • Creating a branch
  • Basic merging
  • Three-way merging
  • Dealing with conflicts
  • Rebasing


  • Cloning from remotes
  • Remote branches
  • Fetching and Pulling
  • Pushing

Using GitHub

  • Setting up a new project
  • Importing
  • Forking

Example Workflows

  • Branching workflows
    • Long-running branch
    • Topic branches
  • Organisational workflows
    • Centralised
    • Integration-manager
    • Dictator and lieutenants

Maintaining Your Own Server

  • Protocols (HTTP, SSH, Git)
  • Bare repositories
  • Securing with SSH


Working with Subversion Repositories

  • Communicating with a SVN repo
  • Migrating from an SVN repo

Subversion – New Trainings, New Experiences

The latest training I delivered this week was for a client in the embedded software industry who were changing their version control systems from CVS to Subversion. First, I’ll just plug the course content a bit, then say a bit more about how it went.

I’ve updated my business website with details of the course. For the full curriculum visit the Subversion course page. Broadly speaking, the course covers:

  • Subversion’s architecture and philosophy
  • Clients you can use to interface with the Subversion server (especially command-line, TortoiseSVN or Eclipse integration)
  • The basic workflow
  • More advanced concepts
  • And numerous tips and tricks to make life easier.

In this case, the course was customised to cover certain topics in more detail, in particular the philosophy (because the participants were converting from a version control system with rather a different approach to things) and externals (because the company had another branch in the USA where important software libraries and components were maintained).

The training went well in my opinion. The participants managed to grok the fundamental changes from CVS to Subversion; they all got hands-on experience playing around in sandbox repositories, trying to solve tasks I gave them; and they all seemed very curious, chatty, and generally engaged in the course.

In fact, this last point taught me a little something as a teacher. Most of the teaching and training I’ve done before has been for large companies and universities, places with teaching facilities like large rooms or auditoriums, where I stand at the front of the room with my pointy stick and the participants sit at individual desks. In such cases, it all feels very much like I’m lecturing to a group of students. This time around however, there was no such venue available and the training was conducted in a meeting room (albeit a typically technical one with a projector and Ethernet cables and so on).

So there the participants were, not all facing me like in a schoolroom, but sat with me around a table, more like a meeting or a seminar. I still presented a series of slides, but the conduct of the lesson was much more relaxed and casual. One effect this had was that people seemed much more willing to ask questions when they didn’t understand something. Another (and the really cool one, I think) is that there was a lot more self-teaching going on. When one participant asked a question, another participant sometimes beat me to it and started to answer them (occasionally with one eye on me, as if to ask silently “Am I getting this right?”) Thus, my role there was not so much to lecture them as it was to help them teach themselves — which, by the way, has always struck me as the most effective way to learn a topic.

I think this looser and slightly chaotic approach worked really well. Until now, I wasn’t so insisting on where a training took place. From now on, I think I’ll consider a round-table approach to teaching much more carefully, even when an organisation is lucky enough to have grand lecturing facilities.


Eclipse trainings available

I delivered my first Eclipse training just before Christmas last year. I’m happy to say that the clients, just under a dozen programmers working for a large German corporation, have reported being “very satisfied” with my two-day seminar. I’m also happy to say I enjoyed it even more than I thought I would, probably due to the lack of nervousness I thought I might experience. In fact, I was so at ease and enjoying myself, I’m now hugely looking forward to delivering it again for other clients.

For anyone who wishes to know more about the Eclipse training I provide (perhaps you’re interested in it yourself?) here’s the basic overview:

  • Downloading and installing
  • Introducing the working environment (workbench, views, perspectives)
  • Programming using the editor, basic functions
  • Backup and versioning, local history
  • Using plug-ins and updates sites
  • Project administration
  • Features for object-oriented programming
  • Features for Java development
  • Debugging and Running programs
  • GUI development using visual editors
  • Automated testing using JUnit
  • Version control using Subversion and Subclipse
  • Developing UML diagrams
  • Editing XML files
  • Plug-in development
  • Practical tips and tricks

These subjects are by no means carved in stone, but they certainly embody what is necessary for beginners to learn (with the possible exceptions of UML, XML and plug-in development) and represent what can be covered in a minimum of two days. Beyond that, my curriculum is flexible and open to discussion.

If you’re interested in knowing more or booking a training, then please feel free to get in touch via mail@karlbeecher.com.


First Saros Release of the Year: 11.1.7

Saros development has resumed normal service and last Friday made available its first release of 2011.

To quote some interesting passages from the release notes:

The integration of version control support (VCS) into Saros has been given its final consolidation. Developers can now collectively work on a project under version control and Saros will manage the co-ordination between the participants whether they have VCS software or not.

Note that so far Saros is only compatible with the Subversion program. We hope to include other popular VC systems in later releases.

We have also improved the perceived latency of Saros by lowering the interval time between which your updates are sent to your collaborators. In the unlikely event that this causes overload problems for the XMPP server, it can now be configured to a higher value.

Whereas Saros used to enforce the latency of transmitted edits itself (present out of courteousness; after all, Saros can use public servers and we wouldn’t want to overload them) we are now passing that power onto you. The rate at which your edits are transmitted to others in your session is now configurable via the advanced preferences, which now comes pre-set to a lower value to give you a more responsive feel. Use your fearsome new power wisely!

Get Saros today from http://dpp.sf.net/update, or visit http://www.saros-project.org for more information.


Poll: What version control system do you use with Eclipse?

Eclipse logoIt was so much fun using the poll technology last time, I thought I would try again.

You may be familiar with Saros — our plug-in which provides distributed collaborative editing in Eclipse — and you may even know that Saros now features version control system (VCS) integration, so that all participants can work directly on the project repository together. At the moment, this feature only supports Subversion, but thanks to some clever architecture we can easily chuck in a bit of new code to support any VCS we like. But our resources are limited, and in lieu of a contributor coming forward and writing their own code (which is always welcome!), we have to pick and choose which VCS to support next.

To help us decide, please take a few seconds for this poll. The most popular VCSes are included, but feel free to add others.