lsfusion/platform

lsFusion is an extremely declarative open-source language-based platform for information systems development

English | Russian

lsFusion

lsFusion is a free open-source platform for information systems development based on the fifth-generation programming language of the same name.

Incremental computing, function-level, reactive, and event-based programming, the ability to write and iterate over all function values, multiple inheritance and polymorphism, no encapsulation, and lots of other fundamentally new ideas greatly improve the development speed, quality, and performance of created systems compared to traditional approaches.

Main features

• Single language for data

  The platform is free from the object-relational semantic gap, so developers don't need to constantly choose between "rapid" SQL queries and a "convenient" imperative language. Both of these approaches are almost fully abstracted and united. Each developer always works with data using a single paradigm, while the platform takes care of how and where to do all the remaining work.

• No ORM, Yes SQL

  When a certain action requires data processing for many objects at once, the platform tries, whenever possible, to perform this processing on the database server through a single request (i.e. for all objects at once). In this case, all of the queries generated are optimized as much as possible depending on the features of the database server.

• Absolute reactivity

  All computed data is automatically updated once the data it uses is changed. This rule applies always and everywhere, whether you're displaying interactive forms or simply accessing data inside the action being executed.

• Dynamic physical model

  The platform allows you to materialize any existing indicators in the system at any time, add new tables or delete existing ones, or change the location of materialized indicators in these tables.

• Constraints on any data

  The platform allows you to create constraints for the values of any data (even computed data), and all such constraints (as with events) are global, so inexperienced users or developers cannot bypass them with an invalid transaction.

• Efficient client-server communication

  Client-server communication at the physical level minimizes synchronous round-trip calls (i.e. each user action leads to a single - usually asynchronous - request/response pair). The desktop client also archives and encrypts all transferred data (when necessary). During client-server communication (via TCP/IP for the desktop client or HTTP for the Web client), the platform provides guarantee of delivery - it resends any lost requests and ensures that they are processed in the correct order. All these features help the platform run efficiently even on low-bandwidth, unstable, or high-latency communication channels.

• Three-tier architecture

  The platform executes the imperative part of the system logic (i.e. everything related to data changes) on application servers and the declarative part (i.e. everything related to data calculations) on database servers. This separation simplifies the scaling of the system you develop and strengthens its fault tolerance due to the different nature of workload on these servers (e.g. using swap on an application server is much more dangerous than on a database server).

• Everything as code

  All elements of the system, from events to form design, are written in the lsFusion language and stored in ordinary text files (without any shared repositories with an unknown structure). This allows you to use popular version control systems (Git, Subversion) and project-building tools (Maven in IDEs) when working with projects. In addition, this approach simplifies the support and deployment of the system you develop - you can use an ordinary text editor to view and quickly modify the logic when necessary and also easily identify any element in the system by file name and line number in this file.

• lsFusion programming language

  • Polymorphism and aggregations

    Supports inheritance (including multiple inheritance) and polymorphism (including multiple polymorphism). And, if inheritance isn't enough for you for whatever reason, the platform also provides an aggregation mechanism that, together with inheritance, allows you to implement almost any polymorphic logic.

  • Modules and extensions

    The extension technique allows developers to extend the functionality of one module in another (e.g. they can modify forms or classes created in another module). This mechanism makes the solutions you create much more modular.

  • Metaprogramming

    If you want to create your own high-level operator, or maybe you just don't know how to generalize the logic, but want to reuse it, lsFusion provides full support for automatic code generation, from both the server side and IDE.

  • Namespaces

  • Java & SQL integration

  • Internationalization

• Easy-to-use IDE

  Intellij IDEA-based IDE with everything developers could ever need: search for uses, code/error highlighting, smart auto-completion, quick jump to declarations, class structure, renaming of elements, usage tree, data change breakpoints, debuggers, and more.

