Even with all of the many criticisms of the Scaled Agile Framework (SAFe), people still seem to use it. So let's do a thought experiment and ask the question, "if SAFe were a programming language, would you use it?"
To answer this question, let's hypothesize a satirical programming language.
Introducing SafeScript: A DSL for building valuable software using the SAFe methodology
SafeScript is a domain-specific language (DSL) geared toward building valuable software using the SAFe methodology.
It is a statically typed, purely functional, expression-based language executed by a special interpreter called the Execution Train Engineer (ETE).
Providing the SafeScript ETE with a SafeScript program enables you to get good, cheap, and fast execution thanks to its fully reversible design.
Design principles
Modular and functional: The core building blocks of SafeScript are functions and modules.
Functions can be contained within modules and modules are contained within files. Logic may be contained within either functions or modules, but modules cannot be within functions, though don't forget they are in files. Logic may not live outside of a function unless inside a module in the form of bindings. In this essay
All functions are anonymous by default: Functions are the backbone of your application, the workhorses of all modern software. Just as developers are the workhorses of a software product's construction! Because of this similarity, functions are anonymous by default, just like SAFe treats developers as nameless and faceless.
Value is a top-level concept: As part of SafeScript we’ve made val a keyword so it becomes very clear where your software adds value. This makes it very easy for static analysis to determine how much business value a program adds by simply counting the prevalence of val keywords.
Syntax forged in the fire of conceptual theft: Just like SAFe borrows a little bit from various project management frameworks, as well as adapting concepts from Agile software development, the syntax of SafeScript borrows from other languages. Mostly, it descends from OCaml, Elixir, and a car crash.
Total side-effect conversion: All side-effecty program units are automatically converted to side-effect free code using a process called total disjoint removal. This functionally prohibits non-essential operations such as printing to the screen, which you probably didn't need to do anyhow. If management wanted developer input, they'd ask for it.
Objects, done right and done safely: Object systems are a fantastic language feature which help to promote productive linkages between related data and behavior. However, they can also be a source of bugs, so SafeScript has a built-in safety net which uses pre-emptive inspection to actually optimize away any fallible code.
Security from the get-go: The SafeScript compiler ships with an approval engine as part of the SafeScript Workflow Approval Platform (WAP). This means that it will only accept programs which have been pre-approved. To gain approval, submit your program to the appropriate team by opening a ticket. Please be sure to include the business rationale and a funding stream. You will receive approval within 5-10 business days, following which you may use the --approve compiler flag. This will activate all instances of the approve keyword in your source code.
Deliberately branchless: While most programs make heavy use of conditional logic in the form of if statements, SafeScript has no such concept. In SafeScript, you make a plan when you write your code, and you stick to it no matter what.
Examples
While there is no hello world equivalent for SafeScript (why would there be, you should be getting to work and delivering value instead of standing around gabbing all day), the following is a valid program.
using [Core]
val panda <~ "bamboo" do
Core.export(panda)
end
Top comments (1)
I feel like if we're gonna have this language, the functions need to declare how many story points of CPU they think they need to run and if they get it wrong they get added to the retro queue to be specially optimized by the compiler