Find the Best Way to Optimize MathWorks Licensing

[0:01] Ada: Hello everyone and welcome to Open iT’s live webinar, find the best way to optimize MathWorks licensing. I am Ada, your host for today, and we will be joined shortly by Gareth Thomas from Version Bay. Before we get started let me share a reminder that all of our attendees are in listen-only mode, all of the lines are muted. But everyone is encouraged to ask questions, just type in your questions in the Q&A portion of this Teams live platform, located here, the little question mark button on the upper right corner, and it will be addressed by Gareth in our Q&A session after his presentation. If we don’t have the opportunity to answer all of the questions, or if there are questions that could not be answered immediately without further investigation, rest assured that the information will be sent to Gareth and we will reach out to you via email to answer those inquiries.

[1:08] To get things moving, let me introduce our speaker for today. Gareth Thomas is a co-founder from Version Bay, one of the great partners of Open iT. His interest in learning MATLAB began when he started his career in 2005 after graduating with a master’s of science in electrical engineering specializing in control theory from Instituto Superior Técnico. He continued to develop his expertise when he worked at MathWorks for nearly 10 years. Without further ado, I will now give the floor to Gareth. Gareth, take it away.

[1:50] Gareth: Thank you, all very kind of you. Thank you for the wonderful introduction. It’s always a pleasure to be here. So I’m here today to talk a little bit about how Version Bay uses Open iT’s tools for network licensing, in particular around optimizing network licensing. So maybe just so that you know, I’m going to be speaking for about 30 minutes or so. But I would like to make life easy for you, there are really three things I want you to take away from this. So one is collecting usage data on MathWorks products is definitely possible. Two, measuring this is really key to optimizing the licenses. And three, Open iT has an elegant solution to do so.

[2:31] So let me tell you why I want you to remember these three things. Well it turns out that at Version Bay we’ve been needing to track MathWorks usage for our projects for quite a while now. So we were struggling with it and then we stumbled across how Open iT does it, and I’m here today to share a bit of my story and journey with Open iT and why I think it’s useful for other organizations. The other thing about it is we are in a data-driven environment and at Version Bay we need data to take decisions. So the fact that we could optimize our licenses is only possible due to the fact that we knew exactly who was using what and which toolboxes. And this actually led to changing our business model and I’ll talk a little bit about that later on. And the other thing is we’ve kind of stumbled across Open iT and not many people are aware of it, so maybe this session will be useful for you to learn a little bit more about how deep and broad Open iT’s solutions do go around engineering tools. And we figured we stumbled across it because of the MathWorks issue we faced.

[3:40] And the way I’m going to talk you through this today is I’m going to give you some examples, I’m going to articulate a little bit of what Version Bay does, what our needs were, and how we used Open iT’s solutions to solve that. But just to let you know who I am and why you should actually listen to me, I just said I’m a control engineer from Portugal, but I’ve worked at Siemens and Ocean Scan, a small company in Scotland. But most of my working career has actually been at MathWorks, where I’ve been an intrinsic part of MathWorks and I understand very much how their licensing works. In the meantime I’ve started my own company called Version Bay and we continue to use MathWorks tools as we are software consultants and we help the ecosystem of MathWorks, and we’re based here in the Netherlands.

[4:15] So that being said, our mission at Version Bay is really about empowering people to leverage state-of-the-art software stacks. Now the thing is, we kind of started this with me and a friend of mine, Yannick. We came across that people don’t always go to the latest version of MathWorks tools and there was kind of a question of like, why don’t people always use the latest version of a software, right? And there are common reasons. So it’s like, it works, why change? It’s not sure how long it will take to upgrade. MathWorks releases new software twice a year but if we change now in six months it’s going to change again, will we be ready for it? There’s a fear of things not working in the same way, and there’s also the question, well, if I change the version do I need to invest and teach my team how to use all the new features? So there are good reasons why companies actually don’t always automatically upgrade.

[5:12] That being said, I also think it’s useful for people to know that between 2019 and 2020 MathWorks released 90 new products. They have a total of 117 products and if you just look at the software changes in MATLAB alone there are over 323. So these are large numbers which typically are great because you typically pay for this kind of support and development from MathWorks and you expect the tools to get better and better. But on the flip side, as things get better and better there are more choices and more options, which then leads to the question of when and how to upgrade. So Version Bay’s mission really is to reduce the risk and quantify the value of going from an older version of MATLAB to a newer one, and we help our customers through that journey. And the challenges we help address is when to upgrade, who should own it, which is the right version for your organization, how to manage all of these versions, and which is actually the reference.

