HNHacker News
TopNewBestAskShowJobs

twotwotwo

1,841 karma · joined June 24, 2012

submissionscomments
twotwotwo··on Brain-Computer Interface Smashes Previous Record for Typing Speed
A neat thing is this uses a language model reduce the error rate a lot. Autocorrect, conceptually, though theirs is offline rather than as-you-input. In a way the clever software involved is maybe the thing that most makes it relevant to this site.

Other tricks we use for noisy touchscreen input could apply here too. For one thing, we've got different models for to collect input. You could try offering autocompletions/predictions to make typing long words faster (long a thing in e.g. single-switch input tools), if watching a screen doesn't slow the person down much. You could try a swipe-like flow where you collect a chunk of data imprecisely but fast (mentally type or scribble a whole word, say), then offer choices.

(Thinking about other extremes, I wonder if there's a way at faster input using a T9-like reduced alphabet (3x3 grid, pick row and column?) or something like that. Or if it could someday work to for people to try to speak or visualize words instead of handwrite.)

You might be able to glue the letter decoding and language model together more closely--feed the letter-decoding NN's uncertainty and less-probable guesses (25% chance this 'e' was really an 'l') to the lang model.

You could learn a person-specific language model, seeding it with a person's writings/speech before the injury or disease (if available), whatever else you think they might need (family/friend names, care requests, etc.), and training the language model as they use the interface (paper already does that with the character-recognizing model).

You could do explicit "mutual training"--while the machine samples how you write letters, it can show you its certainty scores (based on the model it has so far) or maybe something graphical to help you write the letters how it expects (exaggerate certain differences etc.). They already have an "optimized alphabet" that maximizes the machine-visible differences between letters.

From their paper, the existing language model already did very well at producing clean results in this test, but the more you can refine the cleanup, the more you can potentially sacrifice cleanliness of input for greater speed, and maybe get closer to speaking rate.

FWIW some Googling found http://web.stanford.edu/~shenoy/GroupPublications/WillettEtA...

twotwotwo··on Downloading files from S3 with multithreading and Boto3
(Er, some files >100MB not >100KB. If they maxed out around 100KB we probably wouldn't have picked S3 to store them!)
twotwotwo··on Downloading files from S3 with multithreading and Boto3
When you have a lot of small files, the latency on each operation, though not huge in absolute terms, can end up taking up more time than the data transfer and whatever other work is being done on the content.

(At work, we had an upload job with ~800k files, ranging from <1kb to >100kb. I looked at rearranging how we stored things to avoid small files, but it ended up a straighter shot to continue to use little files but use a worker pool to make the transfer parallel.)

twotwotwo··on The Western Digital WD Black SN850 Review: A Fast PCIe 4.0 SSD
And Micron knows more than anyone but Intel about it--capital costs, yields, directions for improvement, etc. Owning the sole fab for fast NVRAM and trying to get out suggests things aren't great.

I think the slot for a new NVRAM has gotten harder to fill. You almost have to sell it on read latency alone, because throughput (GB/s, parallel IOPS) is already high and scales with RAID, and most folks are either OK with Flash write latency or OK hiding it with (possibly powerloss-protected) DRAM buffers.

In a way maybe the easiest pitch is "instead of doubling your RAM, add 3x as much of this stuff," because relatively small caches can show real gains, so there isn't so much pressure on cost/GB. But it still has to be way cheaper than RAM and more performant than 'just' a great SSD.

And if the pitch is "replace your whole Flash array with this," beefy boxes tend to have TBs of Flash and most customers will only pay so much for improved latency, which puts a cap on the cost/GB of a commercially viable alternative SSD. Even the fastest Flash SSDs don't seem that popular!

A breakthrough could always happen, but I wonder if short-term we're looking more at progress through tweaks to the existing technologies rather than a leap to anything vastly different. If so that's largely because the current tech is pretty good, which is not the worst problem to have.

twotwotwo··on Build your own “data lake” for reporting purposes
Appreciate the info on real-world use here. A data warehouse would be sort of interesting at work but is not urgently needed (because reporting from MySQL works, without the nifty speedups data warehouses can achieve), and we're somewhere between the size you're talking about and the really-big-data use cases I tend to see blogged about more often. Am curious about ClickHouse and a lower-cost deployment might make it worthwhile when it wouldn't be otherwise.
twotwotwo··on Minimally Invasive (and More Accurate) Analytics: GoAccess and Athena/SQL
Yep! I had a situation where I wanted more than one file per bucket (for the sake of other code that uses the same data), and needed the improved bucketing for that.
twotwotwo··on Minimally Invasive (and More Accurate) Analytics: GoAccess and Athena/SQL
Yeah, when I was looking into this stuff it was sad to see the blog post about why Trino had to switch names. Unsurprisingly given the history, the Trino blog was the only place I could find written-up details about things like how to name files so they work with the new version of bucketing. The new features look really neat and hope the project has (continues to have) success!
twotwotwo··on Minimally Invasive (and More Accurate) Analytics: GoAccess and Athena/SQL
I want to second that plug for Athena for ad-hoc analysis. (If you're hosting your own stuff and at the scale where it'd be useful, there's Presto/Hive, which Athena is based on, and/or at Trino, the Presto fork maintained by some of its initial developers.)

It was useful for me when tweaking spam/bot detection rules a while ago; if I could roughly describe a rule in a query, I could back-test it on old traffic and follow up on questionable-looking results (e.g. what other requests did this IP make around the time of the suspicious ones?). We also used Athena on a project looking into performance, and on network flow logs. The lack of recurring charges for an always-on cluster makes it great for occasional use like that.

You can use what the docs call "partition projection" to efficiently limit the date range of logs to look at (https://docs.aws.amazon.com/athena/latest/ug/partition-proje...), so it was free-ish to experiment with a query on the last couple days of data before looking further back.

More generally, Athena/Presto/Hive support various data sources and formats (including applying regexps to text). Compressed plain-text formats like ALB logs can already be surprisingly cheap to store/scan. If you're producing/exporting data, it's worth looking into how these tools "like" to receive it--you may be able to use a more compact columnar format (Parquet or ORC) or take advantage of partitioning/bucketing (https://docs.aws.amazon.com/athena/latest/ug/partitions.html, https://trino.io/blog/2019/05/29/improved-hive-bucketing.htm...) for more efficient querying later.

As the blog post notes, usability was...imperfect, especially during initial setup. Error messages sometimes point at one of the first few tokens of the SQL, nowhere near the mistake, and there are lots of knobs to tweak, some controlled by 'magical.dotted.names.in.strings'. CLIs were sometimes easier than the GUI. But you can get a lot out of it once you've got it working!

twotwotwo··on How fast does interpolation search converge?
In college I played with a variation of this where you fix the size of the collection to a power of 2 (sprinkling in zeroes/repeated values if needed): you make your initial guess for where to look is just by taking the top bits of the searched-for value, then estimate the number of slots off you were from the top bits of the _difference_ between the value you found and the one you want (clamping your next guess to the first/last item if you'd fall off the end otherwise). In the concrete example I was playing with, it worked to just stop there then do linear search, but you could be cleverer about how long to iterate and when/how to bail out to something with a better worst case.

As Lemire says the problem (a good "problem"!) is that hashtables and B-trees can be quite fast, robust against different distributions, and you have them right at hand. It'd almost have to be some weird situation like you're handed data in a format that kinda fits the requirements and you're looking for how to work with it in-place.

twotwotwo··on Ask HN: How PostgreSQL source code is 3x shorter than MySQL's one?
So I cloned the mysql-server and postgres repos and ran sloccount. It's not the deepest dive or anything but was interesting.

I saw MySQL had...600k lines of JavaScript?

It turned out that the storage/ndb directory had a Web-based management interface for NDB, which vendors in the Dojo JavaScript framework. It also had ~50k lines of Java for the "ClusterJ" framework, which interfaces with NDB skipping the SQL layer. Overall, sloccount reports about 1.4M lines of code in storage/ndb/.

NDB is a specialized cluster database where all secondary indexes have to fit in the cluster's RAM(!). Work on it started at Ericsson, then it was spun out into a startup which MySQL AB eventually bought. I imagine MySQL management at the time hoped the future of DB clusters might end up looking more like NDB and less like...gestures at today's database landscape.

There are also ~500K lines of Unicode tables in the strings/ directory. I recall Postgres calls out to libc for locale/collation related stuff so probably doesn't need those tables in-tree.

Even accounting for those chunks you still end up with ~1M vs ~2M SLOC as measured by sloccount. (I don't want to pretend the numbers are super precise.) There are probably other differences in what's in scope for the repo or other surprises. [Edit: see johannes1234321's comment which lists some of them.]

Besides those, though, might be truth to others' comments about MySQL spending lots of code supporting drastically different old and new "worlds" in a single binary (non-transactional and transactional storage, originally very-nonstandard vs. currently more-standard SQL, statement-based and row-based replication...). And at a totally non-technical level, as a product MySQL seems to have had more money thrown at it and that tends to mean more code.

This was fun but was an incredibly quick and dirty dive into it, and I'd love to hear more from folks who can look more or just know more.

twotwotwo··on Latency Numbers Every Programmer Should Know (2012)
In "The Datacenter as a Computer" there was an interesting diagram sketching a datacenter memory hierarchy latency and capacity and bandwidth to access RAM, SSD, and HDD in the same machine, the same rack, and a larger cluster. It's page 72 of https://www.morganclaypool.com/doi/pdf/10.2200/S00874ED3V01Y... and with luck https://books.google.com/books?id=Td51DwAAQBAJ&pg=PA72 will get you to the page. The numbers have changed (commodity SSDs have markedly improved!) but the idea still makes sense.

Fun to consider that boxes under one top-of-rack switch can hold dozens of TB of RAM and hundreds of TB of Flash with latency measured in µs between them. There's legitimately interesting space in between writing code for a single machine and code for huge, spread-out clusters of thousands of boxes.

twotwotwo··on On modern hardware the min-max heap beats a binary heap
This made me search around about unsorted B-tree-like collections. Turns out Clojure[1] and the im immutable-collections crates in Rust[2] use a structure called an RRB-tree, and searching 'blist' (because why not) turned up a Python module[3]. So, yes, a thing!

Tricky bit is trying to work well when used like a plain vector too. Clojure's RRB-tree special-cased repeated small appends to the end to help with this, and the Rust page mentions a clever chunking technique for append/prepend. And I imagine largeish leaf pages might help with average prepend/append/iteration overhead, at some cost when inserting in the middle?

Anyway, just neat that it's been taken further than I realized!

[1] https://infoscience.epfl.ch/record/213452/files/rrbvector.pd...

[2] https://docs.rs/im/15.0.0/im/struct.Vector.html

[3] https://pypi.org/project/blist/

twotwotwo··on On modern hardware the min-max heap beats a binary heap
Yeah--JS seems to allow enough weird stuff with arrays that fast paths for when things aren't weird seem inevitable. I admit when I clicked I still found V8 had more implementations than I expected, haha.

What they do with strings is kind of neat, because if you do a lot of concats in a row (potentially an O(n^2) series of operations done the naïve way), they defer actually concatenating all the data until you try to get a character out or such (the string is just a "ConsString" pointing to the source strings): https://gist.github.com/mraleph/3397008

It's also impressive how much dynamic instrumentation they can do. Beyond finding hot code and guessing types, they're even e.g. using it to guess which garbage will be long-lived (for "pretenuring" to avoid needing to copy it).

There's a limit to how much clever stuff you can do implicitly since you don't want to impose big costs for code that's doing everything right; something like QList isn't that adventurous but it's also clearly wrong when you want to compactly store a bunch of small structs in memory. And like the linked post on V8's thing notes, when you patch over a problem in one specific case the 'fix' can be fragile. Still, interesting area.

twotwotwo··on On modern hardware the min-max heap beats a binary heap
So, kind of a non sequitur, but I occasionally think about Qt's QList<T>. When introduced, it was odd for reserving space at the beginning as well as the end, so you had constant-time inserts/removals at the beginning. That and storing pointers for any T larger than a pointer also reduced the constant factor on insertion/deletions from the middle. Since it was always stored as a list of pointer-sized items, some code could be shared between implementations for different types, so your program's binary could be a bit smaller. I think they said at the initial release that they benchmarked a bunch of options in some real code and this won.

That was waaay at odds with the mindset of the STL, which seemed to me and I think a lot of folks like the state-of-the-art of containers at the time: with the STL if you prepend/insert much you need to use a deque/linked list, you decide pointer vs. value each time you declare a type, and if you want to know about the constant factor on an insert in the middle of the list you probably already lost.

(Qt has/had some other fun pragmatic things, like copy-on-write types in a lot of places. I didn't really do nearly enough with it to discover the pitfalls, but was fun to read.)

So I think about that, about how there are likely some trees out there that could just as well be sorted arrays, about adaptive structures that change their behavior based on dynamically observing how they're used (one recently discussed here: http://blog.erlang.org/the-new-scalable-ets-ordered_set/), even about tricks in in JS string implementations and VMs. I don't have answers, but I sometimes wonder if we should be thinking more in terms of tools that may not be perfect on all axes but soften or eliminate performance cliffs we take for granted. Not that the zero-overhead fine-tuned types are going away, just that they aren't the only imaginable approach.

I wonder if we'll see progress in those sort of imperfect-but-resilient tools over time. I think the long-run trend is towards some form of programming being accessible to more people more easily (like how, as you note, folks do real work in Python now). That certainly fits with trying to make your tools resilient to "misuse"--or, better, properly supporting more patterns so they're not even misuse. No conclusions, just hand-waving, but I do wonder if anyone working in software construction tools will eventually more usefully wave their hands in that direction :P

twotwotwo··on On modern hardware the min-max heap beats a binary heap
Like folks mentioned there, I wonder if a higher-fanout heap (people asked about 4-ary) might also do well in practice. Looking at Wikipedia (https://en.wikipedia.org/wiki/D-ary_heap), it looks like maybe so -- the growth in number of comparisons isn't that bad, and it mentions 4-ary heaps working well specifically.

(Like how linear search wins for small N, or insertion sort helps with small subarrays in introsort: more steps, but each step is also a lot cheaper on modern hardware due to fewer branch mispredictions, better cache locality, or something else that better fits the hardware's strengths.)

twotwotwo··on Is WebP really better than JPEG?
JPEG XL is worth mentioning here. It includes a JPEG1 repacker (Brunsli) that saves about 20% and allows recovering the original file exactly. All that existing JPEG1 content isn't going anywhere, so that seems good. It has some other neat features like the ability to mix a DCT-based codec with lossless (modular) mode in an image. Its lossless/modular mode (successor to FLIF/FUIF) is interesting on its own.

It can be illuminating to stretch codecs a bit past the visually-indistinguishable threshold, both to better nail down where that threshold is and to see how annoying the artifacts you end up with are. Lots of comparisons you can do; this is a fun one: https://encode.su/threads/3108-Google-s-compression-proje%D1...

At very few bits-per-pixel like the first (bridge) image, everything has some artifacts. On that image AVIF tends to just blur lower contrast areas, whereas HEIC produces some visible ringing (faint lines that weren't there before) around the bridge. Unlike JXL, AVIF and HEIC both have spatial prediction (extend pixels above/to the left of this block in whatever direction), which is particularly helpful with straight sharp lines like the bridge image happens to have. I wouldn't put too much stock in results on that one image, but I do like being able to judge results subjectively.

(FWIW, a presentation on JPEG XL suggested they were targeting the equivalent of ~2bpp JPEG quality[0], so perhaps performance in this super-low range wasn't as much of a priority.)

Anyway, I hope both these formats get wide support, because they each have clear benefits in some application: JXL's include the upgrade path for JPEG1 content and the multiple modes, and AVIF may be able to salvage a bit more quality at super low bitrates. AV1 (on which AVIF is based) has wide industry backing, and the JPEG XL effort is also going for a royalty-free codec and has support from Google, so hopeful they actually will be usable relatively soon.

(Although HEIC's images are OK and it has Apple's support already, it's patent-encumbered, limiting what you or I can do with it.)

[0]: https://www.spiedigitallibrary.org/conference-proceedings-of...

twotwotwo··on Tuxedo Book BA15: AMD-only and Linux-preinstalled laptop
FWIW, early signs are Linux worked well on at least one 4700U thin-and-light (after upgrading the kernel for support for the iGPU): https://www.phoronix.com/scan.php?page=article&item=ryzen7-4...

One 4700H(S) machine with a dGPU (and other parts without drivers) did not do so well: https://arstechnica.com/gadgets/2020/04/linux-on-laptops-asu...

Some of the 4700U laptops perform better than you'd think from the nominal 15W TDP. Partly just to be expected from the spec (still >4GHz single-core boost and 8C), and also seems most of these run at a 25W TDP-up when plugged in (often noisily so, under load).

Would be nice to see these put into better designs; right now I'm mostly seeing 14-inch 1080p machines. Previous gens of AMD chips had the same issue, but it's especially annoying when, in terms of performance, battery life, and weight, you can see the elements for a great laptop are there.

twotwotwo··on What developers should know about TCP
Yeah. Fun problem for beginners, because 1) your incorrect code may work for a while when reads/writes are small or it's only run on a local network or such, 2) you might design a broken protocol if you don't understand fragmentation, etc., which will tend to be harder than (say) an isolated client bug to fix, 3) the implementation-dependent nature of fragmentation can make it look like you hit a language/library/OS issue, 4) your language/library may or may not offer tools to help a beginner to implement a delimited or framed wire format properly (ideally with things like record-size limits and timeouts).

Not sure it says anything you haven't, but a StackOverflow answer on fragmentation (framed by asker as Go not behaving like C) is one of the more-read ones I've written: https://stackoverflow.com/questions/26999615/go-tcp-read-is-...

twotwotwo··on New Grad vs. Senior Dev
Go's strings.Index/bytes.Index also often use the "find first byte" approach; now on amd64 it's a fancy vector instruction. If it finds the first byte too many times without a full match, it falls back to a Rabin-Karp match using a rolling multiplicative hash.

The strings.Index code is at https://golang.org/src/strings/strings.go?s=25956:25988#L101... and the internal bytealg package with all the CPU intrinsics is at https://golang.org/src/internal/bytealg/ with index_amd64.{go,s} as the relevant files for x64.

Battle-tested implementations of fundamental things like string searches, sorts, hashtables, allocators, graphics primitives, etc. are often interesting 'cause you find out a lot about what you need (and/or don't need) to work well in practice as well as protect from exploding worst-case scenarios.

twotwotwo··on Brunsli: Practical JPEG repacker (now part of JPEG XL)
Thanks. If there are places the public can follow progress post-CD, I'm curious. (I see https://gitlab.com/wg1/jpeg-xl/ was updated late Feb, yay.)
twotwotwo··on Brunsli: Practical JPEG repacker (now part of JPEG XL)
Thanks, I appreciate the corrections and detail.

I was mostly going by the committee draft on the arXiv (https://arxiv.org/abs/1908.03565 ), which still mentioned the quantization constraint (J.3) and a "mathematically lossless" mode (annex O) distinct from modular. "Four formats" was just imprecise wording on my part.

The material already public about JPEG XL's design rationale, testing, and so on has been really fun to follow as an outsider. I selfishly hope there's more of it as the work on it and rollout continue. Even with the standard itself public, a lot can be mysterious to those not immersed in this stuff.

twotwotwo··on Brunsli: Practical JPEG repacker (now part of JPEG XL)
This could be what provides the 'activation energy' to get large Web sites working with JXL; it avoids the situation where you don't want to touch a new standard until everyone else switches too. If Google ships a decoder in Chromium, I would give JXL decent odds of getting a lasting niche.

Also, 20% off JPEG1 sizes is better than it may sound; you only save about 30% more by switching to any of the new codecs (JXL's VarDCT or the video-codec-based ones) that apply a ton of new tools. Given JPEG1 was published 1992, that just confirms to me Tim Terriberry's quip that it was "alien technology from the future."

Working against JPEG XL: it's four modern image formats in one (VarDCT, Brunsli, FUIF, and a separate lossless codec) so a ton of work to independently implement. Also, video codecs already have ecosystem support, and have or will probably get hardware support first.

Further out: "JPEG restoration" is something I mostly see experimental work about but could also take the old format a bit further. The idea is to use priors about what real images should look like to make an educated guess at the information that was quantized away, so you get less of the characteristic blocking and ringing from overcompresed images.

(For example, look at Knusperli, JXL's "edge-preserving filter", or AV1's CDEF. The "quantization constraint" supported by the first two of those is, to me, what makes it "restoration" and not just another loop filter: it can always return pixels that could have compressed to the exact DCT coefficients in the file.)

twotwotwo··on Age, Sex, Existing Conditions of Covid-19 Cases and Deaths
With many viral respiratory bugs, symptoms appear a few days after infection, peak a few days after that, and then there's a long tail of sniffling and coughing. Deaths happening in the peak and recovery being declared nearer the end of the tail leads to the intuition that maybe deaths could cluster earlier than recoveries. Of course, I don't know how/when recoveries are being tallied right now and don't want to guess.

Bigger picture: lots of factors go into a good estimate, and epidemiologists are not new to mathematical modeling. When back-of-the-envelope math doesn't get the same prediction as the consensus models of what's going on, we shouldn't assume the epidemiologists are wrong.

twotwotwo··on Servers for an Accelerated Future
It's binned. Everything public indicates they do not manufacture a 6-core chiplet and are turning stuff off on 8-core ones.

Curiously, TSMC seemingly published their N7 defect densities and they're low enough that most chiplets would not have outright dead cores. Specifically, they said 0.09 defects per square cm in a slide you can see at https://fuse.wikichip.org/news/2879/tsmc-5-nanometer-update/ . If that's saying what it appears to, lower SKUs must use a lot of chiplets where all the cores turn on, but (say) might not hit the top chip's performance spec within its TDP.

The 7742 needs all cores to run at 2.5GHz averaging ~3.2W apiece if you leave 25W of the 225W for the I/O die. The 7642 is looser: 2.3GHz averaging ~4.1W apiece, and that after dropping the "worst" core from any CCX where they all work. (For non-obsessives, a CCX is a four-core group connected to a 16MB chunk of L3 cache.)

Note lower SKUs like the 3700X/3800X and 7232P use 8-core chiplets. You can figure the chiplet count for an SKU by dividing its L3 capacity by 32MB, and from there you can figure how many cores each chiplet has enabled.

There's also plain market segmentation, i.e. enabling/disabling stuff on identical chips to sell at different prices. In this gen I doubt it's good strategy for AMD to hold back much performance like that, though, since they really want to get some market share right now.

(If turned-off cores generally work but below spec, that suggests there could be some way to make them useful for extremely-threaded workloads. Split hardware threads onto two lower-clocked physical cores when it looks like a net win, say. Can see enough potential thorns not to bother trying, but thinking of possibly-useful silicon sitting there turned off makes it just so tempting, heh.)

twotwotwo··on FLIF – Free Lossless Image Format
The fancy new lossy mode has some incremental loading too; could be interesting for both.
twotwotwo··on FLIF – Free Lossless Image Format
JXL is an interesting standard. Integrates a recompressor that shaves ~20% off .jpgs without further loss(!), FUIF for essentially-lossless images in a progressive/interlaced mode like this, a separate lossless format, and a new lossy format with variable-sized DCTs and a bunch of other new tools (other transforms for DCT-unfriendly content, postfilter for DCT artifacts, new colorspace, chroma-from-luma...). It's intended to be royalty-free.

I'm not sure if putting it all under one standard will make it hard to adopt, and/or if AVIF (based on AV1) will just become the new open advanced image format first. Interesting to see in any case.

Brief presentation: https://www.itu.int/en/ITU-T/Workshops-and-Seminars/20191008...

Longer presentation with more of the rationales for choices: https://www.spiedigitallibrary.org/conference-proceedings-of...

Draft standard: https://www.researchgate.net/publication/335134903_Committee...

Play in your browser: http://libwebpjs.appspot.com/jpegxl/

twotwotwo··on TypeScript’s quirks: How inconsistencies make the language more complex
These can make sense if you think of TS as better-checked JavaScript, not as a from-scratch design for a statically typed language. Excess property checks catch a common JavaScript bug (typoed property names), structural static typing matches the dynamic duck typing JavaScript authors had already been working with (though I see how nominal would be useful), and it's awesome they found a workable hack for discriminated unions where the code and objects look like what you'd do in vanilla JS, but checked (and requiring the class to have a specific structure seems fine as limitations go).

I get how folks coming from "natively" static type systems could find all this weird, but I think by targeting "JS but with better checks" instead of a more fundamental redesign, the TypeScript crew have managed to build something that can get traction where other efforts have not.

twotwotwo··on TypeScript’s quirks: How inconsistencies make the language more complex
> Most other languages I know of only have a single type for a variable (and if you want to pattern match you must give each case a new variable name).

FWIW, Go also changes the variable's type in type-switch cases: https://tour.golang.org/methods/16

twotwotwo··on Trying out the Pinebook Pro – a $200 ARM Laptop
I have an old RK3399-based Chromebook. I now end up using its Intel "Core m"-based counterpart (originally bought for my partner) more, but the ARM machine was/is 100% fine as a fancy terminal for my backend Web dev work. I had no trouble messing with Go on an even earlier ARM (Tegra K1) Chromebook.

The Surface Pro X did not take off, but I suspect that's a combination of ARM not being competitive at the high end and needing a friendlier ecosystem. ARM might do a bit better once larger core designs and denser process nodes (RK3399 is 28nm!) filter down to lower-priced devices and there's great software to run, like a refined Windows/ARM or Chrome OS w/Android or something else.

(I've been hoping for ARM to make inroads into Serious Computers for some time, so who knows, but it does seem successful in lower-end Chromebooks, and Amazon and MS are publicly experimenting with it, so...)

twotwotwo··on Using neural networks to solve advanced mathematics equations
The potentially interesting thing here, to me, is using networks to short-circuit searches that could grow explosively with expression size, but then filter down to answers that can be shown correct. That's also a way to get some value out of a system that doesn't always produce the correct answer as its first guess.

In some cases it may be easy to prove the correctness once you have the proposed answer, but in others the network might need to produce intermediate steps or some kind of 'argument' to let the CAS check correctness in reasonable time. Perhaps do that by instrumenting a CAS to output intermediate steps and train the network on that, not just problem/answer pairs.

Broadly, humans who have seen a lot of problems solved can say "this looks like a situation where you could try X" and do X without going down all the blind alleys that a CAS might. So it doesn't seem implausible that automated learned models might also outperform the heuristics CASes have hard-coded in for making those kinds of guesses.

(You can imagine closer coupling, e.g. a CAS that calls out to an NN to propose solutions to certain hard-to-solve-but-easy-to-check subproblems, or uses learned models to try to guess the right branch to go down in a solution process that already looks like searching a tree of possibilities. But the more you have to crack open the CAS, the less appealing the whole thing becomes.)

← PreviousPage 6 of 19Next →