Wednesday, August 28, 2013

Motivated by work on a book and by the stacks projects,
I just wrote a new web-based LaTeX editor, which I've just released.
You can try it now by making a free account at https://cloud.sagemath.com, then
creating a project, and uploading or creating a .tex file, then opening it.

Features

Side-by-side LaTeX editing, with re-build on save (you can set the autosave interval if you want).

Forward and inverse search.

Parsing of the log file, with buttons to jump to corresponding place in tex file and pdf file.

Preview uses high-resolution color png's, so it will work in browsers that don't have any support for pdf.

The command to LaTeX your document is customizable.

The build process should run LaTeX, bibtex, and sagetex automatically if the log file says they need to be run; otherwise you can click a button to force bibtex or sagetex to run.

Scales up to large documents -- my test document is a book! -- for me sitting at home working on my 134 page book, the time from making a change and clicking "save" to when it appears in the preview pane in high resolution is less than 7 seconds.

Forward and inverse search: jump from point in .tex file to corresponding point in pdf and conversely (it seems the competition doesn't have this, but I bet they will implement it soon after they read this post)

If you need a full xterm for some reason you have it: you can run arbitrary purpose programs on that command line. This means, you can download some data (file, website, database, experimental result files, use git), process them in the most general sense of computing, and generate those files or parts of it for your LaTeX document.

It scales up to large documents more efficiently (in my limited tests), since I was pretty careful about using hashing tricks, parallel compute to generate png's, etc.

A different synchronization implementation for multiple people editing the same file at once; the others lock the editor when the network drops, or reset the docuement when the connection comes back; in real life, network connections are often dropping...

I put some effort into trying to make this latex editor work on iPad/Android, though you'll want to use a bluetooth keyboard since there are major issues with CodeMirror and touch still.

The error messages are not displayed embedded in the tex document (not sure I want this though).

You must have a cloud.sagemath account (free) -- you can't just start editing without signing up.

Single file download is limited to 12MB right now, so if your PDF is huge, you won't be able to just download it -- you can scp it anywhere though using the terminal.

Behind the Scenes

As a professional mathematician, I've spent 20 years using LaTeX, often enhanced with little Python scripts I write to automate the build process somewhat.
Also, I've spent way too much time over the years just
configuring and re-configuring forward and inverse search under Linux, OS X, and Windows with various editors
and previewers.

All the new code I wrote to implement the LaTeX editor is client-side CoffeeScript,
HTML, and CSS, which builds on the infrastructure I've developed over the last year (so, e.g.,
it can run bash scripts on remote linux machines, etc.).
Here are some specific problems I confronted; none of the solutions
are what I expected two weeks ago or first tried!

Problem: How should we display a PDF in the browser

I investigated three approaches to displaying PDF files in the web browser: (1) show a bunch of images (png or jpg), (2) use a native
pdf viewer plugin, and (3) use a javascript pdf renderer (namely pdf.js).
Regarding (2), Chrome and Safari have a native plugin that efficiently
shows a high-quality display of a complete PDF embedded in a web page, but Chromium has nothing by default.
Regarding (3), the Firefox devs wrote pdf.js, which they include with Firefox by default; it
looks good on Firefox, but looks like total crap in Chrome.
In any case, after playing around with (2)-(3) for too long (and even adding a salvus.pdf command
to Sage worksheets in cloud.sagemath), I realized something: the only possible solution is (1),
for the following reasons:

Inverse and forward search: It is impossible to read mouse clicks, page location, or
control the location of the pdf viewer plugin in some
browsers, e.g., in Chrome. Thus only using a PDF plugin would make inverse and forward
search completely impossible. Game over.

It might be possible to modify pdf.js to support what is needed for inverse and forward
search, but this might be really, really hard (for me). Plus the rendering quality of pdf.js
on Chrome is terrible. Game over.

My test document is this book's PDF, which is about 8MB in size. With PDF viewer plugins,
every time the PDF file changes, the entire 8MB pdf file has to be transferred to the browser,
which just doesn't scale -- especially if you replace 8MB by 60MB (say). I want people
to be able to write their books and Ph.D. theses using this editor.
When editing a LaTeX document, the PDF file often changes only a little -- usually only a few
pages changes and everything else remains identical; only the changes should get sent to the
browser, so that even a 1000-page document could be efficiently edited. This sort of thing
doesn't matter when working locally, but when working over the web it is critical.

So we are stuck with (1) for the main PDF preview for a file we are actively editing using LaTeX.
There are a long list of apparent drawbacks:

One substantial drawback to (1) for general PDF display is that there is no way to do full text search
or copy text out of the PDF document. Neither of these drawback matters for the LaTeX editor application
though, since you have the source file right there. Also, there's nothing stopping me from also providing
the embedded PDF viewer, which has search and copy, and that's what I've done for cloud.sagemath.

