;;;; Common Lisp implementation of the Web Economy Bullshit Generator.
;;;; See http://dack.com/web/bullshit.html for the original.
;;;;
;;;; Examples:
;;;;
;;;; CL-USER> (bullshit-list)
;;;; (TARGET MAGNETIC INFOMEDIARIES)
;;;;
;;;; CL-USER> (bullshit-item)
;;;; "Exploit sexy initiatives."
;;;;
;;;; CL-USER> (bullshit-sentence)
;;;; "We guarantee to engage enterprise relationships to reintermediate
;;;;  cross-media vortals."
;;;;
;;;; CL-USER> (bullshit-paragraph)
;;;; "It is imperative that we productize cross-media e-markets or enable
;;;;  compelling applications.  We engineer holistic methodologies in order
;;;;  to embrace 24/7 infrastructures to monetize impactful niches.  We
;;;;  guarantee to expedite sexy mindshare and redefine 24/7 e-business.
;;;;  This makes it possible to orchestrate killer technologies to e-enable
;;;;  best-of-breed bandwidth to be able to utilize compelling
;;;;  infrastructures."

(defparameter *verbs*
  '#(
     aggregate
     architect
     benchmark
     brand
     cultivate
     deliver
     deploy
     disintermediate
     drive
     e-enable
     embrace
     empower
     enable
     engage
     engineer
     enhance
     envisioneer
     evolve
     expedite
     exploit
     extend
     facilitate
     generate
     grow
     harness
     implement
     incentivize
     incubate
     innovate
     integrate
     iterate
     leverage
     matrix
     maximize
     mesh
     monetize
     morph
     optimize
     orchestrate
     productize
     recontextualize
     redefine
     reintermediate
     reinvent
     repurpose
     revolutionize
     scale
     seize
     strategize
     streamline
     syndicate
     synergize
     synthesize
     target
     transform
     transition
     unleash
     utilize
     visualize
     whiteboard))

(defparameter *adjectives*
  '#(
     24/365
     24/7
     B2B
     B2C
     back-end
     best-of-breed
     bleeding-edge
     bricks-and-clicks
     clicks-and-mortar
     collaborative
     compelling
     cross-platform
     cross-media
     customized
     cutting-edge
     distributed
     dot-com
     dynamic
     e-business
     efficient
     end-to-end
     enterprise
     extensible
     frictionless
     front-end
     global
     granular
     holistic
     impactful
     innovative
     integrated
     interactive
     intuitive
     killer
     leading-edge
     magnetic
     mission-critical
     next-generation
     one-to-one
     open-source
     out-of-the-box
     plug-and-play
     proactive
     real-time
     revolutionary
     rich
     robust
     scalable
     seamless
     sexy
     sticky
     strategic
     synergistic
     transparent
     turn-key
     ubiquitous
     user-centric
     value-added
     vertical
     viral
     virtual
     visionary
     web-enabled
     wireless
     world-class))

(defparameter *nouns*
  '#(
     action-items
     applications
     architectures
     bandwidth
     channels
     communities
     content
     convergence
     deliverables
     e-business
     e-commerce
     e-markets
     e-services
     e-tailers
     experiences
     eyeballs
     functionalities
     infomediaries
     infrastructures
     initiatives
     interfaces
     markets
     methodologies
     metrics
     mindshare
     models
     networks
     niches
     paradigms
     partnerships
     platforms
     portals
     relationships
     ROI
     synergies
     web-readiness
     schemas
     solutions
     supply-chains
     systems
     technologies
     users
     vortals
     web-services))

(defparameter *sentence-starts*
  '#(
     we
     |we guarantee to|
     |it is important to|
     |it is imperative that we|
     |we ensure to|
     |this makes it possible to|
     |this enables us to|
     |always remember that we|
     |moreover, we|))

(defparameter *sentence-separators*
  '#(
     and
     or
     to
     |in order to|
     |to be able to|
     |which enable us to|))

(defun random-symbol (vector)
  (svref vector (random (array-dimension vector 0))))

(defun bullshit-list ()
  (list (random-symbol *verbs*)
	(random-symbol *adjectives*)
	(random-symbol *nouns*)))

(defun print-sentence (list)
  (format nil "~@(~{~a~^ ~}~)." list))

(defun bullshit-item ()
  (print-sentence (bullshit-list)))

(defun bullshit-sentence ()
  (let ((l (list (random-symbol *sentence-starts*)))
	(r (1+ (random 2))))
    (declare (type fixnum r))
    (loop repeat r do
	 (setf l (append l
			 (bullshit-list)
			 (list (random-symbol *sentence-separators*)))))
    (print-sentence (append l (bullshit-list)))))

(defun bullshit-paragraph ()
  (let ((s "")
	(r (+ 3 (random 3))))
    (loop repeat r do
	 (setf s (concatenate 'string s
			      (bullshit-sentence)
			      "  ")))
    (subseq s 0 (- (length s) 2))))