 APL strips away a lot of boilerplate fluff, but it does so in a way without over-abstracting the problem. So, it delivers an ultra-high-level high-productivity programming language that allows you to reason at a high level, at the machine level. So it allows you to do something called mechanical sympathy, or to have mechanical sympathy. So you get a programming language that is basically an executable mathematical notation that performs oftentimes faster than handwritten C code and other stuff. And it's portable, it's platform-independent, all of these things that you want in a high-level language, but you get this ultra-high performance from it. And the language itself makes sense to domain experts. People who are statisticians, mathematicians, chemical engineers, business information, people, logicians, all these people who have all this domain knowledge, say an actual area or an accountant, who has all this knowledge about a given domain, APL can enable them to solve their problems directly in their code, write those solutions without ever having to have a big IT team to support that. And so then the IT team can focus on delivering cleaner architectures rather than trying to figure out what the special knowledge is that the domain expert has. So it empowers your team, or even your individuals, to do what they do best. So the domain experts can actually make sure that the code is doing what they want it to do, doing the right thing, while the IT guys can focus on delivering good software engineering around that. And it creates a really good synergy, and it does so at a very high level of productivity and performance.