perimo's comments

To get the best performance you typically want to know something about the sparsity structure of your problem. Do most nonzeros fall near the diagonal? Or do they clump into dense submatrices?

If you don't have that information, you can look at how your matrix will be accessed. Do you need fast access to random rows, or columns? Do you need to write new values? Are those values already in the sparsity structure?

All of these questions can lead you to choosing the right sparse format, but it does take some experience to know where to look.

Same here. I've been searching for software that can simulate that accidental audio system monitor ever since, but so far I haven't found anything. Maybe I'll just have to write it myself...

If you're wondering why, the one town that managed to get fiber installed (Leverett) is relatively densely populated with UMass Amherst faculty.

For IPython-based profiling, I find the %timeit and %memit magic commands invaluable. This post has a good overview: http://pynash.org/2013/03/06/timing-and-profiling.html

I contribute to the Doppio JVM project (https://github.com/int3/doppio), which we initially wrote in Coffeescript. About 9 months ago, we decided to port the whole thing (~10kloc) to Typescript, and it proved really useful:

- Typescript is a superset of Javascript (mostly), so we ported by converting all the Coffeescript sources to Javascript and renaming them with .ts extensions. There was a bit of cleanup involved in getting modules to play nice together, but most of the code ran without modification.

- The JS that the Typescript compiler generates is much easier to read, in part due to less "magic" in the language.

- It also makes performance much easier to reason about, for the same reasons. One issue that bit us several times was Coffeescript's auto-return feature, which was invisibly accumulating large arrays of values from our interpreter's bytecode loop! This is no longer a concern with the current Typescript codebase.

- The inner workings of the JVM are fairly complex, so enforcing types at compile-time actually does catch bugs before they happen.

I kicked around with some JS manifold learning stuff[1] a while back for essentially the same purpose: practice in writing things from scratch, while making it easier for other people to play with.

[1]: https://github.com/perimosocordiae/js_manifolds

If it's possible to integrate this with BrowserFS, you'd be all set: https://github.com/jvilk/BrowserFS/#browserfs

Shameless plug: this seems like a good application for Doppio: https://github.com/int3/doppio

The whole JVM lives in the browser, so you don't need to rely on hacks to "sanitize" user programs.