Selected developer quotes:

“I’m torn. I’d like to help provide updated data on this question but also I really like using AI!” — a developer from the original study early-2025 when asked to participate in the late-2025 study.

“I found I am actually heavily biased sampling the issues … I avoid issues like AI can finish things in just 2 hours, but I have to spend 20 hours. I will feel so painful if the task is decided as AI-disallowed.” — a developer from the new study noting selection effects when choosing what tasks to include in the study.

“my head’s going to explode if I try to do too much the old fashioned way because it’s like trying to get across the city walking when all of a sudden I was more used to taking an Uber.” — a developer from the new study noting selection effects when choosing what tasks to include in the study.

JADEx (Java Advanced Development Extension) is a safety layer that run on top of Java. It currently supports up to Java 25 syntax and extends it with additional Null-Safety and Readonly features.

GitHub: https://github.com/nieuwmijnleven/JADEx

This release focuses on improving JADEx IntelliJ Plugin stability and responsiveness

Key Improvements

• Lexer Stability Fix

  • Resolved a crash in JADExLexerAdapter caused by discontinuous token offsets.
  • Ensures continuous token start/end offsets, preventing editor and indexing issues in IntelliJ.

• Improved Code Completion

  • JADExCompletionContributor refactored to provide smoother and more reliable completion suggestions with better IDE integration.

• Enhanced Reference Resolution

  • JADExPsiReference resolve logic updated for more dependable symbol resolution in the editor.

• Parser Performance Optimization

  • Internal trigger logic related to executing the JADEx Processor has been optimized to reduce latency and speed up code editing.

Impact

• Safer and more stable editing: Files can now be opened and indexed without lexer crashes.
• Faster and more responsive IDE experience: Code completion and parsing are more efficient.
• Reliable symbol resolution: References resolve correctly even in complex JADEx codebases.

The IntelliJ Plugin for JADEx v0.49 is now available on the JetBrains Marketplace.

We highly welcome your feedback on JADEx.

Thank you.

So my manager today asked me if I could stay later when there's broken things in prod, and then today his star dream employee yolo'ed a full stack change into prod without review. It's fucking massive and implements new API endpoints, touches >20 files. Many of the diffs are too large to render in the browser.

It's almost comical, but something immediately broke.

Most of my day, I'm digging through code to identify bugs created from this shit, just to get a stealth merge midday.

I kind of don't know what to do.

cross-posted from: https://piefed.social/c/uxn_computing/p/1854047/what-is-uxntal-the-programming-language-for-uxn-ecosystem

uxntal is the programming language for the uxn virtual machine.

uxntal is a concatenative language, which works like a pipeline of functions which take the result from the previous function, apply a transformation, and return the value to the next operation. "[T]here are no precedence rules, the calculations are merely performed in the sequence in which they are presented".

In concatenative languages the block mul(add(x, y), z) could be written as z x y add mul. Each function takes its parameters from a common data structure, which in this case is a stack, and data types are dynamic, but may be infered with dev tools.

A stack is a data structure where values are "pushed" / added on top of the stack and "popped" / removed from the stack. Operations will always be applyed on the top element(s).

In uxntal you work with bytes (8 bits) and shorts (16 bits), usually in hex notation, and you have some basic stack operators.

• LIT, push a value to the stack
• POP, pop a value from the stack
• DUP, copy a value from the stack

(so the program)  
LIT 00 DUP  

(would end up with a stack)  
00 00  

(and adding a POP)  
LIT 00 DUP POP  

(would remove the last element)  
00  

• https://wiki.xxiivv.com/site/uxntal.html
• https://en.wikipedia.org/wiki/Concatenative_programming_language

When you call the humans who keep production safe “the bottleneck” you’re painting a very specific picture. The reviewer as the obstacle. The gate as friction. Something to route around. Cue in the Balrog scene from Lord of the Rings. That picture determines what you build. The tools to remove reviewers look different from tools to support them.

What LLMs revealed is how many people in our industry don't like to code.

It's intriguing that now they claim and showcase what they "built with Claude", whereas usually that means they generated a PoC.

It's funny, as people still focus on how they're building, so it's all about the code. And if that's the message sent outside, together with the thought that LLMs are already better than "average coder Joe", then the logical follow-up question is: why do we need those humans in the loop?

I'm pretty happy with the progress that I've made in the past few days. I'm hosting Keyboard Vagabond, a collection of Fediverse apps for the traveler/digital nomad niche, on a set of VPS's in a self-hosted kubernetes cluster.

One of the points of the services that I haven't been wild about is that I have my registry/docker image cache exposed to the internet more than I would like because I have to push images to it that are larger than the Cloudflare 100MB limit.

I've been selfhosting Gitea on my home computer and finally got the service running on the cluster and migrated the source code over. I then got ci/cd builds running for each of the services and also upgraded them so that each of them has a DB migration pod that runs before the web and workers. Now they're all consistent in that.

The result now is that I no longer have to push build images and the builds can be faster due to not having to go over the internet/wifi as much. Although I've noticed in a few piefed deployments, the pods didn't actually restart, so I'll take another look at that.

But the next phase is to put the registry behind the cloudflare tunnels and finally remove the last bits of ingress-nginx since everything else is now on istio and the gateway api.

I'm pretty happy with this outcome and it felt nice to see things working.

What kind of code microprofiling/benchmarking software do you guys use? I was wondering if anyone knew of any that can also be used as a separate tool (open source preferred but I dont mind proprietary) rather than already integrated into something like Visual Studio.

Edit: I would like it to support Windows and Linux. I mostly program in C right now, but expanding into other languages (e.g., Rust, Python)

