frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Toyota, Nissan, and Honda to standardize parts to lower costs

https://www.caranddriver.com/news/a74490092/toyota-nissan-honda-standardize-parts-lower-costs/
609•zdw•8h ago•365 comments

Pill to treat pancreatic cancer hailed as 'biggest breakthrough in decades'

https://www.theguardian.com/society/2026/nov/20/pill-pancreatic-cancer-breakthrough-daraxonrasib
1077•rafaelc•1d ago•228 comments

A real Linux kernel, compiled to WebAssembly

https://github.com/pithings/unkernel
53•DonAtimator•4d ago•11 comments

Lean verification of the Riemann Hypothesis

https://leanprover-community.github.io/blog/posts/riemann-hypothesis/
1070•g-b-r•21h ago•887 comments

Harsher on Male? Evaluating LLMs on Gender-Asymmetric Moral Framing in Conflicts

https://arxiv.org/abs/2606.14068
46•rzk•2h ago•18 comments

Sandwich Simulator

https://stulle.app/
306•subdomain•12h ago•104 comments

Self-hosted library branch over public web OPDS

https://joinmayberry.com/
17•philips•2d ago•2 comments

Inkling-2-Mini in 5.4 GB Memory

https://github.com/ShinMegamiBoson/lookatmyquant
481•k__•18h ago•120 comments

Show HN: The Riemann Proof Handbook

https://github.com/tamnd/riemann-handbook
63•tamnd•6h ago•28 comments

Detonating a pile of lead azide

https://www.science.org/content/blog-post/detonating-huge-pile-lead-azide-really
625•beginning_end•22h ago•392 comments

Data Processing Incidents on Inference Providers

https://openrouter.ai/blog/announcements/data-processing-incidents-on-inference-providers/
174•sdko•10h ago•66 comments

Getting the mind to steer the body to steer you

https://notnottalmud.substack.com/p/getting-the-mind-to-steer-the-body
301•jger15•1d ago•101 comments

Notes on the discrete Fourier transform (DFT)

https://eli.thegreenplace.net/2026/notes-on-the-discrete-fourier-transform-dft/
36•kouosi•5h ago•5 comments

If tiny 'primordial' black holes exist

https://phys.org/news/2026-11-tiny-primordial-black-holes.html
41•wglb•2d ago•19 comments

Fast-Anything: Don't rewrite it in Rust. Rewrite the 5% that's slow

https://github.com/EL4CTEO/fast-anything
50•BaselAshraf81•8h ago•31 comments

My monitor was cutting my download speed by 75%

https://blog.tymscar.com/posts/studiodisplayethernet/
603•soheilpro•1d ago•279 comments

PcapAnalyzer – self-hosted pcap analyzer with 27 problem detectors

https://github.com/sebaandrada-cell/PcapAnalyzer
125•sebaandrada•14h ago•18 comments

Is 'fork' missing operation in sandboxes?

https://avrea.com/blog/avrea-sandboxes-computers-should-be-forkable
9•damezumari•2d ago•6 comments

The Mythology of Conscious AI

https://www.noemamag.com/the-mythology-of-conscious-ai/
81•Anon84•10h ago•169 comments

Advice for the next 100 Rust GUIs

https://linebender.org/blog/next-100-guis/
186•raphlinus•14h ago•78 comments

Pandex – Official European Law for AI Agents, over MCP

https://www.pandex.io
103•vasie•15h ago•26 comments

Split Radiance Cascades

https://www.jacktollenaar.top/articles/split-rc.html
40•ibobev•2d ago•0 comments

87% of the Anthropic power will come from gas and 11% from coal in 2028

https://betterdatacenterproject.com/2026/11/16/how-ai-is-powered-a-breakdown-of-byop-and-grid-power/
187•happosai•3h ago•268 comments

Reversing the Next-Page Prefetcher in Skylake-X

https://devsh0.github.io/microarchitecture,/intel,/computer-architecture/2026/11/17/reversing-the...
13•todsacerdoti•3d ago•0 comments

Upload2Shell (CVE-2026-125396)

https://pwn.ai/upload2shell
127•f311a•17h ago•63 comments

LLMs can read and write executables byte by byte from a hex dump

https://sgiannopoulos.github.io/blog/machine-code-programming/
263•fortran77•3d ago•160 comments

GnuPG Security Advisory for GPGME

https://lists.gnupg.org/pipermail/gnupg-announce/2026q4/000517.html
257•gdgghhhhh•1d ago•106 comments

Hurried Announcement: Alessandro Masullo GRH

