tagt

Name: totally awesome [global|generic|][tool|tools|tech]

Reorganize - note Darren, and get info links from him

Command-line tool

About

Specs

Core command

Command names

tagy (all systems)
t (optional alternative - set by default)

Command structure



global command (but configurable)
might install Firefox, Chrome and Opera
tagy install browsers

external command (not provided by us)

might ping all servers in list and print an appropriate output
t ping-servers [cluster-or-server-name]


local command (for a personal project)
a script we use to set up set up a server and cluster
t tagmata sus [server-name]
t tagmata suc [cluster-name]

Hierarchical command structure

Tagy files

Makeup

can be comprised of multiple files of different script types
scripts can be in the same file or external
config info is stored in a YAML section (hence the ‘y’)
dependencies etc are all handled
if all parts in the file, then are split using code below

## [tagy] (if the part is YAML)
or
## <tagy> (if a script)

code must occur as first character of the line
if YAML included
can occur in any order

Listing all available commands

Development

Pending

Core

Install so it call from anywhere

self-install into /usr/local/bin
can be called from anywhere

General option parsing

some options common to all commands
e.g. -y = yes to all questions

Handling of tagy files

split files into parts
read YAML
check for dependencies
- install if necessary
save parts to /tmp folder to execute
execute (in background an option
- can set periodic checker to kill if necessary
delete temp files

Importing of global files

default paths for looking for global config files
search in local folder, home folder and /etc (or similar)
global config file sets up paths where projects can be imported

Importing of external files

idea is to make a generic tool for any task
over time can build up large repository of scripts
as much as possible try to make scripts customizable
can have info stored in tagy files (Tag + YAML)
external files can overwrite global files
- ask permission

Importing of local files

automatic detection of projects using global config
all projects use the generic config / commands
each project can have its own config
each project can have commands specific to the project
local files can overwrite global / external files
- ask permission (option -y to ignore warnings)

Servers and backups

Connecting to remote servers

remote login
remote execution
uploads / downloads
combine pushes using Git and pulling on the remote server

Backups using Git

installs git
checks that SSH keys are installed
- can import one / more keys
- can generate one / more keys
self-updates from BitBucket by default (configurable)
might use Github if open-source it later

Complete backup / install

combine Git backups with installations on remote servers
wide range of options
can be tailored to the project

Install package groups

using OS package manager
make generic in nature
initially focus on Ubuntu
can import package groups from external sources

Groups :

core
server
devel …

Progamming

Language features

syntax-agnostic

customizable / extendable

potentally could add additional functionality to the syntax - just need to define before

completely customizable (syntax, natural language, inline/hidden meta info)

internationalized

omni-directional (ltr, trl, ttb, btt, mixed (e.g. chinese - inline ttb, but ltr or rtl in flow

meta-separable

meta-selectable (use selectors on flow elements) - meta sheets, for min/max values for loops, permissions

use selectors like in CSS

composite

object-structured

teacheable (AI) programming

AI (so can say that if a loop exits with less than 4, that it means x - and can reference

flow objectified

non-cascade selectable

don’t have to always follow a downward trend - can up check too

universally consistent

everyone uses the same platform / elements (even though can customize) - so bugs are easier to fix, as only done in one place

composite-oriented

Server platform

Core

Installation

Pending

Install script for the core software

OpenResty
Couchbase
Node.JS
Jison

Couchbase

Pending

OpenResty

Pending

Short-term

Node.JS

Pending

Medium-term

Elastic Search

Hortonworks

Long-term

Code-analyzer

Analyzing code

Generic

Importing code

Gingko

Basic features

Import of all external Gingko code
Re-generate nice JS that seems hand-written
Mix up the order of the functions etc
Re-format the code to my style
Work out comments to make look like my work (harder)

Development platform

Core

Card-organizer

Objects

Definitions

General

Types

Definition

For building all the object definitions

Elementary

Basic selectors / type checkers etc.

These will actually be built in a circular way, from things like list / table objectts, but are used as building blocks rather than on their own

Complex

Definition objects built from other objects (either elementary definition objects or other, more complex, objects)

Coding

For building up all the systems into an integrated framework - for client, server, batches or more

Coding

Include parsers in any / all programming languages that people use

Flow

For branching etc

Data

For all data flow

API

For integrating with arbitrary services

In

Out

Database

For integrating with various databases

Relational

NoSQL

Data processing

Importing / Exporting

For parsing individual files or data streams

Text

Line-based

Could be CSV, tabulated or a customary format

Example: importing

Markup

XML

HTML

MathML

Wiki

Binary

Merging / Splitting

Combining multiple data sources into meaninful combinations

Visualizations

Actions

Events

Customization

For building customized configurations and admin panels

Configuration

To make it quicker and easier

Admin

For building admin panels for config nodes

Interface

Combines configuration and admin panels, potentially along with any other objects

Interfaces

Implementations

Browser tools

Server API

Development

Nginx config file for following features:

basic page load

single page where put in URL
loads JS
analyses JS
loads previous analysis for comparison
displays

Inter-connected web

profits are made through providing excellent marketing services
no ugly advertising
revenues are shared by the people that create quality content that is popular
p2p
use a lot more URN’s instead of URLs (though can still be used)
don’t have ugly advertising everywhere
site owners can worry about creating quality content that’s useful to people
if they do a good job, then will earn revenues
gingko in multiple directions
bi-directional / multi-directional associations
use standardized software to perform the analyses - the rules are decided upon / modified by everyone (experts primarily)
need to develop a new kind of browser
p2p
encrypt all data
separate who provides a service and where the data is stored
e.g. can select one or a few people to hold financial information
choice is made by the user, not the company
new type of system - built into the framework of the network
peer agreement / blockchain
need to be such that only the two ends and the intermediary have access to the information

Notes

Designs

Integrate

Fonts

Google fonts

Font squirrel

adobe edge web fonts

http://alternativeto.net/software/adobe-edge-web-fonts/

Javascript

Tools

Site

Logo

Usage

In other logos

Other logos, for all the different services we will offer, can incorporate the stylized tag into the rest of the logo

The tag with the two t’s can easily be recognized, and is distinguishable from the ‘f’ of Facebook etc

Idea

In the background, a circular, plastic-looking tag (like dogs have), with a hole in the bottom right. On the tag are two t’s, to the left, slanted backwards about 20 degrees, and the t to the right, slanted back at a more acute angle.

The t’s are rounded a bit to follow the contours of the tag.

In between them, there are the letters ‘a’ and ‘g’. The g is sort of wrapped around the hole in the tag, which is between the two t’s, and the ‘a’ somehow perched between them.