Deploying OR solutions and shipping projects

Question

My background is a bachelor in mathematics. I learned basics OR on my own using the following :

• Introduction to Operations Research by F. Hillier and G. Lieberman
• Integer programming by l. Wolsey
• How to Solve It: Modern Heuristics by D. Fogel and Z. Michalewicz
• Constraint programming online courses available at Coursera

I learned to use some open-source solvers (Clp, CBC, etc.)

Now I want to learn skills that are useful for deploying solutions and doing end-to-end projects. I don't know where to start. How about a course in software engineering such as CS169 at Berkeley? Is it useful? Any suggestions for other skills that may be useful?

P.S: I know how to code using Python, C++, and Java

Answer 1

(I focus on the skills rather than suggesting specific courses).

If you want to deploy something, I assume you need a GUI. With that in mind:

• If you want to host it somewhere, as Stradivari suggested, you can work on Web API. If you want to have it as an executable, well, the software development courses (such as the one you mentioned yourself) can be useful.
• Do you intend to show some reports or maybe some visualization? If so, you need to know how to do that in the language of your choice.
• Depending on how you are thinking about your application and how it should work, how it should read the data (from somewhere online, from users, etc), you may need to acquire database management knowledge.
• Assuming you are familiar with LP and MIP and some open-source solvers, you may want to learn (if you don't know it already) how to solve your desired problem using one of the well-known commercial solvers as well. Because you may hit the wall of the open-source solvers' abilities pretty soon when you try to solve harder problem instances.
• You can also learn about heuristics and meta-heuristic algorithms for solving difficult problems in case the solvers cannot provide you with an optimal (or even feasible) solution as fast as you like (even after tweaking their parameters). In those cases, you may consider the trade-off between quality and speed and knowing how to develop heuristic algorithms can be your only option.
• After developing your application, you may find it useful knowing how to gather and process the analytics you collect from the users (such as how many times it's being used? Are there any additional feature requests? How to handle those or answer users' questions? Are there going to be bots involved for the users to interact with and get the answers to some of their basic questions? etc.)

Answer 2

I think the best way to learn, is to start by building small prototypes for OR tools, and slowly build something bigger. You might already know someone who is struggling with a planning problem where you can help! Maybe a local business, club or organization.

If you start doing that, I think you will obtain the following skills I think are required to build an OR solution end-to-end:

OR skills (the secret sauce in your application)

• Formulate a problem into a mathematical model
• Coding an algorithm or use a mathematical solver on your model
• Present your result in a compelling way

I think the only way to obtain these skills is by solving many different kinds of OR problems.

Full-stack engineering skills (building stuff)

• Creating a user interface
• Load and save data from API-calls, databases etc.
• Creating a maintainable infrastructure by separating your code into smaller modules
• Ensure your code is robust and have unit tests

A way to obtain these by start building some smaller projects yourself or contribute to open-source projects.

Product management skills (figuring out what to build)

• Talking to users to understand their needs and requirements
• Deciding which features to build
• Testing the product which users to obtain feedback

I can recommend the following two books: "Dan Olsen - The Lean Playbook" and "Eric Ries - The Lean Startup"

Good luck. The world needs more OR solutions!

Answer 3

Gurobi has a series on Adopting Optimization in Your Organization.

Recently they showcased a state-of-the-art architecture for optimization applications that you can try out on their website. You can even get your hands on the source code. Here is the accompanying webinar: https://www.gurobi.com/resource/gurobi-optimization-application-demos/

Answer 4

Maybe it's because people take them for granted, but we're forgetting some fundamentals here. No matter what you develop, what solvers you use, what 3rd-party libraries you incorporate,... put your projects in version control. And then learn how to use version control effectively. This helps everyone from developers to end-users to salespeople.

Yes it's subjective, but in my experience the most difficult part of deploying a solution is not developing the software, it's tracking all the moving parts and expeditiously identifying root causes of problems. This is especially true in multi-developer/team environments. So in addition to version control, let me also throw in documentation, unit testing, code coverage, build automation, and all those types of tools and practices that target code quality and comprehension. They can be boring to learn at times, but they will save you countless hours in the long run.

And always keep track of the use cases. :)

Answer 5

How about creating a small end-to-end program (GUI, data stored, OR, business logic). It could be a program with GUI that lets the user solve a sudoku. What sets your program apart from various other solutions is a "Solve by MIP" where you then solve it by a MIP like this.

You could also make a reverse Sudoku game where you start with a solved game and then make the user remove numbers while keeping a unique solution to the instance. This is somewhat like a game of finding the longest path (very loosely speaking)

Of course you don't really need a MIP for this problem...

Answer 6

Very interesting question.

I think that it is more general than OR: how can I deploy a solution for my customer? It seems to be a software engineering question.

I imagine different scenarios depending of the problem context and the customer:

• Deploy as a web service: there is an endpoint that the customer can GET/POST to get solutions
• Provide ONE solution: you are asked to solve a particular instance and you just provide the solution to that instance of the problem in a file
• Build an offline tool that solves the problem for your customer: it could be something like a jupyter notebook that guides you through the solving process, or just an executable file that takes input.txt and gives you solution.txt
• Deploy as a backoffice where your customer can upload the input and get the solution in a self-service manner

Answer 7

This is my job so I can write an essay on this, but I'll give you the highlights:

• Open source solvers have just enough bugs that you can't charge money for them. The most vexing thing about them is that they can't be trusted to return the right flags so it's not really viable to use them as dependencies.
• You will bleed before you get open source to build on Windows. I hired a pro to do this and it took him 3 months.
• If you use open source, you have a lot of license limitations to worry about, on top of making sure your dependencies don't break.
• GPL software must be avoided like the plague, unless there's a runtime exception. Even then, link at your own peril.
• Due to license limitations you can't statically compile most dependencies into your binary, which means that you need professional-level skills to make sure that your binary doesn't link to the wrong library when deployed to a customer.
• Compile everything at the lowest version of GLIBC that you can afford to, as it's not backward compatible and will break between different Linux systems.
• Be mindful of the fact that shared libraries have dependencies of their own, that don't necessarily match those of your code.
• Have something that works on Windows, that's what most people use.
• You can use Docker for fool-proof compatibility/deployment, but customers don't like installing Docker just to run 1 thing. Ideally, use a native Windows build or deploy over a Web API.
• If you do use the Web API, try a Linux server and Flask + React, it works like a charm on every system.
• Don't worry about providing a GUI unless you absolutely have to. GUIs are very complex to debug and to set up quality control.
• Use continuous integration. This is the first thing you should do.
• Come to terms with the unfortunate fact that deploying a solution that works and getting paid for it in this space requires a team of people who know what they are doing, because the overwhelming majority of open source OR code is just not at the quality level where it can be used out of the box by anyone who is not the author of that software.

As a final thought, if you want to learn how new software is deployed correctly and reliably, get a job at a software startup that is at that stage. Crucially, make sure there's at least one person there who know what they're doing, otherwise you won't learn much and the company will flop. Deployment is one of the toughest things to execute correctly in software.

A few months in that environment will give you a lifetime of experience.

Answer 8

We built this software with the idea of automating some of the steps in deploying an optimization model solution: https://fuinn.github.io/mos-docs/ .

Perhaps it may be helpful.