[–] 1 point 2 months ago

Simple agents won't understand git. They can make web requests. If they want to check for reference code/source code, I assume they would request the rendered html.

I assume the frequency comes from many people asking various things, and the agents in the background pulling this data.

I'm not sure whether the scale-to-load ratio is plausible, because I lack the numbers, but it doesn't seem implausible to me that various agents for various prompts and tasks from various providers for many people repeatedly make these requests to a degree that significantly impacts the hoster.

  • source
  • parent
  • context
  • [–] 3 points 2 months ago (1 child)

    if I was going to expand my horizons

    Python is well liked and beloved, but it never captivated me or felt intuitive.

    Writing magic init logic feels like a hacky workaround, like putting frameworks and concepts around what is, at its core, a scripting language. If you're committed to it, maybe you'll get past that barrier and find it's good, I don't know, I never got there. From outside, and with experience in other languages/ecosystems, it just never felt correct to me.

    Have you considered alternatives? For example, C#/dotnet?

    Just my experience/opinion. As I said, it seems well beliked by others. I can't speak for their views or experiences.

  • source
  • parent
  • context
  • [–] 5 points 2 months ago*

    TL;DR: we spend more CPU cycles rendering commits for scrapers than we spend on all other kinds of legitimate access, including git clones.

    I've read similar and even worse before. Probably from Codeberg, or maybe a smaller host of Forgejo or GitLab.

    The blame html pages were repeatedly being requested. Which is even worse and even less plausibly useful than a commit html page.

  • source
  • [–] 3 points 2 months ago* (2 children)

    They're not scraping to cache or store, they're operating as an agent - scraping or single user requests.

    Which is obviously bad and damaging, especially on their scale and on repeatedly fetched websites that they could be caching.

    Google indexed the entire web. It's baffling that such indexing is not the norm on these huge providers.

    Just my interpretation anyway.

  • source
  • parent
  • context
  • [–] 5 points 2 months ago

    Looking into the mentioned unforgivable vulnerabilities and stubborn weaknesses published by CISA:

    Unforgivable Vulnerabilities (PDF)

    Given the above criteria, following are some candidates for unforgivable vulnerabilities that satisfy all (or most) of the criteria for an unforgivable vulnerability. […]

    1. Buffer overflow using long strings of "A" characters in:
      • a. Username/password during authentication
      • b. File or directory name
      • c. Arguments to most common features of the product or product class
    2. XSS using well-formed <script> tags, especially in the:
      • a. Username/password of an authentication routine
      • b. Body, subject, title, or to/from of a message
    3. SQL injection using ' in the:
      • a. Username/password of an authentication routine
      • b. "id" or other identifier field
      • c. Numeric field
    4. Remote file inclusion from direct input such as:
      • a. include($_GET['dir'] . "/config.inc");
    5. Directory traversal using "../.." or "/a/b/c" in GET or SEND commands of frequently-used file sharing functionality (e.g., a GET in a web/FTP server, or a send-file command in a chat client)
    6. World-writable critical files:
      • a. Executables
      • b. Libraries
      • c. Configuration files
    7. Direct requests of administrator scripts
    8. Grow-your-own crypto
    9. Authentication bypass using "authenticated=1" cookie/form field
    10. TOCTOU race condition – symlink
    11. Privilege escalation launching "help" (Windows)
    12. Hard-coded or undocumented account/password
    13. Unchecked length/width/height/size values passed to malloc()/calloc()

    Stubborn Weaknesses

    | CWE-ID | Description | 2023 Rank | |


    |


    |


    | | CWE-787 | Out-of-bounds Write | 1 | | CWE-79 | Improper Neutralization of Input During Web Page Generation (‘Cross-site Scripting’) | 2 | | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command (‘SQL Injection’) | 3 | | CWE-416 | Use After Free | 4 | | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | 5 | | CWE-20 | Improper Input Validation | 6 | | CWE-125 | Out-of-bounds Read | 7 | | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory (‘Path Traversal’) | 8 | | CWE-352 | Cross-Site Request Forgery (CSRF) | 9 | | CWE-476 | NULL Pointer Dereference | 12 | | CWE-287 | Improper Authentication | 13 | | CWE-190 | Integer Overflow or Wraparound | 14 | | CWE-502 | Deserialization of Untrusted Data | 15 | | CWE-119 | Improper Restriction of Operations within Bounds of a Memory Buffer | 17 | | CWE-798 | Use of Hard-coded Credentials | 18 |

  • source
  • [–] 1 point 2 months ago (1 child)

    It's not the exact thing; it just makes it worse. For many people, it's personality and psychology; they go the path of least resistance and don't care about much besides their main goals. Whether you embed it in capitalism or not, these fundamental causes remain.

    Do you have an economic or social system in mind where it would be solved or better?

  • source
  • parent
  • context
  • [–] 1 point 2 months ago*

    and CSSWG recommends using OKLCH for gamut mapping.

    I followed the link to section 14.2, but don't see any such recommendation. (Excluding subsections, which seem more specific; unrelated to a recommendation.)

    All three CSS gamut mapping algorithms aim at constant-lightness, constant-hue chroma reduction in the OkLCh color space.

  • source
  • parent
  • context
  •  

    Over the years, our server has been racking up costs, and the now-unsupported software it was running on finally gave out.

    All online services have now been migrated into permanent offline features. We made sure nothing was lost.

    • The Level Editor now saves levels directly to your disk […]
    • All community-created levels […]
    • All-time high scores have been immortalized […]
    • New high scores are saved locally […]

    The game Dual Snake on Steam is free and was released in 2018.

     

    Pike is a dynamic programming language with a syntax similar to Java and C. It is simple to learn, does not require long compilation passes and has powerful built-in data types allowing simple and really fast data manipulation.

    int getDex()
    {
      int oldDex = Dex;
      Dex = 0;
      return oldDex;
    }
    
    private void
    show_user(int|string id, void|string full_name)
    {
      write("Id: " + id + "\n");
      if (full_name)
        write("Full name: " + full_name + "\n");
    }
    
     

    The Go 1.18 release introduced generics and with that a number of new features, including type parameters, type constraints, and new concepts such as type sets. It also introduced the notion of a core type. While the former provide concrete new functionality, a core type is an abstract construct that was introduced for expediency and to simplify dealing with generic operands (operands whose types are type parameters). In the Go compiler, code that in the past relied on the underlying type of an operand, now instead had to call a function computing the operand’s core type. In the language spec, in many places we just needed to replace “underlying type” with “core type”. What’s not to like?

    Quite a few things, as it turns out! To understand how we got here, it’s useful to briefly revisit how type parameters and type constraints work.

    For the Go 1.25 release (August 2025) we decided to remove the notion of core types from the language spec in favor of explicit (and equivalent!) prose where needed. This has multiple benefits: …

     

    However, there are some important features that WinSock just doesn’t expose. […]

    Rust’s current async ecosystem is built atop a particularly cursed concept. It’s an unstable, undocumented Windows feature. It’s the lynchpin of not only the Rust ecosystem, but the JavaScript one as well. It’s controversial. It’s efficient. […] Without it, it’s unlikely that the async ecosystem would exist in its current form. It’s called \Device\Afd, and I’m tired of no one talking about it.

     

    However, there are some important features that WinSock just doesn’t expose. […]

    Rust’s current async ecosystem is built atop a particularly cursed concept. It’s an unstable, undocumented Windows feature. It’s the lynchpin of not only the Rust ecosystem, but the JavaScript one as well. It’s controversial. It’s efficient. […] Without it, it’s unlikely that the async ecosystem would exist in its current form. It’s called \Device\Afd, and I’m tired of no one talking about it.

     

    However, there are some important features that WinSock just doesn’t expose. […]

    Rust’s current async ecosystem is built atop a particularly cursed concept. It’s an unstable, undocumented Windows feature. It’s the lynchpin of not only the Rust ecosystem, but the JavaScript one as well. It’s controversial. It’s efficient. […] Without it, it’s unlikely that the async ecosystem would exist in its current form. It’s called \Device\Afd, and I’m tired of no one talking about it.

     

    Seed7 is a general purpose programming language designed by Thomas Mertes. It is a higher level language compared to Ada, C/C++ and Java. The Seed7 interpreter and the example programs are open-source software. There is also an open-source Seed7 compiler. The compiler translates Seed7 programs to C programs which are subsequently compiled to machine code.

    In Seed7 new statements and operators can be declared easily. Functions with type results and type parameters are more elegant than a template or generics concept. Object orientation is used where it brings advantages and not in places where other solutions are more obvious. Seed7 contains several concepts from Pascal, Ada, C, C++ and Java.


    The author posted on Reddit; quoting in part:

    Seed7 is based on ideas from my diploma and doctoral theses about an extensible programming language (1984 and 1986). In 1989 development began on an interpreter and in 2005 the project was released as open source. Since then it is improved on a regular basis.

    Seed7 is about readability, portability, performance and memory safety. There is an automatic memory management, but there is no garbage collection process, that interrupts normal processing. The templates and generics of Seed7 don't need special syntax. They are just normal functions, which are executed at compile-time.

    Seed7 is an extensible programming language. The syntax and semantics of statements (and abstract data types, etc.) is defined in libraries. The whole language is defined in the library "seed7_05.s7i". You can extend the language syntactically and semantically (introduce new loops, etc.). In other languages the syntax and semantics of the language is hard-coded in the compiler.

    Seed7 checks for integer overflow. You either get the correct result or an OVERFLOW_ERROR is raised. Unlike many JVM based languages Seed7 compiles to machine code ahead of time (GRAAL works ahead of time but it struggles with reflection). Unlike many systems languages (except Rust) Seed7 is a memory safe language.

    Some programs written in Seed7 are:

    • make7: a make utility.
    • bas7: a BASIC interpreter.
    • pv7: a Picture Viewer for BMP, GIF, ICO, JPEG, PBM, PGM, PNG, PPM and TIFF files.
    • tar7: a tar archiving utility.
    • ftp7: an FTP Internet file transfer program.
    • comanche: a simple web server for static HTML pages and CGI programs.

    Code Example

    # Print a Fahrenheit-Celsius table with floating point numbers.
    
    $ include "seed7_05.s7i";  # This must be included first.
      include "float.s7i";     # Subsequent includes do not need a $.
    
    const proc: main is func
      local
        const integer: lower is 0;
        const integer: upper is 300;
        const integer: increment is 20;
        var integer: fahr is 0;
        var float: celsius is 0.0;
      begin
        for fahr range lower to upper step increment do
          celsius := float(5 * (fahr - 32)) / 9.0;
          writeln(fahr lpad 3 <& " " <& celsius digits 2 lpad 6);
        end for;
      end func;
    
     

    Lean is a theorem prover and programming language that enables correct, maintainable, and formally verified code

    /-- A prime is a number larger than 1 with no trivial divisors -/
    def IsPrime (n : Nat) := 1 < n ∧ ∀ k, 1 < k → k < n → ¬ k ∣ n
    
    -- 'Grind' efficiently manages complex pattern matching and
    -- case analysis beyond standard tactics.
    example (x : Nat) : 0 < match x with
      | 0   => 1
      | n+1 => x + n := by
      grind
    
    -- Automatically solves systems of linear inequalities.
    example (x y : Int) :
        27 ≤ 11*x + 13*y → 11*x + 13*y ≤ 45
        → -10 ≤ 7*x - 9*y → 7*x - 9*y > 4 := by
      grind
    

    Does anyone have experience with Lean? Can it be useful for implementing algorithms or logic beyond mathematical proofs, for software libs?

     

    Hare’s boringness is a feature, not a bug. Our goal is not to make programming exciting again, but to make it easy to write simple, obvious programs which are optimized for reliability and longevity. An exciting programming language cannot meet that goal as effectively as Hare does. We have instead sought out the smallest and simplest language design which accommodates these goals. Because we have relatively few features, Hare programs tend to converge upon the single obvious way of solving their problems with the tools at their disposal.

     

    Examples from the README

    example 1

    [
      { "let": { "name": "JSON", "times": 3 } },
      {
        "for": {
          "var": "i",
          "from": 1,
          "to": "times",
          "do": [
            { "print": { "add": ["Hello ", "name"] } }
          ]
        }
      }
    ]
    

    example 2

    [
      { "import": "system.jpl" },
      { "print": { "call": { "now": [] } } },
      { "print": { "call": { "osName": [] } } },
      { "print": { "call": { "cpuCount": [] } } },
      { "let": { "a": 9, "b": 4, "name": "JPL" } },
      { "print": { "add": ["\"a + b = \"", { "add": ["a", "b"] }] } },
      { "print": { "mul": ["a", "b"] } },
      { "print": { "div": ["a", "b"] } },
      { "print": { "mod": ["a", "b"] } },
      { "print": { "&": [6, 3] } },
      { "print": { "||": [false, true] } },
      { "print": { "gt": ["a", "b"] } },
      { "def": { "sq": { "params": ["x"], "body": [{ "return": { "mul": ["x", "x"] } }] } } },
      { "print": { "call": { "sq": [5] } } },
      { "def": { "greet": { "params": ["who"], "body": [{ "return": { "add": ["\"Hi, \"", "who"] } }] } } },
      { "print": { "call": { "greet": ["\"JSON Fan\""] } } },
      { "if": { "cond": { "<": ["b", "a"] }, "then": { "print": "\"b < a 👍\"" }, "else": { "print": "\"b >= a 🤔\"" } } },
      { "for": { "var": "i", "from": 1, "to": 3, "step": 1, "do": [ { "print": { "call": { "sq": ["i"] } } } ] } },
      { "print": "\"All features in one! 🎉\"" }
    ]
    

    example 3

    [
    // 🚀 Welcome to JPL — JSON Programming Language!
    
    // Import system utilities for fun stuff
    { "import": "system.jpl" },
    
    // Print system info
    { "print": { "call": { "now": [] } } },
    { "print": { "call": { "osName": [] } } },
    { "print": { "call": { "cpuCount": [] } } },
    
    // Define a math function to square a number
    {
      "def": {
        "square": {
          "params": ["x"],
          "body": [
            { "return": { "mul": ["x", "x"] } }
          ]
        }
      }
    },
    
    // Greet a user
    {
      "def": {
        "greet": {
          "params": ["name"],
          "body": [
            { "return": { "add": ["Hello, ", "name"] } }
          ]
        }
      }
    },
    
    // Declare variables
    { "let": { "a": 7, "user": "Kapil" } },
    
    // Use greet function and print
    { "print": { "call": { "greet": ["user"] } } },
    
    // Conditional message
    {
      "if": {
        "cond": { ">": ["a", 5] },
        "then": { "print": "a is greater than 5" },
        "else": { "print": "a is 5 or less" }
      }
    },
    
    // Loop with break and continue
    {
      "for": {
        "var": "i",
        "from": 1,
        "to": 10,
        "step": 1,
        "do": [
          { "if": { "cond": { "eq": ["i", 3] }, "then": { "continue": true } } },
          { "if": { "cond": { "gt": ["i", 7] }, "then": { "break": true } } },
          { "print": { "call": { "square": ["i"] } } }
        ]
      }
    },
    
    // Fun ending message
    { "print": "🎉 Done with curly braces and JSON fun!" }
    ]
    

    view more: ‹ prev next ›