I personally feel 1 is the most right answer, but tbh I hadn't seen the complex analysis stuff which suggests other things. So, neat article, thanks for sharing.

Thanks. It's definitely intriguing.

I will certainly grant you that there doesn't seem to be any shortcut to learning logarithms and exponentials, though. I searched for a "proof without words", but unless you start to do something fancy with trigonometry and Euler's formula, I'm not sure there are any shortcuts to understanding.

It might help motivate learning, at least, if you forced the class fo use a slide rule

Oh wow, that's probably just it. Slide rules are "analog computers" that you can directly experience, so you are basically learning what the logarithm "is" in the process of using one.

Even more interesting: slide rules can serve as a tactile aid to understanding not just logarithms, but ANY monotonic function (even ones that are only piecewise continuous).

There's even a professor at UCSD who has apparently written up a paper that formalizes the mathematics of slide rules.

.

Related rates problems are possibly the easiest type of calculus problem which people struggle with. Which is interesting since the *setup* seems to be the hard part.

I think I'm going to withdraw from graduate school for a few years after this spring term. My advisor is toxic and actively bad for my mental health, I'm too late in the game to switch to a functioning group (nor do I feel capable of rolling the dice again), and I feel burnt out on academia. I can return to my program within a few years without re-applying, so assuming I don't get too comfortable at whatever job(s) I end up with, I should be able to come back easily. I thought that having a good project to show my advisor, that he seems happy with, would allow us to have a functioning relationship wherein we do productive science together, but he's retracted his funding offer which was contingent on my finishing my thesis by the end of October (which I did, for the most part) without any sort of explanation to me. I have funding lined up for the spring contingent on him sticking around to be a formal advisor but work with an experimental group, but he is set on divorcing himself from any work that I do and refuses to let me continue working under other funding but remain as an advisor.

He refuses to communicate with me, lashes out when he begins to think he might be wrong in our meetings, never offered any direction on my research in four years, and has been repeatedly saying "You need to impress me," without offering any guidance as to what would "impress" him enough to "justify my being a student of his." At this point, especially with the project I'm writing up now, I've done enough to show that I can work at the appropriate level, and yet he refuses to try to engage with me as a productive use of his time.

Sounds pretty ****, dude. Sorry to hear that. A break sounds like a good idea if it's a viable thing to do. You say you can't switch to a functioning group this late in the game; would that change after a hiatus?

Good luck!

that's my hope. 4 years in with only a single paper to show requires a lot of explanation (which I can give, but the context is a ****ty personal story). walking away with the master's, working for a few years, and trying to do something different is probably easier to explain: grad school didn't work the first time around, I worked, and I'm ready to return and finish it.

https://www.phoronix.com/scan.php?page=article&item=linux-420-bisect&num=1

Spectre: the gift that keeps giving

I was reading through some C++20 proposal stuff and I started thinking back to my compilers course in university.

Compilers courses really suck.

Let me be clear: compilers courses notoriously suck. Every student who takes a compiler course knows they suck. Instructors keep hearing the same complaint every year and the answer seems to be warning students about the difficulty of the course, as if that were the extent of the problems.

Basically, this is my realization: CS instructors have no clue what they’re doing. Compilers courses have nothing to do with compilers! They are actually something much closer to Applied Formal Languages, totally divorced from the pertinent topics of modern compiler development.

The standard curriculum pisses away the first 10 weeks on parser generators, pays perhaps a week of lip service to code generation (always for some synthetic stack machine designed to make the task trivial), and the capstone project is something like a stripped down Pascal interpreter written in Bison.

Nobody uses ****in Bison or anything else anymore. Every single non joke compiler has a hand written recursive descent parser. Because they’re fast enough. Because they’re easy to maintain. Because they compose. Because they give good error messages. Because they can parse any formal language. Because because because. Parser generators are super cool and people are making amazing new parser generators every year, but as far as the development tool industry is concerned they are dead.

What should a compiler course cover? Well, um, how about the meat and potatoes of actual compiler development? We don’t use stack machines, we use register machines. How do you get away calling yourself a compiler course if you don’t cover something as universally important as register allocation? What about SSA representation? Modern compilers need to do semantic analysis, so where’s the material on flow analysis, modern type systems, SAT solvers and **** like that? Why not teach code generation for a real CPU? X86 is too hard, but what about MIPS? Why isn’t the final project just, like, straight-up using LLVM, so your compiler might actually be useful once you’re done it?

idgi. It’s like profs start on page one of the dragon book and recite it until they run out of time, without one second of actual thought.

.

Yup.

I'd be interested to see how well this well-known book lives up to its title in your opinion (especially since ML is supposed to be so well suited to writing compilers in).

Hmm. Though recursive descent is mentioned reasonably early on, I still see stuff on something they are calling "ML-yacc" later on. So maybe still dated.

