Many suggest resources for compiler implementations, i personally would start prototyping the language itself, think about it's type system and its runtime properties.
There are many possibilities in terms of type systems, from static to dynamic and everything in between, concepts like linear types, algebraic types, etc.
Runtime properties are things like it's memory model (garbage collection, yes or no). All of this depends on the purpose of your language.
The second part would be choosing a platform to run on (so you only have to write a compiler frontend). There are many great technologies to host a language, but i'd advocate two specific ones here:
ZetaVM is a great target for dynamicly typed and/or jit compiled languages like python or javascript.
LLVM is used in many low level / near metal languages like C, C++, rust and so on.
None of both must be your final targets, your compiler frontend can be moved to target another platform like the JVM later.
As a last part, implement your compiler frontend. This involves lexing/parsing source code, type checking if needed and generating your target's intermediate representation.
I personally prefer hand-written recursive descent parsers using a parser combinator framework (like https://github.com/Geal/nom) over parser generators.
For further processing like type checking, there is the common monolith aproach and the nanopass framework/approach https://www.youtube.com/watch?v=Os7FE3J-U5Q
Also there's a great series on compiler frontends by Alex Aiken: https://www.youtube.com/watch?v=sm0QQO-WZlM&list=PLFB9EC7B8F...
I don't think you can generalize it this way, ASTs could be compiled to fast machine code, also it really depends on the solutions the algorithms come up with. The NN is bound to its number of parameters, while the Genetic's program varies in length and can become quite small if length is part of the fitness function.
The second part would be choosing a platform to run on (so you only have to write a compiler frontend). There are many great technologies to host a language, but i'd advocate two specific ones here:
* https://github.com/zetavm/zetavm (shoutout to @love2code)
* https://llvm.org/
ZetaVM is a great target for dynamicly typed and/or jit compiled languages like python or javascript. LLVM is used in many low level / near metal languages like C, C++, rust and so on.
None of both must be your final targets, your compiler frontend can be moved to target another platform like the JVM later.
As a last part, implement your compiler frontend. This involves lexing/parsing source code, type checking if needed and generating your target's intermediate representation. I personally prefer hand-written recursive descent parsers using a parser combinator framework (like https://github.com/Geal/nom) over parser generators. For further processing like type checking, there is the common monolith aproach and the nanopass framework/approach https://www.youtube.com/watch?v=Os7FE3J-U5Q Also there's a great series on compiler frontends by Alex Aiken: https://www.youtube.com/watch?v=sm0QQO-WZlM&list=PLFB9EC7B8F...
Hope this gives an overview. :)