HISE Transformation to the new age

[HISEnberg]

@Christoph-Hart Yup I just wrote what a pain it is to always correct the variable type. There's small behaviours I notice they do which I suppose we can start to keep a list of, and you can adopt the parser to correct for the obvious? One thing I notice is they always mess up the x/y order for something like this:

g.drawLine(0, 100, 50, 100, 1.2); // x1,x2,y1,y2,linewidth

I believe in Javascript (could be wrong) it is usually x1, y1, x2, y2? I notice an AI will always make this mistake...

[David Healey]

@Christoph-Hart said in HISE Transformation to the new age:

I just removed that entirely so if you define a var statement in an inline function the parser just silently converts it to local.

So in the final script will the var appear as a local or is it completely hidden from view?

[Christoph Hart]

Hidden from view and resolved internally in the parser:

inline function dudel()
{
    // valid code now:
    var iAmSoSorryDave = "Why did I need to explain this to users for 5 years"?;
}

local alsoValid = "allTheTimeSpentExplainingThis...";

There's literally no field in the 2x2 matrix of valid input vs. scenarios that has more than one valid syntax so all this did was to make it complicated for both LLM and new user.

Type	Inline / callback	function / root
local	Works	compile error
var	compile error	Works

[David Healey]

@Christoph-Hart said in HISE Transformation to the new age:

var iAmSoSorryDave = "Why did I need to explain this to users for 5 years"?;

Hmm I'm not sure how I feel about it - if we answer that question there is a real answer - it's important to educate newbies about the concept of scope. Experienced devs already know better, so this is really just of benefit to newbies who will remain ignorant and AI agents. Do we really want more ignorant scripters... maybe improving the error message to be more educational would have been another route, no going back now

[Christoph Hart]

local is still here to stay, obviously otherwise every single script in HISE would break, so you can still emphasise this distinction if you think it adds value to the semantics of a script when teaching human noobs. The LLMs don't need that guidance though :)

[dannytaurus]

@David-Healey said in HISE Transformation to the new age:

Do we really want more ignorant scripters

Like it or not, this is the way everything is going. At least, what I believe you mean by 'ignorant'. I feel the same.

It's a hard pill to swallow that all the years we've spent learning to code amounts to little when AI can produce excellent results from fairly simple prompts.

[David Healey]

@dannytaurus said in HISE Transformation to the new age:

At least, what I believe you mean by 'ignorant'.

I mean users who don't understand the code they are "writing" because the inner workings are being hidden from them.

@dannytaurus said in HISE Transformation to the new age:

AI can produce excellent results from fairly simple prompts.

But an ignorant scripted doesn't know what excellent results are. I think the focus here is too much on people who know what they're doing. I see a lot more threads popping up asking me to fix AI slop :p

But I'm happy to be wrong and see HISE become easier for people to use.

[dannytaurus]

@David-Healey said in HISE Transformation to the new age:

I mean users who don't understand the code they are "writing" because the inner workings are being hidden from them.

Yes, but it's all just abstractions all the way down to the metal. JUCE is an abstraction of pure C++ APIs. HISE is an abstraction of JUCE. And AI agents coding will be an abstraction of HISE.

One could argue that HISE scripters are ignorant of the inner C++ workings of the plugin they're building.

I see a lot more threads popping up asking me to fix AI slop

This is very much the start. Give it time.

[David Healey]

@dannytaurus said in HISE Transformation to the new age:

This is very much the start. Give it time.

This is what people have been telling me for years :)

[dannytaurus]

@David-Healey said in HISE Transformation to the new age:

This is what people have been telling me for years :)

Nah, this is the start. The last few years were just getting LLM to get the language working.

[David Healey]

@dannytaurus said in HISE Transformation to the new age:

Nah, this is the start.

Tell me that again in 5 years

I'm not quite as cynical as I seem, I use AI all the time, I'm just cautious.

I also am concerned about AI inbreeding which is a real problem with limited solutions at the moment.

[dannytaurus]

@David-Healey said in HISE Transformation to the new age:

Tell me that again in 5 years

I'm marking my calendar

[Christoph Hart]

@David-Healey I don't want to be condescending, but have you tried using an AI agent with the latest models? Not like the local LLMs that you can run on your GPU and not one-shotting generic prompts into a ChatGPT window? You literally sound like me 2 weeks ago and I would have agreed 100% with you then and 0% with you now :)

