Dynamic Site Builder (DSB)

What is the DSB?

The DSB, or Dynamic Site Builder, is the first real piece of software I ever wrote. It started out humble enough: a collection of a few files and folders that created a website in a sensible way.

Over time, it grew. And grew. And grew. Currently, the DSB is in version 2.5+ and has a lot of the initial functionality separated into modules.

To date, there are over 100 modules in the DSB, and this doesn't even include the some of the larger files and frameworks!

It's become so large in fact that I've had to separate them into 2 separate softwares just to keep track of it all!

The Dynamic Site Builder

Everything you need to build a website,
with a little of everything you'd want.

The Dynamic Software Builder

Everything you need to build most software,
plus a lot of stuff you'll love.

Everything you need?
That's a mighty big


It's true though. This very site was created using both!

The Dynamic Site Builder

  • A skeletal structure that all sites follow
  • A javascript-driven development platform
  • A PHP-compatible server
A brief history of the DSB (and why it exists)

In the beginning, the DSB was a collection of a few files and folders. A way to make sense of how to build dynamic websites where one thing could be changed without causing a cascade of other things that needed to be changed.

WordPress was a bucket of bolts at the time, limited, overbloated, and full of security concerns. I had used WYSIWYG editors starting out (my initial field was marketing). Once I had reached the limitations there I looked to programmers. What I got was a bunch of headaches and lighter wallet. Frustrated, I began researching how to do it myself.

Over several years, the DSB took it's form. It became a solid infrastructure for building sites much more quickly, cleanly, and easily.

What does the DSB do?
  • provides consistency and standards by using a structured file system dependent on only a handful of key files
  • provides a development platform with essential tools
  • works with databases and caching
  • easily enables optional features like cookies and analytics
  • provides a GUI manipulator for frame elements (great for theming)

it keeps me out of the back-end so I can focus on the front!

In the beginning was the DSB, and it was good.

After a while, things got a little out of hand.

Okay, really out of hand.

It was clear something had to be done.

Enter the DSB, version 2.0

Over 100 modules so far.

Logic condensed to seconds.

Templates that make you say "Ooh"

Mutable signatures for make you say "Wow"

The Dynamic Software Builder

  • A top-level library of really sweet modules
  • A self contained debugging and diagnostics utility
  • A collection of extensible objects for rapid development

Zip, zoom, bing, bang, done.

"I don't always write application logic, but when I do, I dsb-".

Active Modules

animate animates a thing with great control
animation JS driven animation station (with CSS3 as able)
animations a collection of animations and triggers
args an argument processing utility
array does many useful things with arrays
attach importer tool for modules and files
between determines if a number is within min and max
belongs determines if an object belongs to a constructor
callback a sophisticated callback handler
chop splits a logical string into an array
collides hitbox detection in 2D and 3D space
compare compares 2 items (objects, arrays, numbers, strings have optional loose compare)
console returns native console or a recreated one. optionally adds missing methods to existing console (if found)
construct creates an object from signature( [parent], [presets], keys, [default] )
contains checks if an object, array, number, or string contains X
count counts the items in an object, array, or string
debug an easy to use debugging tool
debug-lite a much lighter version of dsb-debug
debug-mini an easy to use debugging tool not reliant on dsb-debug
debug-presets some default items to test against
debugger an comprehensive debugging tool
defined returns false if {value} is {undefined} or {root}
each the essential iterator
first returns the first X of Y, with some useful variations
group a factory for groups - can have a parent group and child groups
handle accepts (handle, handlers) where handle corresponds to a key in handlers. handlers are methods.
has determines if an object has any or all provided property keys. optionally returns 1st match
html dynamically creates HTML elements for the DOM
is checks if {A} is {X}, with a lot of possible correct answers (typecheck, compare, etc)
keys extracts the keys of an object and returns them in an array
last finds the last N in an array, object, number, or string (with useful variations)
learn teaches an object the properties of another (prototype if available)
log a simple logging function through root.console
magic-string the string formatter we've always needed
merge merges two or more objects
mute TRAIT mutes, unmutes, tells if muted
native determines if a module is a dsb module
number a collection of essential number methods
offsets retreives dimensions and placement of an object in a given space
object a collection of useful object methods
package an all-in-one utility for configuration objects
primitive creates a clone of JS primitive to use as DSB primitive
printr prints an object in a nice, neat fashion
queue creates a queue for organizing things procedurally
random a collection of generators for random things (numbers, colors, etc)
read reads a file or folder
resolve resolves a conflict of some sort
resolver resolves the 'signature' of arguments, an object, or an array
setting for working with configuration objects
stack returns property of an object through array or concated.string ( obj, 'real.prop' ) => obj[real][prop]
store an extremely simple, store-only object storage system
strap strap imports and attachs local modules in an easy way
string a collection of essential string prototype methods
string-args converts argument(s) to string as appropriate type
string-contains checks if a string contains another string
teach adds a property or properties to an object's prototype (or directly, if non-constructor)
templater a useful module for building standalone methods from the primitive modules
test creates a generic test to be used with dsb-tests
timer Useful timer functions
to a library of object converters/transmutors
traits a collection of traits to strap to objects
typecheck returns the real type of an object
utils a collection of essential methods

