The result is Coreisma.
In this article, I’d like to share the steps I took to build it.
I believe that good software is written deliberately. Meaning the choices that a programmer chooses should come from a set of philosophies. For Coreisma, I these philosophies to:
- Create a simple architecture pattern; not another framework
- Not tie myself to a particular framework (ie. jQuery, Prototype, YUI)
- Use TDD to ensure test coverage.
The Small Steps
Coreisma starts, as all very abstract cores should, very small. I simply provided a means to extend the object itself. Pass a json object or more powerfully a function that receives Coreisma itself.
1 2 3 4 5 6 7 8 9 10 11 12 13
Then, using this
extend function, I exposed a more developer-friendly way to add an extension. I boringly called this function
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
I wanted a way to name extensions. It isn’t retained or used in any way but it is a nice way to briefly describe what the extension does. Maybe one day this will allow for some simple self documentation.
Likewise, addExtension stores all extensions in a, you guessed it, “extensions” private variable.
addExtension passes core and a hub to an extension. At first hub is undefined, but coreisma wouldn’t be useful without it, so I figure it is a safe assumption that some “hub” will be there.
I probably should have broken the next extension up into three separate extensions:
getModule, and finally
stop of Coreisma. I believe that the root of this was because I was TDDing. I could not seem to think of a way to test addHub without starting Coreisma. Seems like a good candidate for a refactor, but for now here is the “Hub” portion of Coreisma.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
Despite the name “Hub” of the previous extension, we haven’t defined a working hub yet.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
The Hub exposes four functions: register, find, listen, and broadcast. They do what you expect them to do.
registermakes a module known. It passes the core and hub to the module to work with and automatically sets up a modules init and shutdown functions
findretrieves a module by name.
listensetups up a callback when a certain event happens.
broadcastdeclares that a certain event has happened to all listeners.
There is room to grow with Coreisma but I think this spunky architecture has a bunch of potential.