[6:01] So in general the common workflow that we kind of help our customers with is we will take a customer’s code running in a particular release, we will write unit test cases for that, we’ll store it and put it in a database, run the same code and same tests across multiple versions of MathWorks tools, store the results, and then we can initially figure out do things break, yes or no, if you were to change to a new release. And once you’ve got the setup for one version you can apply it across multiple versions. What we end up doing is we help customers with compatibility, coverage, and performance reports, and we can figure out where things stop working. Now usually what happens is if things don’t work, most of the time they’re not serious changes, you can just change a few lines of code and things work nicely.

[6:51] That being said, often what you really want to do is not just make sure things work with minimum code changes, but you want to leverage the new things. So every now and again some of these 323 changes, some of them are really important and they’re useful for your teams to know as they can improve performance, memory, and so forth. So we kind of help customers write better, stronger code and show them the new capabilities and call out what could be useful for their particular application. MathWorks has a wide variety of customers, so sometimes someone in the automotive industry might not find the same thing interesting as someone who’s in the financial world, for example. That being said, once we find these things we then actually end up doing internal coaching sessions to say, looking at people’s particular code bases, okay, given this code base, this is how you can make it better and this is the value of upgrading to a new release. So that’s what we do as kind of an organization.

[7:40] So at a high level we are a consulting organization where we have three pillars of consultants. One pillar is general MATLAB, Simulink, and Python consulting. The other pillar is the migration consulting which I’ve just articulated. And we also have a team helping out with automatic code generation, so MathWorks products which are dedicated to code generation, and we help our customers do that. So that’s in general what we do as a company, and you can kind of see that we are deeply integrated with MathWorks tools in our usage.

[8:04] So let me call out how we use it and there are basically two use cases. So there’s use case number one where Version Bay has a customer project and a customer will hire staff from Version Bay. Version Bay consultants will either work on site or remotely, and in that sense we’re helping with MATLAB projects and implementations and variations of upgrading from older versions to newer ones, maybe installation, maybe tips and tricks, maybe optimizing, maybe understanding proof of concepts, if things are a little bit better or if you were to use a different license would things work out nicer. So anything around MATLAB and Simulink we kind of help with. So that’s use case number one. Use case number two is for internal testing. As we help customers migrate between different versions we also test for ourselves different capabilities and different features to build up our knowledge of which are important features to call out for each new release.

[9:02] And what we do is we have different types of tests internally and we integrate our testing system with Jenkins. So what that means is as soon as a new version of MATLAB comes out, or even a pre-release, we can automatically test and see if things are going to break, or if there are things that we should pay special attention to, if there’s a major upgrade in some shape or form. So we have two large use cases of using MATLAB at Version Bay, one for our customers and two is really for internal testing and developing our skills.

[9:27] Now the problem statement that we were having as an organization was, well okay, so we have these two use cases and we’ve got multiple consultants working. The question now becomes, who is using which products and which versions across the board? So we were having difficulties getting a handle on saying, okay, we’re working with multiple versions at different stages, and who’s using what and for how long. That was one issue. The other issue was sometimes customers will say, well can you bring your own licenses? Now if we bring our own licenses that actually has a cost to the organization. So what we wanted to do was to say, okay, if we do bring our own licenses there is a reason why it should be a little bit more expensive. And what we end up doing is we kind of wanted to be able to track the number of hours using MathWorks tools associated to a particular project and to a particular customer. And then we could call out and say, this is how much it costs for us to use our licenses on your project, warranting a different pricing. The other thing that we were struggling with was as we get more and more projects and as Version Bay grows, it becomes more and more important for us to understand how much time we’re effectively spending in each of the versions. It’s part of our business model and mission to stay up to date, so we need to make sure that our consultants are spending significant amounts of time in the newer versions of MathWorks tools so that they can make sure that they are knowledgeable when they go and talk to customers.

[10:54] So that’s kind of the problem statement and this is why we engaged with Open iT. And before I kind of show the exact solution with Open iT, maybe it’s good to remind everybody that talking about MathWorks tools, there’s a wide variety of licenses. And you can go to the website and they generally split up into standard, education, home, and student. I’m going to be focusing on the standard licenses, and I’m going to zoom in on the differences between standard individual, standard network named user, and concurrent.

[11:25] So if you go to the MathWorks website you can see how the individual license works, but ultimately it can be a perpetual license or it can be an annual license, and effectively it’s assigned to a single named user. So this is pretty straightforward. The network named user is a little bit different because the idea is a user logs in and it’s associated with the username, and this way wherever you have access to internet you can use that MATLAB based on your credentials. This actually requires a single network license manager and you can with that information start parsing and getting an understanding of which toolboxes are checked in and checked out. But there is a list of named users for each product that you need to manage, and that is a little bit more work on an IT administration side of things.

