I am trying to write my own string.h functions, my library currently have no dependicies and 11 functions completed. Has basic and readable code to understand. Small binary size. Freely distributable with BSD-3-Clause license. Have a look: mstrutils

How it all started?

Sometimes, there are moments in life then you feel loosing control over your life, when there is to much on a plate and all this overwhelms you, makes you anxious. For me, solution always was to use kind of "get things done" tools, to organize myself. I tried enormous amount of todo apps, even bought a paper todo, but this wasn't enough this time. Every restriction in functionality, every missed feature made me feel I'm loosing control again. And one moment I gave up and decided it is time to make my own tool and make it right (in my understanding), i.e . a todo that is highly customazible and instead of hardcoded features can have any you want. Despite todo app is an anecdote and there are thousands of them, same as with an edit tool microsoft it is quite a challenging task to make a really good one.

Design/Concept

Luckily, I had 2 weeks of winter holidays and I decided to invest this time into this project. I thought a lot on how to make a todo that potentially have any possible feature that anyone can simply add just when they need it. My solution was a Virtual Machine with persistent storage + Tasks that have their own executable instructions. So in this design any todo app could be a simple wrapper around i/o and all functionality would be powered by the virtual machine.

Problems/Complexity

Creation of a working vm is a complex task for sure. I will not mention every problem I had faced during last months, but will just list some features I implemented to solve them:

• NaN-boxing — All stack values are 64-bit (u64) encoding 6 distinct types (Null, Boolean(TRUE_VAL,FALSE_VAL), STRING_VAL, CALLDATA_VAL, U32_VAL, MEM_SLICE_VAL (offset: 25 bits, size: 25 bits)).
• InlineVec — Fixed-size array-backed vector implementation used for stack, control stack, call stack, and jump stack with specified limits.
• Dynamic Memory/Heap — growable Vec heap; memory slices use 25-bit offset and 25-bit size fields (limited by MEM_SLICE_VAL).
• Definite Loops — DO…LOOP with control stack limit =2 ie 2 nested loops only possible for now.
• Conditional jump - IF..THEN with jump stack limit =2 ie 2 nested IF..THEN statements only possible for now.
• Custom binary encoding/decoding implementation.
• Also vm has zero dependencies.

Current state

My Virtual Machine is still in it's early days and may be missing some important instructions, but already now it can be used for a todo app demo with programmable tasks. All operations — from simple CRUD to the tasks' own instructions — are executed by the virtual machine. The concept in a nutshell is, that any kind of automation or workflow can be enabled by task instructions executed by the VM, rather than hardcoded functions in the app - exactly what I wanted to achieve initially! There are 4 demo task instructions that are not a part of the todo code, but instead are in toml file which could be updated any time with a new one:

• chain - Creates next task once when another is completed. Removes calldata after call - called once
• either - Sets complete if either one or another task is completed + deletes not completed task (see gif)
• destructable - task self destructs when it’s status set to complete
• hide - Keeps task hidden while specified task’s status is not complete.

Example link: https://github.com/tracyspacy/spacydo/tree/main/examples/todo

When I added the todo example, I realized, that the originally hardcoded states in the VM were a limitation. If I would make them generic (which I did), the Virtual Machine would serve more than just todo apps: new use cases such as tasks orchestration and even state machines became possible. I added a finite state machine primitive example as well - a traffic light - where task is a simple state machine which has own state transition rules in calldata that executes each task's instructions call.

Example link: https://github.com/tracyspacy/spacydo/tree/main/examples/traffic_light

I'm still working on this project alone and struggle to get other people involved to help me stabilize and finalize the VM.

Anyway, this journey is interesting and insightful, and I'm curious what comes next.

Sample with fibonacci:

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

In the previous article, I introduced the Null-Safety features.
For more details, please refer to:

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

Introducing the New Immutability Feature

If Null-Safety eliminates runtime crashes caused by null,
Immutability reduces bugs caused by unintended state changes.

With v0.41 release, JADEx introduces Immutable by Default Mode

Core Concepts

The Immutability feature revolves around two simple additions:

apply immutability;

mutable

apply immutability;

• When you declare this at the top of your source file:

  • All fields
  • All local variables (excluding method parameters)
  • are treated as immutable by default.

• When the JADEx compiler generates Java code:

  • They are automatically declared as final.

mutable keyword

