The Language-Driven Development™ (LDD) Process is the methodology associated to the Scalor™ platform. Like the Rational Unified Process (sometimes referred to as The Scandinavian Approach), originally the Objectory Method, and other methodologies that instantiates into processes, we speak about LDD™ as a software development process. We refer to LDD™ as a methodology while noting that it is continuously developed together with our customers based on our core technology. Unlike any other methods or methodologies or processes, LDD™ is a methodology firmly anchored in a specific highly researched mathematically founded and ground breaking new technology. This technology, the core technology at Functor AB, is the new constructive programming paradigm. To this end, the Scalor™ platform is, true as it is, a language for languages — although, at Functor we refer to Scalor™ as the language of languages. With LDD™ you begin with the language of the customer and you end with the language of the target machine.

The process is completely mathematically rigorous although you will not see it unless you wish to see it. Indeed, you can profit vastly from the method without anything near formal methods or verification, but you can rest assured that you stand on rock solid mathematical foundations. LDD™ is an entirely new way of developing software. The focus is on languages and obviously development begins with the human language since we must gather requirements and analyse the problem domain before domain experts, designers, architects take over, and it is all iterative, risk-driven. Scalor™ makes refinement of languages possible even up to mathematical precision (semantics preserving mappings) while also making traceability a reverse mapping which you, if you like, fully or in parts, make precise. Languages can be extended, refined, combined. With Scalor™ the focus is entirely on very high-level languages (EDSL’s) and on “code”, that is expressions formed from these languages and your incremental construction of new languages for the various components and artifacts in your project and problem domains. The focus is on code in the entire development process. Parts of your code maks up small languages, e.g. the language of a specific control system component, financial application, hardware model, telecom system, cryptographic protocol, etc. Your code is refined and traced back in each incremental step in development. The process is very coherent and can, for those parts you may prefer it to be, even be as mathematically rigorous as you wish it to be. Due to its focus on code and its lightweight approach, focus on people and languages, LDD™ inherits many traits of incremental and agile development processes by its very nature. And for most projects, the mathematical foundation is simply there. It ensures that you stand on firm ground, but you need no knowledge about it and no expert skills beyond programming.

With a general-purpose programming language or platform the programming process, left alone the entire development process, can be illustrated as in the first diagram below. This should be compared to the language-driven approach based on iterative, incremental refinements of embedded languages. Scalor™ is based on technology used in academia to model both programming languages and even natural languages. The expressive power of the Scalor™ platform at the very core of this new software development process, and the advantage is summarised in the second illustration showing that the programs expressed in a domain-specific languages have, to begin with, advantages in productivity. Requirements engineering, conceptual modelling and domain engineering becomes fully integrated with the programming activity with Scalor™ and LDD™ combined.

Scalor™ is a very high level of abstraction where embedded languages are directly supported (as well as, somewhat interestingly, systems programming).

Every problem domain has its own vocabulary. Every expert has his language. This applies also to the designer, architect and the developer of each component of a complex software system. We can trace these languages, appearing at various stages in an incremental development process, back, ultimately, to the language of the customer so that the intentions of the customer is faithfully preserved while gradually refined or extended into the intentions of the programmer with efficient Scalor™ compilation into executable programs from artifacts that in other software development where not captured in code. Functor’s core technology is capable of expressing even modelling languages such as UML (and as research has shown, even whole programming languages and natural languages, as spoken by humans, not computers). So although Scalor™ is, in the end, pure mathematical logic and constructive mathematics which can be compiled, all you need to know is that your artifacts are expressed in a language for languages which has a highly researched foundation that ensures that your programming is safe and that you become productive with an EDSL-based method for software development. Programming using the Scalor™ platform remains to be programming as you know it, in practice (the theory giving the safety guarantees, statically, and the expressivity, mathematically). The Scalor™ syntax and FFI/interoperability means that you can still use your ANSI C code and your OCaml, Haskell, Erlang, Scala, C++, Objective-C, Ada experience and make the leap in small steps rather than in one giant leap, still harvesting good value from this new technology.

Let’s put it in simple terms – with LDD™ and Scalor™ you can deliver software faster and with higher quality. You can also focus on and even reuse the artifact that is sometimes regarded to be of highest possible refinement in programming — code in the form of embedded languages and contractually specified components. With contractually specified interfaces, no longer in the form of logic but instead of a rich language of strong types which is more natural to us programmers, teams can work more independently since the contractual interfaces enforce all properties you wish to to hold between components in the system at hand. These components cannot be assembled if the “wiring” (interfaces) is wrong. Up to now, the wiring has been rudimentary. With contractual interfaces at the level of statically checked types this wiring can be very carefully laid out to avoid defects that propagate from one component to another, or worse, that are solely global. Interfaces are types, like in Java or Objective-C. It’s just that they, based on mathematical foundations, goes so much further than what we have so far seen in C++, Java, Scala, Haskell, etc and can express precise properties, based on dependent types, which are statically ensured to hold so that a bad program simply does not compile since interfaces and types would be violated and the type checker logically tells us so before the program has caused any damage. In this way, many problems can be prevented both at the smaller scale and at the larger scale with our core technology and with LDD™/ Scalor™ being deployed.

