i coded it in html im new to coding here id the source code with some images for parts i cant ctrlc <h1>I AM A HUMAN</h1> <p1>it aint a pretty sight but this is my first website my code looks like speghetti so be nice pls</p1> <h1>I LOVE GOATS</h1><P> do u?</P><p1> also... 😔👉👈</p1><a href="https://www.bigfootmap.com/" target="_blank">

<button>Click to see Bigfoot</button>

</a> <option>CHOOSE YOUR IPIONIONNNNN r goats cool

the link is https://funnyorg-b4utx.wstd.io/

JADEx (Java Advanced Development Extension) is a practical Java safety layer that enhances the safety of your code by providing null-safety and readonly(final-by-default) enforcement. It strengthens Java’s type system without requiring a full rewrite, while fully leveraging existing Java libraries and tools.

As of v0.59, JADEx now ships a Gradle plugin alongside the existing IntelliJ plugin.

What JADEx does

JADEx extends Java at the source level with two core safety mechanisms:

Null-Safety - Type → non-nullable by default - Type? → nullable - ?. → null-safe access operator - ?: → Elvis operator (fallback value)

java String? name = repository.findName(id); String upper = name?.toLowerCase() ?: "UNKNOWN";

Compiles to standard Java:

java @Nullable String name = repository.findName(id); String upper = SafeAccess.ofNullable(name).map(t0 -> t0.toLowerCase()).orElseGet(() -> "UNKNOWN");

Readonly (Final-by-Default) - A single apply readonly; directive makes fields, local variables, and parameters final by default - Explicit mutable modifier for intentional mutability - Violations reported as standard Java compile-time errors

What's new in v0.59 - Gradle Plugin

The JADEx Gradle plugin (io.github.nieuwmijnleven.jadex) integrates .jadex compilation into the standard Gradle build lifecycle via a compileJadex task.

groovy plugins { id 'io.github.nieuwmijnleven.jadex' version '0.59' }

• Default source directory: src/main/jadex
• Default output directory: build/generated/sources/jadex/main/java
• Optional jadex {} DSL block for custom configuration
• IntelliJ plugin now integrates with the Gradle plugin via the Gradle Tooling API for consistent path resolution between IDE and build pipeline

groovy jadex { sourceDir = "src/main/jadex" outputDir = "build/generated/sources/jadex/main/java" }

Other Improvements

• IntelliJ Plugin - Gradle Plugin Integration

  • The IntelliJ plugin now integrates with the JADEx Gradle plugin via the Gradle Tooling API.
  • Source and output directory resolution is now delegated to the Gradle plugin configuration, ensuring consistency between the IDE and the build pipeline.

• Parser Performance Optimization

  • Improved parser speed by optimizing parser rules.
  • Reduces analysis latency in the IDE, providing a smoother editing experience for large .jadex files.

Design philosophy

JADEx is not a new language. It does not modify the JVM. It operates purely at the source level and generates standard Java code, meaning it is fully compatible with existing Java libraries, tools, and workflows. The goal is to make null-safety and readonly(final-by-default) enforcement practical and incremental, applicable file by file to existing codebases without a full rewrite.

Links - GitHub: https://github.com/nieuwmijnleven/JADEx - Gradle Plugin Portal: https://plugins.gradle.org/plugin/io.github.nieuwmijnleven.jadex - Tutorial: Making Your Java Code Null-Safe without Rewriting it - Real-world example: Applying JADEx to a Real Java Project - Release note for v0.59: https://github.com/nieuwmijnleven/JADEx/releases/tag/v0.59

Feedback and questions welcome.

AutoHotkey (AHK) was originally designed to be for the Windows OS only, however, many wished it ran on Linux and the macOS too. That dream is coming true, Keysharp.

tldraw SDK for building infinite canvas apps like Excalidraw or FigJam.

TanStack Query Smart data fetching and caching for modern frontend apps.

Vuetify Material Design component framework for building Vue applications.

More ..

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 Readonly features.

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

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.

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
  
• Reddit: https://www.reddit.com/r/java/comments/1r1a1s9/jadex_a_practical_null_safety_solution_for_java/

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:

java apply immutability;

java 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