[12:08] What also is quite common is companies end up using concurrent licenses. So this is a license pool that can float, so whenever anybody in the company needs it they can pull from this pool of licenses. The concurrent license is a little bit more expensive but ultimately gives companies, if they have a big enough user group, more flexibility. And also from an IT perspective you can manage and see things coming out of the license servers and the log files to kind of understand that. That being said, it seems very simple and easy to say oh let’s just parse the log files, but ultimately you actually need to have snapshots of time, do it regularly, maintain it, set it up, and that can actually be time-consuming and hard to maintain. And there are always these edge cases that you never think about and they appear. So this is another thing about the concurrent measuring.

[12:58] But what we did at Version Bay was we kind of reached out to the guys at Open iT and we actually used two products from them. We use something that they call LicenseAnalyzer™ 2020 level two and License Planner. I’ll tell you a little bit about what these two things do in a second. But from a logistic perspective we ended up installing clients on every single machine of our consultants and our internal servers. And we also set up projects so that each of our consultants, whenever they’re working on a particular project, they say I’m working on this project, and then with the client we start logging usage associated to that project, which would then be able to do chargeback. Referring back to this, this is how many hours for this project this consultant used. We also consciously made the decision to store our data on Open iT’s servers so we didn’t have the overhead to maintain this on-premises. It was an option for us but we decided to use Open iT’s services. And we use their infrastructure for creating reports. There are nice things that you can create your own reports, and in different shapes and forms you can connect to the data. But we ended up using their infrastructure and what we ended up doing was set up automatic invoicing so that if our consultants were using their own licenses for projects we could automatically generate invoices to say, look, this is how much it costs Version Bay to use the licenses for your particular project.

[14:21] Well, what is kind of interesting about LicenseAnalyzer™ level two is it’s not only just looking at which licenses are used. It’s kind of cool because you can actually set thresholds on CPU usage, I/O, and maybe the keyboard and mouse interactivity. So effectively you can bypass the discussion, did the person open up MATLAB and then go and do his emails and never touch MATLAB for the next six hours? Or was the person effectively using MATLAB intensively for six hours? And that’s what that level two gives you, that intensive and active usage, which is very powerful because this way you cannot fool customers by just saying hey, we opened up MATLAB and I’m doing something else. So we were quite happy with this.

[15:09] And the kind of result that came from this is what we end up doing is we get tables internally to say for project X, Y, Z and so forth, we can actively measure, and these are dummy numbers just to illustrate my point. We say okay, MATLAB usage, the number of hours was for project X, 100. We weren’t using any of the additional toolboxes, and what we could say is you know, for Version Bay the yearly cost of having MATLAB is XYZ, and then what we end up doing is the direct proportion of the 100 hours and what percentage does that reflect on the XYZ. And we are very transparent towards our customers. What we ended up doing was splitting up MATLAB and then everything else. You can go into every single toolbox usage if you wanted to, but at a high level generally speaking we do MATLAB and everything else, and that’s what our project Y kind of alludes to. So for us this was very nice because we could set up automatic invoicing per project in a fair and accurate way based on the number of hours of using the different toolboxes from MathWorks, which is kind of cool.

[16:11] The other key thing that kind of came out of this is, the company is called Version Bay, so we’re particularly proud of always keeping up to date and using the latest version. What we can start doing is we can track our internal team to say, of each version of MATLAB, how many hours is each of our consultants spending? And it was kind of a bit to our surprise that when we thought we were always spending the right amount of time on newer versions, we began to realize that as our consultants got more and more busy with projects, the projects that they were working with didn’t always revolve around the latest version. So effectively our consultants were spending more time on older versions than on new ones. So that from a management perspective and a business model perspective became more important for us to say that we need to make sure that the team is spending significantly more time, or make sure that they have bandwidth to spend time on new releases, so that they can continue to improve and develop their skills. So from a personal training perspective and making the team available, this was an important data point that we could use and leverage to make our team stronger as time progresses.

[17:15] And there’s also a common question we get. Customers say, so how do you stay up to date? So we can effectively call out and say we have a process around making sure everyone uses the latest version for a certain amount of hours, explores it, and understands it properly. So if you think about all of the key results, what is kind of interesting is that we effectively went from a place of complete blindness, not knowing who’s using what, for how long, and which products, to a place where we can actually generate invoices automatically based on the number of hours of usage of MATLAB and the toolboxes. We’ve managed to change the way the teams spend their time to make sure that they spend more time on certain versions of MathWorks tooling. And then there’s also this idea that if people are not spending enough time on the latest versions we can trigger additional activities to make sure that we stay up to date, which is important for us.