https://math216.wordpress.com/2026/11/20/hurried-announcement-alessandro-masullo-grh/
2426•jasondavies•1d ago•1179 comments

PostgreSQL Extensions in Go

https://jespino.github.io/gopgext/
155•valyala•19h ago•25 comments

Show HN: Compile the same source for GPUs and CPUs

https://github.com/ThrudTheBarbarian/xc
20•spacedcowboy•1w ago•2 comments
Open in hackernews

Detecting if an expression is constant in C

https://nrk.neocities.org/articles/c-constexpr-macro#detecting-if-an-expression-is-constant-in-c
49•signa11•1y ago

Comments

wahern•1y ago
> This works. But both gcc and clang warn about the enum being anonymous... even though that's exactly what I wanted to do. And this cannot be silenced with #pragma since it's a macro, so the warning occurs at the location where the macro is invoked.

You can use _Pragma instead of #pragma. E.g.

  #define C(x) ( \
    _Pragma("clang diagnostic push") \
    _Pragma("clang diagnostic ignored \"-Wvisibility\"") \
    (x) + 0*sizeof(void (*)(enum { tmp = (int)(x) })) \
    _Pragma("clang diagnostic pop") \
  )
EDIT: Alas, GCC is a little pickier about where _Pragma is allowed so you may need to use a statement expression. Also, it seems GCC 14 doesn't have a -W switch that will disable the anonymous enum warning.
pjc50•1y ago
It's remarkable that people will say that doing this kind of thing is better than learning a language which actually lets you enforce this with the type system.

(or even just insist that users use the version of the language which supports "constexpr"!)

oguz-ismail•1y ago
What language is that? Is it available everywhere (everywhere) C is?
mitthrowaway2•1y ago
Indeed, usually if I'm using C these days it's because I only have access to a c compiler for my target platform, or because I'm modifying an existing C codebase.
uecker•1y ago
I do not think anybody said this. The point is that these macros work for early versions of C. If you need to support early versions of C, learning another language is not a solution. If you don't have to, you can use C23's constexpr.
trealira•1y ago
C used to seem like a beautiful and simple language to me, but as I used it and learned more about it, it seemed more complex under the surface, and kind of janky as well. It's just utilitarian.
wat10000•1y ago
Learning such a language doesn’t mean I can use it.
o11c•1y ago
The problem is that no such language exists.

There are many languages that provide one particular feature that C doesn't provide, but they do this at the cost of excluding numerous other features that C widely relies on.

kjs3•1y ago
"I have no idea what problem you're trying to solve, what the constraints are, what the use cases might be, what tools are available on the platform, what the job or regulations require, what the skillsets of the people involved are, what the timeline is...but I'm absolutely, unshakably certain that I have a magic bullet that will make all your problems go away."

FTFY.

sleirsgoevy•1y ago
The Linux kernel has even a way to determine whether the expression is compile-time, WITHOUT aborting compilation in either case.

The trick is this (copied vebratim from Linux):

#define __is_constexpr(x) (sizeof(int) == sizeof(*(8 ? ((void *)((long)(x) * 0l)) : (int *)8)))

Explanation: if x is a constant expression, then multiplying it by zero yields a constant 0, and casting a constant 0 to void* makes a null pointer constant. And the ternary expression, if one of its sides is a null pointer constant, collapses to the type of the other side (thus the type of the returned pointer will be int*, and the sizeof will match). And if x was not constant, then the lefthand side would not be considered a null pointer constant by type inference, the type of the ternary expression will be void*, and the sizeof check will not match.

With a few more clever tricks, it's even possible to implement a compile-time "type ternary expression", like this: TYPE_IF(2 * 2 == 4, int, long). This is left as an exercise for the reader.

amelius•1y ago
This reminds me of the days when Boost was a thing. It was full of tricks like this.
usrnm•1y ago
It still is a thing, though.
cperciva•1y ago
With a few more clever tricks...

I did this with my PARSENUM macro (https://github.com/Tarsnap/libcperciva/blob/master/util/pars...) to parse strings into floating-point, unsigned integer, or signed integer types (and check bounds) using a single interface.

bobbyi•1y ago
I thought this would work:

#define C(x) (sizeof(char[x]), x)

sizeof is a compile-time operation so x need to be known at compile time.

It didn't work as expected. It turns out there is an exception and the standard says that sizeof is actually calculated at runtime specifically for variable length arrays:

> The sizeof operator yields the size (in bytes) of its operand, which may be an expression or the parenthesized name of a type. The size is determined from the type of the operand. The result is an integer. If the type of the operand is a variable length array type, the operand is evaluated; otherwise, the operand is not evaluated and the result is an integer constant.