I’ve never read that book and I haven’t read the second link, but given ML is a domain specific language over algebraic types I think it’s pretty obvious why ML is good for writing compilers (at least up till the mid end).

Of course, it doesn’t matter whether you learn LALR in ML or C, the algorithm doesn’t change. The only difference is the pure mechanical difficulty of writing your course project, which somehow magically becomes rote, even trivial once you use a language that is suited to the task (how odd; it’s almost like writing a language frontend isn’t very difficult). Which suggests that maybe a compiler course shouldn’t be wasting all of its time talking about it.

That does remind me of something, though. A former employer once bought a nimble startup competitor to flesh out their static analysis offering. It turned out Ocaml was really the secret to their success - they could write new checkers or overhaul their engine in a fraction of the time as a C++ one. From what I gathered all of the acquihires ended up quitting, because management threw away their code because they liked C++ better.

*shrug*

This also comes to mind (just posting for the two diagrams).

I just remembered seeing a course on compilers that I think might alleviate most of the problems that Jon`C has mentioned: Niklaus Wirth's Compiler Construction

In particular, he gets to recursive descent parsers almost right away, on page 18:



And then later, he targets a very simple RISC machine, which he defines for the purpose of the course.

And actually, in another course, he shows you the complete source code for a tiny operating system written in Oberon. He has even implemented the entire system on an FPGA.

I think Wirth has succeeded in making the entire system simple because he designed the entire system, from language (Oberon), to compiler, to operating system, to RISC architecture, to FPGA implementation. Every piece of the system tries to be as simple as it can be, given the freedom to design said simple parts at the same time.

Also, I heard somewhere that Wirth's test for adding an optimization to the compiler was to see first whether or not the optimization didn't actually increase the compilation time of the compiler itself. As a result, the compiler (and language) are both fast and also implemented in very few LOC.

On the other hand, I have never seen a course webpage that actually uses this stuff. It's a complete system, but one that seems to exist in isolation from the rest of the world.

Profs honor Wirth by using a Pascal variant for the course project. Oh, did I say honor
him? I mean insult him, by brazenly ignoring everything he says while using him as an excuse to subject their students to a language that is cryptic and irrelevant.

Apparently, Stanford offers a "compiler" class to undergrads that doesn't even talk about parsing at all, doesn't require it as a prerequisite, and goes directly to dataflow, register allocation, and even SMT solvers, using compilers for machine learning applications (CUDA) as a motivating application.

This seems much better, and students can learn about all the formal language theory stuff in basic "theory of computation" course.

Not sure where an actual modern compiler course would fit in to this scheme though. Maybe just read the LLVM tutorial for making a toy language using recursive descent. I don't know how hard writing an unoptimized compiler using LLVM really is, but if it just amounts to learning a few techniques and making use of some classes provided by LLVM, then by comparison the traditional university compiler course seems rather reductionist indeed.

wait, what am I saying. The whole point of LLVM is that you get this (optimization) pretty easily too.

https://www.theatlantic.com/education/archive/2018/11/anxiety-depression-mental-health-graduate-school/576769/

In other news, earlier today the Australian government decided that nobody should buy Atlassian products anymore.

Now, keep in mind that Atlassian is an Australian company that sells closed-source software development tools. Almost every software company in the world uses something from Atlassian, even just JIRA Helpdesk running locally.

The question you need to start asking today isn’t whether the Australian government has ordered Atlassian to add backdoors into their products. Atlassian is the most successful Australian software company and a major cloud service provider. That order has been signed and the government goon is sitting in their lobby right now, waiting for the senate to pass the bill. So that isn’t the question. The question you need to ask is how long it will take China or another IP disrespecting state actor to hack the backdoor.

Why are politicians so irreparably stupid when it comes to software?

Is that a rhetorical question?


Politicians, like the wealthy, are superficial and atavistic. They're dealing with software the same way they've dealt with all new things: how do we own it, how do we use it to enrich and empower ourselves. They've never needed to understand anything before, and they can't be convinced that this time is different.

Businesses are ****ing terrible at software, and they make the ****.

https://www.faception.com/

Using machine learning to bring phrenology to the 21st century!

Probably In-Q-Tel

I'm a Low-IQ Introvert, but I'd still like to think of myself as a Threats.

Gawd, it gets better. I can find out whether any of my employees are High-IQ Professional Poker Player Terrorists.

Apparently it’s a private company headquartered in Tel Aviv. Which is collecting photographs of people. And classifying them as threats.

Arab-looking + angry = terrorist

If you have nothing to be angry about, you have nothing to fear.

always angry

This is absolutely true, since it's simply the contrapositive of the Yoda Lemma.

Libertarian techbro hand-wringing about patent trolls makes me positively turgid.

What was that? Oh, a non-practicing entity? Someone who makes money from something just because they own it, even though they did nothing to create that property and don’t do any of the real work to use that property? And you have a problem with that? Huh weird