DSB Modules

server an easily configurable express server for testing web applications
jade-templates essential jade templates for rapid GUI development
system a global organizer. exact purpose YTD as it could be too dangerous
gui GUI development/manipulation toolkit
gui-frame made specifically for the DSB framework (for theming)
gui-spoof creates an empty shell of an element (with the same dimensions & placement)

Transfers Modules

logger a more sophisticated logging tool. has GUI support
loader keeps track of loaded files. can load files as well
baby 3D Baby as an npm module
world a world system for baby

External Modules

chalk dsb-fancy-console syntax for chalk!
dom creates a working DOM for testing modules that require a DOM
event an event manager built on top of the Node Event module
jade jade with some extra functionality
jquery literally just jquery.min.js
node-argv provides a cleaner way to gather args from CLI and Node's processes.argv

Basic Modules

array-contains checks if an array contains a given item
base base creates/registers a new global property
capitalize capitalizes the first letter of a word
clone clones a js object
env returns string {Node version} or boolean {false}
is-object-array checks that an object is an actual object with properties { a: 1, b: 2 }
is-url URL matching through Regular Expressions. Returns boolean.
lowercase converts a string to lowercase characters
root finds and returns the root (global) object.
simple-return returns whatever is provided or new Boolean(true)
template a template for building larger javascript modules
template-lite a light template, ideal for smaller javascript modules
thru returns the first argument provided (through method)
to-array just your run-of-the-mill toArray method
to-string native Object.toString method
trim removes space characters from the beginning and end of a string
types returns an array of types (primitives + extended)
uppercase uppercases a string

Beta Modules

diag processes all modules with a certain prefix for diagnostics

Alpha Modules

date the things you need when it comes to Date
docate an auto-documentation software
grammar wordplay made easy. useful for things like auto-tensing states (skip, skipped, skipping)

Retiring Modules

functions a collection of methods that are mostly elsewhere now

Removed Modules

sizzle just sizzle. considering it to replace jquery selectors in few dsb modules that use it.
solidify accepts an object with {target: HTMLElement}, adds {self: $(HTMLElement) }
template-site too underdeveloped at this point. code still in site builder

Obsolete Modules

tap I considered using tap in my debugging process, but went with vanilla

Other Modules

lab a collection of various experimental things

So yeah. Phew. There's quite a bit there when you look at it like this. It even suprises myself!

The DSB will (hopefully) reach 3.0 in a few more months (mid-2017). Part of it will be open-source, the rest packaged out, and all of it (eventually) available as a complete web system (in the form of a subscription service).