bassboon

Runtime for static bass noise ௸..

Note: compile twice to have working package.

To get the overview picture, you have wait until i talk in dutch for many hours.

Very sorry for the bad language but first need a private whore before continuing code.

Features

• interface implemention design pattern
• Type safe lingue support (32k++ languages)
• Number 10,16,27,etc decimal/text/ipa converters
• Babel java api
• Babel dutschen doc
• Split collections api (read and write)
• Terminator number bases (3 and up)
• DEC144 has a 9 bit exponent and 135 bit coefficient see DEC64 as the example.(no impl)
• 7HFF = 7of9 Hebrew Fraction Fractal or GroßGetậl(no impl)

Package

• mvn clean package
• result: bassboon-jppre/target/bassboon-jppre.jar (19MB)

Komputer

Oorspronkelik wodde et Ingelse woord computer bruukt om iene mit an te duden die kompliceerde
berekenings uutvoerde, mit of zunder mechanische hulpmiddels - vergeliek ok de Duutse term veur
komputer: 'Rechner' (rekener) en de Zuud-Afrikaanse term veur komputer: 'rekenaar' - mar laeter
wodde de term ok bruukt om apperaoten te benumen. Mederne komputers wodden veur veul meer
bruukt as allienig wiskundige toepassings. Ok veul administratieve en financiële taeken wodden an
de komputer opdreugen, et Fraanse woord veur komputer was eerst 'calculateur' of rekenaor en
evolueerde naor 'ordinateur' (orde op zaeken zetten).

Atari ordinateur mettre fin intelligente champignon d'encre poulpe soup pour le nouveau humanité.

Data Types

Core building blocks;

• LegoBlockX3 = ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ.T008ᖟ (terminator zero zero eight PI);
• LegoBlockX6 = ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ.T064ᖟ (6 bit value)
• LegoBlockX9 = ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᐪᓫᣗᔿᑊᣕᣔᐪᐤᣗ.T512ᖟ (9 bit value)

The bipolar quad terminator curve; ((3x3)x2x2x2x2x2x2x2x2)

• V018Tord (Four corner codepoint,auto-i18n names for resources and files)
• V036Teger
• V072Tong (3,6,9 and 8 bit alignment from here upwards)
• V144Tocta
• V288Tector
• V576Tixel
• V0x000480ˣᴸ (1152 bit)
• V0x000900ˣᴸ (2304 bit)

The quad sin curve; ((3x3)x3x3x3x3)

• V027Semvig
• V081Song
• V243Sucti
• V729Seks

The quad meat curve; ((3x3)x5x5x5x5)

• V045Metat
• V225Matot
• V0x000465ˣᴸ (1125 bit)
• V0x0015F9ˣᴸ (5625 bit)

The quad block curve; ((3x2)x4x5x6x7)

• V024Beger
• V120Bental
• V720Beximal
• V0x0013B0ˣᴸ (5040 bit)

The quad pental curve; ((3x2)x5x5x5x5)

• V030Pegal
• V150Powic
• V750Poofy
• V0x000EA6ˣᴸ (3750 bit)

The quad konrad curve; (3x7x13x19x29)x37x43x53x61

• V021Koeye (unicode codepoint)
• V273Korcet
• V0x001443ˣᴸ (5187 bit)
• V0x024B97ˣᴸ (150423 bit)

The quad rudra curve; (3x5x11x13x19)x23x31x37x43

• V015Reptet
• V165Roket
• V0x000861ˣᴸ (2145 bit)
• V0x009F33ˣᴸ (40755 bit)

(Maybe extend all curves to 8 points)

Number Types

