
Ask HN: “Git” for Microsoft Office? - toyg
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.<p>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.
======
tomashubelbauer
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](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.

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

~~~
tomashubelbauer
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.

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

~~~
tomashubelbauer
No worries at all! :-)

------
theshrike79
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...](https://support.office.com/en-us/article/Collaborate-on-Word-
documents-with-real-time-co-authoring-7dd3040c-3f30-4fdd-bab0-8586492a1f1d)

~~~
prepend
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.

~~~
robenkleene
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?)

~~~
TheCloudlessSky
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/](https://procedureflow.com/)

------
Jaruzel
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.

------
jedieaston
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.

~~~
smacktoward
_> 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.

~~~
toyg
_> 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.

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

~~~
wenc
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.

~~~
wnissen
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?

~~~
CPAhem
Syncdocs [https://www.syncdocs.com/](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.

------
dec0dedab0de
_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.

~~~
rakoo
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

------
jandinter
Working on it: [https://julesdocs.com](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).

~~~
asimpletune
Is this implemented as a git plugin?

------
nilsandrey
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.

------
discordance
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...](https://support.office.com/en-us/article/enable-and-configure-
versioning-for-a-list-or-library-1555d642-23ee-446a-990a-bcab618c7a37)

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

~~~
toyg
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.

------
fzumstein
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](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](https://www.xltrail.com)

------
delcaran
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.

------
eggsnbacon1
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

~~~
6c696e7578
> 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.

------
wombatpm
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.

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

------
wgx
From 2017:
[https://news.ycombinator.com/item?id=14552140](https://news.ycombinator.com/item?id=14552140)

------
tiffanyh
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.

~~~
arethuza
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.

~~~
MikusR
Or Onedrive.

~~~
arethuza
I think the backend for OneDrive for Business pretty much _is_ SharePoint
Online.

------
thrower123
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.

~~~
folmar
> 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.

------
jacekm
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.

------
anonme4ever
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](https://wiki.documentfoundation.org/Track_changes)

[1]
[https://wiki.documentfoundation.org/Libreoffice_and_subversi...](https://wiki.documentfoundation.org/Libreoffice_and_subversion)

------
taffit
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/](https://github.com/timabell/msaccess-vcs-integration/)

~~~
smitty1e
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.

------
Bedon292
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.

------
Intermernet
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.

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

Which make a version control pretty much impossible.

~~~
saurik
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".

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

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

------
eudoxus
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/](https://snipply.io/)

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

------
microcolonel
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.

------
ToFab123
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

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

~~~
prepend
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.

~~~
dahauns
>I wish there was a git blame for office.

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

~~~
prepend
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.

------
swiley
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.

~~~
major505
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.

~~~
swiley
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.

------
wiseleo
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.

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

------
dirtnugget
Confluence has this: [https://marketplace.atlassian.com/apps/1210818/scroll-
versio...](https://marketplace.atlassian.com/apps/1210818/scroll-versions-for-
confluence)

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.

------
ssss11
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.

------
wegs
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. :(

------
JamesG124
.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?

~~~
saalweachter
(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?

------
WhiteOwlLion
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.

------
prepend
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.

~~~
basch
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.

~~~
prepend
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.

~~~
basch
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.

------
dtsdwarak
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/](https://git-lfs.github.com/)

------
rb808
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.

------
joyj2nd
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.

------
emmelaich
Something to help is coming in the form of Fluid.

[https://www.theverge.com/2020/5/19/21260005/microsoft-
office...](https://www.theverge.com/2020/5/19/21260005/microsoft-office-fluid-
web-document-features-build)

[https://support.microsoft.com/en-us/office/get-started-
with-...](https://support.microsoft.com/en-us/office/get-started-with-fluid-
framework-preview-d05278db-b82b-4d1f-8523-cf0c9c2fb2df)

~~~
kator
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.

~~~
toyg
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.

~~~
Jaruzel
> _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...](https://support.office.com/en-gb/article/track-changes-in-
word-197ba630-0f5f-4a8e-9a77-3712475e806a)

~~~
toyg
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.

------
quickthrower2
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.

------
classified
> 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.

~~~
jamieweb
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

~~~
dakna
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.

------
globular-toast
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.

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

------
nojito
Onedrive stores file changes as files are modified.

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

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

------
willis936
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.

------
joaogfarias
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/](https://grindeq.com/)

------
savrajsingh
Office 365 with documents stored in the cloud. #formerMSFT

------
modmans2nd
Share point and Teams all the way

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

------
pabbasian
Microsoft Teams?!

------
kwanbix
Office 365?

------
yspeak
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/](https://imanage.com/product/document-email-management/)) and
professional comparison software like Workshare Compare
[https://www.litera.com/products/legal/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).

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

~~~
daveslash
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

------
kfk
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.

~~~
fzumstein
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.

~~~
kfk
Python + Html is a better option for reporting

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

