frontpage.
newsnewestaskshowjobs

Open Source @Github

fp.

Frostbite: A new CPU architecture discovered, designed and verified by AI

https://architectlabs.com/blog/frostbite
101•shioyama•1h ago•71 comments

Carnival Cruises emits ten times more sulphur oxide than all of Europe's cars

https://ecohustler.com/article/one-corporation-to-pollute-them-all/
53•sammatilda•2h ago•20 comments

If you can't explain something in simple terms, you don't understand it (2017)

https://kottke.org/17/06/if-you-cant-explain-something-in-simple-terms-you-dont-understand-it
28•sammatilda•1h ago•12 comments

OpenSSL: Buffer overflow in EVP_EncodeBlock() (CVE-2026-121481, CVSS 9.8)

https://github.com/openssl/openssl/pull/33652
273•JacobHenner•9h ago•217 comments

The Strongest Sokoban Solver

https://healeycodes.com/introducing-the-worlds-strongest-sokoban-solver
71•ibobev•3d ago•14 comments

µ-Wire – USB on an ATtiny 10

https://cpldcpu.com/2014/03/19/%c2%b5-wire-usb-on-an-attiny-10/
45•mofosyne•1d ago•1 comments

FFmpeg 9.1 'Gauss'

https://ffmpeg.org/download.html#release_9.1
158•gyan•7h ago•26 comments

Postgres 19 Repack: Faster, Built-In Table Bloat Cleanup

https://www.snowflake.com/en/blog/engineering/postgres-19-repack-table-bloat/
114•craigkerstiens•8h ago•11 comments

"I can tell you wrote this yourself"

https://em-online.bearblog.dev/i-can-tell-you-wrote-this-yourself/
201•BrunoBernardino•4h ago•209 comments

Garage Door Spam

https://blog.harrison.page/garage-door-spam/
883•harrisonpage•3d ago•374 comments

Claude solves two open problems in the physics of black holes

https://www.anthropic.com/research/claude-black-hole-physics
509•cybermango•17h ago•238 comments

The Making of Oxygene

https://jeanmicheljarre.com/aaa/the-making-of-oxygene
7•hggh•49m ago•1 comments

Show HN: Tinnitus frequency finder and audio notch tool

https://trynotched.com/find
14•brianrhea•2d ago•10 comments

PostgreSQL 19

https://www.postgresql.org/docs/release/19.0/
225•linzhangrun•7h ago•10 comments

How to CAD Almost Anything

https://ocw.mit.edu/courses/res-16-002-how-to-cad-almost-anything-january-iap-2024/
277•o4c•3d ago•96 comments

Jujutsu Primer

https://ethanlowman.com/posts/jj-primer/
130•renehsz•5h ago•89 comments

Vint Cerf on why TCP/IP was never patented

https://seremot.com/p/vint-cerf-on-why-tcpip-was-never
115•emot•10h ago•55 comments

What Comes After AGI?

https://institute.deepmind.com/essays/what-comes-after-agi/
74•jdkee•8h ago•134 comments

Bit Shifting in Basic

https://subethasoftware.com/2020/06/11/bit-shifting-in-basic/
46•efren6•3d ago•2 comments

Show HN: Radiotherapy Delivery Demo

https://tps.neuralrad.com
3•coolwulf•5d ago•0 comments

Synology Security Advisory

https://www.synology.com/en-uk/security/advisory/Synology_SA_26_21
157•choult•13h ago•117 comments

UK fridges secured from hackers in secret nationwide operation

https://www.bbc.co.uk/news/articles/c6eq49zyx7p4o
46•tomnext•1h ago•27 comments

Pancreatic cancer halted by virus injection in three patients

https://www.newscientist.com/article/2528235-pancreatic-cancer-halted-by-virus-injection-in-three...
792•cybermango•18h ago•137 comments

Automatic Checking of Compiler Correctness with E-Graphs

https://stng.substack.com/p/automatic-checking-of-compiler-correctness
43•g0xA52A2A•2d ago•0 comments

The 98% Slot Machine: How Paid Advertising Became an Extraction Tax

https://globalcommercegraph.com/writing/the-ninety-eight-percent-slot-machine
303•dev1one1•16h ago•154 comments

Pete Warden on local AI, open models, voice interfaces, the future of hardware

https://thedataexchange.media/pete-warden-moonshine/
253•datascientist•19h ago•222 comments

What people are building, discovered through new domains

https://startups.novumsignals.com/
4•walterschnitzel•1h ago•2 comments

Weight-Space Programming builds neural networks like a 1990s researcher

https://notesbylex.com/weight-space-programming-1990s
97•lexandstuff•2d ago•8 comments

Anthropic’s Nasdaq debut

https://www.reuters.com/business/finance/anthropics-historic-debut-put-ais-promise-peril-wall-st-...
1092•wslh•18h ago•2161 comments

Someone reported java4shell bug in September 2026

https://github.com/openjdk/jdk/pull/32781
431•notmine1337•23h ago•120 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.