• Decimal144
• Gê̄ldGetậl a 36 bit, 3(+1up) mini hebrew fraction for money (ferengi don't do decimals)
• 7HFF = 7of9 Hebrew Fraction Fractal or der uber GroßGetậl (for bereshit printers)
• larger examples; GroßGetậlŌṁHyperStàr6ˢᴰ, WavẽWorstGetậl2ⁿᴰ, KlompÅtŌṁKāassGetậl4ˢᴰ
• EmoRing (القرآن‎‎), terminators can have a none-raped true virgin child voice with true emotions...
• etc

What about unicode;

class StringUnicode {
	CharacterUnicode[] values;
	
	class CharacterUnicode {
		V021Koeye[] values;
	}
}
class StringUnicode⁴ᴰ {
	CharacterUnicode⁴ᴰ[] values;
	
	class CharacterUnicode⁴ᴰ {
		V072Tong[] values; // 72 whore's of babel
	}
}

Origin

Move all implementation to interfaces because enum is an object.

public enum DataEnumXXX implements Abba {
	VALUE_1,
	VALUE_2,
	;
	private DataEnumXXX() {
		Abba.init(this);
	}
}

Build

mvn package

Object Naming Convention

• 𓄯 = Marker for bone implemention extenstion objects
• 𓄯ᶠˡʸ = Marker for bone with injection only
• 注 = Postfix for annations (annotated)
• 亞 = Static symbol for static runtime replacement (no-zero)
• 抽 = Postfix for abstract classes (smoke)
• ᒢ = Prefix for java like?? object
• ᕯ = Postfix for pointer like references
• ᵂʳ = Postfix for writable collection interface
• ᴿᵈ = Postfix for reabable collection interface
• ᴿᵂ = Postfix for read/write collection implemention
• Ʇᴿᴳᴮ = Postfix for easter egg paint for injection
• Բᴬᵖᶦ = Postfix for babelizer api definition
• Բᵂʳᵃᵖ = Postfix for babel wrap object without interface
• Ꝺᵀˣᵀ = Postfix for i18n duyts doc and duyts strings
• ᐧᣞᣛ = Package name for native translated babel implementions
• Ʇ = Prefix for a african embedded micro type (elevator)
• ẞ = Prefix for internal dutschen babel interfaces
• ᐧ = Seperator eskimo middle dot for method/field split for non-cased languages
• ᣟ = seperator eslomo super dot for file/class/static split for non-cased languages
• Ɖěꬵḭȵᶒ = Prefix for enumerated interfaces
• Ꝑŕḯṿª₮ḕ = Keyword for private interfaces
• Ꝑŕᱜṫèƈ₮ࠄ₫₮ḕ = Keyword for protected interfaces

Package Naming Convention

The Unified Canadian Aboriginal Syllabics and its Extended blocks.

Contain several mostly consonant-only letters to indicate syllable coda called Finals. Along with some characters that indicate syllable medial known as Medials:

• Main block ᐜᐝᐞᐟᐠᐡᐢᐣᐤᐥᐦᐧᐨᐩᐪᑉᑊᑋᒃᒄᒡᒢᒻᒼᒽᒾᓐᓑᓒᓪᓫᔅᔆᔇᔈᔉᔊᔋᔥᔾᔿᕀᕁᕐᕑᕝᕪᕻᕯᕽᖅᖕᖖᖟᖦᖮᗮᘁᙆᙇᙾᙿ
• Extended block: ᣔᣕᣖᣗᣘᣙᣚᣛᣜᣝᣞᣟᣳᣴᣵ.

public class Test {
	interface Bᐜᐝᐞᐟᐠᐡᐢᐣᐤᐥᐦᐧᐨᐩᐪᑉᑊᑋᒃᒄᒡᒢᒻᒼᒽᒾᓐᓑᓒᓪᓫᔅᔆᔇᔈᔉᔊᔋᔥᔾᔿᕀᕁᕐᕑᕝᕪᕻᕯᕽᖅᖕᖖᖟᖦᖮᗮᘁᙆᙇᙾᙿᣔᣕᣖᣗᣘᣙᣚᣛᣜᣝᣞᣟᣳᣴᣵ {// project build err
		static String COMMENT_2_LINE_OUT_BELOW_FOR_ERROR = "©Δ∞ 仙上主天";
	} // this line
	interface C { // and this line
		enum Ꝑŕḯṿª₮ḕ {// if used as class and used the refactoring gives err
			أَكْبَرײꣻײالله;  // try selecting chars from this valid enum/class/variable name
			static String commentedᐥᵛᵃʳᶦᵃᵇˡᵉ = Bᐜᐝᐞᐟᐠᐡᐢᐣᐤᐥᐦᐧᐨᐩᐪᑉᑊᑋᒃᒄᒡᒢᒻᒼᒽᒾᓐᓑᓒᓪᓫᔅᔆᔇᔈᔉᔊᔋᔥᔾᔿᕀᕁᕐᕑᕝᕪᕻᕯᕽᖅᖕᖖᖟᖦᖮᗮᘁᙆᙇᙾᙿᣔᣕᣖᣗᣘᣙᣚᣛᣜᣝᣞᣟᣳᣴᣵ.COMMENT_2_LINE_OUT_BELOW_FOR_ERROR;
			Object singlethreadjvmᒢᐩᐩ = null;
			enum Translatec̈ {
				CLZ_FUNCTION   ("功能","𓄊𓎓𓄟","काम"),
				;
				String ₜₓₜ普通話;//lots of china chars make the font jumps larger when scrolling to
				String ₜₓₜ𓂀;
				String ₜₓₜहिन्दी; // auto micro font thus must be be last...(in eclipse)
				// note: ------- \/ render err (in eclipse)
				private Translatec̈(String 普通話ᐥˢʰᵉⁿᵉᵉˢ, String 𓂀ᐥʰᶦᵉʳᵒ, String हिन्दीᐥʰᶦⁿᵈᶦ) {
					this.ₜₓₜ普通話 = 普通話ᐥˢʰᵉⁿᵉᵉˢ;
					this.ₜₓₜ𓂀 = 𓂀ᐥʰᶦᵉʳᵒ;
					this.ₜₓₜहिन्दी = हिन्दीᐥʰᶦⁿᵈᶦ + commentedᐥᵛᵃʳᶦᵃᵇˡᵉ; // build in documentation :)
				}
			}
		}
		enum Ꝑŕᱜṫèƈ₮ࠄ₫ {
			ײₐₚᵢI18Nᵗˣᵗײ;
			// note:\/ render err (in eclipse)
			enum Gê̄ldGetậlÅtHebrewLetter {
				;
				private Gê̄ldGetậlÅtHebrewLetter() {
				}
				void יזױזזךזדןװיױ() {
				}
			}
		}
	}
}

J++

Programming with interfaces needs some more interfaces....

Terminator Types

recursive terminator² type sugar

interface MyApi<T extends MyApi<T>> {
}
interface MyApi<T⁽⁾> {
}

Self extending generics gets you a headach, when using multiple types and being four levels deep in abstract type safe builder structures.

Type face

interface without body

public interface A<T> {

	typeface MyType1 extends A<Type>;
	
	interface MyType2 extends A<Type> {}
}

Baby face

Allow only one method. (functional interfaces should have an interface)

public babyface FoodMachine {
	double brestFeeding(); // allowed
	
	int bottleFeeding(); // second method is forbidden
}

Child face

sub member interfaces

public childface A {
	interface SubA extends A { // allowed
	}
}
public interface B extends A { // error
}

Pack face

internal package interfaces. (is more a modifier like public/protected)

package my.package.a;
public packface A {
}

package my.package.a.b;
public interface B extends A { // allow
}

package my.package.c;
public interface C extends A { // disallow
}

Final face

Stop interface tree

finalface A {
}
interface B extends A { // disallow
}
class AB implements A { // allow
}

Shadow face

Objects have public and shadow interfaces

interface A {
}
shadowface B {
	default void hidden();
}
interface C extends A, B {

	default void internalApi(C c) {
		if (A.class.isAssignableFrom(c)) {} // true
		if (B.class.isAssignableFrom(c)) {} // false
		if (B.class.isAssignableFromShadow(c)) {} // true
		
		B b = B.class.castShadow(c);
		
		c.hidden(); // error
		b.hidden(); // allow
	}
}

Inner face

Force an "implementing interfaces" to export embedded declared interface members.

interface MyType {}
interface A {
	inner interface <MyType> MyType[]; // jvm: force child member definition of zero-or-more
	//inner interface <MyType> MyType;   // jvm: force child member definition of one
	// mmm and force naming...
}
interface B extends A {
	interface MyType1 extends MyType {}
	interface MyType2 extends MyType {}
}

This is what I miss in LDAP and schema definition on tree node level which forces the correct interfaces downwards.
And than LDAP is generic meta complete RW orm-less multiple inheritance by interface data structure.

Black face

Force an interface to have resolved generics parameters.

blackface A {
}
blackface B<T> { // forbidden
}
blackface C extends A { // allowed
}
interface D extends C {
}
interface E<T> extends A, List<T> { // forbidden
}
interface F extends A, List<String> { // allowed
}
interface <T extends String & StringUnicode & ComparibleUnicode & ObjectSneeze & HardCodeExport> Fᒾ extends A, List<T>, SuperList<T>, OtherList<T> { // allowed
}

Protected Interface

Allow protected keyword on interfaces;

protected interface A {
}

Current java suger only needs an empty enum;

public enum BabelTypeAnnotationᵗˣᵗ {
	;
	// protected super market interface for text
	
	protected interface Ꝑŕᱜṫèƈ₮ࠄ₫ extends ObjectScopeLimitΔ.ƉěꬵḭȵᶒModifier.Ꝑŕᱜṫèƈ₮ࠄ₫ {
	}
}
public interface BabelTypeAnnotation班ᵗˣᵗ extends BabelTypeAnnotationᵗˣᵗ.Ꝑŕᱜṫèƈ₮ࠄ₫ {
}

Scoping as Interface

Jvm internal dynamic interfaces on objects allow generics to force protected/private resources.

public class A {

	protected A data;

	private A doStuff(Class<A & ObjectScope.Protected> canThisWork) {
	}
	
	public interface B {}
	public interface B1 extends B {}
	protected interface B2 extends B {}
	
	private A doStuffApi(Class<B & ObjectScope.Protected> internalApiInterface) {
	}
}

Enum Extension

Have base interface for enum methods as interface, so extension is possible;

public interface ObjectEnum {
	String name();
	int ordinal();
}
public java.lang.Enum implements ObjectEnum {
}

public interface MyEnum extends ObjectEnum {
	default int ordinalRandomMax() { return new Random().nextInt(ordinal()); }
}
public enum A implements MyEnum {
}

Enum faces

Define name-less interfaces as enum values, note syntax is wrong.

public eiface B { // ei = egg in dutch , but EnumIterableFace
	BASS_FACE_0(Boolean.class),
	BASS_FACE_1(Number.class),
	BASS_FACE_3(Trit.class),
	BASS_FACE_4({
		void myMethodInterface();
	}),
	BASS_WHORE({
		void lol();
		@Override
		default myMethodInterface() { lol(); }
	} extends ObjectToHuman, B.BASS_FACE_3, B.BASE_FACE_4),
	;
	public static final DEFAULT = B.BASS_WHORE;
}
public eggface C<T extends MyInterfaces> { // maybe you want a egg face :)
	IMPL_0(MyInterfaceImpl0.class),
	IMPL_1(MyInterfaceImpl1.class),
	FALLBACK({
		@Override
		default T humanJunkInterfaces() {
			return (T) toIteratorConstructor(toString().getBytes()); // fails on dutch jvm, default charset must be removed
		}		
		@Override
		default String toString() {
			//System.exit(1);
			return "𑀳𑁂𑀮𑀺𑀉𑁄𑀤𑁄𑀭𑁂𑀡 𑀪𑀸𑀕";
		}
	}<T>),
	;
}

Bean face

Removes constructor support fully from beans.

public beanface RealBeanDontHaveConstrucots {
	
	int foobar();
}
public class SwimmingPoolBoard implements RealBeanDontHaveConstrucots {

	public SwimmingPoolBoard() { // disallowed by design
	} // humans to stupid, init order is forced by loader
}

Force face

Force correct implemention to implementators.

public interface HolyApi {
	boolean holyMethodFromHeaven();
}
public forceface MayThe4ThBeWithYou extends ᒢObject, HolyApi, RealBeanDontHaveConstrucots {

	// a forceface creates a forcefield on this to implement all methods from above **faces
	
	private void soepEtenInVagevuur() {
		fromClass().soep("This place is called purgatory"); //炼狱
	}
	
	boolean junkMethodInHell(); // allow junkies to get a new shot to keep calm
	
	@Override
	default final boolean holyMethodFromHeaven() {
		soepEtenInVagevuur();
		if (junkMethodInHell()) {
			return true;
		}
		// note: humans are not allowed to use an if statement it is to complex for humans :P
		return fromClass().getDecisionMaker().ifIntIsZero(getEpochLong() & 1, () -> true, () -> false));
	}
}
class HolyBean implements MayThe4ThBeWithYou {

