strategic-communication

A best-of-breed language with a holistic approach to moving the needle.

Example program

This program prints the numbers 0 to 9 to stdout separated by newlines:

align Engineering and HR with stakeholder engagement
align revenue streams with stakeholder engagement
revamp revenue streams
align Finance and Manufacturing with customer experience
moving forward, think outside the box
deliver customer experience
deliver stakeholder engagement
innovate customer experience
innovate revenue streams
restructure revenue streams to think outside the box

Translated to pseudocode:

stakeholder_engagement = 10 // '\n'
revenue_streams = stakeholder_engagement * -1
customer_experience = 48 // '0'
do {
  print(customer_experience)
  print(stakeholder_engagement)
  customer_experience++
  revenue_streams++
} while revenue_streams < 0

More examples can be found in the examples directory.

Register names

There are 8 available registers. Each one starts with a value of 0, and can hold any 32-bit signed integer. They are named as follows:

customer experience
revenue streams
core competencies
best practices
stakeholder engagement
key performance indicators
return on investment
assets

Constants

There are 10 constants used to represent literal numbers (more information on using these can be found in the Constant expressions section below):

0: HR
1: Engineering
2: Legal
3: PR
4: Finance
5: Marketing
6: R&D
7: Sales
8: Manufacturing
9: Executive Management

Operations

A Strategic Communication program consists of a series of operations separated by newlines.

Unless otherwise denoted, all operands must be register names.

Description	Formats	Notes
increment the value in `x`	`innovate x` `value-add x`
decrement the value in `x`	`streamline x` `optimize x`
multiply the value in `x` by -1	`revamp x` `overhaul x`
multiply the value in `x` by 2	`amplify x` `incentivize x`
divide the value in `x` by 2	`backburner x`	any remainder is discarded
set the value in `x` to a random number between 0 and 9 inclusive	`paradigm shift x`
set the value in `x` to the value in `y`	`align x with y`	`y` can be a register name or a constant expression
set the value in `x` to the value of `y`	`align y with x`	`y` must be a constant expression
add the value in `x` to the value in `y` and store the result in `x`	`synergize x and y` `integrate x and y`
subtract the value in `y` from the value in `x` and store the result in `x`	`differentiate x and y`
read a single byte from stdin and store it in `x`	`crowdsource x`	if EOF is encountered, the value in `x` is set to -1
print the value in `x` to stdout	`deliver x` `produce x`	UTF-8 encoding will be used
define a label called `x`	`moving forward, x` `going forward, x`	`x` can be any string containing no register names or constants
jump to label `x`	`circle back to x` `revisit x`	`x` must be a defined label
jump to label `x` if the value in `y` is zero	`pivot y to x`	`x` must be a defined label
jump to label `x` if the value in `y` is negative	`restructure y to x`	`x` must be a defined label

Constant expressions

A constant expression is a sequence of one or more constants separated by , or and. The value of the expression is the result of concatenating the values of the constants. For example, Engineering has a value of 1 and Marketing has a value of 5, so the expression Engineering and Marketing has a value of 15.

More examples:

Engineering, Marketing, and HR = 150
Engineering = 1
HR and Engineering = 1 (leading zeros are ignored)
Marketing, Marketing, Marketing = 555

Comments

The syntax of Strategic Communication meets or exceeds the highest standards of corporate discourse, therefore comments are unnecessary and not supported.

Editor support

For those who are not seasoned executives, there is a syntax highlighter made by dnchu for VS Code: https://github.com/dnchu/vscode-strategic-communication

Running a program

To run a Strategic Communication program, download the interpreter for your system from the latest release and provide the path to the source code when running the command.

Windows

strategic-communication.exe examples\hello_world.business

macOS/Linux

./strategic-communication examples/hello_world.business

Building the interpreter

Clone this repo
Install Rust
cargo build

A note on performance

The way I implemented the interpreter is super naive; it re-parses every line it executes from its string representation every time. There are likely other easy performance gains I've ignored as well. For those that require high-performing Strategic Communication code (perhaps you want to write a stock-trading script for a Fortune 500 company, or maybe you're just annoyed that the FizzBuzz example takes multiple seconds to run), zydeco made a fork with much improved performance via LLVM JIT compilation.

rotoclone/strategic-communication