• Advanced tools for administrators

  The platform provides a complete set of administration tools for systems that are already running: interpreter (executes lsFusion code), process monitor (receives detailed information about processes that are running, e.g. call start time, stack, user, etc.), scheduler (executes periodic or scheduled actions), profiler (measures the performance of all actions executed for all/given users, e.g. builds a graph of calls, sharing time between the application server and the database server, etc.), messenger (for internal notifications/communication with users in the system), and numerous logs (connections, errors, etc.).

For a more complete list see lsfusion website.

Installation

See https://docs.lsfusion.org/Install/

Code examples

• Score table

  Simple application that allows you to calculate the score table of a hockey tournament. It contains exactly one form, in which the user can enter game scores, based on which the score table is automatically built.

  Using this example you can get an idea of how to quickly develop "Excel-style" applications in which form data are editable, and any changes to them will cause all dependent data on the form to be updated incrementally.

• Materials management

  Example of creating a simple stock management business application. In it, the user can manage receipt and shipment operations, and also obtain item balances.

  This example shows a way to create an application for processing documents that have headers and lines. All forms are created in "Dialog style". In this approach, for each class in the system, a form with their list is created, in which only buttons for creating, editing and deleting objects are available for editing. Clicking the corresponding button opens a separate dialog form, with which the user can create a new object or edit an existing one.

• How-To

  How-to section of documentation contains examples of typical tasks, categorized.

Try online

It is possible to run the code snippets in lsfusion programming language online.

Online demos

• Score table

  • docs
  • github
  • username: guest
  • password: guest

• Materials management (MM)

  • docs
  • github
  • username: guest
  • password: guest

Links

• Homepage
• Documentation
• Repository
• Downloads

Feedback

• Issue tracker
• Slack community
• Telegram group

License

The platform is licensed under LGPL v3, which allows you to freely use, distribute, and modify the platform as you wish.

platform's Issues

NEWSESSION and NESTEDSESSION property draw options for all actions

Now they are supported only for NEW, EDIT, DELETE. It will break backward compatibility, so need to be extra causious with that.

Remove = from anonymous property expression rule in FORM operator

The problem is that the grammar will stop being LL* in that case (however it is already non-LL* but in only couple of very simple rules). So apparently some pretty complex lookahead is needed (as far as i remember the problem is that after property draw options block there comes a property expression without any prefix)

Implement search in UI

Now only filter is supported, and sometimes it is more convenient to find first object instead of all objects.
All necessary infrastructure (for example like SEEK operator) is already implemented.

Especially this feature is important for trees, where it should be implemented differently (with recursion, and that is why filter can not be used for searching)

Support NESTED block when canceling APPLY with CANCEL operator

Now this block is ignored (used only when clearing session)

Read statistics directly from SQL server

Now this statistics is recalculated, on one hand, that makes updating statistics platform-independent, but on another hand it may be really time-consuming. So it's better to read statistics from server (this also will make both statistics relevant to each other), but so far it is not so clear what to do with quantile statistics (top 80% distinct values).

Make GROUP LAST / CONCAT deterministic by default

Either throw an error if not all parameters in ORDER clause, or automatically add them to the end of that clause. It might give a little overhead, but mistakes are really too often, when using this operator.

NULL values statistics support in tables

Now only NOT NULL statistics is supported, so if there are no null values in field f, then statistics for IN JOIN A AND A.f IS NULL will not be correct, and ANTI JOIN optimization will not work.

Support conditions like 1<=a<=5 (without any other "table/subquery joins" for a)

In this cases we have to generate "virtual" recursive joins (just like when instead of 1<=a<=5, would have been System.iterate(a, 1, 5)). This feature will allow to disable number of heuristics with ExprIntervalJoin.

Changing property value by typing objects name without opening a dialog

Here is an example how this can be done :

Setting rowHeight in rows (not in pixels)

Similarly to charWidth (numRowHeight or something like that)

Collect all EXTENDs for an element in a single code block

This feature is the most important for forms.

