Hacker Newsnew | past | comments | ask | show | jobs | submitlogin
Ask HN: “Git” for Microsoft Office?
145 points by toyg on May 20, 2020 | hide | past | favorite | 139 comments
I’ve recently changed job and now I am basically swamped in MSOffice documents. This makes collaboration very hard: people are fearful you’ll touch their precious files, there are manual procedures to produce “gold” documents, fixing a typo is an ordeal, and if the same slide is present in 15 Powerpoint decks any edit will require tons of mindless and error-prone copypasting... it made me realize how good developers have it with git, github, and the likes.

Is there anything out there, capable of working with MSOffice stuff in a granular and collaborative way? I can’t believe non-geeks have lived like this for 30 years.



This might not be exactly what you're asking for but I'll just leave it here in case someone finds it useful:

A couple years back I built this: https://github.com/tomashubelbauer/modern-office-git-diff

It is a pre-commit script which unpacks Office XML into text contents and tracks that alongside the source file. This way you can consider the binary to be a source of truth, but with each commit you also get a textual diff showing what changed content-wise. More or less.

Some person built the same thing for OpenOffice and I link their project in my readme, too.


This feature now built into Word, and has been for some time. see my other comment in this thread.


Sure, it's probably better to use that if you don't mind that. I am big on plain-text files and Git and sometimes I have to bend reality a little bit in order to keep working my way when others won't. This is one of those cases.


I wasn't dissing yours - Sorry if it came across that way!


No worries at all! :-)


> but with each commit you also get a textual diff showing what changed content-wise. More or less.

You can do that with pandoc[1] as a git diff-viewer[2] too.

[1] https://pandoc.org/

[2] https://github.com/vigente/gerardus/wiki/Integrate-git-diffs...


This is pretty cool, I might even use it for some personal stuff. Probably not enough for non-programmers, but could be the basis for something else to emerge.

Thanks!


O365 has had live editing for a while now[1], it's not even that hard to use.

You can have that Golden Version and everyone can suggest changes and edits, then the document owner can accept or decline the edits.

[1]: https://support.office.com/en-us/article/Collaborate-on-Word...


I find if I enable edit permissions, people can do more than suggest changes, they can make them. An editor can turn off tracking, that has to be done frequently to fix formatting and layout issues, and changes aren’t visibly tracked.

I wish there was a “pull request” for office with a permission that allowed suggestions but not edits.


This sounds great... in theory. But has a pull request feature ever been created for a non-plain text format?

Intuitively, this doesn't really seem possible to me for a sophisticated document format. E.g., how would you represent a change to an embedded graph in a pull request? (And would that same approach scale to any form of embedded media?)


It's not an easy task, but it's doable! I co-founded a company called ProcedureFlow[0], that allows change requests but for hyperlinked flowcharts. My inspiration was 100% GitHub/pull requests.

A procedure is made up of many flows that are linked together. Everyone that uses the procedure views the "live" flows (like a master branch). Each user gets their own branch which we call a "draft". In a draft, a user is free to make any changes they want (add/delete/modify flows) and then submit all the changes for approval. Approving the change request then merges the changes into the "live" for everyone else to see/use. I even went so far as to build side-by-side diff of the flowcharts, rebasing/merging with live, and conflict resolution.

It's simplified in the UI so the terminology isn't 100% like git. But, one of our biggest hurdles though is actually teaching users how this works why it's better than the current mode of document locks/real time editing. And when our customers "get it", they really fall in love with the concepts and why it's better!

[0]: https://procedureflow.com/


My understanding is that collaborative live editing à la Google Docs was already here for Microsoft Office? E.g., I routinely edit the same Excel file from my iPhone, iPad, and Mac.

My current understanding is that live collaborative editing is the solution for the same problem version control solves for non-plain text file formats (and therefore, also the solution for non-programmers). Think of how much programmers complain about the complexity of git, and that's using it with plain text, a format that facilitates version control like no other.

For collaborating in every document format that isn't plain text, my solution has been to use live collaborative editing.


Sadly, our Sharepoint implementation is "in progress", so $deity knows when we'll be able to use this consistently... Thanks anyway, I guess it's my only option.


Does this somehow prevent you from using Groups/Teams?

>if the same slide is present in 15 Powerpoint decks any edit will require tons of mindless and error-prone copypasting

This is exactly what you want SharePoint for. Have 15 people open the same PowerPoint deck, in desktop PowerPoint, editing the file simultaneously. It's fully versioned and you have no merging of files back together.


15 people opening the same deck is not the same as 15 people opening 15 different decks that have just one slide in common.


