Plastic is a DVCS too. So you'll use the same workflow: you commit first (checkin) then you push your changes to the remote repo.
In Plastic you can work centralized if you want to. SVN style directly doing checkin without intermediate clone? Possible.
While coders will love DVCS, other roles like artists and designers will probably go for central.
Creating feature branches often, switching to them, switching to others...
Everything in Plastic can be done visually from the GUI. You'll end up using the Branch Explorer for all things related to branching and merging.
Push and pull branches from remote repos.
You can do partial replicas: meaning you can simply pull a branch, without bringing all the parents and merge sources, and be able to add changes and push back.
Very good merging.
Git has good merging. Merging in Plastic is even better. The merge engine in Plastic can deal with moves and renames that make Git break.
Plastic includes its own diff and merge tools too.
Plastic can handle really big files – what fits in RAM is not the limit.
Plastic is good with very big repos too.
"Remotes" – there's no such a concept in Plastic, you just push and pull the branches you want to the repos you want, no need to define "remotes" first.
Clones: you don't need to "clone" the full repo to start working on a replicated repo in Plastic. You can simply run what we call a "partial replica" which is much faster.
Then you can work on the repo, make new changes and pull back.
It is the equivalent to a shallow clone with a restricted depth but capable of pushing back .
Submodules – we call them Xlinks and they're greatly enhanced and simplified submodules:
Plastic speaks the Git network protocol, so it can push/pull to a remote Git server. The Git server *thinks* Plastic is just another regular client.
You can use GitSync to push and pull from a GitHub repo, or any other Git server. It supports the git protocol and also http and ssl.
GitSync does not support the file protocol yet, so you can't contribute to a local repo on your disk... unless you run a local server.
Plastic implements the fast-import and fast-export commands, which are totally compatible with their Git counterparts.
Fast-import/export commands are meant to be used for an initial import from Git to Plastic and in order to have a way to safely move away from Plastic if required. For regular daily operations GitSync is an easier choice.
Git clients can directly push/pull to any Plastic Server that has the GitServer feature enabled.
GitServer turns any Plastic SCM server into a full-featured Git server. This means it is a "universal connector" to plug any Git tool to Plastic (issue trackers, repository analysis tools, DevOps/Continuous Integration, code reviews and many more).
Alternatively, GitServer plays a key role helping organizations transitioning to Plastic while keeping repos in sync with other teams using Git.
It can also be used as a way to collaborate with external teams delivering repos in Git format.
While most of the underlying concepts are the same, a few things change:
We just call it checkin while Git calls it commit. Just the act of submitting changes to the repo.
Each new change on the history of the repo, grouping several individual file and directory changes.
Whenever you create a repo in Plastic there's always an "empty" branch. We call it main. We could also have used "trunk" in SVN style... :P
Downloading content to the workspace (working copy). We call it "update" because we use "checkout" with a different meaning
No equivalent on Git.
When you checkout a file in Plastic you're basically telling Plastic you are going to modify the file. It is used for two purposes:
Exclusive checkout or lock
Means locking a file so nobody can touch it. It is useful only for non-mergeable files, like binaries, images, art in a video game and so on (we would never use it for code!!!).
We don't handle rebases in Git fashion, at least not so far.
Plastic doesn't rewrite history. It is not that we're against it, it was a design decision, a philosophy. We're not religious about it so we don't discard we'll change it one day.
That being said: rebasing is a subtle topic in Git: you can only do it *before* you push (in fact many recommend not to use it ever) and most of the time it is used to be able to *understand* the history without going crazy with all the merging.
Plastic has the Branch Explorer which simply lets you understand what is going on, graphically. So chances are you don't go crazy and you don't miss rebasing.
Second: when you diff a branch with several merges, it is hard to see what you really changed on the branch and what comes from the merge... this is also solved in Plastic .
No changes here, a repo is a repo: the "database" where the entire history of the project is stored.
The difference is that in Plastic the repos are stored on a separate directory from the working copy.
And repos in Plastic are, in fact, databases: we use standard databases like sqlite, SQL Server, MySQL and more to store data and metadata.
In Git you have the working copy and the repo on the same location. You have a working copy and a .git hidden dir with the repo. In Plastic this is slightly different since repos and workspaces are separated.
It means you can have several workspaces working with the same repo, and I mean against the same "local repo", something you can't do in Git without an intermediate repo (which changes the scenario again).
Long ago version control used to be considered a commodity. You just had to use one, it didn't really matter which one. But that was before the DVCS revolution and before Git, Mercurial and our own Plastic SCM changed everything.
Plastic is not based on Git, it doesn't use the same core, and it is not another layer on top of it. And you can use it as an advantage, because if version control is a competitive advantage and all your competitors use the same DVCS... what's the plus?
Git did a fabulous job educating the entire software community on branching, merging, pushing and pulling. New tools, new patterns and new best practices were adopted and everything changed.
Plastic SCM starts with all the strengths of Git and then it adds support for large files, consistent GUIs, ACL-based permissions, handles huge repos, even stronger merging, partial replica, semantic diffing and merging...
We build the Plastic server core, the entire branching and merging engine, the storage layer on database, the optimized network protocol, but we also develop the diff and merge tools, the GUIs on Mac, Linux and Windows, the integrations with issue trackers and IDEs... It is a lot of work for a small team like ours, but we get something in exchange: great consistency.
Developing the entire stack, from the core to the GUI, gives us the chance to get the maximum out of each new feature. Think on our integrated multi-file semantic diff that detects methods that have been moved to a different file and changed . It goes down from diff calculation, adding semantics to the algorithm, to the way in which the GUI is rendered.
Whenever we design a new feature we don't stop on the server side or the command line, we go all the way up, we think how the developer is going to use it, that's the final goal in fact.
Compare it to what you get with regular Git tools: ok, different teams on different companies collaborating together, which is great, but very often you see how GUI tools are just wrappers on the command line, they don't look and feel as if they were designed consistently, do they?
This is one of the key advantages when you use Plastic SCM: everything has been designed by the same team, and hence consistency and attention to the detail has been built-in from the beginning.
The same happens at the support level. We build, use and work every single minute with Plastic SCM. So you get engineering level support: you can access the team actually coding Plastic.