This issue is related to lsfusion/plugin-idea#4

Fix wrong line index in DebugInfo inside metacodes

Metacode usage instruction @ could be written in several lines of code. This leads to wrong line index determination.

In debug mode reconnect client automatically after server is restarted

One click less when developing.

Implement HEADERS in IMPORT form operator

Just like HEADERS in EXPORT form operator.

Respect context when updating PREVs during single apply in global events execution

Now when changes are immediately applied in database ("single applied"), all PREV values used in global events are also materialized in some temporary tables (this values will be needed when executing corresponding events). It is done for all values, even ones that will not be used later. For example if we have CONSTRAINT CHANGED(f(a)) AND g(a), it is wise to calculate PREV(f(a)) only for g(a) values. It is pretty tricky, but, it seems, not very hard to implement, at least in most evident cases.

Add ENUM option in FOR operator + ENUM operator

Similarly to NEW option / NEW operator. This operator / option will generate LONG number using System,iterate (recursive subquery) with guarantee that this number will be unique.

SampleWidthValue support in property draw design

This attribute already exists, but it's not possible to set it (it's used only for determining default property value width)

Support migration of _FULL_ properties when migrating classes

Now only CLASS properties migrate with classes. FULL properties are recalculate what can be really time consuming.

Implement syntax for referencing elements via their canonical names

Something like #'Test.test[A.b]'. It is really important for mechanisms that are using scripts and reflection simultaneously (grouping, scheduler etc.)

Remove split and scroll container types and replace them with corresponding container attributes

So in the end there will be only 2 container types : regular and tabpane, and 2 extra attributes : split = true / false, scroll = true / false (just like it is usually done in css).

Also maybe it makes sense to make split option default (in some cases) for better user customization.

Events / actions disabling in run-time

Needed for support purposes. The problem is how to identify anonymous events / actions. It seems, that the only option is using debugInfo - for example ModuleX(144:33);

Implement "group columns" and table customization in trees

Now this feature is supported only for regular (not tree) grids.

Writing action code block directly in NAVIGATOR NEW operator

Just like in FORM PROPERTIES operator, where property expressions and action code blocks are allowed

Implement JAVA RMI integration type in EXTERNAL operator

Also add JAVA RMI as subtype in LSF integration type in this operator.

Fix container size after it has been drawn

This container attribute is really important when there are a lot of dynamic elements (with SHOW IF) in this container. This will prevent interface from leaping.

Implement IMPORT LIST, EXPORT XML ATTR options

At least for symmetry with EXPORT LIST, IMPORT ATTR.

Make ORDER in FORM operator work with expressions (not only property draws)

It was made this way to always see what the current order is. But sometimes it is not very convenient.

Make possible to set all default design attributes for properties and actions

Now only CHARWIDTH and FIXEDCHARWIDTH are supported.

Make possible to specify namespace for group in GROUP selector in DESIGN operator

Now it's only simple id (without namespace)

Remove dependencies on all third party libraries, which are not present in central maven repositories

This will allow to upload lsFusion to central maven repositories, and get rid of repo.lsfusion.org.

Implement CHARSET option for all human readable formats in EXPORT operator

This option is implemented only for some of these formats.

Implement quick documentation lookup for grammar rules

Embed information from documentation.lsfusion.org for the rule, where the caret is at the moment, when CTRL+Q is pressed.

Fix the absence of localization in swing text strings

Swing text strings are not localized when desktop client is started with javaws. Seems that our *.properties files are not used.

Support retryable requests in navigator

Now there is no requestIndex support in navigator remote calls, so retryable requests are supported only in forms (what is a lot more important, but still)

Using simple action reference in default events for properties

Everywhere except this place it is possible to use not only { f(a); } but simple f(a).

Needed grammar rule in LsfLogics.g is nonSemiActionOrPropertyOption.

Add debug info for inlined actions