Google has this feature and it's a damn nightmare. If someone edits a deck but doesn't have permissions to the deck a linked slide is from, the link breaks. Also, changes made only flow one direction (master -> copies). There's basically no repeatable way to use it across multiple contexts. Slideware is not the same as modular code.


These are Google-specific implementation issue, there is no philosophical reason why a single slide could not be a modular, referenceable object. I bet the old COM stuff could do it (of course it would then break if the document was moved, but again, these are implementation-specific bugs).


An underused feature in MS Word is 'Compare documents' - It's under the Review tab on the ribbon as 'Compare'. It allows you to do a 'diff' style compare on two Word documents - it's invaluable for working out what changed between versions if the place you are working at doesn't have any other document tracking systems.


Technically, tracked changes and SharePoint. But in practice, you’d rather send the changes to the project owner via carrier pigeon.

I’ve looked into what it would take to make a git style system for docx (since it’s just zipped XML, right :D), and the file format was a nightmare whenever an edit was made. Someone smart should take a look at it, as there would be a massive market for a DVCS for Office files. Imagine a world where every bill in Congress was committed to a central repo so the whole world could see the changes, or where someone in your team wants to play with the formatting on a shared requirements document without breaking the page you’re writing on. It would be a boon for productivity.


> as there would be a massive market for a DVCS for Office files

Would there, though? I mean, we HN readers want that, but I don't see any evidence that the average Office user is clamoring for it. Even comparatively crude systems like Track Changes aren't used in my experience as often as they could be, and those are a hundred times easier for non-technical people to wrap their minds around than a Git-like system would be.

I suspect that part of the reason this problem is so intractable is that it's really two problems. The first is actually tracking the changes to the underlying document, which, as you note, is hard enough by itself. But then on top of that is the second problem, which is that you'd also have to come up with an interface that could make the power of a Git-like system comprehensible to non-technical users. And you'd need to solve both problems to have a product that would actually be ready to take to market.


> I mean, we HN readers want that, but I don't see any evidence that the average Office user is clamoring for it.

My current experience is that non-geeks have no idea that another way of life is even possible. You won't clamor for something you cannot even conceive.

I bet that tons of orgs would rush to adopt a github-style workflow if MS made it available. After trying out the "Track changes" and collaborative modes people have mentioned here, I can see why people in my company don't use them - they are flaky and don't really enforce rights, they basically just nudge the user.


People get that mailing revisions of documents back and forth feels rickety. In my immediate circle I noticed that people some mild amazement that geeks use Wiki-style collaboration environments instead of office suites.


Not laws, but some US gov tech strategies and policies are tracked and edited in GitHub. It looks like it’s not the literal authors making changes, but someone is making changes to markdown documents.

For example, the Federal Data Strategy, https://strategy.data.gov/overview/, is created from https://github.com/GSA/data-strategy

It’s been nice to follow updates and the specific changes using git diffs.


My wife is a laywer and she and her colleagues (and the other lawyers they are working with) pretty much base their workflow for revising documents on track changes. I've never heard her complain about it.


Maybe she is used to it? I have used track changes and it is good and all ... but it may not be exactly the same as being able to know where and when a change was done, by whom, and with the reasoning sometimes added with it that comes from VCSs like SVN and GIT.


I think that's the point - if you use these things expecting them to work like a revision control system for code you'll be disappointed and frustrated.

Meanwhile, people who have no such expectations cope perfectly well.


> Meanwhile, people who have no such expectations cope perfectly well.

You know how they do that right, stay in online chats and ask who, how, why, when. Awful waste of efforts


> where and when a change was done, by whom, and with the reasoning sometimes added

On Office 365 at least, it does tell you all of those things.


For procedure-style documents, I co-founded a company called ProcedureFlow[0] that allows change requests but for hyperlinked flowcharts. My inspiration was 100% GitHub/pull requests. We found that a lot of organizations store procedures in document form which change all the time. So, the purpose behind our product is to move away from a document into a format that easier to use/change/track.

Copied from another one of my comments in this thread:

A procedure is made up of many flows that are linked together. Everyone that uses the procedure views the "live" flows (like a master branch). Each user gets their own branch which we call a "draft". In a draft, a user is free to make any changes they want (add/delete/modify flows) and then submit all the changes for approval. Approving the change request then merges the changes into the "live" for everyone else to see/use. I even went so far as to build side-by-side diff of the flowcharts, rebasing/merging with live, and conflict resolution.

It's simplified in the UI so the terminology isn't 100% like git. But, one of our biggest hurdles though is actually teaching users how this works why it's better than the current mode of document locks/real time editing. And when our customers "get it", they really fall in love with the concepts and why it's better!