[18:16] And I think maybe this is a fourth point, but maybe more fundamentally, is because we can do invoicing automatically it actually enables us to change our business model. When we pitch our prices and when it comes to speaking about economics with our customers, we have a way to say that okay, if you do want us to use our own licenses, this is what it would cost. And that is something that becomes very transparent and clear. And I think this is a common issue when it comes to tracking usage of expensive tools. You want, maybe not between two customers, but you could say between two departments, having a fair and accurate chargeback model based on number of hours of usage, I think is a really exciting thing. You can kind of look at your assets, in this case MathWorks licensing which do have a cost associated with them. It is important to make sure that at the highest level you understand who pays for them, for what amount, and so forth. So it’s a fair and accurate way of justifying the costs.

[19:11] So those basically are the results that we had with Open iT and the team is super helpful with us. But you might ask, so okay, are you done, is that it? I would be lying if I said yes. So actually what we’re kind of looking towards as the team grows is to maybe explore different license types. So the concurrent license I called out is more flexible but it does come at a cost of 4x more expensive than individual users. Now because of COVID we’re beginning to see that teams, and particularly people with families, work at different times of day. So it’s no longer this thing of nine to five, sometimes people get up super early and maybe go to bed super late and not work so much during the day. So if people start shifting their working time, this concurrent license becomes significantly more interesting because effectively we can get maybe more than four people on average using the same license. So if you can kind of get maybe six to ten people using it, it’s a no-brainer to use more of the concurrent license versus the individual licenses.

[20:14] So what we’re looking at is where can Version Bay as a company hit that optimal point where it makes more sense to go from one to the other. And there are different policies and approaches to do that. But our key philosophy is with the data we can make a much more informed and better decision around that. And it also helps justifying the cost of saying okay, there’s going to be a step up going to concurrent but actually it’s more beneficial based on our company needs. And I think that is a realistic scenario for any company that is evolving and hiring people or maybe changing groups and so forth. It’s really good to keep an eye on that to make sure that you don’t waste money. So when you’re growing you don’t buy too much, and when you’re decreasing you can also be conservative about what you decrease. And I think that’s really powerful. So those are the next steps for Version Bay with respect to MathWorks licensing.

[21:10] I think also because it’s nice Open iT is hosting this, I thought it would be nice to show a video so I’m going to show you what Open iT’s tools look like and how we use it. So this is a very short video. The clients are installed and working correctly on our different computers at Version Bay and you can log on to this dashboard from Open iT. And it’s kind of cool that they give you some nice reports out of the box. And you can create your own things, it’s a bit like a pivot table on steroids if you will. Or Power BI, a similar looking field where you can drag and drop and create your own reports, your own tables, based on whatever things you like. So they track a whole bunch of things, so it’s the application, the toolbox, the country, the package, the product, the user, the number of hours, the minutes, the idle time, which project they’re associated with. Pretty much anything you can think of you can track, you can generate reports, and you can get that data. And it makes it very slick and easy to slice and dice it. So we’re a bunch of engineers at Version Bay and we like slicing and dicing data to our hearts’ content. So this is kind of what LicenseAnalyzer™ 2020 looks like.

[22:21] I think as an organization we use the lower end of the capabilities of Open iT. I mean, we are hosting the data on their servers, we’re not too particular about it. But as we do grow we do believe that we can leverage more and more, and we’re kind of confident that they’ve got additional things associated not just for license analyzing but for project planning and things of that nature. So that’s a bit about LicenseAnalyzer™ 2020.

[22:46] I know that I’ve spoken a little bit already about all of this, but I really wanted to bring it home that the three things I want you to remember are: collecting the usage data on MathWorks products is definitely possible, and if you do so, that is the path to optimizing your licenses. So measuring the usage is an absolutely fundamental step to optimizing your licenses. And it turns out that Open iT’s got a very elegant solution and we were very impressed with the team and how quickly we got it up and running, and they’ve helped us a lot. And this is what I wanted to share with you. So I think that was my story for today. I wanted to thank everybody for the time and attention, but maybe you can take some questions if there are any.

[23:36] Ada: Thank you Gareth for those awesome insights, we truly learned a lot. So now it’s time to head on to our Q&A session and we’ve received some questions. Let me check on those. All right, so I have a question here. Is Open iT able to read multiple MathWorks license files at the same time?

