Skip Navigation

InitialsDiceBearhttps://github.com/dicebear/dicebearhttps://creativecommons.org/publicdomain/zero/1.0/„Initials” (https://github.com/dicebear/dicebear) by „DiceBear”, licensed under „CC0 1.0” (https://creativecommons.org/publicdomain/zero/1.0/)S
Posts
4
Comments
1452
Joined
1 yr. ago

  • In regards to security, Apple does have three upsides, and only those:

    • No sideloading and no unlocked bootloader means you can't sideload malware or install malware-preloaded ROMs. No root also means you can't just install malware that uses root access.
    • Long OS support means fewer people run around with iPhones that are 5 OS versions behind.
    • There's no tiny boutique iPhone manufacturers who sell phones that come pre-loaded with malware.

    The solution for the first one is "don't sideload untrusted stuff" and the solution to the second and third one is "buy an Android phone from a trusted manufacturer that has long term OS support".

  • Look at the data: https://gs.statcounter.com/windows-version-market-share/desktop/asia/#monthly-202408-202509

    Or more specifically https://gs.statcounter.com/windows-version-market-share/desktop/singapore/#monthly-202408-202509

    All the data is nice and smooth, slow rises or declines, as usual.

    And then all of a sudden in July and only ins Singapore, Windows 7 goes from <2% to 92%. All other asian countries stay about the same.

    Does this sound likely to you that 90% of users uninstall Win10 and Win11 in Singapore to install Win7 and all that in a span of just two months?

    Or is it more likely that there's some bug (or some botnet) causing false stats?

  • It's quite interesting that no other country has managed to build a chip foundry that would even remotely rival TSMC.

    Especially considering they use third-party lithography machines.

  • Yeah, that's what I mean. I wouldn't even know how to get a wrap onto a complex 3D print.

  • There are quite a few more. For example Debian, Ubuntu, Manjaro, Arch, Fedora, Alpine and Kali also have ARM ports (and probably many others too). Raspberry OS is purpose-built for ARM Desktop. There's others too.

    Asahi isn't specifically an ARM Linux, but an Apple Silicon Linux.

    Apple Silicon is ARM, but it's also its own semi-custom thing that's not directly compatible with other ARM stuff.

    That's the main issue with supporting ARM: You don't have one platform like x86/x64.

    On x86/x64 there's an abstraction between the machine code language and the microcode that's actually executed in the CPU. There's a microcode translation layer in the CPU that translates one to the other, so x86/x64 chip designers have a lot of freedom when designing their actual CPU. The downside being that the translation layer consumes a little bit of performance.

    There's also the UEFI system and a ton of other things that keep the platform stable and standardized, so that you can run essentially the same software on a 15yo Intel CPU and a modern AMD.

    ARM is much more diverse. Some run Devicetree, some don't. There are also multiple different ARM architectures, and since they are customizable, there's just so much variety.

  • Doing a single colour print and then copy paint onto it sounds really hard. I wouldn't even know which process to use for that.

  • It's not a "themselves". It's large corporations trying to make programmers unnecessary.

    It's like blaming Tesla test drivers for making taxi drivers unnecessary.

    But it's very far from the point where programmers would be unnecessary.

    LLMs lack any understanding of the bigger picture. They work for tiny throwaway tasks that you won't use in the future. The stuff they make is hardly runnable, let alone maintainable. It usually needs multiple rounds of asking it to do the right thing before you get anything remotely worth your time.

    The feedback loop with static code analysis and so on generally doesn't work. Once an LLM gets lost enough to produce compiler errors (which happens quite fast) it gets completely lost, since it then only focusses on fixing the compiler errors while totally forgetting what the actual task was. So it will change the program so that it compiles, but then it will not do what it was supposed to do.

    It's a hot mess.

    Studies say that using LLM while programming reduces measured performance of the programmer by 20-30% as soon as the task isn't something entirely trivial.

    Edit: When an LLM gets into that compiler error loop, it's like taking a non-compiling program written by a first-year student and handing it and the compiler output to the rest of the class and everyone sequentially gets a shot at fixing it while completely ignoring anything the others have done befora apart from taking their code as input.

  • The scan is the easy part. The easiest option is photogrammetry (here are phone apps for that), but it's also quite bad in terms of quality.

    Some iPhone models have special hardware in there that allow for better 3D scanning (they originally added it for face unlock), which is probably your best cheap option.

    You can also get a professional 3D scan, they aren't that expensive. I'd guess it should be doable with <€100.

    The real problem is reproducing this. Most 3D printing technologies only allow for a single color or maybe 4-8 colors at max, with no color mixing.

    The only technology that comes to mind that can do full color 3D printing and is somewhat widely available is MJF, but that technology is firmly professional-grade only, and even small prints are really expensive. Also, depending on how small the prints will be scaled to, the resolution of the color texture and the finish of the final print might not be satisfactory.

    All MJF prints I have seen so far had a low-saturation fuzzy look to the printed colors.

    Just to give you a very rough overview of MJF printing costs, check out this link: https://all3dp.com/1/mjf-3d-printing-price-comparison-charts-5-sample-projects/

    Depending on the size of the finished helmet, expect between €300 and €5000 for one piece.

  • Yeah, that's the technical lingo meaning. Attach a debugger means that you have a running process without a debugger running with it, and then you attach the debugger to it to get debug output from that process.

    But I still don't quite get the intended process.

    So you run the code the LLM outputs with a debugger and let the LLM interact with the debugger? Not really sure if that helps, because for the LLM would need to know how to operate the debugger and would need to understand what problems it should be looking for.

    Current systems (e.g. Github Copilot) combine the LLM with static code analysis and compiler outputs to find and fix errors. They can also execute the code and run tests and compare outputs with expected outputs.

  • This kind of buyout should be made illegal.

  • To be fair again, OOP would probably also have issues with running Linux.exe.

    The release page would probably not helped them much.

  • That's the adult-only version.

  • The question was about GPU drivers, and GPU drivers for ARM-based SoCs aren't even mature on Android. They are going to suck on Linux.

    Compared to the drivers for Mali, Adreno and consorts, Nvidia is a bunch of saints, and we know how much Nvidia drivers suck under Linux.

  • How's the GPU drivers though? Especially to me for Linux.

    Not. The answer is not.

  • I'm sure it's possible to move the final states to the middle positions like you did. But I didn't want to invest more time.

  • Don't know if there's a ready-made site for stuff like that, but it's not hard to do.

    Here's a quick and dirty AI generated piece of trash code as a proof of concept:

     
        
    # sankey_hiring_funnel_direct.py
    # Requires: plotly
    # Install: pip install plotly
    
    import plotly.graph_objects as go
    
    # Node labels (unique)
    labels = [
        "Network",            # 0
        "Hiring.cafe",        # 1
        "Abandoned Lead",     # 2
        "Applied",            # 3
        "Rejected",           # 4
        "No Response",        # 5
        "Screener",           # 6
        "Rejected by Screen", # 7
        "Full Round",         # 8
        "Rejected by Panel",  # 9
        "Offer",              #10
        "Accepted",           #11
        "Declined"            #12
    ]
    
    # Colors for the two source groups (consistent)
    network_color = "rgba(31,119,180,0.8)"      # blue-ish
    hiring_color  = "rgba(255,127,14,0.8)"      # orange-ish
    
    sources = []
    targets = []
    values  = []
    link_colors = []
    
    def add_link(src_idx, tgt_idx, val, color):
        sources.append(src_idx)
        targets.append(tgt_idx)
        values.append(val)
        link_colors.append(color)
    
    # Direct flows from Network and Hiring.cafe into Abandoned Lead and Applied
    add_link(0, 2, 1, network_color)    # Network -> Abandoned Lead (1)
    add_link(1, 2, 58, hiring_color)    # Hiring.cafe -> Abandoned Lead (58)
    add_link(0, 3, 11, network_color)   # Network -> Applied (11)
    add_link(1, 3, 70, hiring_color)    # Hiring.cafe -> Applied (70)
    
    # Applied -> Rejected, No Response, Screener (split by original group)
    add_link(3, 4, 5, network_color)    # Applied -> Rejected (network 5)
    add_link(3, 4, 40, hiring_color)    # Applied -> Rejected (hiring 40)
    add_link(3, 5, 3, network_color)    # Applied -> No Response (network 3)
    add_link(3, 5, 15, hiring_color)    # Applied -> No Response (hiring 15)
    add_link(3, 6, 4, network_color)    # Applied -> Screener (network 4)
    add_link(3, 6, 15, hiring_color)    # Applied -> Screener (hiring 15)
    
    # Screener -> Rejected by Screen, Full Round
    add_link(6, 7, 1, network_color)    # Screener -> Rejected by Screen (network 1)
    add_link(6, 7, 5, hiring_color)     # Screener -> Rejected by Screen (hiring 5)
    add_link(6, 8, 3, network_color)    # Screener -> Full Round (network 3)
    add_link(6, 8, 10, hiring_color)    # Screener -> Full Round (hiring 10)
    
    # Full Round -> Rejected by Panel, Offer
    add_link(8, 9, 1, network_color)    # Full Round -> Rejected by Panel (network 1)
    add_link(8, 9, 7, hiring_color)     # Full Round -> Rejected by Panel (hiring 7)
    add_link(8, 10, 2, network_color)   # Full Round -> Offer (network 2)
    add_link(8, 10, 3, hiring_color)    # Full Round -> Offer (hiring 3)
    
    # Offer -> Accepted, Declined
    add_link(10, 11, 1, network_color)  # Offer -> Accepted (network 1)
    add_link(10, 12, 1, network_color)  # Offer -> Declined (network 1)
    add_link(10, 12, 3, hiring_color)   # Offer -> Declined (hiring 3)
    
    # Sanity check
    assert len(sources) == len(targets) == len(values) == len(link_colors)
    
    # Node colors (visual guidance)
    node_colors = [
        "rgba(31,119,180,0.9)",   # Network
        "rgba(255,127,14,0.9)",   # Hiring.cafe
        "rgba(220,220,220,0.9)",  # Abandoned Lead
        "rgba(200,200,200,0.9)",  # Applied
        "rgba(220,180,180,0.9)",  # Rejected
        "rgba(200,200,220,0.9)",  # No Response
        "rgba(200,220,200,0.9)",  # Screener
        "rgba(255,200,200,0.9)",  # Rejected by Screen
        "rgba(210,210,255,0.9)",  # Full Round
        "rgba(240,200,220,0.9)",  # Rejected by Panel
        "rgba(200,255,200,0.9)",  # Offer
        "rgba(140,255,140,0.9)",  # Accepted
        "rgba(255,140,140,0.9)"   # Declined
    ]
    
    fig = go.Figure(data=[go.Sankey(
        node=dict(
            pad=18,
            thickness=18,
            line=dict(color="black", width=0.5),
            label=labels,
            color=node_colors
        ),
        link=dict(
            source=sources,
            target=targets,
            value=values,
            color=link_colors,
            hovertemplate='%{source.label} → %{target.label}: %{value}<extra></extra>'
        )
    )])
    
    fig.update_layout(
        title_text="Hiring funnel Sankey — direct source flows (no Leads node)",
        font_size=12,
        height=700,
        margin=dict(l=20, r=20, t=60, b=20)
    )
    
    fig.show()
    
    # To save as interactive HTML:
    # fig.write_html("sankey_hiring_funnel_direct.html", include_plotlyjs='cdn')
    
      

    Couldn't be bothered to write this by hand for just an online comment. There's enough that can be improved with this, but I think it's ok to show how it can be done quite easily.

  • The better option is to keep colors from the original input stream for the flows instead of making the flows an uniform color.

    In the input on the left you have pink, green and blue.

    Keep these colors throughout the graph.

    Except of the input, all of the other stages only ever split up and never merge, so keeping this single set of colors is enough.

    The other option would be to get rid of the "leads" stage, since it actually doesn't change any state. All the other stages are an action that happens (e.g. "Applied" changes the state of the application from being just a lead to being an open application and it also filters out data for being e.g. abandoned). But the "leads" stage means the same thing as the first stage. So drop the "leads" stage and instead make flows go from all three input stages directly into "bad lead", "abandoned" or "applied".

    Combine both to get the best result.