Completely language-based

Since our driver is natural language, the whole building process in our platform is reduced to the capability of the user to be precise about the description of the expected end process. This certainly beats needing to learn a technical programming language on top of that. We take the burden of building an application away from a technical role, and give it back to the end-user domain. This means that everything your app will do is based on the language you use to describe it without requiring much else.


 

Build in any language

 

 

Our approach is based on semantics, which is universal to all standard languages. This means that we don't require endless word lists, or specific lingo, or limited dictionaries in order to operate. We don't care for the words themselves, but rather the relationship between them, as inferred by semantic analysis. This enables us to create applications regardless of the actual language/dialect/words used. For each new language, only a very brief one-time configuration is required, and we're good to go.


 

Driven by Requirements

 

 

Since our input is the language used to describe the requirements, we ensure a complete correspondence between what is needed and what is actually built. Consider that 68% of all traditional development projects are destined to fail because of poor needs analysis or informal requirement definition practices. This means that the main driver of failure is a mismatch between what was required and what was delivered. This is not even a technical issue: it is one of language. So a development platform based entirely on proper requirement definition is no small achievement.


 

No Solution Design. No Coding. No Kidding.

 

 

With our platform there is no need to engage in the most technically challenging and volatile stages of software development: Design and Implementation. Once the requirements are described, the platform will design the solution automatically, based on the formal structure already inferred from the language used. This means efficient, streamlined logic designs that cover all the required components, and nothing else. From there, no coding or using a programming language is needed. Based on the design the platform will generate all the software components necessary to turn the text into a functional software application. 


 

Build in Cloud. Run Anywhere.

 

 

 

 

Current development architectures force an application's logic to be helplessly intertwined with the actual code used to implement it. This means you cannot just take away the logic, -wring out the knowledge- and leave the code behind. That's why porting an application into new platforms and languages is so difficult, since it practically demands logic to be rewritten. Conversely, our language-based approach causes your app's design and logic to be inferred from the input text, making the solution model decoupled from any target platform in which it can run. In other words, your app's model, structure and entity definition depend on your natural language, which is constant, and not on a specific programming language. This way we can easily port all applications built with our technology into different platforms, without losing the knowledge and logic already defined.


 

UI Designer

 

 

Once your application is automatically generated, you can edit the visual layouts to your liking using our platform's User Interface Designer, which allows you to customize all screens. In our architecture, screen layout models follow the same protocol as the semantic components that conform the logic. This means that complete visual extensibility is possible without impacting functionality, all via open front-end standards. This includes access to third party visual component libraries, to enrich your app's final polish and experience.


 

 

Analytics-Ready

 

 

If you've ever tried to do Analytics and Business Intelligence reporting on top of an application, you'll know that the biggest challenge is how to re-map standard transactional database models into cube-friendly multidimensional star models ideal for analytic consumption. Yet natural language is, in itself, an ontological hierarchy of components organized in a very multidimensional fashion, much closer to an analytical model than a transactional one. This means that from inception all apps built with our platform have database structures optimized for reporting and analytics. While we have strong reporting capabilities out of the box, you can easily query your information directly from any BI tool of choice without the need of added data manipulation or designing a Data Warehouse.


 

External Connectors

 

We support an extensive connector layer that transforms external inputs into our own semantic protocol. This includes REST based interfacing with external systems and applications, so you can connect and exchange data easily via standard Web Services.


Trying to keep updated the documentation of that legacy application? try again. We all know maintaining proper documentation of software applications is always a pain. Well, not with us. Remember we're based on language? The text you used to describe and create the application IS the documentation. The only way to transform your application is to edit the text. This means that by design, your documentation is  always up-to-date, and there is nothing else for you maintain.

 

Self-Updated Documentation

 

 

 


Building software out of textual requirements is game-changing fast. From scratch, we estimate at least 5x faster to build than using current software development tools and methods, since our whole project is roughly equivalent to the initial Business Analysis stage of the other guys. But how about adding new features? updating the software? this is where we truly shine. Where once you had to revisit your obscure design and code and hope for the best, with Lexica you simply edit the text. As easy as reviewing a draft paper, textual edits will render modifications in the resulting application while preserving versions and backward compatibility with previous builds and any existing data.

 

Fast to Build. Faster to Evolve.