brandmeyer

I'm a fan of the C++ method.

    R"SQL(my string without the sequence S Q L goes here)SQL"

You can use any extra delimiter you want. The concatenation rules make it easy for you to easily insert source code line breaks and indentation without literal string breaks or indentation.

> WAL2 + BEGIN CONCURRENT

Woah. There are some gotchas. It still won't support as much concurrency as row-level MVCC. But it'll still be a big improvement.

https://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md

https://www.sqlite.org/src/doc/begin-concurrent/doc/begin_co...

I agree with you. TR36 is outright terrifying. I might feel more comfortable if the recommendations were already baked into foundational libraries like libicu, but they aren't. Its as if I'm wading into a world with as many footguns and silent killers as C's undefined behavior rules. In C we've spent decades developing tools to help detect and mitigate the problems and they are still regularly exploited. Unicode only has widely-available mitigation tools for a handful of the easiest problems to solve.

C's flaws lead to the development of several different competing programming languages. Various flaws in cryptography lead to the development of algorithms that achieve the same result, but have far fewer implementation gotchas. IMO, the time has come for the development of a truly strict variant of Unicode that still supports the primary objective, but learns from Unicode's mistakes.

> 2^3.3 is approx 10. What alphabet only has 10 characters?

My claim is that the 7-segment display is only usable for its original design scope: the numerals 0-9.

Its the same with SpaceX. Musk wants to build a Libertarian utopia on Mars under his personal control in his own lifetime.

I love it all. Cortex-M0, M3, M4, M7, and A7 all together span several full orders of magnitude in performance. Every one of them has their niche. Unfortunately for ARM, all of those designs are many years old and they are still nearly optimal in their niches. ARMv8-M parts are starting to show up, but they aren't exactly revolutionary compared to their predecessors.

Latin didn't even evolve lowercase letterforms until the 9th century AD. "J" didn't evolve as its own letter until sometime in the 16th century AD. Early Roman had only 19 or 20 distinct (strictly uppercase) letters depending on exactly which scholar and century you're looking at.

IMO, the various letterforms in use by all of the alphabetic languages have more to do with the available writing technology of their day, and in keeping the letterforms sufficiently distinctive to quickly recognize whole words. Compare Etruscan engravings to early Roman engravings to German blackletter to Spencerian cursive to Zaner-Bloser cursive for example.

Hangul has a similar diversity in stroke shapes to Latin characters, but much more diversity in stroke position. I pity the poor engineer who might have been tasked with constructing an N-segment display for Hangul in the days before dot-matrix technology was feasible.

Finally, the 7-segment display doesn't actually look particularly recognizable when being used to render latin text. It only really works for the European evolutionary branch of Arabic/Hindu numerals. Even with only 26 (modern! English!) letters, we still have enough stroke diversity that we'd prefer to render text with more complexity. 2^7 segment combinations for only 2^3.3 characters doesn't sound so optimal any more, does it?

But if you want to stick with your information-theoretic observation, I'll point out the completely unrelated fact that some of the early and successful forward error correction schemes for Gaussian channels use rate 1/2 coding. Anything optimized for burst errors is quite different, though.

Its also important to note that Rust changed radically in its early life. Here's one of its core authors describing some of the changes they went through (in part) as a result of dogfooding the language in its own compiler, in the context of BitC's failures:

https://news.ycombinator.com/item?id=3750882

The language it had evolved into by 2012 is also radically different from the language it became by 1.0 in 2015.

Relevant to interpreting M1 and its sudden jump in 2020:

https://fredblog.stlouisfed.org/2021/05/savings-are-now-more...

Its the list of non-goals that just so happen to be features that I rely on for my livelihood that drive my reaction.

The "Goals and Priorities for C++" document P2137 felt like an open declaration of war by GOOG and NVDA.

<salesman voice>Black's strictness getting you down? Try autopep8: The flexible Python formatter!</>