[0]: https://procedureflow.com/


Or even just OneDrive -- SharePoint isn't strictly necessary anymore.


OneDrive is a client and api grafted on top of sharepoint. It's all sharepoint under the hood.

You also dont need to use OneDrive to sync SharePoint, you can use the File > Open menu to open in Word, Excel, PowerPoint to open files directly.


Use sharepoint, office365, and Teams. It versions, it supports collaborative editing, no more mailing things around, and so on.


Sounds like many commenters here haven't used Office 365 and may have outdated ideas of what Office is capable of these days (it ain't Office 2010).

Of course one can't do a pull request with Office (non-geeks would struggle with the idea anyway) but live-editing of shared documents and version history is now built-in.

If two or more people open the same .docx/.pptx/.xlsx from a shared environment (Sharepoint/Teams/OneDrive), and then proceed click on Open in Desktop App (the browser-based apps are unpolished IMO), AutoSave is automatically turned on, and they're automatically thrown into live collaboration mode. This is the new norm in most enterprises that have Office365.

Most office folks require version history rather than version control -- not many are likely to need to branch, merge, pull, push -- and Office365 definitely supports the former. You can even have a threaded conversation about the changes in the document itself. -- when you add a comment, the chat sidebar opens. The back-and-forth comments are stored in the document.

Note: this is different from "Track Changes" in older version of office -- which still exists but is more for visual diffing. Version history only stores snapshots.


Yep! I think Microsoft lulled people into a false sense that they weren't doing anything with Office, while the Google suite gradually gained features (and to be fair, does 90% of what a normal person would ever do with documents). But it turned out they were busy making every feature in Office work in the collaborative environment, with versioning. It's incredibly impressive, and I am not a natural fan of Microsoft. It doesn't work as well as Google with a crappy or nonexistent Internet connection, but in your typical office environment it's great. I think people will be really surprised at how easily you can do things like assemble slides for a collaborative presentation. Sharing with people outside the organization requires a Microsoft account of some kind (either institutional or your old Xbox Live or Minecraft account) but that's about it. A high fraction of everything can be done in the browser, so it's easier than ever to have a Linux desktop. Plus have you see they have LateX equations now?


Syncdocs https://www.syncdocs.com/ is a tool that lets multiple Microsoft Office and Google Docs users collaborate in real-time on the same document. It uses Google Docs for versioning.


Yep, this is why as a pragmatist, I'm all about "reviewing my priors" from time to time. Things change, constraints change, and we need to constantly update our views.

I lived through the days of Microsoft being predatory and evil and I hated Microsoft because their products sucked (not sure if anyone remembers the strident rhetoric in comp.os.os2.advocacy -- that newsgroup raised Microsoft hatred into an art form). For years this emotional response blinded me to the pockets of genuinely good technology that Microsoft had in its lineup (like SQL Server).

When I started working in an enterprise environment, I often ended doing things the hard way because of this blind spot of resisting anything Microsoft. It cost me so much.

It was only when I was forced to put aside my prejudices that I discovered that it was actually possible to be productive while using Microsoft tech. Nowadays I favor pragmatism and productivity over partisanship, and try to choose the best tool for the job, and if it means choosing MS tools occasionally, that's ok.


You can actually do a sort-of pull request: suggested changes. When editing mode of the document is set to "reviewing" then your changes would appear as sidebar suggestions which the owner can accept or reject.


Yup. This is how I (a developer) often interact with lawyers at work.


The above is true, but there are caveats. Under the hood, Office is constantly saving back to Sharepoint and trying to merge changes. If it can't merge changes it will simply alert the user and give the option of abandoning their changes or saving them locally for manual merge later.

In my experience, merging seems to fail more often with Excel and PowerPoint than Word, but even in Word applying doc-wide changes (e.g. change of language) while someone else edits usually fails.

For sequential editing it works fine and keeps an automatic version history.


That’s interesting——I regularly collaborate with 30+ users and have yet to see a merge conflict.

Is it possible you’re using a older version of Sharepoint that isn’t collaboration aware? I know in older versions of Sharepoint, documents get checked out and locked all the time. Are you able to do live editing? If you aren’t, we might talking about different versions here.

With Office 365 and Sharepoint 2016, I was under the impression that collaboration uses operational transformations (like Google Docs) or CRDTs rather than continuous merging —- which isn’t feasible for real-time live editing anyway. Unresolvable conflicts are rare because the merge is happening at the action level, not document level.

The experience in Office 365 has been similar to Google Suite for me.


Using Office 365 SharePoint and the latest versions of the native apps.


