@serpent7776.bsky.social

@serpent7776.bsky.social

142 Followers 10 Following

The Syntax Sorcerer aka I like programming languages.

Screenshot of an interactive visualization for the AVX-512 KSHIFTLW instruction. The interface shows a 16-bit source mask (k2 = 0x91E3) in purple and the resulting destination mask (k1 = 0x8F18) in green after performing a left shift by an immediate value of 3. Curved arrows illustrate how each bit moves three positions toward the most significant end, with bits shifted past the 16-bit boundary discarded and zeros inserted into the least significant positions. Controls at the top allow changing the shift direction and immediate value, while the bottom summarizes the input and output mask values in hexadecimal and binary. https://serpent7776.github.io/simdvis/kshift.html#kshiftlw
Strict No LLM / No AI Policy No LLM-generated content, whether it be code or prose. No paraphrasing LLM-generated content. No LLMs for editing, including fixing spelling or grammatical errors. No LLMs for translation. English is encouraged, but not required. You are welcome to post in your native language and rely on others to have their own translation tools of choice to interpret your words. No LLMs for brainstorming and then sharing the results of that brainstorming, even if you create the prose. If you use a chatbot to give you advice on a comment on the issue tracker, that comment is unwelcome. No LLMs for finding bugs. No talking about use of chatbot/LLM services. https://ziglang.org/code-of-conduct/
Screenshot of an interactive visualization for the AVX-512 instruction VPCMPB (VPCMPEQB). The interface compares two 128-bit vectors (src1 and src2) as signed bytes using the equality predicate (EQ). Sixteen byte values for each source are displayed in labeled boxes, with matching values highlighted in the resulting mask k1. The output mask shows bits set at positions 0, 6, 8, and 14, producing the hexadecimal result 0x4141 (binary 0b0100000101000001). Configuration controls across the top specify signed comparison, equality predicate, XMM (128-bit) width, and no mask.
A subreaper fulfills the role of init(1) for its descendant processes. When a process becomes orphaned (i.e., its immediate parent termi- nates), then that process will be reparented to the nearest still liv- ing ancestor subreaper. Subsequently, calls to getppid(2) in the or- phaned process will now return the PID of the subreaper process, and when the orphan terminates, it is the subreaper process that will re- ceive a SIGCHLD signal and will be able to wait(2) on the process to discover its termination status. https://man.freebsd.org/cgi/man.cgi?query=PR_SET_CHILD_SUBREAPER&apropos=0&sektion=0&manpath=Debian+13.5.0
Diagram of a computer's CPU topology. A single machine with 23 GB of memory contains one NUMA node (23 GB), a shared 6 MB L3 cache, four 512 KB L2 caches, four 48 KB L1 data caches, and four 32 KB L1 instruction caches. Below the caches are four CPU cores (Core #0–#3). Each core has two processing units (hardware threads): Core 0 has PU #0 and #1, Core 1 has PU #2 and #3, Core 2 has PU #4 and #5, and Core 3 has PU #6 and #7.
The example demonstrates a row pattern that matches one or more consecutive new messages (X), while allowing optional read markers at the beginning or end of a match and between groups of new messages. SELECT id, marker FROM msg MATCH_RECOGNIZE ( ORDER BY id ALL ROWS PER MATCH PATTERN ( (^read)? new+ (read new+)* (read$)? ) DEFINE new AS (marker = 'X') ) T ORDER BY thread_id, id https://modern-sql.com/feature/match_recognize
Haskell should be unusually well positioned to be relevant to AI-enabled engineers and agents. Type safety can be a huge advantage for LLM-generated code if the compiler is helping the agent converge quickly. But that is not the same thing as optimizing the language for humans writing code by hand. Agents have different bottlenecks. They are cheap at generating code and expensive when blocked. They benefit from fast feedback, clear examples, low setup friction, and errors that help them repair the code quickly. https://avi.press/posts/2026-07-10-after-7-years-in-production-scarf-has-reluctantly-moved-away-from-haskell.html
# mutates $x, returns COUNT removed chomp($x) # leaves $x alone, returns the trimmed COPY my $y = $x =~ s/\n\z//r;
Screenshot of an interactive visualization for the AVX-512F VPMOVSXBD instruction in a dark-themed interface. The top section shows a 128-bit source vector containing 16 byte values (for example, 0x91, 0x32, 0x93, 0x34), with byte index [9] (0x3A) highlighted. The lower section shows the 512-bit destination vector, where each source byte has been sign-extended into a 32-bit integer. Bytes with the high bit set become values such as 0xFFFFFF91, while positive bytes become values such as 0x00000032. A connecting highlight traces the selected source byte 0x3A to destination element [9], which is 0x0000003A. A caption at the bottom explains: dst[9] = 0x0000003A ← sign-extend(src[9] = 0x3A); high 3 bytes = 0x000000 (sign bit = 0).
Presentation slide from CascadiaJS 2026 showing keynote speaker Theo Browne at a podium on the left and a large black slide on the right with the handwritten message, “You're not building big enough.”
FreeBSD’s Approach Interestingly, FreeBSD does what Linux does not: after an fsync() failure, pages remain dirty, and subsequent fsync() calls will retry the write. This behavior has existed since 1999, proving that "keeping pages dirty" is technically feasible. However, FreeBSD also compromises -- if the device disappears entirely, newer versions will eventually give up on those pages. https://medium.com/@baotiao/starting-from-postgresqls-fsync-failure-840af156585c
Screenshot of a SIMD instruction visualization for AVX-512 VBROADCASTF32X4 / VBROADCASTI32X4 operating on a 512-bit ZMM register. A 128-bit source vector (src) contains four 32-bit values: 0x00000000, 0x11111111, 0x22222222, and 0x33333333. An orange highlight and arrow indicate the selected source element. Below, a 512-bit destination vector (dst) is shown as sixteen 32-bit lanes arranged in four groups. The four source values are replicated across each 128-bit lane of the destination, demonstrating how the instruction broadcasts a 128-bit block repeatedly to fill the entire 512-bit register. A caption at the bottom explains the mapping rule: dst[4] <- src[4 mod 4 = 0] = 0x00000000.
you people are auto updating your aur apps without reviewing PKGBUILD?
Cute anime girl coder with long wavy dark purple hair featuring subtle snake-scale patterns, wearing black-rimmed glasses and a grey oversized hoodie with code prints and a serpent emblem. She's smiling confidently while typing on a laptop, surrounded by floating terminal windows displaying Haskell and C++ code. Purple neon tech aesthetic, detailed anime style
template <class T> struct optional { T t; template <class Self, class F> auto transform(this Self&& self, F&& f) -> std::invoke_result_t<F&&, std::copy_cvref_t<Self, T>>; };
Dark-themed interactive visualization page for the AVX-512 instruction VSHUFF32x4. Tabs across the top switch between VSHUFF32x4, VSHUFF64x2, VSHUFI32x4, and VSHUFI64x2. The selected tab is VSHUFF32x4, with badges indicating AVX-512F+VL and 256-bit YMM. Controls on the right show a preset dropdown set to “Identity (in order)”, vector width set to “YMM (256)”, and mask set to “none”. The main diagram is divided into three color-coded rows: blue src1, purple src2, and green dst. Each row contains eight 32-bit hexadecimal values arranged as two 128-bit lanes of four words each. Labels above the vectors mark “128b lane 0” and “128b lane 1”. src1 contains values beginning with 0xA..., while src2 contains values beginning with 0xB.... The destination vector dst shows the lower 128-bit lane copied from src1 and the upper 128-bit lane copied from src2, illustrating the identity shuffle pattern. At the bottom, two orange imm8 selector panels display how the immediate control bits map source lanes into the destination: the left selector chooses src1 bit 0, and the right selector chooses src2 bit 1. A footer note reads: “imm8 = 0x02 (bits [1:0] used)”. The visualization demonstrates how VSHUFF32x4 rearranges 128-bit lanes between two AVX vectors using an immediate control byte.
✻ Cooked for 2m 47s ❯ same issue ✻ Cooked for 1m 8s ❯ are you going to do something? ● Sorry — I misread the prior message as system noise and let it sit. Doing it now.
int const* volatile* const volatile* &x; declare x as reference to pointer to const volatile pointer to volatile pointer to const int https://cdecl.org/
git-cherry - Find commits yet to be applied to upstream SYNOPSIS git cherry [-v] [<upstream> [<head> [<limit>]]] DESCRIPTION Determine whether there are commits in <head>..<upstream> that are equivalent to those in the range <limit>..<head>. https://git-scm.com/docs/git-cherry
std::simd is the canonical instance of the pattern. We covered the technical case in std::simd Is a Solution to the Wrong Problem so we will not rehearse it here, but the structural shape is exactly what Stroustrup warned about. One researcher (Matthias Kretz at GSI Helmholtz, building the Vc library since around 2010) spent a decade shepherding P0214 through nine revisions, into the Parallelism TS 2, then into C++26 via P1928. By the time the proposal landed, the world outside the committee had built Google Highway, ISPC, EVE, xsimd, and SIMDe, and the auto-vectorizer in GCC and Clang had improved to the point that scalar loops beat std::simd on -O3 -march=native. The committee shipped a library that compiles ten times slower than equivalent scalar code, runs slower than the auto-vectorizer it was supposed to replace, cannot express ARM SVE's scalable-width vectors, and has no runtime dispatch story. No major user requested it. No production codebase is converting to it. The only group that benefits is the proposers, whose committee work now carries the prestige of "got a feature into C++26", and the field of consultants and trainers who will now teach courses on it. https://hftuniversity.com/post/the-c-standard-library-has-been-walking-itself-back-for-fifteen-years-and-the-receipts-are-public
/*/*/ #include <stdio.h> #define fn int #define println printf("Hello from C++!\n");(void) // */ */ fn main() { println!("Hello from Rust!"); }
# DApp 30-Day Activity Trend 30d Count Percent Latest Block 1 splinterlandsgame ↘-5.0% 1,863,602,521 70.82% 106,526,554 2 hive-engineinfra ↘-6.0% 363,776,034 13.82% 106,526,554 3 hivehive ↘-12.1% 183,289,151 6.97% 106,526,545 4 Other ↗+14.0% 58,575,129 2.23% 106,526,553 5 genesis-league-sportsgame ↔0.0% 40,152,691 1.53% 106,140,487
Fundamentally: programming languages have semantics; prompts don't. You can go read all 892 pages of the Java Language Specification to understand exactly what promises the Java language makes about the behavior of the code you write. Moreover, you can rely on those promises. If you find that your program doesn't work the way the JLS says it should, then there's a bug in the Java toolchain that can be fixed. LLMs make no promises. Unlike the 892 pages of assurances offered by the JLS, you know literally none of the properties of a piece of LLM-generated code without inspecting or testing it in some capacity. When the output isn't what you want, there's no bug in the tooling to fix. That's the fundamental nature of trying to produce a sophisticated artifact from an inherently vague prompt. https://isaacvando.com/nondeterminisms-not-the-problem
let s:search_hist_idx = -1 function! s:CycleSearch(direction) let l:idx = s:search_hist_idx let s:search_hist_idx += a:direction if s:search_hist_idx >= 0 let s:search_hist_idx = -1 return endif let l:pat = histget('search', s:search_hist_idx) if empty(l:pat) let s:search_hist_idx = l:idx echo a:direction < 0 ? 'No earlier search' : 'No later search' return endif let @/ = l:pat echo '/' . l:pat endfunction augroup SearchHistCycle autocmd! autocmd CmdlineLeave /,\? let s:search_hist_idx = 0 augroup END nnoremap <silent> [/ :call <SID>CycleSearch(-1)<CR> nnoremap <silent> ]/ :call <SID>CycleSearch(1)<CR>
Line plot showing all of top 50 custom json hive operations. The 3 of them that dominates all others are: ssc-mainnet-hive, pp_podcast_update, sm_sps.
toystory everywhere meme saying: AI agents AI agents everywhere
It’s worth noting that the Path/PathBuf TOCTOU class of bug is in some ways easier to avoid in C than in Rust. C code naturally reaches for an open file descriptor and the *at family of syscalls (openat, fstatat, unlinkat, mkdirat), and most creation syscalls take a mode argument directly. Rust’s high-level std::fs APIs abstract over the file descriptor and operate on &Path values, which makes the path-based, re-resolving call the path of least resistance. The handle-based APIs exist on every Unix platform; Rust just doesn’t put them front and center. ↩ https://corrode.dev/blog/bugs-rust-wont-catch/
Propagate Errors, Don’t Discard Them Closely related to the previous point, a few CVEs come from ignoring or losing error information. chmod -R and chown -R returned the exit code of the last file processed instead of the worst one. So chmod -R 600 /etc/secrets/* could fail on half the files and still exit 0. Your script thinks everything is fine. dd called Result::ok() on its set_len() call to mimic GNU’s behavior on /dev/null. The intent was reasonable, but that same code ran for regular files too, so a full disk silently produced a half-written destination. The reason was that someone wanted to throw away a Result and reached for .ok(), .unwrap_or_default(), or let _ =. https://corrode.dev/blog/bugs-rust-wont-catch/#propagate-errors-don-t-discard-them
Hive-index operations page showing 30-day trend right next to 30-day activity for top 5 operations # Operation Type 30-Day Activity Trend 30d Count Percent Latest Block 1 custom_json_operation ↘-8.0% 2,625,438,408 63.32% 105,922,886 2 vote_operation ↔+2.5% 1,108,241,991 26.73% 105,922,886 3 comment_operation ↘-32.2% 136,729,416 3.30% 105,922,884 4 claim_reward_balance_operation ↗+6.0% 93,299,687 2.25% 105,922,881 5 transfer_operation ↘-6.4% 91,436,536 2.21% 105,922,878
Firefox's "You've opened 100 Container tabs" popup.
you gave the same fucking answer, I'm not asking about scopeg pages Sorry, I can't answer that. To ask a new question, please start a new chat. Try asking about coding, development, or topics on the Stack Exchange network.
5. Why C++/Rust Can't Match This https://github.com/codereport/max-odd-binary/blob/main/WHY_BQN_WINS.md
But the underlying bug (where -1 is treated as the sentinel) dates back to the 2003 commit that introduced the H.264 codec. And then, in 2010, this bug was turned into a vulnerability when the code was refactored. Since then, this weakness has been missed by every fuzzer and human who has reviewed the code, and points to the qualitative difference that advanced language models provide. https://red.anthropic.com/2026/mythos-preview/
Enter signed integer overflow. TCP sequence numbers are 32-bit integers and wrap around. OpenBSD compared them by calculating (int)(a - b) < 0. That's correct when a and b are within 2^31 of each other—which real sequence numbers always are. But because of the first bug, nothing stops an attacker from placing the SACK block's start roughly 2^31 away from the real window. At that distance the subtraction overflows the sign bit in both comparisons, and the kernel concludes the attacker's start is below the hole and above the highest acknowledged byte at the same time. The impossible condition is satisfied, the only hole is deleted, the append runs, and the kernel writes to a null pointer, crashing the machine. https://red.anthropic.com/2026/mythos-preview/
Picture of interactive PSHUFB AMD64 SIMD instruction visualisation web page.
Typeset Fortress versus ASCII Fortress Typeset Fortress code: histogramWater (x: List[[Z]]): Z = walk (maxCachedTree x, 0, 0) walk (x: Pair, left: Z, right: Z): Z = (*) Potentially parallel recursion walk (x.a, left, x.b.val MAX right) + walk (x.b, left MAX x.a.val, right) walk (x: Leaf, left: Z, right: Z): Z = ((left MIN right) MAX x.val) - x.val ASCII Fortress code: histogramWater(x: List[\ZZ\]): ZZ = walk(maxCachedTree x, 0, 0) walk(x: Pair, left: ZZ, right: ZZ): ZZ = (*) Potentially parallel recursion walk(x.a, left, x.b.val MAX right) + walk(x.b, left MAX x.a.val, right) walk(x: Leaf, left: ZZ, right: ZZ): ZZ = ((left MIN right) MAX x.val) - x.val
Our position is that an architectural definition is something that answers three questions: What are the structural elements of the system? How are they related to each other? What are the underlying principles and rationale that guide the answers to the previous two questions?
The point is: let the agent do the boring stuff, the stuff that won't teach you anything new, or try out different things you'd otherwise not have time for. Then you evaluate what it came up with, take the ideas that are actually reasonable and correct, and finalize the implementation. Yes, sure, you can also use an agent for that final step. https://mariozechner.at/posts/2026-03-25-thoughts-on-slowing-the-fuck-down/
And this begs the question: if you can’t build a well-structured monolith, what makes you think microservices is the answer? Simon Brown
A black cat looking outside the window at cloudy day.
echo '{"name": "Alice", "age": 30}' | json-um -e '{"name": X, "age": Y}' Y: 30 X: "Alice"
// Credit to Matthew Guidry template <typename Tuple1, typename Tuple2> constexpr auto TupleCatHelper(Tuple1 t1, Tuple2 t2) { return [&]<typename... TOuter>(mguid::NamedTuple<TOuter...>) { return [&]<typename... TInner>(mguid::NamedTuple<TInner...>) { return std::apply( [&]<typename... ArgsOuter>(ArgsOuter&&... outer_args) { return std::apply( [&]<typename... ArgsInner>(ArgsInner&&... inner_args) { return mguid::NamedTuple<TOuter..., TInner...>( std::forward<ArgsOuter>(outer_args)..., std::forward<ArgsInner>(inner_args)...); }, static_cast<const typename std::remove_cvref_t<Tuple2>::Base&>(t2)); }, static_cast<const typename std::remove_cvref_t<Tuple1>::Base&>(t1)); }(t2); }(t1); } Lambda None of the Things Braden Ganetsky
std::string operator+ (std::string_view sv1, std::string_view sv2) { return std::string(sv1) + std::string(sv2); } template<typename T> T sum (const T& x, const T& y) { return x + y; } std::string_view sv = "hi"; auto xy = sum(sv, sv); // OOPS: ? (and therefore return type) deduced as string_view std::cout << xy << '\n'; // Runtime ERROR (returned char sequence already destructed) Back to Basics: Strings and Character Sequences Nicolai Josuttis
Software: now we construct it, soon we'll grow it.
# Operation Type Count Percent Latest Block 1 custom_json_operation 2,614,751,679 63.37% 104,916,624 2 vote_operation 1,101,310,746 26.69% 104,916,628 3 comment_operation 136,292,321 3.30% 104,916,516 4 claim_reward_balance_operation 92,490,932 2.24% 104,916,624 5 transfer_operation 91,044,679 2.21% 104,914,516 https://hive.blog/hivedev/@serpent7776/hive-index-now-shows-operations-stats
Unknown Bot detected · Hello, unidentified bot! We detected you via missing-chrome.app. Welcome anyway. Signals: headless-chrome · Action: welcome (not block)
| type | count | latest | |--------------------------------|------------|-----------| | custom_json_operation | 2614742027 | 104891489 | | vote_operation | 1101131308 | 104891500 | | comment_operation | 136291964 | 104891431 | | claim_reward_balance_operation | 92475509 | 104891499 | | transfer_operation | 91044645 | 104890657 |
Models and Zero-Regression Rate: QWen3-Max-2025-09-23 — 0.07 doubao-seed-2-0-pro-260215 — 0.08 QWen3-Max-2026-01-23 — 0.09 doubao-seed-1-8-251228 — 0.09 Qwen3-coder-plus — 0.10 Kimi-K2-Instruct-0905 — 0.12 GLM-4.6 — 0.14 GLM-4.7 — 0.14 Kimi-K2-Thinking — 0.15 MiniMax-M2.1 — 0.15 DeepSeek-V3.2 — 0.20 MiniMax-M2.5 — 0.20 Qwen3.5-plus — 0.20 GPT-5.2 — 0.23 GLM-5 — 0.36 Kimi-K2.5 — 0.37 Claude-opus-4.5 — 0.51 Claude-opus-4.6 — 0.76 https://arxiv.org/pdf/2603.03823
A cat with a thermometer.
Every single one of these transformations is deterministic. Given the same source code, the same compiler version, and the same flags, you get the same binary. (Achieving full reproducibility across build environments is its own discipline, but the compiler itself is a pure function of its inputs.) Every transformation is designed to preserve program semantics, validated by decades of testing, billions of production hours, and enormous test suites. Formally verified compilers like CompCert go further, providing mathematical proofs of correctness. Mainstream compilers like GCC and LLVM aren’t formally proven end-to-end, but they are among the most battle-tested software artifacts humans have ever produced. And it all happens in milliseconds. This is what Musk proposes to replace. With a language model. That hallucinates. https://engrlog.substack.com/p/why-skip-the-code-ship-the-binary
package require Tk # Create main window wm title . "Auto-Refreshing Table" wm geometry . "500x300" # Create Treeview (table) set tree [ttk::treeview .tree -columns {Name Value Status} -show headings] $tree heading Name -text "Name" $tree heading Value -text "Value" $tree heading Status -text "Status" $tree column Name -width 150 $tree column Value -width 150 $tree column Status -width 150 pack $tree -fill both -expand 1 # Label to show last refresh time set timeLabel [label .lbl -text "Last refresh: never"] pack $timeLabel # Procedure to refresh table data proc refreshTable {} { global tree timeLabel # Clear existing rows $tree delete [$tree children {}] # Insert new/updated data (replace this with your real data source) $tree insert {} end -values [list "Temperature" [expr {int(rand()*100)}] "OK"] $tree insert {} end -values [list "Humidity" [expr {int(rand()*100)}] "OK"] $tree insert {} end -values [list "Pressure" [expr {int(rand()*100)}] "WARN"] $tree insert {} end -values [list "CPU Load" [expr {int(rand()*100)}] "OK"] # Update timestamp $timeLabel config -text "Last refresh: [clock format [clock seconds] -format {%H:%M:%S}]" # Schedule next refresh in 3000ms (3 seconds) after 3000 refreshTable } # Start the refresh loop refreshTable
sqlite> CREATE TABLE x1(a, b, c); -- Create table in database sqlite> .expert sqlite> SELECT * FROM x1 WHERE a=? AND b>?; -- Analyze this SELECT CREATE INDEX x1_idx_000123a7 ON x1(a, b); 0|0|0|SEARCH TABLE x1 USING INDEX x1_idx_000123a7 (a=? AND b>?) sqlite> CREATE INDEX x1ab ON x1(a, b); -- Create the recommended index sqlite> .expert sqlite> SELECT * FROM x1 WHERE a=? AND b>?; -- Re-analyze the same SELECT (no new indexes) 0|0|0|SEARCH TABLE x1 USING INDEX x1ab (a=? AND b>?) https://www.sqlite.org/cli.html#index_recommendations_sqlite_expert_
r.cpp:23:15: fatal error: recursive template instantiation exceeded maximum depth of 1024 23 | using rest = rev<t>::output; | ^ r.cpp:23:15: note: in instantiation of template class 'rev<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail<tail
#include <type_traits> template<typename ...Ts> struct types; template<typename ...Ts> struct unpack { using type = types<Ts...>; }; template<typename ...Ps, typename ...Ts> struct unpack<types<Ps...>, Ts...> { using type = types<Ps..., Ts...>; }; template<typename H, typename ...Tail> struct rev { using rest = typename rev<Tail...>::type; using type = typename unpack<rest, H>::type; }; template<typename T> struct rev<T> { using type = types<T>; }; struct Point { int x; int y; }; int main() { static_assert(std::is_same_v<rev<int, bool, Point>::type, types<Point, bool, int>>); static_assert(std::is_same_v<rev<int, bool, char>::type, types<char, bool, int>>); static_assert(std::is_same_v<rev<int, int>::type, types<int, int>>); static_assert(std::is_same_v<rev<int>::type, types<int>>); }
Live updates: ON/OFF button
-- Lux Language Reference (brief) -- ────────────────────────────── -- Types -- pixel Packed ABGR u32 or decoded {r,g,b,a} float channels -- image 2-D grid of pixels with .width, .height, .data -- color Named vector in a colorspace (e.g. yiq.y, yiq.i, yiq.q) -- region Rectangular area {x1, y1, x2, y2} -- scalar f64 numeric value
# Custom JSON ID Count Percent Latest Block 1 sm_market_rent 358,968,236 13.8% 104,426,058 2 ssc-mainnet-hive 344,710,658 13.2% 104,426,918 https://index.hive-adventures.com/
An orange tabby cat peeks out from the center of a massive, tangled ball of colorful wires, yarn, and mechanical gears. The ball sits on a cluttered wooden workbench surrounded by soldering irons, circuit boards, and books. A thought bubble above the cat's head reads, "COMPLEXITY KILLED THE CAT."
--allow-empty Usually recording a commit that has the exact same tree as its sole parent commit is a mistake, and the command prevents you from making such a commit. This option bypasses the safety, and is primarily for use by foreign SCM interface scripts. https://man.freebsd.org/cgi/man.cgi?sektion=0&manpath=FreeBSD%2013.1-RELEASE%20and%20Ports&arch=default&format=html&query=git-commit
UI showing count and latest block numbers flashing green for a brief moment when changed.