ILNumerics® Licensed Uses
While licensing for regular applications is very common today, licensing for libraries is still challenging. The reason for this is that library licensing requires much more flexible usage options for developers than 'end user applications' do. You, as a user of ILNumerics, must be able to work on your final application, write code for it, compile it, share the code with your peers, debug and test the application and finally package and deploy it to your customers. The ILNumerics licensing will support you in any of these phases. And it will do so without you even noticing!
- Execution Use
- Distribution Use
- Development Use, Step by Step
- License Embedding
- Un-Licensing ILNumerics Projects
- Licensing for large Teams
- Working with Version Control
- Working with TFS
- Isolating Functionality
Licensed Uses Overview
ILNumerics Ultimate VS uses an innovative and flexible licensing scheme. It meets the following requirements:
- Library licensing with simple deployment options (meaning: really simple).
- No license server required.
- No callback/ 'call home' or similar for license checking at runtime.
- Resulting assemblies won't require any additional infrastructure.
- Flexible individual licensing options for individual modules.
- Projects can be compiled on licensed developer seats as well as on non-licensed seats.
- Support for subscriptions and perpetual licenses.
- No extra steps required - automatic build process integration.
- Online and offline seat activation.
- Support for all recent versions of Visual Studio (2017 and newer).
- Support for C# and Visual Basic languages, 32/64 bit and AnyCPU targets.
In short: Once installed, ILNumerics will allow you to develop code for any licensed module. The licensing will happen transparently in the background. Simply stick to your common development process without even noticing it!
ILNumerics offers three usage possibilities:
Execution - run your assemblies referencing ILNumerics on your Developer Seat.
Distribution - distribute your assemblies to any other machine and run them there, regardless if that machine is a licensed seat or not. You may see this as Execution on arbitrary seats.
Development - use ILNumerics modules as a developer. Create code for test, debug and package assemblies with ILNumerics. This is where you draw the greatest benefit from using ILNumerics.
Each of the use cases above is individually enabled by the ILNumerics licensing. ILNumerics licenses are purchased for a certain time span and module. Moreover, they specify a certain combination of possible uses. Execution and distribution uses are commonly perpetual. Development is mostly a matter of subscriptions. This means that we only participate in the profit you make using ILNumerics during development. Once your application is finished, you can run it everywhere indefinitely - we will not charge for this execution. No royalties. No runtime fee.
Now, let's take a closer look at the before-mentioned licensing scenarios.
Execution Use - ILNumerics® Usage on Licensed Seats
This case is pretty straight forward: When you buy ILNumerics licenses, you select the modules to unlock. In order to execute a certain module, you need to have a valid license for it.
This use case is actually very simple. For regular subscription licenses Execution Use commonly is defined as perpetual: once created one can commonly execute an application indefinitely.
Distribution Use - Run ILNumerics® Modules on Non-Licensed Seats
Most applications are not only intended to be run on a single developer seat. They are supposed to run on any seat! Distribution use deals with the ability to distribute your applications to any machine and run it there - regardless if that computer is a 'licensed seat' for ILNumerics or not.
Again, this is an easy case for ILNumerics licensing. Once the application is created, one can take it to any machine and execute it here- if you have a license including Distribution use. Commonly, distribution use is allowed indefinitely for all ILNumerics products.
Since ILNumerics modules require a license at runtime, we need to make a license available to the application somehow. In order to enable execution on arbitrary seats, the needed licenses are embedded into your assembly as a regular resource. The process of embedding the license is transparently integrated into the build process and requires a license for Development use. We will take a closer look at this next. For now, keep in mind that Distribution use allows you to take your compiled applications and run them on arbitrary machines.
Development Use - Enabling ILNumerics® Applications for Deployment
Most applications are intended to get deployed to some customer. This means they are not supposed to run on the development seat only. This is where most licensing schemes become clumsy and error prone. Often the process involves the manual creation of some 'runtime license file' and its manual handling for packaging and deployment purposes. We will soon show that this can be done in a much better - namely: automated - way.
Key Values at a Glance
Here are the key advantages of our licensing scheme:
- No manual handling of any runtime license files or the like. Everything is integrated into the common build process in Visual Studio® and runs transparently in the back.
- The licensing works on a project base - instead of assembly base. This means that every ILNumerics project is automatically provided a runtime license by a licensed seat. Afterwards, you can take the project and compile it on any seat - even on non-licensed seats! This allows you to distribute your projects among your peers without having to deploy compiled assemblies. Stick to your version control, source code sharing and project references!
Licensing for Development Use - Step by Step Example
Let's step through a small example here in order to show the common actions to take when building a simple application with ILNumerics. It will not introduce any special steps. Instead we will concentrate on the licensing and point out some of the most important processes happening in the back. For the following steps we assume that you have the ILNumerics Visual Studio Extension installed on your machine. Also, be sure to have activated your developer seat. We will use the ILNumerics Computing Engine, hence your license must include this feature.
In Visual Studio create a new Console Application. We chose Visual Basic in Visual Studio 2019 here. You might use C# language, if you'd prefer. We target .NET 5.0 and add the nuget package ILNumerics.Computing:
In Module1.vb we add the following code:
Now build the project! Visual Studio realizes that this project is using ILNumerics modules directly. It also recognizes that your are building on an activated ILNumerics developer seat. Therefore, it will attempt to create a runtime license for your project:
The license ends up being stored in a folder 'ILNumerics_deploy' as a regular project item. It is embedded into the output assembly and ensures that the project will correctly execute even after deployment on non-licensed seats. Note that no special project template was needed to start with. It was just a regular Console Application. This is working similarly for all common C# and Visual Basic project types.
Run the resulting project, hit F5 or start it directly from the output directory. It will print out a matrix of random numbers as expected:
Let's visit the Visual Studio Output tab. Note, the following line in the Build output:
This is a great indication that your project is now equipped with a license. It prepares your project to run on any machine.
Up from now on, the license will be updated whenever you are building the project.
License EmbeddingThe main advantage of having the runtime license as a project item is the ability to give the project to any seat for compilation and execution. There is no need to re-create the runtime license. Instead, the pre-built license is taken and embedded into the assembly. Afterwards, the assembly can be executed on any machine. The license will be taken from the assembly. Try this yourself: Take the executable and run it on some other machine - it will show the expected random matrix.
The license creation and embedding is done for every build – automatically. Regardless where the build happens: inside Visual Studio, on a command line utilizing msbuild or in Team Foundation Server.
After successfully building on a licensed seat ...
- an up to-date version of the ilnumerics.lic runtime license will be ready in the ILNumerics_deploy project folder, ready to get embedded in subsequent builds. And ...
- the same runtime license will be embedded into the target assembly. There is no need to build twice in order to prepare the assembly for distribution! Both, license creation and embedding are triggered with a single build process.
ILNumerics® Project Un-Licensing
Projects evolve. Sometimes you want to enable new functionality. Sometimes existing functionality is not needed any longer and must be removed. For the ILNumerics licensing this is very easy: after removing all package references from your project you may delete the ILNumerics_deploy folder.
Development Use - Wrapping Up
Development Use refers to application creation. It involves the creation and embedding of runtime licenses. The licenses are maintained in your project as a regular resource item. It follows changes to the project and will get removed if no longer needed. After each build there will be an up-to-date license file as a regular resource item in the project and in the assembly.
Advanced Licensing Scenarios
ILNumerics is being used in large development teams. There are a number of challenges related to licensing for large teams. One of them is the need to have only a part of the developers working with ILNumerics functionality. But all the others want to be able to take the code projects of the ILNumerics experts and compile it in their regular Visual Studio setup. They should not need an ILNumerics license in order to just recompile some code! But the results should work on any seat - with or without ILNumerics installed.
Another challenge rises for collaborated work on large applications, often GUIs. Some developers are working on regular stuff like localization, common UI element design, business logic implementation, testing etc. But for some minor parts of the GUI a handful of ILNumerics experts creates custom controls, based on ILNumerics.Drawing.Panel. Would that mean that everyone working with the sources /design view of the application now requires an ILNumerics license? Certainly not!
Licensing for Large Teams
ILNumerics licensing is well suited for large teams. The scenario: Developer A owns a valid ILNumerics Development License. She is working in a larger team with developer B. B does not create code with ILNumerics and does not work on a licensed seat. However, A and B use the same common source code repository and share each others sources. Both use the same Visual Studio solution to work on their own source code parts. Both need to be able to compile the code of the other one and to run the resulting assemblies on their own machines.
The way ILNumerics enables this scheme is fairly simple: A creates runtime licenses for the project targeting ILNumerics. The license corresponds to the current state of the project and becomes a common project item resource. Therefore, it is checked into the projects version control and accessed regularly by B.
B is able to compile the project on any non-licensed seat in the common way - using regular tools like Visual Studio or MSBuild. The license file will be embedded into the final assembly. Therefore, B is able to compile the final assembly of the project - even without an ILNumerics Development license! Instead it uses the licenses compiled by a co-worker on a licensed ILNumerics seat.
Both, A and B do not have to take any special action for this scheme to work. The license files are maintained on all ILNumerics seats automatically. And the embedding on non-licensed seats happens transparently in the back. However, the runtime license contained in the license.lic file corresponds to the current state of the projects source code. It unlocks the assembly at runtime as long as the code has not been changed. B is able to complete the final compilation but it is not possible for B to change the code of the project! After any changes to the sources, the license file needs to be recompiled on a developer seat with proper ILNumerics licenses installed.
General Recommendations for Version Control
The ilnumerics.lic license file created on licensed seats is a binary file. It will be a regular part of the project and therefore should be checked into version control. The build process on a licensed machine updates the file on each build, hence reflects any code changes to the project.
Developers following the common guidelines for handling with version control systems do update before committing own work. During the update they potentially encounter conflicts on the license.lic file due to changes by other licensed seats. Those conflicts can blindly be resolved by accepting the version from the repository: Afterwards, the developer builds the project which will also update the license.lic file to reflect the current - merged - state of the project. The subsequent commit will publish the license together with the new sources to the repository.
All steps above correspond to the regular handling with version control systems. The message to take away: if you encounter conflicts on license files, resolve it by using the version from your peers. Afterwards, on re-building, you will automatically re-create new licenses for the projects you were working on. Commit the runtime license together with your code.
Working with Team Foundation Server
If you are building your projects on TFS the handling is very similar to building in Visual Studio. The general rules and options apply the same: One can use the build server as a licensed seat or as a non-licensed seat.
If ILNumerics is installed and activated on the TFS agent building your project, the server will be able to unlock any ILNumerics project from the repository itself. This gives the most freedom since you can use any build configuration including any changes introduced by change sets or shelf sets. Note that when building on the server, no custom steps are required. The runtime license will be automatically created according to the current state of the project and embedded in one build step.
If the build server happens to have no ILNumerics installed / not activated, it will not create / change any runtime licenses. Instead the runtime license created by the author of the ILNumerics project will be used. In this case, the license was created on the authoring user seat and checked into the repo together with the change-/ shelf set. It will be simply embedded into the output assembly during the build. Note that in this case, the code must exactly reflect the state of the project at the time of the commit! The build server works in the exact same way as a regular non-licensed seat here.
Especially for larger teams it will be useful to make the build server a licensed seat in order to gain the full flexibilty. However, if it runs as a non-licensed seat only, you will have to keep these guidelines in mind:
- Always do a regular build before checking your project into version control. This synchronizes the runtime license to be embedeed with the state of the project.
- On the build server ensure that the build is based on the same code state as the runtime license was created for. Keep in mind that merging individual revisions typically changes the code as well! Prebuilt runtime licenses will not work until they are rebuilt for the new code.
Note, currently, the ILNumerics_deploy folder and its contents are not automatically added to TFS version control. If the ILNumerics deploy items were added after the project is under TFS version control already, you must add the ILNumerics_deploy folder manually to TFS version control in Visual Studio!
Isolating Functionality within the same Solution
Consider the situation where a large application is created by more than one developer. Let's think of a GUI application, having a number of controls exposed to the user. Some of the controls are based on ILNumerics.Drawing Panel. Others are regular Windows.Forms controls. Only a fraction of the developers working on the application is dealing with ILNumerics. It is only their seats where licenses for ILNumerics are needed. However, the other developers still must be able to work on the non-ILNumerics parts seamlessly.
The ILNumerics licensing allows you to isolate ILNumerics functionality within individual assemblies. It gives your colleagues the chance to access your ILNumerics based functionality without having to have individual licenses for ILNumerics available. In order to make this work, your peers profit from the same licensing scheme which is also responsible for enabling ILNumerics assemblies for deployment.
All functionality accessing ILNumerics goes into own assemblies. Common examples are computing modules or user controls utilizing ILNumerics.Drawing Panel. All developers working on such functionality must be licensed for ILNumerics Development use. ILNumerics will automatically create and maintain valid runtime licenses for these projects. The resulting project sources can be incorporated by regular non-licensed users into the shared solution - utilizing the runtime license contained.
Let me end with a recommendation: while the saving of licensing costs may seem appealing to start with, often enough it does not pay of, eventually. Large teams found it more convenient to equip all developers with an ILNumerics site license, instead of having to maintain and share up to-date licenses among your peers. ILNumerics technology is a real time saver! The additional considerations required for license cost optimization often enough eat significant parts of this advantage.