Fascinating. Not sure why then. But then again doc wide changes are rare for me and my team so maybe that’s the difference.


This is the correct answer, both Office 365 and SharePoint natively version documents. It is the closest built-in thing you will get to Git for Office


Agreed.

The only caveat I'd offer is, for MS Word specifically, you can have: (1) Large complex documents (i.e. lots of links/references, sections) OR (2) Many collaborators. Pick ONE. If you must have both of these, leave track changes off, and use highlights and comments.

I've been in the unfortunate position of being next to a deadline, where the word document was the key deliverable. And then having that document become corrupted. Fairly certain it was a confluence of the above factors that caused it. If the doc is starting to take 30 seconds or more to just scroll down or edit one character, that's your first warning bell.

We tried opening in Word Online, Word Mac, Word Windows and even LibreOffice. No dice. What worked in the end? A smart chap on our team thought to try importing the doc into Google Docs, and then exporting it again...


From my perspective, Office 365 today has an identical experience to GSuite with respect to collaboration.

We regularly edit complex documents with large numbers of collaborators. Track changes and collaboration are different though (the former has been around since time immemorial but collaboration only came out a couple of years ago)


Office365 can be a tad frustrating since the web version and desktop version support different feature sets. It's not that one is better than the other, it's that some features exist in one version that don't exist in the other (mostly collaboration features). Throw in the Mac version of Office and you have yet another subset of features that isn't supported.

I get that they're headed towards WebKit for all their apps, but it's kind of frustrating to have to head to outlook.com for some things and have to use the desktop version for others (though the search via outlook.com is vastly improved over the desktop versions of Outlook).


With sharepoint and onedrive I struggled to coordinate when someone edits/commits. With git you do the change and PR. Office has no concept of someone merging changes.

My $0.02: just use git?


> just use git?

Sounds good in theory - now imagine explaining to a group of regular office workers concept of commits, merges, pull requests, whole workflow and additional software for doing all of this. It's just not possible.


Is there anything out there, capable of working with MSOffice stuff in a granular and collaborative way?

No, but people seem to get work done anyway. It's very strange to me.

My current and previous jobs are very corporate, so much of the business and IT uses Office products all the time. I somehow managed to set the standard that I don't do it that way. I still have to sometimes, but it's not very often.

The key is to acknowledge that using Office effectively is a difficult skill. It makes management feel smart that they know how to do something technical a developer doesn't. Then it's just a matter of finding and highlighting alternatives. Plain text and/or a wiki covers almost everything in my experience.


We used to get work done anyway by sending around zips of the whole repository, but we changed our ways because we had the technical skills to do it. MSOffice users will never be able to write a VCS for documents so they're stuck with whatever the software vendor provides


Working on it: https://julesdocs.com

It’s very hard though, because the files combine data and styling. Plus, the data is spread over several XML files.

If you want to message me: jan at the domain above

Edit: While Google Docs, Office365 and other collaborative editors are great for editing a document at the same time, from my point of view the real power of Git is branching, merging, and having a concept of distinct versions (which may consist of several files).


Is this implemented as a git plugin?


I've worked with non-geeks for many years and the best results were achieved with Sharepoint or O365. The versioning system it's simpler for them than GIT; it has a lot of missings but has great support on the clients' apps, specially MSWord and the revision and merge features.

There's a variant to use TortoiseGit as a git desktop client (only Windows) versioning directly office documents because of that one pops up the resolution of the conflicts directly with the office apps.

There're some folks followed me to markdown-git using desktop clients like Typora and Gitbook (editor and other services), but it's not suitable for everyone.


Office365 has version history. You can flip back and forwards and see the changes any other collaborator has made. You can set the history to be pretty deep too:

https://support.office.com/en-us/article/enable-and-configur...


Check https://www.simuldocs.com/ It's a version control SaaS for Word documents. They took a lot of inspiration from git


This is actually the best suggestion of the bunch, at the moment, at least for the most critical Word documents we have. It's cheap enough that I can try to sell it internally with minimal effort. It even has a readonly api that I could use to package the final versions of this or that. The only weakness for my usecase is the lack of support for Powerpoint, which hopefully will come at some point.


With Excel (the stuff that tends to be most critical), Microsoft has gone through a few iterations on this. Just a few days ago, they finally enabled a proper Version History on the online version of Excel, much in the same way as it’s been available with Google sheets for years. If you are bound to offline Excel, your options include 1) Shared workbooks 2) Co-authoring 4) Network drive 5) SharePoint 6) DropBox/OneDrive etc. You can get all the pros and cons in a recent blog post of mine: https://www.xltrail.com/blog/collaborate-on-excel-workbooks. I am part of a group of developers so we agree with you on wanting to have “GitHub for Excel” which is why we built: https://www.xltrail.com


