Home Explore Help
Sign In
swf-projects
/
meeting-minds
2
0
Fork 0
Files Issues 0 Pull Requests 0 Wiki
Tree: f809cdfce2
Branches Tags
meeting-minds
/
meeting-minds.org

meeting-minds.org 10 KB
History Raw

Meeting of the Minds

COMMENT Export 

  (save-buffer)
  (let ((org-confirm-babel-evaluate
         (lambda (lang body)
           (declare (ignorable lang body))
           nil)))
    (org-latex-export-to-pdf))

COMMENT Tangle 

  (save-buffer)
  (let ((python-indent-offset 4))
    (org-babel-tangle))

Introduction   nonum

CLOSED: [2016-04-02 Sat 21:24]

As time has gone on, I've started seeing the "Slack" chat platform become more and more popular. I see this as both a good thing, in that it promotes communication within teams, and a bad thing, in that it's not controlled by the company that actually subscribes to it, and it isn't free software. Because of the benefit, and as a response to the issues, I've decided to build this application, "Meeting of the Minds", built on standards and free software so it's likely to stay around for a long time. Thus, the goal is to produce an application that gives the following features:

  • Archival

  • Group Messaging

  • Easily Defined Groups

  • User-to-user Messaging

  • Simple Management

  • Freedom

To accomplish this task, I've decided to build using the following tools and suites:

IRC

The Internet Relay Chat protocol. I've chosen this as the transport protocol as it's been around for quite some time, and is well supported.

PostgreSQL

An SQL storage backend. This will be a way to store metadata about conversations, topics, users and projects, allowing for data archival. I've chosen PostgreSQL as it has many advanced features and is very space efficient.

Common Lisp

The server implementation language. I've chosen to use Common Lisp to implement Meeting of the Minds for the following reasons:

  • Familiarity

  • Flexibility

  • Library availability

TOC   ignore

WORKING Architecture [0/3]

To accurately emulate Slack, this system must be fairly complex. This can be accomplished by designing the system as it is built, or by laying the ground work first, developing a plan and specifying the design. In the first, which has become popular, while the system can be built quickly, it is often an error-prone and bug ridden process. The second, my choice, can take a bit more time, but because things are thought out before hand, can produce a better, less buggy final product. The goal of this is to define both the architecture of the system, and the protocols upon which it runs.

WORKING Protocol Design [0/4]

Slack has been designed as a team chat software. While it once was implemented on top of IRC, it appears to not be anymore. However, for the specific area that the app targets, IRC seems like a logical choice as a base for a communications protocol. As such, I'll have to leverage various parts of IRC, including the following:

  • Channels

  • Direct messaging

  • Authentication

In addition to these things, I'll have to ensure that logging, user look-up and user management is supported and available.

Use of Channels

Foo

The Back and Forth

Foo

Authentication Mechanism

Foo

Logging Control

Foo

Data Storage Requirements

Foo

Management System

Foo

WORKING Database Design [0/5]

Foo

Users Table

Foo

Conversations Table

Foo

Topics Table

Foo

Archives Table

Foo

Decisions Table

Foo

Management Interface

Foo

WORKING Protocol Implementation [0/2]

Foo

Server Side

Foo

Client Side

Foo

WORKING Packaging [0/2]

WORKING The packages file

This file describes and defines that packages, or namespaces used in the application. These include the following:

meeting-minds.db

The database interaction layer.

meeting-minds.protocol

The server-side implementation of the protocol. This handles authentication, channel management and the like.

meeting-minds.protocol-client

The client side implementation of the protocol. This will handle authentication with the server and provide an interface for both the GUI client and programmable bots.

meeting-minds.log

This provides the logging portion of the server system, and will be used to create logs of group channels.

meeting-minds.web-interface

This provides a management interface and log access system.

meeting-minds.ui

This provides a user interface for chat, log retrieval and management.

meeting-minds

The main package, this is used to tie all of the other packages together, and can be used to produce a callable daemon. 

  (defpackage #:meeting-minds.db
    (:use #:cl
          #:clsql))

  (defpackage #:meeting-minds.protocol
    (:use #:cl
          #:birch
          #:meeting-minds.db))

  (defpackage #:meeting-minds.protocol-client
    (:use #:cl
          #:birch))

  (defpackage #:meeting-minds.log
    (:use #:cl
          #:cl-who
          #:meeting-minds.db))

  (defpackage #:meeting-minds.web-interface
    (:use #:cl
          #:ningle
          #:clack-errors
          #:cl-mustache
          #:meeting-minds.db
          #:meeting-minds.log))

  (defpackage #:meeting-minds.ui
    (:use #:cl
          #:meeting-minds.protocol-client
          #:commonqt
          #:qtools
          #:qtools-ui))

  (defpackage #:meeting-minds
    (:use #:cl
          #:meeting-minds.protocol
          #:meeting-minds.log
          #:meeting-minds.web-interface))

WORKING The ASDF System Definition

The definition of a system, or in Lisp terms, a set of connected and related software, either libraries or applications is what allows this to be put together and built. This is done using ASDF, or the "Another System Definition Facility". 

  (asdf:defsystem #:meeting-minds
      :description "Describe meeting-minds here"
      :author "Samuel W. Flint <swflint@flintfam.org>"
      :license "GNU GPLv3 or Later"
      :depends-on (#:ningle
                   #:clack-errors
                   #:clsql
                   #:stefil
                   #:ironclad
                   #:cl-who
                   #:commonqt
                   #:qtools
                   #:qtools-ui
                   #:daemon
                   #:babel
                   #:uiop
                   #:cl-mustache
                   #:birch
                   #:irc-logger)
      :serial t
      :components ((:file "package")
                   (:file "meeting-minds")))

Clear to odd and appendix   ignore

Terminology

WORKING Packages Used

ningle

A smart, simple web framework for the management/browsing interface.

clack-errors

An error handling library for the clack/ningle framework.

clsql

An SQL interface library that works extremely well with PostgreSQL.

stefil

A testing framework

ironclad

Encryption and hashing.

cl-who

HTML Generation.

commonqt, qtools, & qtools-ui

A GUI library for the user interface.

daemon

A daemonization system for the server.

babel

Byte string manipulation.

uiop

A utilities collection.

cl-mustache

A templating framework based on the popular "Mustache" system.

birch

An IRC bot framework.

irc-logger

To provide IRC logging functionality.

Sources and Documentation Links

Clear to bottom   ignore

Version Information   nonum

This document is version src_sh{git describe –always –long –dirty –abbrev=10 –tags}.