Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a tool, library or favorite off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 9 years ago.
Improve this question
For years, one of my most important tools has been incremental copy utility that compares the contents of two directories and shows me which files are newer / older / added / deleted. Every day I find myself copying folders of source code between my two desktop machines and the server, and such a utility is critical to avoid overwriting newer files with older ones and also to save time by only copying changed files. In addition, the utility allows me to see new files in the source folder that I don't necessarily want to copy (like temp files) that I instead can delete.
Like anyone who subscribes to the NIH way of thinking, I wrote my own utility to compare the contents of two folders and let me mark files to be copied, deleted, diffed or ignored. I've had many versions of this utility going back to DOS, OS/2 and Win32.
I use this utility on a daily basis, and it leaves me wondering: What do others use? Surely there are similar programs out there to do this... My utility doesn't have a diff screen, and it would be occasionally nice to see what the difference is between two changed files.
What do you use for comparing and incrementally copying between folders?
rsync. All the time.
The biggest benefit to rsync is that it trades increased CPU time for decreased transfer bandwidth, as CPUs are super fast nowadays, and even disk-copy is relatively slow, this is a good thing.
I use rsync for some jobs, and unison for others.
For your situation, I would strongly recommend using some version control solution such as Subversion.
As for NIH? While I have written a large number of tools over the years, I always look for an existing tool before writing my own. It saves time, and may have a better solution than I would have used. At the very least, it will give me some "how NOT to do it" examples.
SyncToy is also good at this stuff.
SyncBack (free) or SyncBackSE ($$) is another possible solution. SyncBackSE is one of the few programs I've ever paid for. Health warning: Win only.
IMHO, NIH violates Laziness and Impatience, though it strongly supports Hubris.
I tried Robocopy (included in Vista and available for download for XP) today and it worked fine. To incremental mirror a drive I used: robocopy source destination /MIR
There is also a GUI available: http://technet.microsoft.com/en-us/magazine/cc160891.aspx
robocopy. It's in Vista, and is also part of the Windows Resource Kit. It has a strange command line interface, but it's very powerful & good for this kind of thing.
Still, I find myself wondering whether source control would be a better choice for you.
NIH is not necessarily a bad thing. It can be good when the application has some very personal traits and you want it to be as convenient for you as possible, screw the generality.
I've also rolled my own utility (a Perl script) for this purpose a few years ago, and I'm using it both and home and at work for backups. It's simple to run because it does exactly what I need and only that, and simple to tweak because it's written in a flexible scripting language.
I have been using rsync (Linux to Linux / WinXP to Linux) a lot and like it. Today I tried to get it up and running under Vista and that was quite a challenge. I got it running but are having some issues with network drives and localized chars (i.e. åäö).
SyncToy seems pretty sweet! I noticed that it puts a data file in the synced folders. Anyone knows if it is possible to use it without the data files / have it save the data files to another folder?
I have to try robocopy as well.
Thanks a lot!
Have you considered using version control tool to accomplish this? It will allow you to keep things in sync while also remembering the history of a project.
A few good tools to try here.
Rsync is the ultimate for permissions and deltas on linux but on windows your usually using it with posix so acl permissions aren't perfect.
The people who made delta copy also made a pure windows version from the ground up that is based on rysnc's algorithm:
http://web.synametrics.com/Syncrify.htm
I haven't tried it but hopefully it will bring back good permissions to windows with the amazing incremental offerings of rsync.
Related
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 9 years ago.
Improve this question
It seems like a lot of people here and on many programmer wikis/blogs/ect. elsewhere really dislike VSS. A lot of people also have a serious dislike for cvs. In many places I have heard a lot of differing opinions on whether or not using VSS or cvs is better or worse then using no source control, please rate the worst and explain why!!!!! you rated them this way. Feel free to throw in your own horrible system in the rankings. If you feel it depends on the circumstances try to explain the some of the different scenarios which lead to different rankings.
(note:I see a lot of discussion of what is better but little of what is worse.)
second note: while both answers are nice I'm looking less for good replacements and more for a comparison of which is worse and more importantly why!
No source control at all is the worst option, no need to discuss this and this is actually not an option.
I've used VSS once (10 years ago) and apart from the fact that it had very poor third party tools support, I'll just mention that the repository got corrupted several times (sigh). This surely explain why I don't trust VSS at all and would prefer any open source tools alternative (can't be worse).
If I can avoid CVS, I do it. It kinda works, is widely supported but really lacks important features (the most important one being atomic commits). But it works (it's better than nothing or VSS).
I've used Borland Starteam on a big project. Non technical people may appreciate it's client UI but it was lacking too much important things for developers: no nice IDE integration (even in JBuilder, what an irony), no post-commit hooks, no efficient Java API (to use with Maven for example), damn slow on WAN, etc plus some other very annoying glitches (like the UI not showing directories not in view). Not horrible, but there are better solutions.
ClearCase has been a bad experience, perfect for anti-agile development (was driving me mad). And so was PVCS (a nightmare). I don't even know what to say / where to start: expensive, heavy, poor tooling, etc. People buying these tools can't be the one using them, it's not possible.
Subversion was meant to be the successor of CVS, a better CVS (by providing the missing features), is widely used, is supported by many tools and is still very recommendable. Better than any of the previous solutions.
Then we have DVCS like Mercurial, Git which are more powerful, but require more skills to be used and are still lacking of tools support/integration (using the command line is not an option for everybody). Still, they are recommendable, depending on the context (not everybody needs more power) and Mercurial would have my preference because I find it more friendly.
This is nicely summarized on this picture from Martin Fowler's VersionControlTools page:
He must have read my mind when he wrote this page :)
In my experience -
Git > SVN > CVS > PVCS > none > VSS
Reasoning -
1.) Git - nice distributed model; initially some lack of support on Windows, but now works with any OS; lots of tool/IDE support.
2.) SVN - pretty standard; there can be a small amount of pain setting up server initially, but nothing major; works with pretty much everything.
3.) CVS - old; kind of a pain to work with; but still works with pretty much everything (OS, IDE, tools).
4.) PVCS - proprietary; not integrated into many tools/IDEs; overcomplicated workflow compared to other modern version control system.
4.) none - definitely not preferred, but at least you aren't fooling yourself. This is still pretty inexcusable in this day and age with so many options and Source Control being such a well known best practice.
5.) VSS - definitely not preferred; mostly replaced by TFS; unstable; can silently fail; worse than nothing because you're fooling yourself that it will actually keep your source safe.
The thing about VSS is:
it is a virtual certainty that if you use VSS for any length of time it will eventually corrupt it's repository and require restoring from backup.
that's not even the biggest disadvantage to using it
A batch script that makes a zip of a source folder archive with today's date as the filename is about 10% more powerful and 5x more reliable than VSS.
No source control is definitely worst. You need to keep a history and backup of your code, even if you program by yourself.
Then I would say VSS. I've used it (years ago) and it works, but is basically nothing like a modern source control system. It's better than nothing, but since there are so many free options that work great, I wouldn't really recommend VSS unless you're unfortunate to be in a "MS-Only" shop and have the mindset of "We'll use it 'cause it came with MSDN" which unfortunately I've see too often.
A tiny step above VSS is SourceGear Vault. http://www.sourcegear.com/vault/ It's a 3rd party source control that is basically rewritten from scratch VSS but works better with remote users. I wouldn't really recommend this either, but if it's all you can get approved, is an option.
CVS is better than these. It's free, open source, provides good history and branching/merging support, and enables concurrent development without locking.
SVN is better still and the choice of many. It's free, open source, but also has commercial backing from a number of sources (i.e., you can buy support if you need it). There are many great tools available and it provides very good concurrent development without locking.
The next step is newer distributed version control systems like Git or Mercurial. As far as I understand it, in these systems each user usually gets a complete copy of the repo and has their own local set of branches and history. They can work 100% locally including commits and branches and rollbacks and everything, and when ready, push a set of changes upstream. This can continue in many different configurations fulfilling a variety of needs.
Perforce >>>> CVS > VSS > SVN.
Perforce is the best by far. Everything works fine. I use it mainly integrated in IDE because the integration was good. I use the interface for more advanced tasks.
CVS worked fine, though it was command line only (i used an old version).
VSS was merely ok. It became way too slow after the team grows to 10 people. It was an old version though.
SVN is currently what i use and its non-functionning. At least Tortoise SVN. Status often wont update in explorer, it often fails to track the history of modifications, you always need to clean up their database and their tree is confusing. I would rather do the source control manually than using this tool. But it is not my call so i am stuck with it in my current job, sigh....
VSS is good to use for source control.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a tool, library or favorite off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 8 years ago.
Improve this question
Can someone recommend a version control engine + GUI that will be good for non-technical users? I'm perfectly fine with using Subversion with my team of developers, but I want to find something that will help the rest of our company.
We are a design firm that deal with these type of files: Photoshop, Vectorworks, Microsoft Office, PDFs, etc.
I find GUIs such as SVNx and even Versions(which is pretty nice) too difficult and techy for our designers to use. It's hard for them to understand the idea of working directories and its relationship to a repository.
We are a small company and don't have a huge budget so we would like to stay opensource if possible.
Drop Box.
If you use TortiousCVS|SVN, its not too bad. Its a GUI/file based approach so its fairly straight forward. I've had non-technical people use it and like it.
If your non-techies are on a Mac, I would recommend SVN with Cornerstone from Zennaware. It's not open-source, but not expensive either. Our designers love it and it's got a great GUI.
Doesn't SharePoint come with Windows Server? It can handle file versions.
I can say that Subversion and Perforce are both problematic to non-technical users. We have been using Perforce as a document repository with some success. Though we have had more mistakes and problems than I care to talk about. We had slightly more success with Subversion and TortoiseSVN but even it was too difficult to most non-programmers to wrap their heads around. Though if you are lucky enough to have Mac OSX in the office, I would give rich's suggestion a try.
I would recommend looking for a CMS that supports history instead of a source repository. You should be able to find something out there that will do the job without too much work on your part.
I'd suggest SharePoint or Confluence. They both have a WebDAV interface which allows you to directly open and close files in the repository from Office and other current applications. SharePoint works better with Microsoft Office, as there are Microsoft specific WebDAV extensions in Office. Additionally, Confluence only offers WebDAV through a plugin.
Both of them are commercial products, though Confluence does have a shared source license, allowing you to make local modifications.
Bazaar has a pretty straightforward interface for the basic version-control tasks.
At some level, you're going to have to explain the basic concepts even to non-technical folk for them to make any use of it (there's no real way to "hide" the concept of committing your changes, for instance), but at the very least Bazaar's UI makes it pretty simple to do so, and keeps the option complexity down.
I recommend to check NeverOverwrite.
It keeps all versions of your files automatically. Sounds like an an ideal solution for non-developer.
How about a Wiki with some minimal version control built in ... like mediawiki
Why do you use source repository control for binary files like Photoshop, Vectorworks, Microsoft Office, PDFs, etc? I think Content Management System works better for you. Try using Alfresco, it's opensource and powerful.
I find sourcetree extremely intuitive for git/mercurial (no support for svn). It is for Mac and windows. It makes common operations like switching branches, merging, branching, reverting - which otherwise would be painful - quite easy.
But for your case I think VC solutions (that was built for coders) is not optimal as you will not be able to see differences between two versions of files as .psd, .doc, .pdf - these cannot be handled by the internal diff tool - so you are missing a lot of the power of version control
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 6 years ago.
Improve this question
What arguments can be used against using zip files of source code as a form of version control?
In general each developer is working on their own program and has a responsibility for it. But there are times of course when other developers are involved in work on that program.
Each developer has their own naming convention for zip files ranging from appending the date, a number after the program name or even appending _old / _oldold _newversion etc… When there is collaboration on development of some code. It has to be checked who has the ‘latest’ version of the code – and where it resides, usually the correct version is identified.
There is no easy existing method to diff source trees and during development unwanted changes occasionally slip into code.
The zip file corresponding to software releases that have release to manufacturing are archived. This at least adds some traceability.
Also before RTM there the code is peer reviewed against the previously released version so quality assurance does exist.
Are there any formal white papers explaining the advantages of source control, making clear that the above isn’t a fully valid form of source control? Arguments exist here that since the end product (manufacturing releases) are under control and these are reviewed that there is no problem with the process. Developers do not have too much of a problem working with zip files in this way, but may not be aware of the advantages.
Creating and managing zip files is error-prone.
Real source control gives you tools to understand your code:
History browsing
Diffs between revisions
Annotation of source files to track the origin of a change
Real source control isn't difficult, there's lots of help out there.
The best argument is surely that using a version control system like Subversion or Mercurial is much, much easier and more secure than messing about with zip files. I doubt there has been much paper writing on the subject, as the use of
zip files for this purpose is fairly obviously wrong.
There are a number of SO questions on the general advantages of version control. For example How can I convince my department to implement a version control system? and https://stackoverflow.com/questions/250984/do-i-really-need-version-control
I assume you currently work at a company that practices this method of zip control, and you're looking for ammunition to help you change this practice. There are a lot of questions on StackOverflow about source control, and the community here are in near-total consensus on the benefits of proper source control and the horrors of working without it (for very good reason).
I'll add something here to benefit your battle: YOUR COMPANY IS #$#%&$## CRAZY!!! ZIP FILES??? ARE YOU ##$##% KIDDING ME???
I am assuming that this question was asked because the original poster is working in an office where the standard practice is to share zip files.
Zip files are obviously bad, for the reasons given by Ned Batchelder. The biggest reason I would suggest is that it's clunky, and difficult to merge changes, or get diffs between past revisions easily.
I would recommend you read A Visual Guide to Version Control for some good arguments about why version control systems are very useful, and a superior way of managing code.
I suspect there'll be as many white papers comparing zip files to proper source control as there'll be white papers comparing cutting one's genitals off with a rusty butter knife with buying a puppy.
Zip files work as a very basic form of version control. It's a way to separate "states" of the source. However, it's not a good form of version control because you have to do a lot of work to perform basic source control management tasks. For example:
Bob's team is working on a major feature that requires changing dozens of files. He works in his own private zip-controlled area for a while. He's created 30 new files, added features to 12 existing files, and made changes to existing behavior in 3 existing files over 4 months. How do you merge Bob's work with the main trunk that has also evolved over the last 4 months? Do you hand-diff thousands of lines of code and decide how to merge them? How do you ensure that anything that uses the 15 existing files isn't broken? How do you ensure that Bob's features or main trunk features aren't accidentally omitted?
Alice is investigating a bug in her code and realizes that one of Sam's classes has changed its behavior. Sam says he didn't make the change. How does Alice find when and why the change was made? How does Alice know who depends on the change?
A major customer has reported a bug in an older version of the program. This customer needs a fix and is important enough to warrant a patch. How do you add the code to the old zip file in a way that it also exists in the new files? Also, how do you record that there is a relationship between the two changes?
These are just three scenarios that a version control system handles well. Situation 1 is handled by development branches. Almost every version control system has a notion of branches that can be developed in parallel and merged as needed. Situation 2 is easily addressed by any source control system with a "blame" feature and less easily addressed by just searching commit logs. Situation 3 is a variant of situation 1, but when you merge branches most version control systems make a note. For example, you'd make a branch off of the old version, fix the bug, then merge that branch into the new code. Now when someone asks "Where did this change come from?" they see it was merged from the patch branch and the change was made to fix a bug.
By the way, I've been in each of these 3 situations and used both SVN and Perforce; both made finding a solution very easy.
These people already know all the arguments for SCM, there is nothing anyone can say to them that will sell them on it. These things must happen:
You install SCM on your local machine and use it. If you must, have it autogenerate these .zip files at every build, so no one outside your cube knows the difference.
Some kind of disaster occurs, like loss of work, show-stopper bug is re-introduced or some other worst-case scenario that is the real reason we all use SCM (the other features we learn to appreciate later).
You are unaffected by the disaster, and/or use your personal copy of the code in SCM to fix the problem/recover the lost work/whatever.
You are a hero and everyone wants to know how you did it.
Only by experiencing firsthand the pain of loss caused by poor SCM practices will your organization realize the benefits of SCM. You're smart enough to learn from the mistakes of others, but not everyone is. The rest of the time, you'll just be 2/3X more productive than the rest of the team and maybe, just maybe they'll wonder how.
By the way, this is how you get agile, continuous integration, unit testing, etc into the organization: lead by example.
The ZIP solution requires a pro-active step at the end of the development cycle when things tend to get dropped because no one outside the dev group notices when they doesn't happen. Sort of like that final code cleanup you always plan on doing when things slow down.
An SCM integrated into the dev environment pretty much enforces/encourages keeping a version history with a small amount of effort all the way through the process. This makes it more likely that a version history will actually be created.
On Using ZIP as a SCM
I'm not going to take as hard of a line as some of the others on the ZIP file solution. It is at least better than nothing. It is a perfectly valid way of keeping version histories, it is just a lot more labor intensive, error prone, and lacks a lot of useful features.
Know who you are selling to
Someone in the Dev Group: Focus your arguments on features like ease of troubleshooting by using change histories, safety to experiment with big code changes (because of rollback), and avoiding accidents where work is overwritten by other developers.
Non-Tech Managers/Bean-counters: There are free/low-cost tools that will reduce the labor cost of version control and give greater accountability/transparency into what each developer is doing/the source of coding mostakes.
I wrote a Version Control tool long ago for a company who did the authoring for DVD titles. Before that they had nothing, just a directory full of clips, icons, scripts etc. which anyone could hack away at, and no way to backtrack if it went wrong etc. HOWEVER these people were 'artists', not programmers, so they could not (would not???!) be trained to use a decent Version Control system. So as a bare-minimum, get-out-of-the-mud level tool I wrote a utility which zipped up the current state of the directory, gave the Zip a meaningful name (date + comment supplied by user) and stuck it in a Backups directory, and also allowed you to restore one of these backups.
So zips CAN provide minimum-level version control, and I speak as someone who endorsed that approach when it was right for the skill-level (in terms of programming, I don't want to imply that they couldn't manipulate pixels!) of the people using it.
But as a programmer, you should be thinking to use a tool which really helps you. As such you want to be able to compare differences for individual files, compare differences between complete milestone sets, and (if you are working on anything other than trivial programmes) handle branching and merging. If you want these features you need something BETTER than zip files.
I used to use ComponentSoftware RCS, and if it wasn't for its poor performance over a WAN we might still be using it: it is cheap (even free for single-developer use, in which form I used to use it at home) and simple to use. However nowadays I would suggest looking at SubVersion. It is very flexible, reasonably simple to understand, has a good set of Windows tools to make it even easier (e.g. Tortoise, Ankh), and ... best of all ... you can get it running for free.
It's not good as only creating a zip before a release means loosing a lot of power you get with version control.
Useually you should check in to the repository after you have added/removed/changed a functional aspekt. So that you can go back later when an error occurres that you think migth be because of this change. Or when you say "dammed this worked before the file format changed in someday in march." Naming revisions after changes makes it also easier to remember because you forgot what was done on 27 march 2009.
In general each developer is working
on their own program and has a
responsibility for it. But there are
times of course when other developers
are involved in work on that program.
In a normal development shop, this is not at all true. Different people work on the same source code all the time. XP makes it almost mandatory. Even if you separate the code into modules, there will still be interaction points with code that concerns at least two programmers.
Of course, it's almost impossible to collaborate without major problems if you don't use source control. But the scenario you describe is much more a way to adjust to this limitation than a sane project structure.
Having only a single person working on a module means that nothing will happen when that person is on vacation and you have a major problem when he leaves the company, gets sick for a long time, or dies.
How do you do a merge? How do you do an annotate? How do you bisect? Where are changelogs stored? Just go to wikipedia and look up "Version control" and go down the list: zip files can kind of sort of do about 2 things out of the whole page.
This is like asking "What arguments can be used against shorthand as a form of double-entry bookkeeping?". It's a completely different thing.
For arguments, there's Walter Tichy's original paper on RCS.
For missing features, among many others there's the ability to merge changes from different versions. This is especially well supported by tools like git and darcs, and to a lesser extent mercurial.
P.S. To Mercurial fans: the problem is that Mercurial delegates the merge process to external tools, and it's very difficult for the mercurial novice to know which tool to use, or to understand how they work—the mercurial model of merging seems far more powerful than others but correspondingly difficult to get a grip on.
I haven't seen an answer include Eric Sink's Source Control HOWTO, but it's a valuable reference. I haven't seen any formal white papers on version control, but I'm not sure the argument about "validity" is your strongest one. The problems you describe in your question indicate some pretty serious drawbacks with the current approach. If "the powers that be" in your environment aren't convinced by that, change the argument entirely.
If you make it a question of quality control, and point to continuous integration as a practice that encourages it, then the zip file approach to version control isn't a "not fully valid form of version control", but an obstacle to implementing continuous integration as a practice.
Your question doesn't indicate whether or not the end product "under control" is tested in any automated fashion (in addition to being reviewed). If the process you describe would prevent that from taking place as well, certainly add that to your argument too.
I think your best argument is showing a GOOD form of source control and showing how powerful it is. Don't trash what is currently being done (as someone is surely emotionally attached to that). You don't want to trash the "ZIP Source Control Method." Show the power of something like SVN. Make it very easy to explain. Show common use cases. (A solid demo would help.)
Let the source control version sell itself.
I am interested to know what strategies people have to keep their code AND work versioned across multiple machines. For example I have a desktop PC running XP, a macbook running OSX and VMWare running XP as well as a sales laptop for running product demos. I want to know how I can always have these in sync. Subversion is a possibility for this but i find it less useful for dealing with binary files - maybe I have overlooked something here. What do other people use as they must have similar issues? Do they keep all files on a USB drive and never on the local file system. I am not always online so remote storage is not really an option.
Like others have said, subversion is your best bet for code. For binary files/non-code, I find DropBox to be very convenient. It stores revisions, has undelete, easy sharing, etc. basically an automagic, web-friendly SVN. Not having to think about it is the biggest plus for me.
I use mercurial for keeping my workfiles in sync. It's not great for big binaries either, but it lets me commit without being online and makes it easy to branche/merge different versions.
Ah the old VCS Debate.
The simplest way to share/sync Source Code is to use some sort of VCS (Version Control System) - this gives you plenty of benefits over being able to keep things synced. There are many VCSs out there, I personally use Bazaar-NG and Subversion - though I'd suggest you trial a few and see how you feel using them.
For syncing general files, espescially if it's only for yourself, I'd reccomend using "DropBox" (http://www.getdropbox.com/) - I've been using this for the last week or so, and it makes syncing up my multiple machines with a certain set of files so much more easy.
It also has some extra features that'd probably be useful for collaboration too, but I haven't tried those out yet.
Subversion works just great in our office for sales, project management, design and code files.
I store my dotfiles (.zshrc, etc) in a Git repository that is checked out into my homedir. I also do the same for the LaTeX files comprising my classwork.
I put important builds in Source Control -- it's fine for binary files.
For most files including source code we do use Subversion. It's really great.
If there are larger files oder Project management related documents which are used by people who have no access to the source control system, we use Microsoft SharePoint.
This is especially usefull if you are working with people outside your company.
I keep all my work encrypted on a USB stick. It also has a bootable Linux partition so I can get into a sensible working development environment from any machine, such as a borrowed work laptop with some software to carry to a conference that I can't move to my own machine.
When you have more people working on the same code, I'd put it in a central Subversion repository and set up scripts (in Windows you could use the autorun feature for the USB stick) to synchronize things between the repo and a USB stick always carried along.
The main point I see reg. using SVN as central repository for binary files, is that if those files are of any reasonable size, they will take some time to be synced over the net.
So if you don't want to spend time waiting for your files coming in over the net, here the building blocks for an other mirroring solution:
MirrorFolder
No better tool to be found when it comes to syncing a Data-Tanks with
several other "local" copies.
TrueCrypt
Use this to encrypt your USB-Tank just in case you drop it somewhere.
FolderShare (http://foldershare.com) is also nice for syncing files. I use it to keep documents, etc. in sync between my laptop and my desktop, for example.
Of course, for code especially this doesn't obviate the need for source control.
I'm currently working at a small web development company, we mostly do campaign sites and other promotional stuff. For our first year we've been using a "server" for sharing project files, a plain windows machine with a network share. But this isn't exactly future proof.
SVN is great for code (it's what we use now), but I want to have the comfort of versioning (or atleast some form of syncing) for all or most of our files.
What I essentially want is something that does what subversion does for code, but for our documents/psd/pdf files.
I realize subversion handles binary files too, but I feel it might be a bit overkill for our purposes.
It doesn't necessarily need all the bells and whistles of a full version control system, but something that that removes the need for incremental naming (Notes_1.23.doc) and lessens the chance of overwriting something by mistake.
It also needs to be multiplatform, handle large files (100 mb+) and be usable by somewhat non technical people.
SVN is great for binaries, too. If you're afraid you can't compare revisions, I can tell you that it is possible for Word docs, using Tortoise.
But I do not know, what you mean with "expanding the versioning". SVN is no document management system.
Edit:
but I feel it might be a bit overkill for our purposes
If you are already using SVN and it fulfils your purposes, why bother with a second system?
If you have a windows 2003 server, you can have a look at Sharepoint Services 3.0 (http://technet.microsoft.com/en-us/windowsserver/sharepoint/bb684453.aspx).
It can do version control for documents, and has a nice integration with Office, starting with Office xp, but office 2003 and 2007 are better. Office and PDF files can be indexed (via Adobe IFilter), and searched. You can also add IFilters to search metadata in your documents.
Regarding large files, by default the max filesize is 50MB, but it can be configured.
We've just moved over to Perforce and have been really happy with it. It's a commercial product, but it's so powerful and easy to use that it's worth the price per seat IMHO.
A decent folder structure and naming scheme?
VCS don't really handle images and such very well - would it be possible to have the code in a VCS (SVN/Git/Mercurial etc), along-side a sensible folder structure for the binary-assets (source photos, Photoshop PSD files, Illustrator files and so on)?
It wouldn't handle syncing, but a central file-server would achieve the same thing.
It would require some enforcing and kitten-herding to get people to name things properly, but I think having a version folder for each asset (like someproject/asset/header_logo/v01/header_logo_v01.psd) will basically be like a VCS, but easier to move between different revisions (no vcs checkout blah -r 234 when a client decides they prefered v02 more than v03)
Your question is interesting because your specifying that it be suitable for a small office. At the enterprise level, I would recommend something along the line of EMC Documentum's eRoom, but obviously thats going to be way more than you need, and more than you want cost-wise as well. I'm not sure of the licensing details on this but I've heard that if your office has MS Office, you have access to Sharepoint, which might work well for you. I'm also sure there are a lot of SAAS implementations of this kind of stuff, so you may want to look at that, keeping in mind that the servers will not be hosted by you, so if the material is extremely sensitive, thats obviously not the proper route.
You might want to consider using a Mac as your server and using Time Machine to backup your shared folders. Doing this gives you automatic backups and allows you to share through Samba so everyone can have a network drive on their computer. A Mac server is probably overkill. A Mac Mini would do for a small office or a repurposed desktop machine.
You might also consider Amazon's S3 service to do offline backups. Since it's a pay-as-you-go service this can scale with use, and if you feel you want to move to something else you can always download your data and take it somewhere else.
Windows Vista features local file versioning in its file system, which can be useful, but is limited in terms of teamwork. However, if somebody overwrites somebody else's file, a new version is stored as it should be.
Also consider KnowledgeTree. Have a look at it, some demos/screenshots are available at
http://www.knowledgetree.com/
It has a free open source Community Edition - so it's cost effective. We haven't tried it, but we chose this one over other systems for a small business looking for document versioning solution.