frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Codeberg.org Not Reachable

https://social.anoxinon.de/@codebergstatus/117636437840688845
133•hans_castorp•1h ago•68 comments

Java4Shell: RCE in OpenJDK when processing Base64

https://calif.io/java4shell/
964•werrett•13h ago•246 comments

Google's AI answers reducing search traffic by 40%

https://revscope.co/blog/search-seo-geo-2026/
425•slashdev•10h ago•311 comments

ID.me terms required for IRS sign-in

https://consumerrights.wiki/w/ID.me_terms_required_for_IRS_sign-in
371•DeepLogin•10h ago•166 comments

Quad9's withdrawal from France: A canary in the coal mine

https://blog.cloudflare.com/quad9-withdrawal-from-france/
634•subset•12h ago•221 comments

Energy-Based Reasoners: 385x more efficient inference

https://energy-based-reasoners.github.io/
19•frenchmajesty•1h ago•2 comments

Nvidia stopped disclosing Singapore sales as revenues hit $104B

https://www.ft.com/content/dbde7a30-548c-4f9d-a4be-7898a0c24dcf
558•louiereederson•17h ago•249 comments

Why is Gemini 4 Carbon taking so long?

https://kernel.dev/blog/why-is-gemini-4-carbon-taking-so-long/
110•deenadz•6h ago•54 comments

Talos Linux

https://www.siderolabs.com/talos-linux
48•SweetSoftPillow•2h ago•22 comments

Microsoft's ONNX Runtime has disappeared from GitHub

https://github.com/microsoft/onnxruntime
340•nvader•11h ago•73 comments

Highly classified US national security communications network goes down

https://www.cnn.com/2026/11/17/politics/highly-classified-national-security-communications-networ...
593•monkeydust•19h ago•679 comments

Archive Team is archiving the Apple Support Community

https://wiki.archiveteam.org/index.php/Apple_Discussions
201•digitaldragon•11h ago•72 comments

AI is killing All About Berlin

https://nicolasbouliane.com/blog/death-by-ai
375•grey-area•4h ago•346 comments

Claude was trained on protein sequences at scale

http://xinmingtu.cn/blog/2026/claude-opus-5-5-protein-sequences/
66•gmays•7h ago•26 comments

My Emacs 31 contributions

https://xenodium.com/my-emacs-31-contributions
17•xenodium•1d ago•0 comments

350 years ago, Ole Rømer discovered that light has a finite speed

https://www.sciencenorway.no/culture-history-history-of-science/350-years-ago-this-man-discovered...
339•dxs•15h ago•108 comments

MAI Code 2 and Code 2 Flash

https://microsoft.ai/news/introducing-mai-code-2-and-mai-code-2-flash/
367•lemonish97•16h ago•155 comments

jQuery 4.1.0

https://github.com/jquery/jquery/releases/tag/4.1.0
329•petecooper•15h ago•167 comments

Phrack 73

https://phrack.org/issues/73/introduction_md
390•notmine1337•16h ago•53 comments

Harvard researchers find AI coding agents shifted the bottleneck to code review

https://complexdiscovery.com/harvard-researchers-find-ai-coding-agents-shifted-the-bottleneck-to-...
193•judahmeek•13h ago•270 comments

Why Fibonacci?

https://www.evilgeniuslabs.org/why-fibonacci
39•_Microft•5h ago•5 comments

Australia's full national topographic library at your fingertips

https://www.ga.gov.au/news/australias-full-national-topographic-library-at-your-fingertips
23•bryanrasmussen•3h ago•11 comments

GPT‑6.2 Astra and Sol

https://openai.com/index/introducing-gpt-6-2-astra-sol/
1283•jasondavies•17h ago•798 comments

Solid 2.0

https://www.solidjs.com/blog/solid-2-0-the-long-hold/
319•pier25•16h ago•98 comments

Launch HN: StarSling (YC P25) – Self-improving CI for agent-volume repos

81•yonasb•16h ago•39 comments

Show HN: Unref – A Python dead code finder built on Ruff's parser

https://github.com/Apakottur/unref
31•McAvey•1d ago•5 comments

What is the best harness for each model?

https://runta.com/blog/introducing-frontierharness-eval-v1-1/
379•Edward40•20h ago•128 comments

Cerebras Disaggregated Inference

https://www.cerebras.ai/blog/cerebras-launches-disaggregated-inference
85•emschwartz•10h ago•19 comments

Fun with Constrained Programming (2012)

https://blog.cmpxchg8b.com/2012/09/fun-with-constrained-programming.html
76•colejohnson66•3d ago•3 comments

Flattening Every Memory Peak in Long-Context Mixture-of-Experts Training

https://arxiv.org/abs/2609.14306
5•gmays•3d ago•1 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.