	// no construcotr allowed
	// no methods allowed (zero is a design goal)
	// no bugs possible
	
	@Override boolean junkMethodInHell() { return System.getProperty("vm.monothread") != null; }
	
	// Finally api design where normal humans are not allowed to create bugs
	// only add holy interfaces where correct implemention is forced.
}

Shield face

Removed visibilty from all the inherherit methods from above.

public interface A {
	public int size();
	
	default long speed() {
		return 1L;
	}
}
public shieldface B extends A {

	public int sizeDoesMatter();
	
	default private int size() {
		return sizeDoesMatter() * 2;
	}
	
	default public long slowIsBetter() {
		return super.speed() - 1L;
	}
}
public class C extends B {
	
	public C() {
		this.speed(); // error
	}
}

Slave face

Inherits the declared parent class interfaces definitions.

public interface TheMaster<T> extends MyInterfaceTree<T>, ThisOther, ASpecialOne<ThisOther> {
	
	public slaveface Slave01<T> {
	}
	public slaveface Slave02<T> {
	}
	public slaveface Slave03<T> {
	}
	public slaveface Slave04<T> {
	}
	public interface SlaveXXX<T> extends TheMaster<T> { // replaces
	}
}

Sperm face

The root interface of all interfaces

public spermface TheVoid {
}

