[yotamarker]

Code

package chobit;

public class UwU {
	/*
	 * l -> w r -> w n -> ny ove -> uv ! -> UwU
	 */
	public String convertToUwU(String str1) {
		String uwu = str1;
		uwu = uwu.replace("l", "w");
		uwu = uwu.replace("r", "w");
		uwu = uwu.replace("no", "nyo");
		uwu = uwu.replace("ne", "nye");
		uwu = uwu.replace("ni", "nyi");
		uwu = uwu.replace("nu", "nyu");
		uwu = uwu.replace("na", "nya");
		uwu = uwu.replace("ove", "uv");
		uwu = uwu.replace("!", "^w^");
		return uwu;
	}
}

[frankinstien]

Below is partial code of a unit testing generator I developed where data is collected from a database or is generated randomly.  That library will be integrated with the AI I'm developing. All one need do is select the assembly file which is the dll of class UwU and the code will execute. The process is called Reflection and you can dynamically on the fly compile code or use existing libraries where you just reference the location of it. So Symbolic AI's wouldn't have a problem integrating this process but with an NN there are some issues.

Code

/// <summary>
        /// creates objects with parameters in their constructors
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="assemblyLocation"></param>
        /// <returns></returns>
        private static List<dynamic> CreateAndInitializeProperties(ViableMapAndData aMap, string assemblyLocation)
        {
            Assembly anAssembly = Assembly.LoadFrom(assemblyLocation);
            return CreateAndInitializeProperties(aMap, anAssembly);
        }

/// <summary>
        /// creates objects without parameters in their constructors
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="assemblyLocation"></param>
        /// <returns></returns>
        public static List<dynamic> CreateAndInitializePropertiesWoParams(string fileName, string assemblyLocation)
        {
            Assembly anAssembly = Assembly.LoadFrom(assemblyLocation);
            return CreateAndInitializePropertiesWoParams(fileName, anAssembly);
        }   

/// <summary>
        /// creates objects with or wihtout parameters in their constructors
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="anAssembly"></param>
        private static List<dynamic> CreateAndInitializeProperties(ViableMapAndData aMap, Assembly anAssembly)
        {
            List<dynamic> results = new List<dynamic>();
            List<Object[]> parameterList = ParameterExtruder.BuildParameterArrayList(aMap, ".ctor");
            if (parameterList.Count > 0)
            {
                foreach (Object[] parameters in parameterList)
                    results.AddRange(CreateAndInitializeProperties(aMap, anAssembly, parameters));
            }
            else
                results.AddRange(CreateAndInitializeProperties(aMap, anAssembly, null));


            return results;
        }

        /// <summary>
        /// creates objects without parameters in their constructors
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="anAssembly"></param>
        /// <returns></returns>
        private static List<dynamic> CreateAndInitializeProperties(ViableMapAndData aMap, Assembly anAssembly, object[] parameters)
        {
            List<dynamic> result = new List<dynamic>();            
            
            var propertyStore = aMap.StoredData.Where(x => x.MapType.Equals(DataMapType.PropertyColumnMap)).FirstOrDefault();
            foreach (DataRow aRow in propertyStore.ActualData.Rows)
            {
                dynamic aObject = InI.CreateObjectFromAssembly(anAssembly, aMap.TheMap.ClassName, parameters);
                InI.InitializeProperties(aObject, aMap.TheMap, aRow);
                result.Add(aObject);
            }
            return result;
        }

[frankinstien]

I just want to add that through reflection a Symbolic AI can grow its repertoire of capabilities and integrate a verbal interface to perform new added functions, without haveing to train on a gagillion or gazillion(I'm not sure which is larger) examples!. So it is possible today to do something like what you see in Star Trek and other scifi movies: "Computer give me a chart of the relationship between alien space ships and the observed wormholes."   

[yotamarker]

I just want to add that through reflection a Symbolic AI can grow its repertoire of capabilities and integrate a verbal interface to perform new added functions, without haveing to train on a gagillion or gazillion(I'm not sure which is larger) examples!. So it is possible today to do something like what you see in Star Trek and other scifi movies: "Computer give me a chart of the relationship between alien space ships and the observed wormholes."   

I dont undewstand what youw dww does.
maybe you couwd give some inyput and output exampwes ^w^
and what do you meany integwate with anyy cwass ?
how does it decide what to do with any extewnyaw cwass ?

updated class code

[frankinstien]

With reflection, all I need to do is apply the updated class you just made. Meaning I just reload it for the updated version, which could be set up as a file change or some kind of notification that triggers the update. So the process you list in your class is what gets executed.   

[frankinstien]

Let me add that languages like c# and java have System IO class monitors that can detect file changes.

[yotamarker]

you must mean run string as code, something like this :
https://stackoverflow.com/questions/4389232/run-piece-of-code-contained-in-a-string

[frankinstien]

you must mean run string as code, something like this :
https://stackoverflow.com/questions/4389232/run-piece-of-code-contained-in-a-string

No, it's called Reflection:

Java
.NET

While you can run a piece of code as a string using reflection it's not the best way to use it. If you apply it the way my unit test generator does then the performance hit is only on the first instance of instantiating the object, after that the object is cached for future use and the performance is no different than if you compiled it in the calling code.

[frankinstien]

In Python, it's called Introspection.

But Python is largely an interpreter with the exception of CPathyon, so performance with python really isn't there. 

[frankinstien]

Since kotlin is a java related language it has reflection as well, which is described here.