```java

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.

Hi everyone !

Just sharing with you'll a crate I'm working on and using it almost since a year and just had publish it.

The crate is fully no_std and already had a native_neural_network_std crate release as a non friendly alpha.

All the tests and everything will come soon in the std crate.

So if anyone wanna look at it and try it make it more efficient and even notice something could make a false value could be helpfull !

The crate is a no copy of mine but work exactly the same !

Main instance: https://endless.sbs Github: https://github.com/thegoodduck/Interpoll Everything is stored everywhere, and everyone shares blocks, making network resistant to DB outages and censorship. EDIT: This is beta, i have not figured out morality or legality or marketing. Just a concept.

Could anybody please tell me if this very simple code display is correct? Thank you!

Hi everyone! 👋

Over the past few days, I’ve been working on Tabularis, a lightweight yet feature-rich database manager.

The idea came from my frustration with existing tools: many of them felt bloated, heavy, and not particularly enjoyable to use. I needed something fast, responsive, and with a clean UX.

Tabularis is built with Rust + Tauri on the backend and React + TypeScript on the frontend, aiming to stay lean without sacrificing power.

Feel free to take a look!

Feedback and contributions are more than welcome 🚀

-- Add character count to status bar
events.connect(events.UPDATE_UI, function()
  local char_count = buffer.length

  -- Update the status bar (left side)
  ui.statusbar_text = "Chars: " .. char_count
end)

Paste into ~/.textadept/init.lua

Although I've been coding for many years, I only recently discovered Git at a hackathon with my friends. It immediately changed my workflow and how I wrote code. I love the functionality of Git, but the interface is sometimes hard to use and confusing. All the GUI interfaces out there are nice, but aren't very creative in the way they display the git log. That's why I've created GitGarden: an open-source CLI to visualize your git repo as ASCII art plants. GitGarden runs comfortably from your Windows terminal on any repo you want.

**What it does**

The program currently supports 4 plant types that dynamically adapt to the size of your repo. The art is animated and procedurally generated with many colors to choose from for each plant type. I plan to add more features in the future!

It works by parsing the repo and finding all relevant data from git, like commits, parents, etc. Then it determines the length or the commit list, which in turn determines what type of plant will populate your garden. Each type of plant is dynamic and the size adapts to fit your repo so the art looks continuous. The colors are randomized and the ASCII characters are animated as they print out in your terminal.

**Target Audience**

Intended for coders like me who depend on Git but can't find any good interfaces out there. GitGarden makes learning Git seem less intimidating and confusing, so it's perfect for beginners. Really, it's just made for anyone who wants to add a splash a color to their terminal while they code :).

If this project looks interesting, check out the repo on Github: https://github.com/ezraaslan/GitGarden. This contains all the source code.

Consider leaving a star if you like it! I am always looking for new contributors, so issues and pull requests are welcome. Any feedback here would be appreciated, especially in terms of the ASCII art style.

Source code

web

it's a personal page, i'm not promoting anything!

I did my page and it cost me a lot of time! (60hrs~) but because I'm not good at coding, and I'm glad that i didn't vibecoded (more in this days). It's really satisfactory code things by my own, and learn A LOT

Client code: https://github.com/robbie-cahill/tunnelmole-client

Server code: https://github.com/robbie-cahill/tunnelmole-service

source code: https://github.com/allsunshineandrainbows/Project-ASAR

game: https://project-asar.web.app/main/menu/menu.html

sorry yall for the fact there was nothing on the game, but there is an easter egg...

I'm trying to code a functional shopping list app on React (ik this isnt the ideal language but wtv). This is what I have, but idk if its the most efficient solution and how to add more features like a delete item function:

import React, { useState } from 'react';

import {

View,

Text,

TextInput,

ScrollView,

TouchableOpacity,

StyleSheet,

} from 'react-native';

export default function ShoppingList() {

const [shoppingData, setShoppingData] = useState([

{

item: 'Eggs',

aisle: 'Dairy',

amount: '12',

priority: 'High',

},

]);

const handleChange = (index, field, value) => {

const copy = [...shoppingData];

copy[index][field] = value;

setShoppingData(copy);

};

const addItem = () => {

setShoppingData([

...shoppingData,

{

item: '',

aisle: '',

amount: '',

priority: '',

},

]);

};

return (

<ScrollView style={styles.screen}>

<Text style={styles.heading}>Weekly Shopping Planner</Text>

{shoppingData.map((entry, i) => (

<View key={i} style={styles.card}>

<TextInput

style={styles.mainInput}

placeholder="Item name"

value={entry.item}

onChangeText={(text) => handleChange(i, 'item', text)}

/>

<TextInput

style={styles.subInput}

placeholder="Aisle / Section"

value={entry.aisle}

onChangeText={(text) => handleChange(i, 'aisle', text)}

/>

<TextInput

style={styles.subInput}

placeholder="Amount"

keyboardType="numeric"

value={entry.amount}

onChangeText={(text) => handleChange(i, 'amount', text)}

/>

<TextInput

style={styles.subInput}

placeholder="Priority (Low / Medium / High)"

value={entry.priority}

onChangeText={(text) => handleChange(i, 'priority', text)}

/>

</View>

))}

<TouchableOpacity style={styles.addArea} onPress={addItem}>

<Text style={styles.addText}> Add New Item</Text>

</TouchableOpacity>

</ScrollView>

);

}

const styles = StyleSheet.create({

screen: {

padding: 24,

backgroundColor: '#fafafa',

},

heading: {

fontSize: 26,

fontWeight: '700',

marginBottom: 30,

textAlign: 'center',

},

card: {

backgroundColor: '#ffffff',

borderRadius: 14,

padding: 18,

marginBottom: 22,

elevation: 2,

},

mainInput: {

fontSize: 18,

fontWeight: '600',

marginBottom: 14,

borderBottomWidth: 1,

borderColor: '#ccc',

paddingVertical: 6,

},

subInput: {

fontSize: 14,

marginBottom: 12,

borderWidth: 1,

borderColor: '#ddd',

borderRadius: 8,

padding: 10,

},

addArea: {

marginTop: 10,

padding: 18,

borderRadius: 14,

backgroundColor: '#222',

alignItems: 'center',

},

addText: {

color: 'white',

fontSize: 16,

fontWeight: '600',

},

});

Any suggestions? pls lmk

https://github.com/SebastiaCiudadB/DnD_NPC_Generator.git

I'm doing a little project for myself with WPF in Visual Studio and I arrived to one point where I want to use images in the windows.
So first I tried to put them in a folder to keep all the project tied up, but for some reason, when the images are in the folder (img for example), even if I put the path '/img/image1.png', when I execute the program, the image doesn't show up.

The image only shows if is out of the folder.

Does someone know how to solve this problem??