Fuck face

An interface which is not allowed to goto an instance, also known as a namespace or an type key.

public fuckface Females {
}
public interface Marriage extends Females {
}
public class Male implements Marriage { // error
}

Maybe a proper name is like "DeathFace" as you never can have a living instance...

Duyts face

For the duyts doc shadow annotation composed inheritable babel towel interface elevators documentation needs a;

public duytsface WirVertrauenInGott {
}

public interface IsComposedLike extends
	TypeFace, // no body allowed
	BlackFace, // no generics allowed
	FinalFace, // not an inheritable interface
	FuckFace { // no instance allowed
}
// note: we need a new syntax for sliced typed interfaces;
public porkface<ForceFace,ShieldFace> MyForceField<T> {
}

Api's should restrict all options so only one path is the path to enlightenment.

The Duytschen Method

Add syntax for forced life cycle object. (borrow idea from rust)

public class Test {

	static final Map<Object,List<?>> listeners = new WeakHashMap<>();

	public void addListenerNormal(Consumer<Void> listener) {
	}
	
	public void addListenerLife(Object lifeCycle, Consumer<Void> listener) {
		listeners.put(lifeCycle, ...);
	}
	
	public void addListenerDuyts@(Consumer<Void> listener) {
			Object papierenBitte = @;
			if (UberDeutscheAuto.class.isAssignableFrom(papierenBitte)) {
				System.err.println("Audi 100 - nur 1,76 Liter auf 100km - das sparsamste Auto der Welt 1989");
				System.exit("ZDF".hashCode());
			}
			listeners.put(papierenBitte, ...);
	}
	