Another potential drawback of (1) is that it takes a long time to generate jpg or png images
for a large pdf file -- 5 pages is fine, but what about 150 pages? 1000 pages? I tried
using ImageMagick and Ghostscript. ImageMagick is way too slow to be useful for this.
Ghostscript is incredibly powerful for this, and has a wide range of parameters, with numerous
different rendering devices. The solution I choose here is to: (1) generate a high quality
PNG image just for the currently visible pages (and +/-1), then (2) generate medium quality
pages in some neighborhood of the visible pages, then (3) generate low quality PNG's for
all the other pages. All this is done in parallel, since the host VM's have many cores.
Also, we compute the sha1 hashes of the previews, and if the browser already has them,
don't bother to update those images. Finally, it turns out to be important to replace
high quality images by lower quality ones as the user scrolls through the document,
since otherwise the browser can end up using too much memory. A useful trick for the high quality
pages is
using ghostscript's downsampling feature, so the PDF is rendered at 600dpi (say) in memory,
but output at 200dpi to the PNG.

So the Preview tab in the LaTeX editor shows a png-based preview whose quality automatically
enhances as you scroll through the document. This png preview will work on any browser
(for which cloud.sagemath works), irregardless of PDF plugins.
Summary: It is critical to realize exactly what problem we're trying to solve, which is
viewing a PDF that is often changing locally. This is completely different than the general
problem of viewing a static PDF, or editing a PDF itself, or even annotating one.

Problem: how to implement forward and inverse search in the browser

Forward and inverse search let you easily jump back and forth between a point in the source tex file and the
corresponding point in the rendered PDF preview. You need this because editing LaTeX documents
is not WYSIWYG (unless you are using something like Lyx or Texmacs), and without this feature you might find
yourself constantly being lost, doing fulltext search through the source of pdf file, etc., and generally
wasting a lot of effort on something that should be automatic. The first time I used inverse and forward search
was around 2004 with
the Winedt and TexShop
editors, which I think (at the time) used various heuristics to implement them, since they often
didn't quite work right. I 100% assumed that I would have to do use heuristics for cloud.sagemath, and started
working on a heuristic approach based on pdftotext, page percentages, etc.

Then one morning I searched and learned about synctex,
which was "recently" added to the core of pdflatex. The first thing I did was run it, look at the output file
and try to parse with my eyes -- that didn't work. I then searched everywhere and could not find any documentation
about the format of the synctex files; however, I found a paper by the author of synctex and read straight through
it. In that paper, they mention that they provide a C library and C program to parse the synctex files,
and explicitly don't document the format since they don't want anybody to write programs to parse it, since
they reserve the right to significantly change it. No problem -- so I just call out to the shell and
run the synctex program itself with appropriate options. With a little research into scaling factors,
etc., I'm able to map mouse clicks on the png to the data synctex needs to get the corresponding location in the
source file. This is all actually pretty easy and provides forward and inverse search with
absolutely no hacks or heuristics. Also, forward search works well since using PNG's to display the preview means
one can precisely set the preview location.

Problem: making sense of the LaTeX log file

When you build a LaTeX document, tex spits out a log file full of filenames, parentheses, warnings, errors, etc., sometimes stopping to ask you questions, sometimes refusing to exit, etc. This file is NOT (by default, at least) easy for a human to read, at least not me! You can see an error message that refers to a specific location in a file, but which file that is is often listed hundreds of lines before, and you must manually balance paranthesis to figure this out.
I read some documents about its format, and fortunately
found this Javascript library, which parses LaTeX logs.
Cloud runs pdflatex using the option -interact=nonstopmode, so that the whole file gets processed,
then parses the log file, and displays first errors, then typesetting issues (overfull hboxes, etc.), and finally warnings.
Each message has two buttons -- one to jump to the corresponding location in tex file, and one to jump to
the location in the pdf preview.
This is all easy to use, and I've found myself for the first time ever actually going through tex files
and cleaning up the overfull hboxes.
The log file also says when to run sagetex and bibtex, and whether or not to run pdflatex again to update cross references,
and cloud parses that and automatically runs those tools.
For some reason, sagetex doesn't say "run me again" even though it should when you update
existing blocks, and then you have to do it manually by clicking a button.

Summary: I hope this LaTeX editor in the Sagemath Cloud is useful to people
who just want to edit tex documents, play around with sagetex, and not have to worry about configuring anything. Implementing it was fun
and interesting. If you have any questions about the technical details, please ask! Enjoy.

About Me

I am a professor of mathematics at University of
Washington. In my mathematics research, I use the Birch and
Swinnerton-Dyer conjecture as motivation to explore the
constellation of conjectures and questions about arithmetic invariants of elliptic curves. I do many explicit computations, and started the Sage Mathematical Software project. Currently, I'm working very hard on https://cloud.sagemath.com.