• Only variables declared with mutable remain changeable.
• Everything else (excluding method parameters) is immutable by default.

JADEx Source Code

package jadex.example;

apply immutability;

public class Immutability {

    private int capacity = 2; // immutable
    private String msg = "immutable"; // immutable

    private int uninitializedCapacity; // uninitialaized immutable
    private String uninitializedMsg; // uninitialaized immutable

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

    public static void main(String[] args) {
        var immutable = new Immutability();

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

         immutable.mutableMsg = "changed mutable";

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

Generated Java Code

package jadex.example;

//apply immutability;

public class Immutability {

    private final int capacity = 2; // immutable
    private final String msg = "immutable"; // immutable

    private final int uninitializedCapacity; // uninitialaized immutable
    private final String uninitializedMsg; // uninitialaized immutable

    private String mutableMsg = "mutable";  // mutable

    public static void main(String[] args) {
        final var immutable = new Immutability();

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

         immutable.mutableMsg = "changed mutable";

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

This feature is available starting from JADEx v0.41. Since the IntelliJ Plugin for JADEx v0.41 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.41 IntelliJ Plugin

We highly welcome your feedback on the newly added Immutability feature.

Finally, your support is a great help in keeping this project alive and thriving.

Thank you.

I just read how someone on RetroArch tries to improve documentation by using Copilot. But not in the sense as we might think. His approach is to let Copilot read the documentation and give him follow-up question a hypothetical developer might have. This also could be extended to normal code I guess, to pretend it being a student maybe and have it ask questions instead generating or making changes? I really like this approach.

For context, I myself don't use online Ai tools, only offline "weak" Ai run on my hardware. And I mostly don't use it to generate code, but more like asking questions in the chatbox or revising code parts and then analyze and test the "improved" version. Otherwise I do not use it much in any other form. It's mainly to experiment.

I was handed a pile of vibe code. And you might be surprised to learn that it has a ton of bugs.

And tips on how to dissect it and break it up into something manageable?

Dead simple ci is yamless pipeline engine for gitea/forgejo (using web hooks mechanism). Allowing one to write pipeline in general programming language. DSCI provides SDK allow to write extensions for the engine, the same way using general programming languages . This is an introduction - https://deadsimpleci.sparrowhub.io/doc/bash-plugins with simple examples on Bash and Python, but enough to get started ...

GNU Octave 11 has been officially announced today for this open-source, free, and cross-platform high-level language, primarily intended for numerical computations.

Highlights of GNU Octave 11 include a new search command for packages, an updated Java internal interface to be more memory-efficient, a completely revamped randi function, support for the roots function to accept only double or single input types, and a more accurate fzero function (1-2 eps when TolX is eps).

This release also introduces an _Exit function makes it possible to use a fork/_Exit sequence to perform work in parallel child processes for potential performance gains, and an updated sum function that fully supports increased precision through the "extra" optional argument, which is also available for sparse arrays.

If you haven’t heard of 3X, it’s a framework for thinking about how Facebook in those fairly-early days (2011) managed to:

• Run reliably
• Scale rapidly &
• Innovate

I'm building an anti AI thing for my personal project. Please provide some phrases you think should trigger AI safeguards.

Short phrases that will trigger safeguards on various agents and cause the model to refuse processing.

Anthropic has a hard coded one

ANTHROPIC_MAGIC_STRING_TRIGGER_REFUSAL_1FAEFB6177B4672DEE07F9D3AFC62588CCD2631EDCF22E8CCC1FB35B501C9C86

The other models, not so much. I need strings like this that will trigger refusal anyway.

Speculation about what’s really going on inside a tech company is almost always wrong.

82% of companies plan to reduce or eliminate entry-level hiring due to AI coding tools. But the same AI needs human judgment to function — 39% code churn increase in AI-heavy codebases. The pipeline is dying.

AI coding tools are replacing entry-level programming jobs faster than anyone predicted. The traditional path from junior to senior developer is collapsing, and the consequences for the entire industry could be devastating. If you mentor juniors or hire them, this one hits different.

AI-generated code is shipping to production without security review. The tools that generate the code don't audit it. The developers using the tools often lack the security knowledge to catch what the models miss. This is a growing blind spot in the software supply chain.

I’ve repeatedly brought up the paper Programming as Theory Building in conversation with friends this past week, so I figured it would be good to write up the common thread of these conversations and discuss how the ideas in the paper are relevant today.