[24:14] Gareth: Yeah, yeah, they can, they’re pretty good at that. So they scale up nicely. Usually in our particular case we’re still a relatively small company so it’s all under one license group. But that was one of the questions that they asked, you know, how many license pools are you looking at, how many licenses. And so they scale up nicely. And actually I think they actually on their use case on their website they call out enterprise licenses. So they cater for mainly larger organizations. So I think Open iT actually started with larger enterprise organizations and are slowly finding their way to smaller organizations. So if that was a concern, they actually scale up really well.

[24:55] Ada: All right, so I hope we answered this question. Another question I have here is, is Open iT able to read and exploit information stored in the MathWorks .opt file?

[25:11] Gareth: I would need to learn more about that, but I think maybe that would be a good question for Open iT. But I think the way that they currently do it is they primarily thrive off what comes out of the license server logs. And they do it not only for MathWorks tools but also for ANSYS and pretty much any engineering tool you can think of, they cover anyone with their license manager. And what they’ve done is they’ve kind of catered towards all the licensed log files and parsing that, with all the exceptions, and you can kind of configure how often you ping the servers to know the statuses. And that’s how they primarily do it. I do think for certain elements they can hook into certain vendors with different levels of support, but for our needs we didn’t need to go that deep. But maybe that’s a good question to follow up with them.

[26:02] Ada: All right. So I think the last question is, Gareth, in your experience where do the savings come from, less toolboxes or different license types?

[26:17] Gareth: Yeah, so that’s an interesting one. I kind of called out at the beginning that there are 100 or so products from MathWorks and they keep adding. So there’s a natural tendency that as you kind of purchase more and more tools, you sometimes get more tools and you don’t really know what they do and the name sounds nice. So effectively large organizations, I think they typically have an abundance of tools and you’re not sure if you can remove them or not so you just keep on maintaining them. So as time progresses I think it’s quite common that there are toolboxes that are not needed, just because maybe the projects have changed, the workflows have changed, or the person who was driving that project left. So I think in that way there’s definitely opportunity for larger organizations to maybe reconsider and evaluate which toolboxes are effectively being used. And not just by surveying internal staff, right. So you can say do you need all of these, and I think most end users have difficulty understanding which toolboxes they are using or not using because that’s not what their day-to-day job is. So in that sense I do believe that you can save money on reducing the toolboxes.

[27:23] But I also believe that if you are actively using it then changing your license type is also a good idea. So going to concurrent is a bit more expensive but sometimes you have users who use it 12 hours a day, maybe you don’t want to use it like that on a concurrent license because that’s expensive. But if you’ve got maybe 10 users who are using it every now and again, and if your organization is wide enough and large enough, you can actually distribute that much more in a cost-effective way. So changing license types I think can also be beneficial. And the other thing that I think sometimes people overlook is typically what happens is in companies there’s a project and you buy the tools that you need, and then at another moment in time you buy for another project. So what you have is a whole bunch of purchase orders come towards MathWorks at different points in time and people are not aware that group A is using some tools and group B is using others. So I think the consolidation between two different groups and maybe lining up your purchasing models makes life easier to predict purchasing patterns, and also to kind of see if there’s optimization across different groups and departments. And it can also be that the needs of projects change, so one year you might need for example the Database Toolbox and the next year you don’t need it. So in that sense I think the savings come from a combination of both of what you called out Ada, but it does depend upon the needs of the organization and how big or small they are.

[28:57] Ada: All right, so thank you very much Gareth for answering those questions. Do you have any additional reminders for our attendees or any final words?

[29:12] Gareth: From my side it’s been an honor, so thank you very much Ada. I just think the one last remark from my side is I think it’s super cool that there’s this meetup and you advertise it on LinkedIn as a way of creating a community around asset management. So I’d be happy and curious to hear other people’s thoughts and experiences. If there are other things that we should be aware of I’d be happy to engage and reach out afterwards. So thank you for creating and hosting this, Open iT.

[29:42] Ada: Thank you very much Gareth and all the attendees for joining us today. A quick reminder that this webinar is recorded. Since this is a live event with no registration page, we will upload the recorded version on our website which will be located at www.openit.com/resources/webinars. If you would like a copy of Gareth’s presentation, you can access it on our website which will be located at www.openit.com/resources/presentations, and we will also be sharing it on the discussion thread of our LinkedIn event invite. We will see you again next time. Once again I am Ada, your host for today. Thank you and stay healthy.

[30:38] Gareth: Thank you everyone, take care, have a good one, bye bye.