I see a lot more threads popping up asking me to fix AI slop

Look it at this way: you're just one part of a very slow and ineffective Ralph loop.

[David Healey]

@Christoph-Hart said in HISE Transformation to the new age:

but have you tried using an AI agent with the latest models?

Na I played around with OpenCode and Big Pickle and got bored waiting for it to fail, so then I went back to work :)

I'm waiting for someone to show me something impressive enough to get me interested in it to the point where I'll put some money down.

[Christoph Hart]

@David-Healey Yes I also tried Big Pickle, it has nothing to do with what Opus 4.5 / 4.6 can crank out. I'll try to remember a few of the things that stood out to me in my progress of last week.

• oneshotting a HTTP RestServer for HISE that accepts HTTP requests with a correct threading model.
• finding a bug in a compiled network code that caused a voice to not be killed. It explored it's way through the DLL boundary to the internal class that handles modulation chains and found the one bool flag that I forgot to set
• iteratively increasing the robustness and approximation to what looks like flawless HiseScript code by feeding the conversation history back to itself and just tell it to "learn from your mistakes"
• don't get me started on web dev, it's game over there.
• let it crawl through the HISE source code, extract every single LAF method I define in the ScriptLAF class, analyse the function body, connect it to the correct hise component class (eg. "drawAhdsrGraph" will most likely affect a hise::AhdsrGraph) and write a one-liner description to every obj property that matches exactly what it does, then create a JSON object that I can use for the MCP server. Then let it write a guideline.md file that instructs it to repeat that process whenever I need. Bash script on steroids.
• paste in long weird template compiler errors and get a 5 word sentence back what the problem is and how to solve it. It also wrote this beauty of a C++ template code that a human will never understand, but it works perfectly:

struct VoiceSetter : container::Helpers::sub_tuple<renderer<Oscillators, NumOutputs>...>
	{
		using GainModVS = typename core::extra_mod<NumVoices>::VoiceSetter;
		using GateVS = typename envelope::extra_mod_gate<NumVoices>::VoiceSetter;
		// Use empty tuple when addModToOutputs() is false, otherwise tuple of NumOutputs VoiceSetters
		using GainModTuple = std::conditional_t<addModToOutputs(),
			template_helpers::repeat_tuple_t<GainModVS, NumOutputs>,
			std::tuple<>>;
		using GateTuple = std::conditional_t<addModToOutputs(),
			template_helpers::repeat_tuple_t<GateVS, NumOutputs>,
			std::tuple<>>;
		// Delegating constructor for when we have outputs to manage
		template <size_t... Is>
		VoiceSetter(render_group& t, bool forceAll, std::index_sequence<Is...>) :
			container::Helpers::sub_tuple<renderer<Oscillators, NumOutputs>...>(t.oscillators, forceAll),
			gainModSetters{ GainModVS(t.outputGainMods[Is], forceAll)... },
			gateSetters{ GateVS(t.outputGates[Is], forceAll)... }
		{}
		// Delegating constructor for when we have no outputs to manage
		VoiceSetter(render_group& t, bool forceAll, std::index_sequence<>) :
			container::Helpers::sub_tuple<renderer<Oscillators, NumOutputs>...>(t.oscillators, forceAll),
			gainModSetters{},
			gateSetters{}
		{}
		// Public constructor - dispatches to appropriate delegating constructor
		VoiceSetter(render_group& t, bool forceAll) :
			VoiceSetter(t, forceAll,
				std::conditional_t<addModToOutputs(),
				std::make_index_sequence<NumOutputs>,
				std::index_sequence<>>{})
		{
		}

		GainModTuple gainModSetters;
		GateTuple gateSetters;
	};

compared to the complexity of these tasks, even a mid-tier HISE project should be trivial to implement as soon as the knowledge gap between C++ and HiseScript is solved (and that's my task now).

[David Healey]

@Christoph-Hart said in HISE Transformation to the new age:

template code that a human will never understand

Is there a version that a human would be able to understand or is this the sort of thing that even if a human wrote it would still be gibberish?

How is it for adding features or fixing bugs in the HISE codebase? This is where I would be most interested.