At Functor, we are, frankly, rather amazed by how revolutionary our core technology and its emerging software development processes are. We have noted that other methodologies (strictly speaking, these are, like LDD™, instantiated into a software development processes) have attempted to achieve, and surely to some degrees been successful, some similar advantages (TDD, BDD, LOD, indeed agile methods since they too are code centred) but never have they, as far as we see, before been supported by such a ground breaking technological, even less mathematical, foundation. At Functor, we believe that methodology and technology should fit together perfectly, each tailored for the other. And this is Language-Driven Development™ – after more than four decades of world-leading research internationally Functor can offer something radically new to the industry!


Elsewhere, we read that language-based verification will change the world. We all know about test-driven development and behavior-driven development and the rediscovered value of (embedded) domain-specific languages (quality, productivity, reuse at a very high level). Language oriented programming and intentional programming paved the way for a new and evolving software development process — Language-Driven Development (LDD™) from Functor AB.

Language-driven development (LDD™) is based on software development with full-spectrum tools for the new constructive programming paradigm. We like to speak about our Scalor™ as the language of languages. The underlying technology is new in the industry, but has many years of research behind it (dependent types and Martin-Löf type theory and its extensions). This technology has been proved to be useful even for representing natural languages (Ranta et al) and was, as it began to make it ways into computer science from mathematical logic, used as a (meta) language for programming languages (Plotkin et al) — even programming languages could be embedded into “a logical framework” (which is still contained in Scalor™ today). Now, several years later, basic and applied research on programming theory, programming languages and compiler technology (e.g. normalisation-by-evaluation as in Glimming, 2010) has finally made it possible to introduce a new paradigm to the industry … the constructive programming paradigm. As shown in recent work (Glimming et al, 2011), the approach supports a mathematically founded approach to component-based programming with contractual interfaces. Although it may seem to be irrelevant in practice, the founding on mathematics implies a consistent elegant, scalable approach with optimisations possible via proof techniques, with structure inherited from a category theoretic model, and with an understanding of specifications and interfaces purely in terms of dependent types, W-types and universe constructions. In practice, this means that programming is programming and not logic as in Spec# or Microsoft Code Contracts. There is no need for logical expression or mathematical formulas. The intention of the programmer is instead expressed not only using embedded languages but also using a rich language of types and interfaces that goes far beyond any language used today in the industry. We believe this is the beginning of an important programming (and software engineering) paradigm shift. In fact, we believe it is the beginning of a revolution in how we develop computer programs (indeed “will change the word”, was title of the first paper cited)!. Many decades of research can, at last, be leveraged to help us with the pressing problems in software development — the software crisis in the 1960ies is not quite over yet as society has become entirely dependent on software and 30% of all software projects do not reach conclusion (AT&T, 2012) while about half of all programmers in the United States, every single day, is working on testing software to eliminate bugs and defects while simultaneously, while spotting sometimes very hard to find bugs, unavoidably introduce on average a number of new bugs while doing so.

This paradigm ideally carries a methodology which we refer to as Language-Driven Development (LDD™) at Functor AB. In these efforts, we seek partnership with researchers in software engineering, consultancy companies with an interest in embedded domain-specific languages and also companies who wish to take functional programming to the next level, e.g. for the financial industry or to deal with a grand challenge in control theory (IEEE, 2011). Constructive programming takes a quite significant leap on the basis of functional programming, while supporting elegantly object-oriented and imperative programming. Companies such as Jane Street Capital, whose CTO (CACM, Nov. 2011) pinpoints the value they have drawn from e.g. OCaml, while with Scalor™ mathematical models and higher reliability can now be achieved. Stroustrup (IEEE, Jan 2012) gives two good reasons for this, while with the constructive programming approach the industry can see benefits in several other areas also of great importance (DSL’s, mathematical modelling, optional logic and formal reasoning while completely transparent). Scalor™ has a syntax close to C and also interoperates with ANSI C.

IEEE Spectrum recently had an interesting headline — Computers, it’s time to start over … It is not just technology we need, but also methodology to go with it. Interestingly, here these two key elements of software development are actually unified while standing firmly on mathematical foundations that is not exposed but gives trust that any engineer would expect from his/her toolbox. Interestingly, the toolbox is to a large extent the same admitting a gradual move to a more productive development process giving software of higher quality in shorter time. Quality software actually costs less than other software without identifiable/measurable quality traits, as shown e.g. by AT&T (2012).