Why aren't people moving away from Github? There's Codeberg, Gitlab, and radicle. What's holding them back?

cross-posted from: https://lemmy.bestiver.se/post/966902

Comments

These last ten years I was really enjoying what Microsoft and its .NET teams were doing. Felt like a good community to be a part of. Huge strides to make things run anywhere and be more involved with the open source community.

While that hasn't necessarily gone away, jamming LLM's into everything is leaving a real sour taste. Pointless copilot button anywhere and everywhere. VS and VSCode pushing the GitHub copilot chats and agents.

We are quickly back to the corporate MSFT that doesn't listen to its users or employees. All that good will has been washed away and now I feel the need to switch off of Windows.

In the previous post, JADEx introduced a new feature ~~Immutability~~.
Through community feedback, several confusions and limitations were identified.

In v0.42, we have addressed these issues and improved the feature. This post explains the key improvements and new additions in this release.

Improvements

~~apply immutability~~ -> apply readonly

• The previous term (Immutability) caused misunderstandings.
• Community feedback revealed that “Immutable” was interpreted differently by different developers, either as Deeply Immutable or Shallowly Immutable.
• In v0.42, we replaced it with readonly.
• Meaning: clearly indicates final by default, preventing reassignment of variables.

Expanded Scope of final keyword: now includes method parameters

• v0.41: final was applied only to fields + local variables
• v0.42: final is applied to fields + local variables + method parameters
• Method parameters are now readonly by default, preventing accidental reassignment inside methods.

Example Code

JADEx Source Code

package jadex.example;

apply readonly;

public class Readonly {

    private int capacity = 2; // readonly
    private String? msg = "readonly"; // readonly

    private int uninitializedCapacity; // error (uninitialized readonly)
    private String uninitializedMsg;    // error (uninitialized readonly)

    private mutable String? mutableMsg = "mutable";  // mutable

    public static void printMessages(String? mutableParam, String? readonlyParam) {

        mutableParam = "try to change"; // error
        readonlyParam = "try to change"; // error

        System.out.println("mutableParam: " + mutableParam);
        System.out.println("readonlyParam: " + readonlyParam);
    }

    public static void main(String[] args) {
        var readonly = new Readonly();
        String? mutableMsg = "changed mutable";

        readonly.capacity = 10; // error
        readonly.msg = "new readonly"; // error

        readonly.mutableMsg = mutableMsg;

        printMessages(readonly.msg, mutableMsg);

        System.out.println("mutableMsg: " + readonly.mutableMsg);
        System.out.println("capacity: " + readonly.capacity);
        System.out.println("msg: " + readonly.msg);
    }
}

Generated Java Code

package jadex.example;

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
import jadex.runtime.SafeAccess;

//apply readonly;

@NullMarked
public class Readonly {

    private final int capacity = 2; // readonly
    private final @Nullable String msg = "readonly"; // readonly

    private final int uninitializedCapacity; // error (uninitilaized readonly)
    private final String uninitializedMsg; // error (uninitilaized readonly)

    private @Nullable String mutableMsg = "mutable";  // mutable

    public static void printMessages(final @Nullable String mutableParam, final @Nullable String readonlyParam) {

        mutableParam = "try to change"; //error
        readonlyParam = "try to change"; //error

        System.out.println("mutableParam: " + mutableParam);
        System.out.println("readonlyParam: " + readonlyParam);
    }

    public static void main(final String[] args) {
        final var readonly = new Readonly();
        final @Nullable String mutableMsg = "changed mutable";

        readonly.capacity = 10; //error
        readonly.msg = "new readonly"; //error

        readonly.mutableMsg = mutableMsg;

        printMessages(readonly.msg, mutableMsg);

        System.out.println("mutableMsg: " + readonly.mutableMsg);
        System.out.println("capacity: " + readonly.capacity);
        System.out.println("msg: " + readonly.msg);
    }
}

New Additions

JSpecify @NullMarked Annotation Support

• All Java code generated by JADEx now includes the @NullMarked annotation.
• This improves Null-Safety along with readonly enforcement.

This feature is available starting from JADEx v0.42. Since the IntelliJ Plugin for JADEx v0.42 has not yet been published on the JetBrains Marketplace, if you wish to try it, please download the JADEx IntelliJ Plugin from the link below and install it manually.

JADEx v0.42 IntelliJ Plugin

We highly welcome your feedback on JADEx.

Thank you.

API-wise, native apps lost to web apps a long time ago. Native APIs are terrible to use, and OS vendors use everything in their power to make you not want to develop native apps for their platform.

Following in the footsteps of Hashicorp, Hudson, etc. Zed has chosen to cash in the good will of its now substantial user base and start going to full corporate enshittification. Among other things like minimum age nonsense, they have also added binding mandatory opt-OUT arbitration.

I find such agreements very troubling, because it gives up public funded dispute resolution for private which nearly unanimously benefits larger entities, it lowers transparency to near zero, and eliminates the abilities to act as a class and to appeal. But I worry most will just accept it, as is the norm.

You can however opt out by emailing arbitration-opt-out@zed.dev with full legal name, the email address associated with your account, and a statement that you want to opt out.

I'll just consider my days of advocating for Zed as an interesting new editor over and go back to Neovim bliss.

I am using rust, but this applies to many other languages, I get warnings like, dead code, unused variables, and etc, and while I remove most of them, there are some im not sure of, I like running my program and there being 0 warnings, or 0 warnings as i scroll down my code, so for things im unsure of, i mark them so the compiler doesn't put warnings there. I also add comments, starting with TODO:, it has some information about what to think about when i revisit it, also the todo's gets highlighed in my IDE with my extension, but is this bad practice?