more README updates

README.md

@@ -7,7 +7,9 @@
 
 The *emergent* neural network simulation framework provides a toolkit in the Go programming language (golang) for developing neural network models across multiple levels of complexity, from biologically-detailed spiking networks in the [axon](https://github.com/emer/axon) package, to PyTorch abstract deep networks in the [eTorch](https://github.com/emer/etorch) package.  It builds on the [Cogent Core](https://cogentcore.org/core) GUI framework to provide dynamic graphical interfaces for visualizing and manipulating networks and data, making the models uniquely accessible for teaching (e.g., see the [Computational Cognitive Neuroscience](https://github.com/CompCogNeuro/sims) simulations) and supporting the development of complex dynamical models for research.
 
-See [Wiki Install](https://github.com/emer/emergent/wiki/Install) for installation instructions (note: Go 1.22 required), and the [Wiki Rationale](https://github.com/emer/emergent/wiki/Rationale) and [History](https://github.com/emer/emergent/wiki/History) pages for a more detailed rationale for this version of emergent, and a history of emergent (and its predecessors).
+See [cogent core install](https://www.cogentcore.org/core/setup/install) instructions for general installation instructions. 
+
+The [Wiki Rationale](https://github.com/emer/emergent/wiki/Rationale) and [History](https://github.com/emer/emergent/wiki/History) pages for a more detailed rationale for this version of emergent, and a history of emergent (and its predecessors).  The Wiki tends to be a bit out of date, but can have some useful information.  In general it is best to take the plunge and "use the source" directly :)
 
 The single clearest motivation for using Go vs. the ubiquitous Python, is that Python is too slow to implement the full computational model: it can only serve as a wrapper around backend code which is often written in C or C++.  By contrast, *Go can implement the entire model* in one coherent language.  This, along with the advantages of the strongly typed, rapidly compiled Go language vs. duck typed Python for developing large scale frameworks, and the many other benefits of the Go language environment for reproducible, reliable builds across platforms, results in a satisfying and productive programming experience.
 
@@ -33,9 +35,9 @@ See the [ra25 example](https://github.com/emer/axon/tree/main/ra25/README.md) in
 
 * The `emergent` repository contains a collection of packages supporting the implementation of biologically based neural networks.  The main package is `emer` which specifies a minimal abstract interface for a neural network.
 
-* Go uses `interface`s to represent abstract collections of functionality (i.e., sets of methods).  The `emer` package provides a set of interfaces for each structural level (e.g., `emer.Layer` etc), that are sufficient to support the GUI and other general infrastructure provided by the emergent framework. Any given specific layer must implement all of these methods, and the structural containers (e.g., the list of layers in a network) are lists of these interfaces.  An interface is implicitly a *pointer* to an actual concrete object that implements the interface.
+* Go uses `interfaces` to represent abstract collections of functionality (i.e., sets of methods).  The `emer` package provides a set of _minimal_ interfaces for each structural level (e.g., `emer.Layer` etc), along with concrete "Base" types that implement a lot of shared functionality (e.g., `emer.LayerBase`), which are available as `AsEmer()` from the interface.  Each algorithm must implement the interface methods to support the Network view, logging, parameter setting and other shared emergent functionality.
 
-* The emer interfaces are designed to support generic access to network state, e.g., for the 3D network viewer, but specifically avoid anything algorithmic.  Thus, they allow viewing of any kind of network, including PyTorch backprop nets in the eTorch package.
+* The emer interfaces are designed to support generic access to network state, e.g., for the 3D network viewer, but specifically avoid anything algorithmic or structural, so that most of the algorithm-specific code uses direct slices and methods that return algorithm-specific types.
 
 * There are 3 main levels of structure: `Network`, `Layer` and `Path` (pathway of connectivity between layers, also known as a Projection).  The Network typically calls methods on its Layers, and Layers have methods to access Neuron or Unit-level data.  The `Path` fully manages everything about a pathway of connectivity between two layers, including access to Synapse or Connection level state.