| … | … | @@ -8918,7 +8918,7 @@ easy |
| 8918 | 8918 | \begin_inset Quotes eld |
| 8919 | 8919 | \end_inset |
| 8920 | 8920 | |
| 8921 | | easy-ish |
| 8921 | easy–ish |
| 8922 | 8922 | \begin_inset Quotes erd |
| 8923 | 8923 | \end_inset |
| 8924 | 8924 | |
| … | … | @@ -8935,7 +8935,7 @@ a well defined problem that we know how to solve |
| 8935 | 8935 | \begin_inset Quotes eld |
| 8936 | 8936 | \end_inset |
| 8937 | 8937 | |
| 8938 | | what sort of proccess control system should I build? |
| 8938 | what sort of process control system should I build? |
| 8939 | 8939 | \begin_inset Quotes erd |
| 8940 | 8940 | \end_inset |
| 8941 | 8941 | |
| … | … | @@ -9028,7 +9028,168 @@ how do I limit the search space to avoid search regions that are unlikely to yie |
| 9028 | 9028 | \end_layout |
| 9029 | 9029 | |
| 9030 | 9030 | \begin_layout Standard |
| 9031 | | S |
| 9031 | So there are several solutions to the algorithm–discovering algorithm. |
| 9032 | Aside from employing a bunch of students or engineers, |
| 9033 | one can also ask an LLM to craft algos for you. |
| 9034 | The primary issue here is that you are human–in–the–loop. |
| 9035 | The LLM's can write OK javascript or C++ code if you ride herd and are precise in what you want. |
| 9036 | If you are not precise, |
| 9037 | you get crap. |
| 9038 | Asking the LLM to write Atomese is ... |
| 9039 | well, |
| 9040 | it can be done, |
| 9041 | but its quite low–level work, |
| 9042 | the LLM's sort–of understand Atomese, |
| 9043 | but not all that well. |
| 9044 | \end_layout |
| 9045 | |
| 9046 | \begin_layout Standard |
| 9047 | Let me go off on a tangent here, |
| 9048 | that I've wanted to tangent on for months. |
| 9049 | I am asking the LLM to write the new counting pipeline in Atomese. |
| 9050 | But why? |
| 9051 | Surely it would be more efficient to write it in python or c++ or scheme or ... |
| 9052 | ah, |
| 9053 | well, |
| 9054 | but there's the answer; |
| 9055 | I think I wrote about this in the diary only a week ago. |
| 9056 | Right? |
| 9057 | The previous version of the counting code |
| 9058 | \begin_inset Quotes eld |
| 9059 | \end_inset |
| 9060 | |
| 9061 | worked great |
| 9062 | \begin_inset Quotes erd |
| 9063 | \end_inset |
| 9064 | |
| 9065 | . |
| 9066 | It used the |
| 9067 | \begin_inset Quotes eld |
| 9068 | \end_inset |
| 9069 | |
| 9070 | matrix |
| 9071 | \begin_inset Quotes erd |
| 9072 | \end_inset |
| 9073 | |
| 9074 | code for maintaining counts and computing marginals, |
| 9075 | and it was batch oriented and failed to be flexible in all the ways I want it to be flexible. |
| 9076 | In some imaginary universe, |
| 9077 | I could work with Claude to refactor that code, |
| 9078 | so that is become flexible in all the ways I want it to be flexible, |
| 9079 | but this parallel universe is imaginary: |
| 9080 | I know from hard experience that either Claude turns it into a complete hash of spaghetti code, |
| 9081 | or that the code base stays clean, |
| 9082 | but I put in lots of hard effort and engineering work to make sure its good. |
| 9083 | \end_layout |
| 9084 | |
| 9085 | \begin_layout Standard |
| 9086 | And if I'm going to have to put in lots of hard work, |
| 9087 | lots of engineering, |
| 9088 | well, |
| 9089 | it becomes clear that I do not want to use c++ or python or scheme to write that code... |
| 9090 | I want to use Atomese. |
| 9091 | But why? |
| 9092 | |
| 9093 | \begin_inset Quotes eld |
| 9094 | \end_inset |
| 9095 | |
| 9096 | It becomes clear |
| 9097 | \begin_inset Quotes erd |
| 9098 | \end_inset |
| 9099 | |
| 9100 | , |
| 9101 | I say, |
| 9102 | but really? |
| 9103 | Does it? |
| 9104 | Why not write in some other language? |
| 9105 | \end_layout |
| 9106 | |
| 9107 | \begin_layout Standard |
| 9108 | I don't know if I can give any easy answer. |
| 9109 | I like the self–reflective and recursive properties of Atomese. |
| 9110 | That is, |
| 9111 | its a graph, |
| 9112 | and if I want to redo that graph, |
| 9113 | I apply a collection of rewrite rules. |
| 9114 | But if instead it was javascript, |
| 9115 | I could also ask an LLM to rewrite it for me. |
| 9116 | The LLM becomes the |
| 9117 | \begin_inset Quotes eld |
| 9118 | \end_inset |
| 9119 | |
| 9120 | graph rewriting system |
| 9121 | \begin_inset Quotes erd |
| 9122 | \end_inset |
| 9123 | |
| 9124 | . |
| 9125 | The LLM is of course sloppy, |
| 9126 | but is it sloppier than what my imagined system of rewrite rules could generate? |
| 9127 | Is there some intractable complexity limit? |
| 9128 | Well, |
| 9129 | naively |
| 9130 | \begin_inset Quotes eld |
| 9131 | \end_inset |
| 9132 | |
| 9133 | everything becomes spaghetti code |
| 9134 | \begin_inset Quotes erd |
| 9135 | \end_inset |
| 9136 | |
| 9137 | . |
| 9138 | But the standard counterpoint is that |
| 9139 | \begin_inset Quotes eld |
| 9140 | \end_inset |
| 9141 | |
| 9142 | good design practice, |
| 9143 | such as modular code and API's and unit tests |
| 9144 | \begin_inset Quotes erd |
| 9145 | \end_inset |
| 9146 | |
| 9147 | etc. |
| 9148 | allow you to scale to arbitrary complexities. |
| 9149 | And it would seem that those standard engineering design rules would need to apply to Atomese as well. |
| 9150 | \end_layout |
| 9151 | |
| 9152 | \begin_layout Standard |
| 9153 | What tools do I have? |
| 9154 | Well, |
| 9155 | judicial use of DefineLink and PipeLink and NameNode allows me to assign names to modular components. |
| 9156 | I do not have any framework for unit tests at this level. |
| 9157 | I do not have a good theory of refactoring at this level. |
| 9158 | I know I want to have rewrite rules, |
| 9159 | but what are they? |
| 9160 | How do they work in practice? |
| 9161 | \end_layout |
| 9162 | |
| 9163 | \begin_layout Standard |
| 9164 | For example, |
| 9165 | the rewrite rule that converts between (Trigger (FooLink ...)) and (Trigger (CollectionOf (Type 'ParallelLink) (FooLink ...))) – where is this rewrite rule? |
| 9166 | Again, |
| 9167 | if I have a collection of them ...where? |
| 9168 | How? |
| 9169 | Is there a FilterLink that applies this rewrite to a stream? |
| 9170 | The order of rule applications is important. |
| 9171 | Do I have to rip some pages out of theorem–proving systems (Agda, |
| 9172 | HOL, |
| 9173 | etc.) to create a proper rule management system? |
| 9174 | \end_layout |
| 9175 | |
| 9176 | \begin_layout Standard |
| 9177 | Argh. |
| 9178 | I go in circles. |
| 9179 | So then I say to myself |
| 9180 | \begin_inset Quotes eld |
| 9181 | \end_inset |
| 9182 | |
| 9183 | fuck it. |
| 9184 | Just write some code .. |
| 9185 | something or anything ... |
| 9186 | try to make it work. |
| 9187 | \begin_inset Quotes erd |
| 9188 | \end_inset |
| 9189 | |
| 9190 | And then my code scales out of control and I am back to theorizing again. |
| 9191 | Except now five years have slipped by. |
| 9192 | |
| 9032 | 9193 | \end_layout |
| 9033 | 9194 | |
| 9034 | 9195 | \begin_layout Section* |