Its fast enough, can be made to run incrementally, has enough configuration options, and accepts a project-specific configuration file. There is room for a solution in-between laissez-faire and black's strictness.

The BLAS have historically relied on a wide range of microarchitecture-specific optimizations to get the most out of each processor generation. An ideal solution would be for the browser to provide that to the application in such a way that it is difficult to fingerprint.

See also the history of Atlas, GotoBLAS, Intel MKL, etc.

In the presence of types which are truthy (ie, contextually convertible to bool), its too easy to accidentally swap the unpacking:

    // Oops, backwards!
    auto [result, error_code] = do_something();
    if(error_code) {
      process(result);
    }

This is a widely-held belief, but it isn't true. Maybe once upon a time in the land of spinning rust that was true, but it certainly isn't now. Databases are fast enough that a scripting language frequently is the performance bottleneck.

https://techspot.zzzeek.org/2015/02/15/asynchronous-python-a...

The receiving process gets a copy of the file descriptor. Both processes must close(2) it.

If process A opens a file and passes a file descriptor to process B, then process B's descriptor will continue to refer to the same object regardless of what process A does.

Process A can unlink the descriptor, swap the directory entry out for some other object or whatever, and Process B will still have a handle to the same initial object.

Nothing stops A from mutating the filesystem object in other ways. For example, A's write to the middle of the file or truncation of the file will be visible to B. But merely unlinking the file doesn't alter B's view of the object.

There's no point in aiding someone whose interest lies in flinging monkey poo instead of actually having a good-faith debate.

Is there a way to get this behavior with the implicit index on the primary key?

My own recommendation is NIST Technical Note 1385 "Global Positioning System Receivers and Relativity" by Ashby and Weiss[0], and the GPS ICD for the L1 and L2C signals IS-GPS-200[1].

They are aimed at the practitioner who actually needs to solve problems. TFA is entertaining and pretty, but insufficient to actually get work done.

[0] https://tf.nist.gov/general/pdf/1274.pdf

[1] https://www.gps.gov/technical/icwg/IS-GPS-200K.pdf

Oof, you're right. I was thinking of Raku.

Even better, use a receiver in low-earth orbit. See also: COSMIC, GeoOptics, Spire, and PlanetiQ.

The natural expression of the DOP matrix is 4x4, since the receiver is computing a solution in 4D space-time. Its pretty common for the dominant eigenvector to be along the time-vertical axis for a terrestrial receiver.

Perl uses ~ for string concatenation.

Nothing says that you cannot use both infix "++" for concatenation and unary ++ for increment. "-" is both a unary prefix and binary infix operator, for example.

The intermediate solution is a programming language and/or runtime specifically designed as an extension system. I've had positive experiences embedding Lua. GNU Guile was specifically designed for this too, if you think your users can deal with the parens.

A POSIX filename is a sequence of up to 255 bytes excluding NULL and /

A reasonable person[1] might argue that this is too liberal. IMO the exclusion list should be larger, but silently and automatically rewriting an application's filename into something else at creation time is too far.

[1]: https://dwheeler.com/essays/fixing-unix-linux-filenames.html

Apple filesystems are infamous for breaking this convention. IIUC, they will support codepoints which expand to 4 bytes in UTF-8, but their implicit normalization rules can trip up programs which expect behavior closer to POSIX norms.

The manifesto for the one union which attempted (is attempting?) to organize at GOOG is explicitly trying to reducing what they perceive to be evil, and aren't trying to increase comp.

That's part of why the capture list is explicit in C++. Automatic by-reference captures should only be used for lambdas whose scope is strictly lexical (ie, passed down the call stack, aka "downward funargs"). Otherwise stick with by-value captures.

> the Wachowskis were told the reboot would be going ahead with or without them.

The writers made this part of the plot of the repeating inner world. Between that moment and the painful scenes of the game designers' cyclic rounds of buzzword bingo, I agree that the movie was at least trolling the WB executives.