let foo = 5;
Do you know register held the value 5 when executing that code? Do you even know what a register is or what are plausible answers to the question?
The correct answer to this question is: No, and I don’t care. Registers are locations in a CPU that can hold numerical values. Your computing device of choice calculates values using registers millions of times each second.
Way back when computers were young people programmed them using assembly languages. The languages directly tell CPUs what to do: load values into registers from memory, calculate other values in the registers, save values back to memory, etc.
Between 1943 and 1945, Konrad Zuse developed the first (or at least one of the first) high-level programming languages: Plankalkül. It wasn’t pretty by modern standards, but its thesis could be boiled down to: you will program more efficiently and effectively using logical formulas. A more blunt corollary might be: Stop programming CPU registers!
Software engineering is built upon the practice of developing higher-order abstractions for common tasks. Allow me to evince this pattern:
1837 — Charles Babbage: Stop computing by pencil and paper! (Analytical Engine)
1938 — Conrad Zuse: Stop computing by hand! (Z1, first electrical computer)
1950 — UNIVAC: Stop repeating yourself! (UNIVAC 1101, first computer with programs stored in memory)
1985 — Bjarne Stroustrup: Stop treating everything like primitives! (C++ language, introduced object-oriented-programming to the C language)
1995 — James Gosling: Stop tracking memory! (Java language makes garbage collection mainstream)
2006 — Amazon: Stop managing data centers! (AWS EC2 makes virtual servers easy)
2009 — Ryan Dahl: Stop futzing with threads! (Node.js introduces event/callback-based semantics)
2011 — Amazon: Stop provisioning resources manually! (AWS CloudFormation makes Infrastructure-As-Code easier)
2014 — Amazon: Stop managing servers! (AWS Lambda makes services “functional”)
Software engineers are always finding ways to make whatever “annoying thing” they have to deal with go away. They do this by building abstractions. It’s now time to build another abstraction.
The combination of infrastructure-as-code and serverless apps means developers are inundated with large, complex infrastructure templates, mostly written in YAML.
It’s time we learn from the past. We are humans who work at a logical, higher-order abstraction level. Infrastructure-as-code is meant to be consumed by computers. We need to abstract away the compiling of our logic into infrastructure code.
That’s what Stackery does. It turns this...
...into Serverless Application Model (SAM) YAML without asking the user to do anything more than drag and wire resources in a canvas. Stackery’s own backend is over 2,000 lines of YAML. We wouldn’t be able to manage it all without a tool that helps us both maintain and diagram the relationships between resources. It even performs this feat in both directions: you can take your existing SAM applications, import them into Stackery, and instantly visualize and extend the infrastructure architecture.
You may be a principal architect leading adoption of serverless in your organization. You may be perfectly capable of holding thousands of lines of infrastructure configuration in your head. But can everyone on your team do the same? Would your organization benefit from the automatic visualization and relationship/dependency management of a higher-order infrastructure-as-code abstraction?
As can be seen throughout the history of software engineering, the industry will move (and already is moving) to abstract away this lower level of engineering. Check out Stackery if you want to stay ahead of the curve.