If we have action like FOR f(a) DO g(a) <- h(a); and there is no dependency between f and g, this action will be compiled to f(a) <- h(a) WHERE f(a); but there will be no debug info for this "new action", what is very inconvinient for debug / support.

Support NULL arguments for properties

Now DATA, GROUP and some other operators don't allow having NULL values in their parameters.

It might be really dangerous having NULL arguments in a property, because it will immediately lead to incorrect operations with sets. For example, if we have a = DATA INTEGER (A NULL), and wanna do iteration (for example FOR) over all a(b(param) objects, we will get an exception, because property will be not null for infinite number of objects. But in certain cases it is really convenient so should be implemented.

Also NULL support may be provided for comparison operators (=, >, <, ...etc,)

Probably this issue is related to #11 task.

Implement JAVA option in EXTERNAL operator

For integration with external servers via Java RMI protocol.

Change staticName and staticCaption properties return types to variable length string

staticName and staticCaption properties have fixed length string types. Replacing them with variable length string types can decrease memory usage.

Automatically create indices on non-key fields in temporary tables

Usually it's not needed, but when compiler is trying to convert for example GROUP LAST to subquery with LIMIT 1, and inside there are 2 UNIONS, one of them is big temporary table with filter on non-key field, it might be a problem to not have indices on them.

Inline group change action

Now group change works like not inlined FOR, what is really inefficient when there are really a lot of objects in grid. So, group change (GroupChangeActionProperty) should be implemented using FOR operator, then it will be automatically inlined during basic compilation process.

Add introducing parameters to all operators that has results

For operators READ, EXPORT, EXTERNAL and PRINT (all that have TO clause). Do it similarly to input and import operators.

Also it can be done for EXEC operator, but it will be a little more tricky.

Plus, IMPORT operator does not support working with results as parameters, when fields identification in import is done via their order (and not names).

Support of NULL arguments for properties and actions on form.

Now property is automatically hidden when one of its arguments is NULL. It is not very convenient in some cases (for example adding object, selecting objects when there is no table, etc). Generally it's not possible to find out that out of context, so this option should be set explicitly (however maybe some heuristics may be applied first)

Probably this issue is related to #12 task.

Substract generated header offset from debuginfo for properties / actions when evaling scripts

Sometimes it's hard to understand exact line in code-generation-execution tasks.

Automatically embed existing materializations before every query execution.

It seems, that existing caching algorithm can be used for that.

Grouping data support in web interface

Compile predicates GROUP SUM i > value to SELECT LIMIT value

Similarly to GROUP LAST compilations.

Change LOG-properties canonical name creation

At the moment, LOG-property signature is created using original property's interface classes, not using the signature of the original property. Potentially this can lead to an appearance of non-unique canonical names and, more importantly, this prevents simple migration of the LOG-properties. If we use the signature of the original property, we will move migration of LOG-properties from addLogPropertiesToMigration to setUserLoggableProperties and will add LOG-properties canonical name changes directly to storedPropertyCNChanges right there.

Implement the run-time functionality of hiding the unwanted columns in the reports

Need to implement the possibility of hiding report columns in run-time. Should be implemented with empty space divided between remaining columns.

Fix potential nonuniqueness of property (actions) canonical names

The issue is that different parts of these names are combined using the underscore _ (and special symbols in property (action) canonical names are replaced with the underscore as well) that can be a part of some name. This could lead to the situation when two names formed by different parts could be identical.

• VALUE properties (_OBJVALUE). Name contains form canonical name + object name
• NEWEDIT/NEW/EDIT actions (_ADDFORM/_EDITFORM). Name contains class name + form canonical name
• SECURITY properties (_POLICY). Name contains property (action) canonical name

Methods:

• VALUE: BaseLogicsModule.getObjValueProp
• NEWEDIT/NEW/EDIT: BaseLogicsModule.getAddFormAction, BaseLogicsModule.getEditFormAction
• SECURITY: BusinesLogics.setupPropertyPolicyForms