3,995 karma · joined July 17, 2016
https://www.youtube.com/watch?v=TazTAqBQakQ
Johnny told him "Just be yourself. That's the only way it CAN work."
Conan spends the entire bit unpacking that advice.
2. Then install a Hasu FC660C Controller, and start customizing the firmware. Typing, like sex, is far more about software than hardware.
3. Now prepare yourself for the split/ergo keyboard advocates. They have a point if your hands move. If you rearrange your layout so pretty much anything is nearly home row, but a tap-hold one-finger-each-hand chord, your hands don't move.
Typing is bimodal. Sometimes you're in the saddle, hard at work. Sometimes you're reaching in to find "pause" with a glass of wine in the other hand. A conventional keyboard is handy for reaching in, even if it's secretly a chording keyboard along home row.
People who use lisp like the parentheses.
I don't, though they're no more objectionable than all the {}; languages. I just don't like unnecessary punctuation.
I coded in scheme for years using a preprocessor that understood
define-syntax opt
syntax-rules |
$ _ (x v) b ...
let || x | if (null? x) v | car x
b ...
(define-syntax opt
(syntax-rules ()
((_ (x v) b ...)
(let ((x (if (null? x) v (car x))))
b ...) )))
I gave this up learning Clojure so I could use other people's tools. Instead I prefer lighter parentheses, and I use this script to tailor fonts for coding lisp:
https://gist.github.com/Syzygies/226253bc38743ef474ee67cbf58...
I have the most trouble with comment characters, in any language. In various languages I used a preprocessor that implemented a practical version of "comments are flush, code is indented" (hey, it cost me one level) and relied on syntax coloring to mute the comments. Again, I gave this up to use other people's tools.
In Haskell I can add a handful of lines to parallelize an "embarrassingly parallel" computation. For example, there are 66,960,965,307 atomic lattices on 6 atoms. A 20 core Mac Studio can figure this out by reverse search in just over four minutes; divvy the work up into piles, and have everyone count the work in their pile. For the problems I care about, everyone's looking for needles in a haystack; they can report what they found with no concern for what anyone else is doing.
So what's the dumbest "try this first" approach in Clojure?
https://download.clojure.org/papers/clojure-hopl-iv-final.pd...
The design decisions in this paper strongly resonate with me. It helped me to overcome my aversion to JVM-hosted languages, and settle down to learn Clojure.
I'm a research mathematician, at one extreme where code is steps up a mountain. I don't need to summit twice, so productivity is far more important than speed. Nevertheless, the fastest Clojure time trials use GraalVM:
The majority of the lines I've ever written were in C. When I look at Rust, all I see is `{};`
Rust is in part designed to look familiar to C programmers. Rob Pike once famously described C syntax as able to survive a channel that mangled whitespace. That's less of an issue now, but habits die hard. Indentation in place of syntax is nevertheless controversial. That's a toy version of the bigger question: Why should text be required to carry a load that a smart editor can infer? In Clojure, some prefer ;; to ; because the comments stand out better. Um, syntax coloring? I dislike all comment characters, and for many years I preprocessed a practical version of "comments are flush, code is indented".
Ownership is nevertheless pure genius, and one can define more powerful operations on Rust's restricted notion of data than on general data. I'm imagining a "lisp without parentheses" that transpiles monadic parsers on steroids (aimed exactly at Rust data) to Rust. It will take me a while.
As a professor one of my students had a seizure then stopped breathing, during one of my exams. There were fifty students closer to her than me, yet somehow I found myself giving aid, as everyone else either dialed 911 or swooned "there goes my professor!" There was that second where all these thoughts went through my mind, but then she started breathing.
As for false accusations, there's a principle that accusers should understand but don't: NEVER assume you're the craziest person in the room.
By "manual" I mean various scripts, on MacOS. "bib" for example is an Alfred keyword that runs a script scraping the front browser page for bibtex data, and initializing a new folder based on this data. Other scripts write search output files that "Find Any File" thinks it saved; FAF offers a nice Finder-like interface for selectively opening search results.
I've avoided any canned solution. I don't want vendor lock, and I'd rather be crippled by my own lack of imagination than someone else's.
By far the most useful metadata are the dates of access. One wanders continuously through an idea space no software can adequately categorize, yet adjacent items in time are likely related.
The holy grail I haven't coded yet is to generate web pages with URI schemes that open each PDF in a viewer. GoodReader is a nice viewer on iOS with such an interface; stunningly its own browser can't understand these links, but DropBox can. To simplify versions for MacOS and iOS, one can write a custom URI handler on MacOS that recognizes the GoodReader link, and redirects it on a Mac.
The goal here is to meaningfully browse closer to the speed of light than clumsy current standards. Just as lock-picking is both skill and cycles, research is both skill and cycles: One wants to have the right three ideas in close enough proximity for our feeble brains to notice the connection. We have to be in our happy place when we're flailing for hours, days, years; it would nevertheless be nice to accelerate this process.
I've been in constant friction with the MathSciNet team: I believe that it should present itself as the premier playground for machine learning mind mapping experiments, in addition to maintaining its stodgy hand curation. There is some controversy as to how math is organized. Many great mathematicians wander freely; others never read a paper outside their field after the age of 23. Departmental hiring meetings degenerate to "it's the number theory group's turn", perpetuating a dated view of how math is organized. Independent views of the MathSciNet database could give us new understandings of our field.
Mathematicians pursue math in defiance of the far greater rewards of other paths. I know at least nine Fields medalists and many near misses. Unlike the Nobel prize, neither the quest nor the realization of the Fields medal turned anyone into an ashpile.
Linear differential equations are a great introduction to eigenvalues. There's a chicken-and-egg problem understanding this, and it would be helpful to take ODEs and Linear Algebra together.
As I first read in Feller, generating functions are a formation that runs the full length of mathematics and beyond; the Laplace transform from ODEs is just a continuous version of a generating function.
As Marcel-Paul Schützenberger first made clear, the notions of "rational" and "algebraic" from pure mathematics match up with finite state machines and push-down automata from computer science. One studies these most easily using generating functions. As Richard Stanley explains in Enumerative Combinatorics Vol. 2, there's a third class of generating functions beyond algebraic: D-Finite. Roughly, this corresponds to how one learns to expand the solution to a differential equation in ODEs as a power series. The true significance of this class in both pure mathematics and computer science is poorly understood, but there's something clearly out there as significant as rational and algebraic. That is intrinsically fascinating.
When I see someone filling a blackboard with equations, I see someone flailing because they don't know what to do. The best math is simple, and can be expressed as philosophy, like recognizing this formation crossing the sky.
I was always put off by Rust syntax (it's a fly-pollinated flower, to attract C programmers), but I'm starting to get the genius in its machine model. Learning Rust forces one to understand what's happening at the machine level, but offers better control as a reward. Its expressiveness is a lot closer to Ruby than I had imagined, it won't put me back in the C99 stone ages. So my provisional answer is that Rust is a Faster Ruby.
[1] http://www.randomhacks.net/2005/12/03/why-ruby-is-an-accepta...
My yard is absurd clay. I've used my wet/dry vac, along with an electric pressure washer, to dig holes and remove tree roots (easier to cut what you can see).
A drain would increase my work time, at the expense of thicker sludge when I'd have to empty the vac manually. What I really want is to move the mud slurry, not store it. I suppose I should build an open frame to replace the vacuum body, and just use the pump lid.
So the creatures who can take flight in a light breeze are the ones who can sense the breeze. That sounds about right.
Blackboards themselves also vary in quality; some ceramic surfaces can rival traditional slate. One can't really judge the experience starting with a cheap, dirty board and using institutional chalk and erasers.
I've enjoyed whiteboards in well-funded companies. In academics, it is profoundly embarrassing how often a speaker will have traveled for a lecture, only to find a dirty whiteboard and the local markers dried out. This is why speakers would rather lip-sync to PowerPoint slides. Were I using a whiteboard, I'd also bring my own tools.
Pad and paper is certainly easy, but artists brave serious messes to produce oil pastels for sale. In my case, students are carrying student loans half their lives. I prefer chalk over slides because it forces a live performance. I then share my Notability drawn notes, because they're better.
[1] https://www.amazon.com/HAGOROMO-Fulltouch-Color-Chalk-White/...
[2] https://www.amazon.com/Hagoromo-Fulltouch-72pieces-Yellow-Or...
At the same time I love physical media. As a math professor I defend a widespread preference for blackboards over soul-sucking whiteboards, imagining that musicians will still play grand pianos in a century, and they'll still snicker over Ryan Gosling playing a toy piano under the spotlight in that classic movie "La La Land".
I've hoarded Hagoromo chalk; I'm the one with the chalk attaché case in [1]. I've always carried multiple grades of drawing paper, and I've worked through many hundreds of artist grade felt tip pens, scanning all my math notes for thirty years.
Then, pandemic. Just as World War 2 accelerated women in the workplace, the pandemic has accelerated the uptake of digital tools for visual presentation. To teach over Zoom, we needed to embrace drawing on a tablet. I understand that the pandemic radically accelerated similar trends in architecture.
The algorithmic possibilities of drawing on a tablet are truly addictive; returning to paper feels like returning to a mechanical typewriter. For my purposes, Concepts offers the most involving algorithmic experience; I wrote [2] to support my note taking and diagrams for papers. However, Notability offers the least friction. I can have the same psychological relationship to taking notes on my tablet as I had with phyical paper, with the benefits of algorithmic reuse. (Pushing the envelope exposes how inconsistently Notability handles implicit layers, but one learns to draw around this.)
In a few decades, after all living mathematicians have drawn on tablets since birth, math will be far more visual, conveying ideas with far more immediacy. Math communication is now still largely constrained by its resemblance to typeset prose. Ever leave a startup because reading your coworkers' code put you in "Just kill me now!" territory? I did. Mathematicians write the equivalent of bad code, rarely actually machine-checked, to formalize their ideas. Other mathematicians try to decipher this code, to reverse-engineer the ideas. We declare people who can actually do this as having a gift for mathematics. As I learn to teach combinatorics more visually, my classes swell with students who share my frustration.
I've come to realize this summer that I pretty much despise mathematics. I can't wait for the visual revolution. This revolution didn't take hold on physical paper; one needs a digital accelerant.
[1] https://www.youtube.com/watch?v=PhNUjg9X4g8 [2] https://github.com/Syzygies/concepts-artboards
Rather than complicating my build.ninja files, I handle build variants in my script. Easy enough to output a new variant, probably faster to use, and certainly easier for others to understand.
People are more likely to adopt ninja as we did if they see it first as the easiest way to manage a small project. Why bother with CMake or other tools, if one can script in one's favorite language? I'm sick of working with bad build description languages; ninja is going straight to the bare metal.
I had to write these build files over again, and I just couldn't stomach the idea of writing another makefile.
The source will be shareable once we get it running again. Other than historical curiosity, people are most likely to use it for assistance in converting old work to the successor program Macaulay2.
The script bin/ninja.rb creates two flavors of build.rb, one that keeps going no matter what, writing error files for each exception, and another for use once everything works. One might be able to craft a single file that does both, but I'll want to ditch these complications once we're done with the conversion, and end users won't want to see them.
It would have helped me to see more examples like this, learning ninja.
First approximation: No one's happy with any build tool, with good reason. Then I discovered Ninja. It's an assembly language for builds, advertised as a back end for higher level tools, but many people script Ninja themselves.
For me, 15 lines of Ruby code plus some heredoc boilerplate spawned a 138 line build.ninja file. Back in the day, this computer algebra system used to take an hour to build. Make still needs a frustrating number of seconds. Ninja on all my cores is a correct fraction of a second.
Ninja is exceptionally fast, and handles parallelism extraordinarily well. It scales; they use it for Google Chrome. Various tools such as CMake can target Ninja. It is unique for its design goals.
Most importantly, looking at Ninja code is not a "Just kill me now!" experience.
One can only make sense of progressions like this by finding relationships between the levels. There are at least two ways to see a connection between addition and multiplication: The logarithm, and polynomials. Polynomials are well-studied expressions combining addition and multiplication.
Algebraic geometry studies sets defined by polynomial equations, as linear algebra studies sets defined by linear equations. Tropical geometry [1] is a version of algebraic geometry that replaces addition by minimization, and multiplication by addition.
Pure mathematicians like to hear music in their choices; they want these choices to arise naturally and support deep theories. Tropical geometry passes this test. One wants an inevitability to one's choices, a belief that alien life would reach the same conclusions.
If there are two answers to "what's zeroth? What's fourth?" that itself is interesting. However, one wants extensive evidence to believe that there's branching. Otherwise, we decide that we've simply stepped onto the wrong trail and need to backtrack. Pure mathematicians live in profound fear of just playing house, making stuff up because it sounds good, even if it looks to everyone else like that's what we do.
Mind mapping is a critical application of computers, still in its infancy. I have thousands of math articles in digital form that are beyond my ability to track from memory.
My primary need isn't note-taking. I want a "Finder" alternative for managing digital assets, my own folder structure that I independently store and sync. I want to wander through old papers and open them in readers on both MacOS and iOS, at the speed of daydreaming. The timing of my herd paths, and some deliberate annotations, should be my gardening influence on a largely automated process for discovering proximities. I'm still not sure what tools to use, so I slowly write my own.
Those days predate most people reading this, yet many new language syntaxes opt for "familiarity". I wish that all language design went through a filter where every character mattered like the designer was in an episode of Squid Game.
Bill Joy famously explained that syntax matters, a dense syntax puts more on screen. This is true even now. I struggle with this; my favorite syntax is a preprocessor that eliminates the need for most Lisp parentheses. The result is code poetry. Nevertheless, Haskell is more expressive.
(Here's an easy test: Anyone who proposes a way to minimize Lisp parentheses, who hasn't introduced a symbol for missing outline levels, is just pulling out chunks and hasn't used their system to write thousands of lines of code.)
I've written most of my lifetime of code in C, established my career in C, and C syntax is ground glass in my eyes.
One could learn the Apple II inside-out. I've never had that experience again. My first week I took a soldering iron to it to provide lower case support; I've been the surgeon for friends' computers ever since. There was a book (it must be somewhere on this archive) that explained the purpose of every byte in low memory.
For perspective, I was avidly learning Go as I started grad school, till I read on the back cover of one of James Davies' books that he had dropped out of math grad school to pursue Go. Ouch! The Apple II was a completely different, more approachable scale. I could master it and stay in grad school.
https://www.math.columbia.edu/~bayer/coffee/
One wondered then as much as ever about things one read on the web. For example, Kopi Luwak was a legendary coffee fished out of paradoxurus marsupial feces. All references on the web could be traced to a single source, yet apparently this is true.