[–] 3 points 1 week ago
  • Fixed "Illegal instruction" error on certain x86_64 CPUs without SSE4.1. pr#5162
  • Fixed "lock() not supported" error on Solaris. pr#5167

Further details are available in the changelog!

me follows link to changelog, same two list items

  • source
  • [–] 9 points 1 week ago*

    I guess I don't know what kind of posts you mean specifically, but yes, please do.

    "Programming" can be and is typically interpreted quite broadly. It's not just "writing code" but development in general, and entails computer science.

    Looks like this programming.dev instance does not have a computer science community yet, but I would love to see one. Cross-posting is possible too.

    Tangential, there's !experienced_devs@programming.dev, but that's a different branch even if it can entail compsci.

    I would love to see more practice or science or theory or hands-on posts in this community.

    In the end, there's the option of just trying and seeing what votes and comments tell; appreciation or rejection.

  • source
  • [–] 3 points 2 weeks ago

    I didn't have this issue, but I will share my opinion anyway.

    What do you mean by "actual programming"? I would expect that to include not knowing stuff beforehand, to explore and prototype solutions and missing information. That's the opposite of what you seem to expect, judging from the rest of your sentence? (missing know how, unclear docs, no youtube course to follow along to)

    I learned through hacking website and related stuff in php, going into a popular C++ FOSS project, and other projects. I oriented myself through what already existed and documentation.

    The best way to learn is through self interest, through actual projects or functionality you try to implement. If it's scoped small enough, with a doable challenge, that's how you grow.

  • source
  • [–] 4 points 2 weeks ago*

    Implementations

    • Vervis is the reference implementation of ForgeFed. It serves as a demo platform for testing the protocol and new features.
    • Forgejo is implementing federation.
    • Pagure has an unmaintained ForgeFed plugin.

    Only one of the three weblinks works. And no, it's not the reference implementation…

  • source
  • parent
  • context
  • [–] [S] 2 points 2 weeks ago (1 child)

    In this game at least, there doesn't seem ot be any items or XP.

    But I thought of this as an interesting mechanic as well when they mentioned expert period and deliberately falling to regenerate the following area. It leads to a weighing of lost time due to falling/falling back vs the chance of better alternatives.

    Even for a novice period, falling, whether deliberately or accidentally, and getting a better outcome doesn't seem like a bad thing to me. They describe how that makes progression easier by chance rather than through explicit deliberate game design with easing and fallbacks.

    Other games and game mechanics make use of risk vs potential reward too. I'm thinking of roguelites right now where you can pick something up or not or activate something at a cost. A gain may not be guaranteed. Or it offering a reroll of items on offer.

    I don't see this much different. The form is different through level generation/spooling and a different cost, but the tension or strategy mechanism is not fundamentally different in my eyes.

    I guess it comes down to what you see as "exploitation". When you see it as deliberate game design it's not really exploitation. If it's deliberately part of the influenced scoring then it's not an exploit either. Even if it's multiplayer, it can be part of game depth and game strategy.

  • source
  • parent
  • context
  • [–] 9 points 2 weeks ago* (last edited 2 weeks ago)

    It wasn't a scarce resource before. Why is it more scarce now if we're just offloading into the cloud which makes it, supposedly, significantly more efficient? People had RAM before. Now they can't get any [for similar price].

  • source
  •  

    Attackers compromised Trivy GitHub Actions by force-updating tags to deliver malware, exposing CI/CD secrets across affected pipelines.

    Recent updates from the Trivy maintainers confirm that this attack was enabled by a compromised credential with write access to the repository. The incident is a continuation of the earlier March breach, during which credentials were exfiltrated from Trivy’s CI environment. Although secrets and tokens were rotated in response, the rotation process was not fully atomic, and the attacker may have retained access to newly issued credentials. This allowed the threat actor to perform authenticated operations, including force-updating tags, without needing to exploit GitHub itself. While the exact credential used in this phase has not been publicly specified, the root cause is now understood to be residual access from the earlier credential compromise.

    trivy.dev:

    [Trivy –] The All-in-One Security Scanner

    Use Trivy to find vulnerabilities (CVE) & misconfigurations (IaC) across code repositories, binary artifacts, container images, and Kubernetes clusters.

     

    Two versions of telnyx (4.87.1 and 4.87.2) published to PyPI on March 27, 2026 contain malicious code injected into telnyx/_client.py. The telnyx package averages over 1 million downloads per month (~30,000/day), making this a high-impact supply chain compromise. The payload downloads a second-stage binary hidden inside WAV audio files from a remote server, then either drops a persistent executable on Windows or harvests credentials on Linux/macOS. Stolen data is encrypted with AES-256-CBC and a hardcoded RSA-4096 public key before exfiltration. The RSA key and operational patterns are identical to the litellm PyPI compromise, attributing this attack to TeamPCP with high confidence.

    No PyPI trusted publisher (OIDC) is configured. Trusted publishers bind PyPI uploads to a specific GitHub repository and workflow, making stolen tokens useless outside that context. Without this protection, anyone with the API token can upload any version from any machine.

    The most likely scenario is that the PYPI_TOKEN was obtained through a prior credential harvesting operation.

     

    Uiua () is a general-purpose array-oriented programming language with a focus on simplicity, beauty, and tacit code.

    Uiua lets you write code that is as short as possible while remaining readable, so you can focus on problems rather than ceremony.

    The language is not yet stable, as its design space is still being explored. However, it is already quite powerful and fun to use!

    Uiua uses special characters for built-in functions that remind you what they do!

    ⚂ # Random number
    ⇡8 # Range up to
    ⇌ 1_2_3_4 # Reverse
    

    cross-posted from: https://programming.dev/post/46403010

    Sample with fibonacci:

    ⍥◡+9∩1 is the fibonacci in this language


    Commenter maegul writes on the Programming community post:

    I tried to go through the tutorial a year or so ago.

    I can’t recall when, but there’s a point at which doing something normal/trivial in an imperative language requires all sorts of weirdness in Uiua. But they try to sell it as especially logical while to me they came off as completely in a cult.

    It’s this section, IIRC: https://www.uiua.org/tutorial/More%20Argument%20Manipulation#-planet-notation-

    When they declare

    And there you have it! A readable syntax juggling lots of values without any names!

    For

    ×⊃(+⊙⋅⋅∘|-⊃⋅⋅∘(×⋅⊙⋅∘)) 1 2 3 4

    Which, if you can’t tell, is equivalent to

    f(a,b,c,x) = (a+x)(bx-c)

    With arguments 1, 2, 3, 4.

    I wanted to like this, and have always wanted to learn APL or J (clear influences). But I couldn’t take them seriously after that.

     

    From the README:

    What is KORE?

    KORE is a self-hosting programming language that combines the best ideas from multiple paradigms:

    Paradigm Inspiration KORE Implementation
    Safety Rust Ownership, borrowing, no null, no data races
    Syntax Python Significant whitespace, minimal ceremony
    Metaprogramming Lisp Code as data, hygienic macros, DSL-friendly
    Compile-Time Zig comptime execution, no separate macro language
    Effects Koka/Eff Side effects tracked in the type system
    Concurrency Erlang Actor model with message passing
    UI/Components React/JSX Native JSX syntax, components, hot reloading
    Targets Universal WASM, LLVM native, SPIR-V shaders, Rust transpilation

    Example

    // Define a function with effect tracking
    fn factorial(n: Int) -> Int with Pure:
        match n:
            0 => 1
            _ => n * factorial(n - 1)
    
    // Actors for concurrency
    actor Counter:
        var count: Int = 0
    
        on Increment(n: Int):
            count = count + n
    
        on GetCount -> Int:
            return count
    
    fn main():
        let result = factorial(5)
        println("5! = " + str(result))
    
     

    Girard's insight was that communities resolve internal conflict through scapegoating: the selection of a victim to bear collective guilt, whose expulsion or destruction restores social cohesion. The scapegoat need not be guilty of the crime attributed to it; it need only be acceptable as a target.

    Some dangerous individuals, however, institutionalize such ritualistic practices into what I call Casus Belli Engineering: the use of perceived failure as pretext to replace established systems with one's preferred worldview. The broken feature is the crisis that demands resolution. The foundation becomes the scapegoat, selected not for its actual guilt but for its vulnerability and the convenience of its replacement. And in most cases, this unfolds organically, driven by genuine belief in the narrative.

    The danger is not the scapegoating itself; humans will scapegoat. The danger lies in those who have learned to trigger the mechanism strategically, who can reliably convert any failure into an opportunity to destroy what exists and build what they prefer.

    The linked article title is “Casus Belli Engineering: The Sacrificial Architecture”, which I didn't find particularly descriptive. I used the second headline, “The Scapegoat Mechanism”. It doesn't include the architecture or strategy aspects, but serves well as a descriptor and entry point in my eyes.

     

    There exists a peculiar amnesia in software engineering regarding XML. Mention it in most circles and you will receive knowing smiles, dismissive waves, the sort of patronizing acknowledgment reserved for technologies deemed passé. "Oh, XML," they say, as if the very syllables carry the weight of obsolescence. "We use JSON now. Much cleaner."

    view more: ‹ prev next ›