If you use svn or git to track your files, both TortoiseSVN and TortoiseGIT when asked to compare two files (ie, "diff from last revision) will spawn the version manager integrated in office.

Is not perfect but it works.

Tested with TortoiseSVN 1.11.1, TortoiseGIT 2.10.0.2, MS Office 2010 on docx documents.


We fixed this at my company by converting our documents to markdown and using git. Can can also use LaTeX. They're honestly better formats for things like user manuals anyways because its trivial to display them on web and devices.

We have our non-technical editors using Markdown and git just fine, but you may have a lot of initial resistance. We were able to force them to switch because we're mostly a tech company. They hated it at first even though they love it now.

Never found a good solution to powerpoint


> Never found a good solution to powerpoint

tpp or LibreOffice's Impress.

Using open formats diff better. There's also the homebrew method I use where I decompress the document and store that tree in git too, sometimes it helps and is easy to recompress into document format. It's part of my regular checkin script.

Long story short, some recruiters don't like pdf's (from LaTeX) so I've got a mixed setup of LaTeX and libreoffice. The LaTeX copy produces several different documents with varying amounts of personal information. This is toggled through variables in the script so some outputs are web-safe (nothing but email), some I sent to recruiters which have temporary phone numbers on which are disconnected when I'm FTE. The other has a real SIM mobile on that I use on company internal job boards.

LaTeX wins here, but to keep some recruiters happy I copy the changes into an odt format. Yes I know about Calibre.


> Never found a good solution to powerpoint

There are lots of markdown presentation tools, I've enjoyed using https://remarkjs.com/ which sounds like it could fit your workflow.


Track changes works for Word. Still no solution for Excel.

One thing that can make things better is to teach people to use Styles correctly.


Well, most people, including me I must admit, are using excel when they actually should use a database.


https://www.xltrail.com/


From 2017: https://news.ycombinator.com/item?id=14552140


I assume you’re not using the online version of Office 365. It’s collaboration capabilities are better than most people give it credit for.


Collaborative editing is supported by the desktop apps as well - I use it in Word a lot and it works pretty well. Your document has to hosted in SP online though.


Or Onedrive.


I think the backend for OneDrive for Business pretty much is SharePoint Online.


Using Office365 versions with Track Changes turned on is probably the most viable option with normal people.

Technically, you could use git, and it works decently with the xml-based Office file types, but it's a hard job to get people used to the workflow, and things like merge conflicts are going to be even more of a headache.


> Using Office365 versions with Track Changes turned on is probably the most viable option with normal people

I beg to differ as normal people would expect their old documents to work, and the subset of things that work in web is not enough. Quite like LO-supported, totally not on par with native.


I vaguely remember that change tracking was a feature in Word even before O365 era. Nevertheless, like others said - Office365 is what you need. Versioning in O365 is not necessarily user friendly and intuitive, but it works. It saved me and my colleagues many times.


You should take a look at libreoffice collaborative feature, with the basic "track changes"[0] settings.

You can even work with multiple users as the same times (for example when opening files via webdav with nextcloud, or any other way to share your data) !

Edit: There's some recommendations on versionning odt files by using .fodt extension [1].

[0] https://wiki.documentfoundation.org/Track_changes

[1] https://wiki.documentfoundation.org/Libreoffice_and_subversi...


For MS Access files there exists a project ([1], last activity in 2018) which basically splits the file into its components (like forms, queries, macros etc.) which you can then check into your VCS. This way, single versions of an MS-Access-file are diffable to previous versions and you can track exactly what has been done... in a developer fashioned way, though.

If you would need an exact version, you can build this version out of its components of that version.

[1] https://github.com/timabell/msaccess-vcs-integration/


The forked version which is an Addin runs about 4x faster, and is actively being developed now

https://github.com/joyfullservice/msaccess-vcs-integration


The MS Access Application object has some additional powers, LoadFromText() and SaveToText() not really found elsewhere in Office.

However, you can't really used them to dump the current database, and they don't both appear to be used in timabell's work for a quick glance.

The loader method even allows for the lighter-weight Forms from the other Office applications to be pulled into Access, though the motive for using them would not be clear.

My intent had been to write an Excel macro workbook as a manager tool, and use it to manage Access Dbs in git.

I have a library I call "The NecroVisualBasiCon" out in GitHub that I'll share if anyone is interested in peering into an abyss.


Microsoft Teams comes out of the box with the necessary SharePoint like features for document collaboration. That includes editing right in the web browser, as well as a button to open the document in your local install of Office. You can see if the document is synced online, look at changes, comment, and merge changes. Everything you need for a decent experience. No longer a need for setting the whole thing up yourself, and non technical folks can definitely use it.

You still have some pains with it, but its better than anything else I have seen for a non technical user.


First point. MS office documents have a vaguely capable version control system built in. It's not Git, but it may be enough.

Second point, I haven't tested this, but docx, xlsx etc are XML based and may be happily Git compatible.

Third point, if the above doesn't work, look into automatically saving / converting documents into and out of a Git compatible format with minimal loss of formatting etc. You may be able to convince your team that this is an acceptable compromise between the tools they are used to, and the power of DVCS.


Docx & co are XML based, but they are _zipped_, therefore binary.

Which make a version control pretty much impossible.


I mean, git supports applying filters on the file for exactly this purpose? The content that is being compressed is likely going to still diff poorly, but git also supports custom differs for example that purpose, so I don't know why you are saying "impossible".


> I mean, git supports applying filters on the file for exactly this purpose?

Indeed, pass (https://www.passwordstore.org/) uses this to allow diffing and sane tracking of its password files, even though they are binary encrypted GPG blobs.


That's what "flat" OpenDocument files are for. Use .fotd, .fods and then you can have all the file content, plus referenced images, objects etc. all separate files under version control without the zip container.

I do this with LibreOffice. I've not tested Microsoft Office with this workflow.


I never try, but I thought you just need to rename the .docx/.xlsx/.pptx to .zip, unpack them then do the version control on that files?


That works. It's clumsy, but can be automated.


Snipply[1] is a great option for you. It will be released shortly!

It allows you to create "Cards" or snippets of any size, of any part of the document, and save it, version it, and sync it with any other document. Even with documents in Google apps (Docs, and Sheets). A Card can be a sentence, paragraph, or entire document, up to you.

Disclaimer: I'm the CTO of its parent company.

[1] https://snipply.io/


In my team we have been using svn/totortoisesvn to store our word documents. It integrates nicely with word’s doc compare.


We're working with LibreOffice, but MS also supports OpenDocument. The quality of the XML produced by these programs is extremely poor. LibreOffice, for example, changes the name of every (or nearly every) automatic style every time you save, which makes it very hard to use the diffs. Also ODS doesn't stride formula references when you repeat rows, which baffles me.

Nonetheless, by simplifying the FODS files to use a subset of the format, the diffs are looking okay now. I created a wee little canonical string representation of the style parameters I want to use, and putting that string in the style:name attribute when I clean up the document.


Yes. Store the document on OneDrive. Give people a link to the document and you can all collaborate on the same document in real time. Onedrive also has version history so you can revert / see / compare previous versions


I mean, this is what Office 365 does - and pretty well: collaboration and versioning.


Versioning is good for restoring backups, it’s hard for seeing changes over time.

I recently worked on a word doc with four other collaborators. Someone inserted a footnote. Looking through versions it took me 10 minutes of sifting through the dozens of versions (auto save creates new versions very frequently) to find who and when that section changes.

I wish there was a git blame for office.

I also wish the old day of “checked in” versions where I could set a number and a comment.


>I wish there was a git blame for office.

That's exactly what "Track changes" is for.


Track changes can’t be turned on and off to replay versions. There is compare document, but it takes longer and is one version at a time.

Blame goes through the entire history of a file.


You might consider encouraging people to write markdown and then generate the final document using pandoc with an msword stylesheet.

This is what I did in college because (for some reason) everyone expects word files for everything.


Thays Why I use markdown and latex for everything. I was back in college 2 years ago, after 15 years. DOing mechanichal engeneer. All my reports where writen on markdown and latex, and saved on gitlab.


Now days I use asciidoc mostly because there’s an official spec and latex math and bibliography are included. Every markdown is different and that’s pretty frustrating sometimes.


One aspect I find interesting is the need for ransomware protection. Looking into a way to automatically make git commits whenever a file is added or modified in a directory. The idea is to make it transparent to user, but possible for an admin to undo whatever damage they may have caused. I am not certain whether tortoisegit by itself can accomplish this. One repo would be local and another somewhere in the cloud.


I haven't tried it, but gitfs (https://github.com/presslabs/gitfs) sounds nice.


Confluence has this: https://marketplace.atlassian.com/apps/1210818/scroll-versio...

Workplaces where knowledge is organised in some shared drives folder tree are rather unproductive by nature. There are tools to deal with that for a good reason.


Law firms use document management systems to maintain versioning of files, but only one user can edit at a time for the ones I’ve seen. I’ve found them to be annoying if I’m totally honest.

Ive also seen some advanced document comparison tools that plug into MS Word and redline differences (more advanced than the built in one).

I guess these tools could help ensure faith in the latest approved or “gold” version.


I've used git+latex for a very long time, and more recently, git+markdown.

It works really well!

But it won't work with your nontechnical office staff. :(


.docx is plain text xml though (You can even save explicitly as .xml which has all the images in base64).

Is track changes not good enough?


(1) Now you get to train your office mates who have been emailing .docx files to each other for twenty years in git, specifically to merge XML files.

(2) What happens when someone checks in a hand-reconciled merge that is not a valid XML file, because whoops?


Yes, it is called Google Docs. It has all the version history and the person that made the edit known. Still unimpressed with Office collaboration features and all the other Microsoft tools you need like SharePoint. Its 2020! Microsoft had 20 years to get it right and they are still giving us sub-par features.


I wrote this comment in response to a deleted comment that said something like “use SharePoint.”

I find that most office users can’t use SharePoint. There’s too many things that are confusing or don’t work as expected, so it’s rare to find a business user who can set up SharePoint sites or workflows or even document organization.

So I’ve seen “SharePoint developers” who are consultants who know what to click and configure.

If I’m going to have to hire special people to make web sites, I’d rather just hire more technical people who can code something or tie together products. SharePoint developers cost the same as Wordpress developers to me.

The big advantage, I think, for collaboration software is to have contributors work directly with each other. Having to go through a secretary to convert work to some special format eats up the big benefits from stuff like SharePoint.


You dont ever even need to see SharePoint. People create groups, save files to groups. Opening & Editing can all be done directly from Excel or PowerPoint. If they can use Excel and PowerPoint, they can use SharePoint the same way they save files to a network drive or local folder.

Document organization will be a problem wherever you settle. What are your abstractions, what are your folders, who can create what at what level.


For me, I use SharePoint to find files to edit and collaborate on. And to put context around files so they can be found and used.

Files can be opened directly from within word or excel, but browsing a team’s SharePoint is faster than navigating Excel’s open dialog. Similar to how browsing File Explorer or Finder and then opening a file is faster.

So avoiding SharePoint isn’t very likely, I think.


I tend to use search a lot.

It's much much faster to open Excel and type a couple characters of the filename into the File > Open search field, than it is to navigate structures.


If I understand correctly, this might be of some use - Git LFS.

An open source Git extension for versioning large files https://git-lfs.github.com/


Word and Excel have Review menu items that allow fixing documents then adding edits and comments which need approving. Make sure you know how this works because most people dont use it.


I worked in clinical research with the FDA and complex word documents. I am not a programmer, but lordy lord, how often did I wish we would use something like git.


Something to help is coming in the form of Fluid.

https://www.theverge.com/2020/5/19/21260005/microsoft-office...

https://support.microsoft.com/en-us/office/get-started-with-...


This looks very interesting but I doubt large enterprises will allow it considering the online nature and the inability to secure confidential work on internally hosted systems.


That's my reaction too - most people here are somewhat jealous of their "ownership rights" over this or that document, since this often define their actual roles. It looks like Fluid is trying to "share everything" and that's too much.

I'd be happier with something that simply allows me to have a github-like workflow where I can propose and justify changes to this or that block of document, and an owner can sanction and merge. This would not touch internal hierarchies (the most sacred element of corporate life) but would improve collaboration.

If Fluid is a step in that direction, it's welcome. Unfortunately to me it looks more like "web-native COM objects" and few people ever liked those.


> can propose and justify changes to this or that block of document, and an owner can sanction and merge

This is called 'Tracked Changes' and 'Comments' in Word. Under the Review ribbon.

Here's the How-To: https://support.office.com/en-gb/article/track-changes-in-wo...


I've tried the equivalent feature in Powerpoint and I'm not impressed. I gave permission to edit to a colleague (it's either that or readonly, as far as I can see in SP), let her change it, then looked at the document again. "Show changes" lasted a few seconds and then disappeared, never to return. And I guess the Compare items will only come up if you have a different file? Just opening the same file from SP, they are all greyed out...

Absolutely not comparable to a github experience, as far as I can see.


It’s going to be open-source, so I’d bet that Microsoft will package some kind of on-prem server like Exchange and SharePoint if enterprise demands it. But since lots of enterprises are moving to Office 365 anyway (including big banks that historically had massive security requirements), if Microsoft can make a security SLA, maybe it’s enough?


If it’s word you can use word itself as a diff tool to compare different versions. I guess just track versions in Git and you”re done.


> I can’t believe non-geeks have lived like this for 30 years.

Given how shitty MS software has always been, I can't believe people not only pay money for it but also accept it as the norm.

As for your question, non-geeks have been coping with this by saving a copy of a document before each edit so that when the inevitable catastrophe occurs, they can roll back. As a geek, you can use git manually. Adding that as a feature to Office would make it even more incompatible with itself than it already is.


Ah yes, I love working out which is the most recent document out of:

* Document1 FINAL

* Document1 FINAL DRAFT (DO NOT EDIT)

* Document1 FINAL EDITED

* Document1 v2 FINAL


Outside of development work using repositories, I also handle a good amount of design documents, think Indesign/Photoshop etc. My workflow is like this:

- Substantial changes result in a new version number at the end of the file:

Document v34

- Branching to try out ideas uses a marker what this idea was:

Document v34-2 test-color-scheme

If the idea is approved, it results in a new version:

Document v35

- Tagging for long running designs adds the context where it was last used, this can be considered a final release version

Document v36 - July 2020 promo

Once a file is used like that, an export copy with the same name is saved in the same folder:

Document v36 - July 2020 promo.pdf

This document is copied using a general name and then moved to a different folder:

promo2020/july/flyer/Document.pdf

This is what is printed, e-mailed etc. Date and file size allow comparisons to find out which version this was.

While this falls apart for testing a lot of similar ideas at the same time, it has served me well to have a history of snapshots and their context, have all final documents archived, and ignore (or delete) all the versions in between, while still saving progress over days/weeks.


One thing I did to make this hell more tolerable is I would write all my documents in org-mode (markdown) and use Pandoc to convert to MS Word format for distribution. My Word documents actually looked better than everyone else's. I was still able to use git to control the source of the documents.

Less than a year later I left that job. I'd rather learn a trade than be paid to use MS Office.


Basically we should use OneDrive/SharePoint. For comparing just Excel files, WinMerge is my mate.


Onedrive stores file changes as files are modified.

It even lets you switch to any version on the fly.


Would be also good to know if something similar exists for LibreOffice Writer.


My SO does a lot of document writing and editing. She doesn’t write code, but wants her essential stuff backed up somewhere. I taught her the concept of version control and she literally uses git for her office documents. Not a perfect solution, but not a bad one imo.


LaTeX solves it :) It's simple markdown and full of extensions / hooks / templating, so any person can edit it in a controllable way.

https://grindeq.com/


Office 365 with documents stored in the cloud. #formerMSFT


Share point and Teams all the way


Could you use Google Docs or something similar for some of the more collaborative documents?


Microsoft Teams?!


Office 365?


Nongeeks haven't been living with this. They (mostly lawyers) use document management version control systems like iManage ( https://imanage.com/product/document-email-management/) and professional comparison software like Workshare Compare https://www.litera.com/products/legal/workshare-compare/ (orders of magnitude better than tracked changes in Word though Word has gotten better over the years).


This is the sort of answer I was hoping for. Workshare-Compare looks pretty cool (if not cheap).


I second this. Medical, Aerospace, and Government, and other engineering also use these systems. Start looking at official documents -- you'll often see something in the footer like, in tiny font, that looks like 23-14453 Rev 8 -- that's usually a Document ID number and the revision number. With my company, whenever we want to Rev a document (make changes and create a new revision), we make the changes with Word's "Track Changes" turned on, which produces what we call "Redlines" -- a Diff between that version and the previous version. We check that into our Doc Control along side the document without the Redlines. This doesn't really help when comparing Version 3 with Version 8, but as others have pointed out -- you can use Word's "Compare" if you really need to do that.

Part of my company uses SAP for their doc control, part of my company uses MasterControl. I hate hate hate SAP. I have a few bones to pick with Master Control, but overall, it's tolerable. If you'd like to chat more about how this process works in the workplace, you can find me on twitter @failbridge or on reddit as /u/daveslash


Takeover more power and then move people to markdown with a sleight of hand. I cannot cope with MS Office anymore. I was in finance 5 years, plenty of Excel work, when I open Excel today I am quickly reminded how painful it is and go back to Python.


I'm with you. So many people I work with don't understand my visceral hatred of Office and Google's offering.

It's not that I think they are inherently bad pieces of software, they're actually all pretty amazing. It's just that after years of using markdown, org-mode and python, I get frustrated by how long it takes to debug a spreadsheet or format a document.


I agree with you mostly, but Excel is still often a good choice for reporting. And with a package like xlwings, you can do it all from Python.


Python + Html is a better option for reporting


not if you don't know anything about css ;)




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: