I would have offered to send a pdf

I would have never considered doing anything but sending a PDF. Even if they do know LaTeX. Unless they’re offering to help edit the code for me, what good is it? It’s objectively harder to read than the formatted PDF.

That said, marking up a PDF is much more difficult and does require more specialised software and know-how than editing plain text or even editing a Word document. So there are some advantages to it.

Preaching to the choir. “But Box already supports ‘versioning’, why use a confusing hacker tool instead?”

Missing diffs is a problem, though.

I don’t get how Microsoft owns GitHub yet hasn’t figured out any way to actually create a spec that would be git compatible for Excel, Word, and PowerPoint files yet.

I’m going to send you a pdf, you van email me back with the notes or comments in the PDF itself, whatever souts your fancy, and I’ll keep those notes and send you a new PDF with them.

I do this, but from Word.

I learned Latex for my master thesis. Never used it again afterwards, except for my resumé.

If you think this process involves enough mindpower to check the time, let alone figure out where the dashes are in whatever language keyboard setup I’m using at the time, you are wildly overestimating how much care goes into doing this.

and then there are fucking PIs insisting on word files who never heard of tracked charges let alone of file naming conventions.

I also have my reports in latex inside a git repo, complete with a makefile to generate graphs from csv containing simulation results. However I am too ashamed to publish the entire version control to a public repo

#LyX 2.0 created this file. For more info see http://www.lyx.org/

Wait, I thought you guys did it manually…

Anyway, I should still learn it.

Why on Earth would you curse yourself with MS Office anyway

idk it says .docx in OP’s image

This is the way.

This is the way.

Do you have a good LaTeX template for it. I did make a data driven based LaTeX pdf for my resume but it’s a nightmare when applying for jobs these days, since they have that ATS parser nonsense, which will throw the entire resume down if it isn’t as very plain and boring word document without much formatting.

I know it’s a long video but you have no idea what’s possible.

https://youtu.be/cMlRAiQUdD8

HTML. Some it people have their CV on their personal website.

(And CSS and JS, I guess)

I was on Word, then LibreOffice Writer.
Now thinking of making it a markdown source, with CSS styling to get an HTML based PDF. This way, the same source can be used on a webpage with different generation code.

This seems to me, to be simpler than L^AT_EX, but still good enough for a resume.

Yes, I also mde my. Thesis slides in LaTeX which was nice as I coukd reuse the figures.

I mean yes you can use beamer to make slides, but it is a lot less flexible than ppt/LibreOffice Present.

Makefile in other comments. You’ll need something like this on the title page (this assumes you use my Makefile which puts the version in VERSION.tex [that’s the literal name of the file, not a placeholder]):

{\bf{\color{red}DOCUMENT REVISION:}} {\color{blue}\input{VERSION}}

Sure thing. This also includes the beamer bit which I used for my defense. It’s all pretty hacky but hope it’s useful!

#
# Errors aren't handled gracefully (tex doesn't write to stderr, it seems)
# If you encounter errors, use "make verbose"
#
# For small changes (probably those without references), use "make quick"
#
# Thanks to https://gist.github.com/Miliox/4035649 for dependency outline

TEX = pdflatex
BTEX = biber
MAKE = make -s
TEXFLAGS = -halt-on-error
# $(MAIN).log is dumb if we have multiple targets!
SILENT = > /dev/null || cat $(MAIN).log
SILENT_NOER = 2>/dev/null 1>/dev/null
EDITOR = vim -p
PDFVIEW = evince
MAIN = main
PRES = presentation
ALL = $(MAIN).pdf
RECURS = media/ manuscripts/
VERSION := $(shell git rev-parse --short HEAD | cut -c 1-4)$(shell git diff-index --quiet HEAD && (echo -n ' ';git log -1 --format=[%cd]) || (echo -n '* '; date -u '+[%c]'))

all: recurs $(ALL)
pres: $(PRES).pdf
scratch: scratch.pdf

scratch.pdf: scratch.tex
	@echo "TEX	(final)	$<"
	@$(TEX) $(TEXFLAGS) $< $(SILENT)

verbose: SILENT = ''
verbose: $(ALL)

recurs: $(RECURS)
	@$(foreach DIR, $(RECURS), \
		echo "MAKE	(CD)	$(CURDIR)/$(DIR)"; \
		$(MAKE) -C $(DIR) $(MAKECMDGOALS);)
	@echo "MAKE	(CD)	./"

clean:
	@echo "SH	(RM)	Not recursing; 'make allclean' to clear generated files."
	@rm -f *.aux *.log *.out *.pdf *.bbl *.blg *.toc *.lof *.lot *.bcf *.run.xml

allclean: recurs
	@echo "SH	(RM)	A clean directory is a happy directory"
	@rm -f *.aux *.log *.out *.pdf *.bbl *.blg *.toc *.lof *.lot *.bcf *.run.xml
version:
	@echo "SH      (ver) $(VERSION)"
	@echo $(VERSION) > VERSION.tex

nixpages: main.pdf
	@echo "PDF     (pdftk)"
	@pdftk main.pdf cat 1 4-end output final.pdf

quick: $(MAIN).tex version
	@echo "TEX	(final)	$<"
	@$(TEX) $(TEXFLAGS) $< $(SILENT)

$(MAIN).pdf: $(MAIN).tex $(MAIN).bbl all.tex tex/abstract.tex tex/intro.tex tex/appendix.tex tex/some_section.tex tex/some_other_section.tex
	@echo "TEX	(draft)	$<"
	@$(TEX) $(TEXFLAGS) --draftmode  $< $(SILENT)
	@echo "TEX	(final)	$<"
	@$(TEX) $(TEXFLAGS) $< $(SILENT)

$(MAIN).bbl: $(MAIN).aux
	@echo "BIB	(bib)	$(MAIN)"
	@$(BTEX) $(MAIN) > /dev/null
	
$(MAIN).aux: $(MAIN).tex $(MAIN).bib version
	@echo "TEX	(draft)	$<"
	@$(TEX) $(TEXFLAGS) --draftmode  $< $(SILENT)

$(PRES).pdf: $(PRES).tex $(PRES).bbl tex/beamer*.tex tex/slides/*.tex
	@echo "TEX	(draft)	$<"
	@$(TEX) $(TEXFLAGS) --draftmode  $< $(SILENT)
	@echo "TEX	(final)	$<"
	@$(TEX) $(TEXFLAGS) $< $(SILENT)
$(PRES).bbl: $(PRES).aux
	@echo "BIB	(bib)	$(PRES)"
	@$(BTEX) $(PRES) > /dev/null
$(PRES).aux: $(PRES).tex $(MAIN).bib
	@echo "TEX	(draft)	$<"
	@$(TEX) $(TEXFLAGS) --draftmode  $< $(SILENT)

edit:
	@echo "EDIT	(fork)	$(EDITOR)"
	@$(EDITOR) ./tex/*.tex *.tex

view:
	@echo "VIEW	(fork)	$(PDFVIEW)"
	@$(PDFVIEW) $(ALL) $(SILENT_NOER) &

Markdown + pandoc means it goes through an intermediary latex template on the way to pdf land - which means your markdown can be a bastardized mix of markdown, html, latex commands, and sometimes more ;)

I absolutely love R markdown! Being able to iterate on your analysis and report at the same time is fantastic

If you are, like I once was, the poor fool who has to maintain a bunch of VBA macros… Extract them into files and source control those. Make a script to extract them and to put them back, and use git-lfs for the actual workbook if you need a template workbook.

Now pardon me, I need to add this to the agenda for my next therapy.

Just fork git to handle zipping, formatting and ignoring metadata! Or just put your office document in the cloud and use the basic versioning it provides.

Someone could probably build a tool which sits in between you and Git, which unzips the file before committing and after pulling, so Git sees the raw xml file, but you always see the zipped docx.

edit: never mind. Just read @petersr@lemmy.world’s comment explaining why this is a bad idea.

Which isn’t any different than keeping them as separate files space wise so what’s the problem?

(Other than Word having built-in versioning.)

I think you can write clean/smudge filter that will turn docx into tree(folder)

Never heard of latex

Fuck, I’m old.

Well in this thread people were saying you can set up your own local git repository? What’s a newbie friendly way of doing that. I’ve watched videos and understand that git version control system but I can’t quite seem to grasp more than that.

I’m doing my math homework with latex this semester, I’m probably slower but it looks good and is more maintainable.

Typst is Markdown-ish with the possibilities of LaTeX.

Me with Jupyter Notebooks

They are generally large, uncompressable and replaced instead of updated like text files. All files stay in the repo history forever, they make repos big and slow compared to text files with no advantages provided (e.g. as you said, diffing etc is useless).

If a binary file needs to be stored in git, it’s usually more appropriate to use git LFS for that file. Git LFS stores the binary outside of the repo in the same way that database engines store binary outside of the respective table.

In this case, it would be much smarter to use version control on the text in the document, not tte binary file, which is a feature of essentially every document writer program.

Thanks for explaining!

Thanks!