I feel like SAT solvers and the like are getting a lot more attention on HN recently (for example https://news.ycombinator.com/item?id=44259476) - justifiably so! I think that they're a great tool that's often criminally underused in industry for a whole subset of problems.
In my experience, 95% of the times I'm considering applying SAT/SMT to a problem, I should actually think about it for another day (perhaps while throwing a SAT solver at it, if that seems fun) and will invariably find that the problem I'm trying to solve is actually something else... In the remaining 5% of problems, there's usually a solution you can download (which maybe uses SMT under the hood).
Sure enough, SMT is really cool and extremely powerful where it's applicable.
You are not wrong. But I can wear both hats (no pun intended, I think).
On one hand people are not going to be using SAT/SMT to solve problems on a dayly basis.
On the other hand these algorithms are a bit overlooked in CS books (not Knuth, of course). Compare, for instance with a FFT. In the livetime of an average programmer they might actually find it convenient to use SAT solvers here and there on a few occasions. Maybe just as much as a FFT.
Combinatorics is a hard subject and SAT shed light in many situations where better tailored algorithms might exist but might be difficult to come up with.
It's occasionally helped me with the NP-hard problem of "finding a regular language consistent with a set of samples that also satisfies some structural constraints". But more often, the minimal DFA (when it exists) has a few dozen too many states, and the solver gets trapped in the exponential pit of despair, which hasn't really endeared me to the approach. I've yet to actually run into a class of problems where things like SAT or ILP are wildly successful while all other approaches fail.
> the requirements for advanced math classes for every computer science major seem unnecessary
Computer science is much more than programming - and I think that most of the value derived is from being able to think about problems, which largely require the abstract type of thinking encouraged by more advanced math. Code is just a tool.
This is one of those things that MIT’s missing semester course aims to help with (https://missing.csail.mit.edu/), and although computer science is different from software engineering, the reality is that most CS grads go into software engineering, and thus should try and learn these essential skills.
Computer science in the graphics space requires a ton of gnarly coding. If we consider post-doc computer science in particular, the idea you dont then need to be at least a semi-competent programmer is.. a surprising idea to have.
Which is to say, the idea CS do not need to ever code is a stretch. How does a person work on cutting edge graphics algorithms without building something with it? Without coding in a pretty serious way?
One example, at the end of my intro to programming, the final assignment was to build something, I wrote a chess program (with a GUI). While some classes are quite theoretical, I strongly disagree that a person can get through all of a CS program without their coding skills being challenged.
For a younger age group (13-15 maybe), George F. Simmons’ “Precalculus Mathematics in a Nutshell” (https://www.amazon.com/Precalculus-Mathematics-Nutshell-Geom...) is quite good though might require a bit of help to grasp. It features lots of exercises and a quite decent explanations for the age range.
> we can also add local storage of telemetry data in an efficient circular buffer. Typically, local storage is cheap and underutilized, allowing for “free” storage of a finite amount of historical data, that wraps automatically. Local storage provides the ability to “time travel” when a particular event is hit.
I think that this is a good idea when storage is concern for high-volume logs / production. Persisting the buffer when high error rates / unusual system behavior is observed would be a cool idea.
This is a good approach and is pretty common in the embedded world. You use a ring buffer to store a relatively short but detailed log, and then if you encounter an error (or whatever other relevant trigger criteria you use) you snapshot the contents of that ring buffer. Then later you can retrieve the snapshots to figure out what happened.
A good, decently detailed look at signal processing required. I also like https://ciechanow.ski/gps/, which has some fantastic visuals to go along with this explanation.
Wow that blog never ceases to amaze me. I was actually thinking about it when I read this post, that it’s exactly the type of post Bartosz could have made. And he had! Those interactive graphics are unbeatable.
