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
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 (2010 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.
This case is pretty straight forward: When you buy ILNumerics, you select the modules to unlock. In order to execute a certain module, you need to have a valid license for it.
Which modules are needed by your assembly is easy to dertermine: each ILNumerics module referenced by your assembly requires an individual license. So if you used a module during development you will need a license for it. Licenses are checked at runtime, before the application starts executing. If licenses for all modules used are found the application will execute normally.
This use case is actually very simple. Once created one can commonly execute an application (and all modules used by it) indefinitely.
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.
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
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 ILNumerics installed on your machine. Otherwise go here to get your copy now! Also, be sure to have set up your developer seat.
In Visual Studio create a new Console Application. We chose Visual Basic in Visual Studio 2012 here. You might use any Visual Studio version from 2010 or pick the C# language here, if you'd prefer:
Now we introduce a reference to ILNumerics and add some very simple code to make it more interesting. First, we add two references to ILNumerics modules to the project: ILNumerics.Core (always needed) and ILNumerics.Computing. You may chose different modules as available and change the code below:
In Module1.vb we add the following code:
Now build the project! Visual Studio realizes that this project now turned into an ILNumerics project. A message box appears:
From now on the project will automatically manage the ILNumerics 'deploy items'. Basically, there is a runtime license included into those items. It will end up being embedded into the output assembly and ensures that the project will correctly execute even after deployment on non-licensed seats.
Since this addition requires a change to the project file, Visual Studio will ask you to reload the project:
Note that no special project template was needed to start with. It was just a regular Console Application. It is the ILNumerics Visual Studio extension which is smart enough to detect the dependency to ILNumerics and prepare the project for deployment with ILNumerics. 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 and read the build output generated during the build:
Did you recognize the first line? It reads that some licenses has been 'compiled' for the project. This is a good thing and tells you that your project now owns a license. Having a license is a very good thing, since it allows to run your project on any machine - regardless if ILNumerics is installed and licensed or not. The output text does also explain where the license has been saved to. The 'ILNumerics_deploy' folder has been created and added to your project magically. It holds - among other stuff which we will skip over for now - the newly created license file. We can open that ilnumerics.lic file and inspect its content. But don't expect it to actually make any sense. This is a binary file and it was not designed in a human readable format.
Did you count how many steps were needed in order to setup your project for the license creation? Exactly two: one click on 'OK' in the first dialog box and another click to confirm the project reload. Easy, right? :)
Up from now on, there will be a valid license maintained for your project.
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.
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: it will be there if you need it. And it will go away otherwise. Just as the licensing was included into your project automatically – once there are no more references to ILNumerics it will automatically go away.
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 many 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 compile 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 ILPanel. Would that mean that everyone working with the sources /design view of the application now requires an ILNumerics license? Certainly not.
Do you know of any licensing scheme which is able to serve those situations well? We couldn't find any, so we designed the ILNumerics licensing accordingly.
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.
The sharing of runtime licenses between licensed- and non-licensed seats is limited by the following restrictions:
- The same compiler needs to be used for licensed and non-licensed seats. Usually, this will be the .NET compiler within Visual Studio.
Both seats need to target the same platform. Or stated in another way: the platform target of the project must not be changed by the developer on the non-licensed seat. The same is true for the Debug / Release target settings.
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.
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 (single) 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! Make sure that the following items are added from the ILNumerics_deploy folder: ilnumerics.lic, ILNLicHelper.cs / ILNLicHelper.vb, 2 *.target files.
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.
The common shared application solution therefore does not require any references to ILNumerics modules. Instead it references the custom user controls / computing module projects only. These custom assemblies should be designed in a way that no reference to ILNumerics is needed in order to use them. Make sure not to expose any ILNumerics type in their API which would cause users of the API having to reference any ILNumerics module. Of course, no special considerations are necessary, if you purchase licenses for all developer seats.