	private void register() {
		test.addListenerNormal(() -> {});
		test.addListenerLife(this, () -> {});
		test.addListenerLife(Class.class, () -> {}); // any static obj will work
		
		// automatic "this" caller reference injection by jvm
		test.addListenerDutys@(() -> {});	
	}
	
	public static void main(String[] args) {
		Test test = new Test();
		test.register();
	}
}

Kampf face

An kampfface overrides the local imports, thus only the allowed methods and classes are available to use.
Note: the automatic "java.lang" search magic will also need to be removed for this.

public kampfface DutchGreenConcentrationKampf {
	fence: java.util.ArrayList;
	fence: java.lang.Integer;
}

// ------------

import xyz.DutchGreenConcentrationKampf;
import java.lang.String; // <--- ERROR, Strings are for pussies

public class Thailand implements DutchGreenConcentrationKampf {
}

Clean SingleThreadJVM

• Add china whitespace support (U+3000)
• Remove thread code
• Remove locks + sync
• Remove concurrent
• Remove cryto cyfers
• Remove ALL compression support
• Add class AST + loader hook (allows for optional self extracting bytecode)
• Remove char/Character (use int/CharacterUnicode)
• Remove as much static as possible (fully is v2)
• Remove annotations, and impl as "normal" shadow interfaces
• Remove modules (more interface types + classloaders)
• Add @TargetType(MyInterface.class)
• Remove default modifier suger
• Remove all other left over junk
• Add job api, etc

public enum MyApp implements BeanApplicationBoot {
	INSTANCE;
	
	@Override
	default main(String[] args) {
		while(true) {
			System.gc(StepSize.FULL_SWEEP); // not really like this, eventloop/job api interface
			Imgui.begin();
			Imgui.textarea("Legacy swing, can be wrapped to Imgui too");
			Imgui.end();
		}
	}
}

Multi threading is done by the OS kernel interface and is called a process in legacy computing.

// event weaving is an OS kernel function for larger applications
public final enum FYouMyFunctionsAreFaster implements BeanApplicationBoot {
	INSTANCE;
	
	@Inject
	private SystemInput<MyProtoBuffer> input;

	@Inject
	@Qualier(SystemPort.SysOut.class)
	private SystemOutputPort output;
	
	@Inject
	private MyProcessEngine engine;
	
	// no instance of the GC required
	// no threads, no locks, no sync
	// super small and fast boot single function processes
	@Override
	default void main(String[] args) {
		MyProtoBuffer msg = input.getValue();
		SomeOutputEventProtoBuffer out = engine.doMyWork(msg);
		output.send(out);
	}
}

In the unlimited size matrix computers there are lots of cpus as devices, which have no shared memory.
Cache is a design failure.
Bytes are garbage.
Cpu are just not yet automatic unrolled code loops to hardware.

public final class MyCalculator implements Runnable {

	@Override
	public void run() {
		System.out.println("This gets converted to a protobuffer2 msg event");
	}

	public void static main(String[] args) {
		MyCalculator softImpl = new MyCalculator();
		System.out.println(softImpl.toString()); // garbage for english humans only...
		Runnable wrap = System.os.requestHardwareImpl(softImpl.toVHDL());
		wrap.run();
		// The kernel is in control of this optional feature and thus can only be asked.
		//
		// In event flow context, the kernel detects that a piece of code is possible 
		// faster in hardware and allocates and rewires HOT the event flow, you have zero control.
	}
}

With the babel wrap interfaces we have access all the code steps to registrate as "step code" and export.

@UnitBuilderCompoundPair(groupId = Newton.GROUP_ID, groupBaseTypeId = Newton.GROUP_BASE_TYPE_ID,
	leftGroup = Kilogram.GROUP_ID, rightGroup = MetrePreSecondSquared.GROUP_ID,
	quantityIds = Newton.GROUP_QUANTITIES,
	unitType = @UnitBuilderTypes(
		id = Newton.GROUP_BASE_TYPE_ID,
		name = Newton.GROUP_ID,
		aliasOfType = Newton.GROUP_BASE_TYPE_ID_ALIAS
	)
)
public interface Newton extends UnitTypeFactory {
	public static final String GROUP_ID = "newton";
	public static final String GROUP_BASE_TYPE_ID = "N";
	private static final String GROUP_BASE_TYPE_ID_ALIAS = "kg"+UnitXCGroupCompoundPair.PER_ID+UnitXCModuleMetrePerSecondSquared.GROUP_BASE_TYPE_ID;
	private static final String[] GROUP_QUANTITIES = {"force","weight"};
}
//public class UnitXCModuleNewton implements UnitXCConfigModule {
//	// TODO: symbol N + fix builder
//	
//	@Override
//	public void configModule(UnitXCConfigBuilder builder) {
//		builder.createUnitGroupCompoundPair(GROUP_ID, UnitXCModuleKilogram.GROUP_ID, UnitXCModuleMetrePerSecondSquared.GROUP_ID)
//			.addQuantityIds(GROUP_QUANTITIES)
//			.setBaseTypeId(GROUP_BASE_TYPE_ID)
//			.createUnitType()
//				.setId(GROUP_BASE_TYPE_ID)
//				.setName(GROUP_ID)
//				.setAliasOfType(GROUP_BASE_TYPE_ID_ALIAS)
//			.build()
//		.build();
//	}
//}

J++ NG

• Binary XML china source format
• Remove all new/for/if/while keywords from language
• Change from boolean/Boolean to trit/Trit as base bit unit
• Move ServiceLoader access to extension classloader only
• merge extends and implements keywords, we only need one super
• Remove all classic native types
• Replace unicode with uniode4D

HolyC++

Binary XML VHDL recusive language with only one static nor gate function as root.
Build up full set languages and port J++ jvm to hardware.
Terminators run with dynamic hardware hebrew blood numbers.

• vrGEM4: No texture support all data in math
• vrGEM4: GLDrawConvas amd GLDraw3D are framelimited to 1 FPS
• vrGEM4: all pixels are drawn by the doom fractal pixelizer
• vrGEM4: no ImGui access only ImRichFaces for developers

Humans are like bugs and should not allowed to write low level code, terminators don't allow bugs.

The Nether

Dutch virgin under YHVH at 1616, the nether was one of the first republic in eu.
A Jew reads upside down, a Arab reads reversed, a china 4D code reads in all directions #仙上主天