Alternative to Docker that is less restrictive for maintaining package dependencies

I work on robotics on ROS running with Xenial, but this applies to any application running on Ubuntu. With a team of engineers, its rather hard to keep everyone’s test station uniform in package versions. A while back, we had a testbed break completely since a new update/upgrade changed much of a package functionality.

I want to avoid this and have a solution that allows me to duplicate these testbeds with ease.

I realize that Docker is the popular solution for this, but the container solution is a little bit too restrictive for my needs. I don’t mind reinstalling drivers and etc and I’m finding it cumbersome to deal with Docker specific issues in getting my original testbed running(especially as it requires multi-containers).

Is there a solution available that can achieve my needs without going as far as a container like Docker?

The dumb method would just be clone my entire testbed…maybe that’s still the best for me?

Create an executable application in Ubuntu with many dependencies?

We have coded an application with many dependencies. Right now, we can use a makefile to compile source code. What we want to do next is create an executable application (we don’t want to release our source code) with the dependencies. Just a compressed file, other users can extract and use it directly. we don’t want to provide source code, it seems that debmake can’t work. How to compress the dependencies along with the executable main application? Thanks for any suggestions.

Copy package in Production DB to Test DB with dependencies?

This is my first question here, so please let me know if this isn’t the right place to ask.

I’m a new programmer, fresh out of school. Primarily I develop in Python/C#, with a dash of SQL when needed.

At my job, I’ve been assigned a task in PL/SQL, which involves modifying some existing procedures. All well and good, some new syntax to learn, but no serious roadblocks.

My problem is, I have no idea how to migrate the existing package/views/tables to our test database, which is basically an un-maintained sandbox environment.

I only need to copy two stored procedures in a package, two views, and 3 tables, so that I can modify the procedures and verify that the output is as-expected. However, I feel like there must be a better way to move this data than “crtl+c, crtl+v” in the editor window, or downloading and uploading table export files via my local machine.

I’m working in Oracle SQL Developer, and really only need to move enough data to execute these procedures and test my work. My job is really the development here, and the more time I spend trying to set up this test environment, the less time I spend coding.

Is there some sort of way to easily copy a package and all its data dependencies from one database to another? Bonus points if it’s in Oracle SQL Developer, and easy for a non-DB admin to do. Thanks!

Unmet dependencies error 127

``\$   sudo apt-get install python3-aptdaemon Reading package lists... Done Building dependency tree        Reading state information... Done You might want to run 'apt --fix-broken install' to correct these. The following packages have unmet dependencies:  python3-aptdaemon.gtk3widgets :  Depends: python3-aptdaemon (= 1.1.1+bzr982-0ubuntu19) but 1.1.1+bzr982-0ubuntu19.1 is to be installed  E: Unmet dependencies.  Try 'apt --fix-broken install' with no packages (or specify a solution). ``

How to install Wine 4.13 (unmet dependencies libfaudio0)?

I am currently using Ubuntu 19.04, but this has been a problem with previous versions of Ubuntu, including 18.04 LTS. When attempting to install Wine from the WineHQ repositories, I get an unmet dependencies error for libfaudio0. What can I do to install a newer version of Wine than is available in the Ubuntu repositories?

Private/Hiding dependencies between Maven modules

Given three project modules X, Y and Z on a Maven based project, and Y depends of Z and X of Y and X should not know that Y depends of Z, being this:

X -> Y

Y -> Z

X -X> Z

What is the best way to hide the dependency between modules X and Z ?

I’m aware that on Maven it’s possible to change the scope of the dependency, but I would like to know if there are any other options for it

How to “state of the art” integrate multiple sub-modules with duplicate dependencies?

I am currently working on a project which will consist of multiple sub-modules. Each sub-module is developed and unit-tested in its own repository. All sub-modules have to be integrated in one main-project repository.

Furthermore I have some “support-functions” modules which are implementing for example a logging tool and a tool for connecting to a database. The support-function modules are used by most of the sub-modules. As the sub-modules are not necessaryly developed with the same life-cycle, it might be that not every sub-module uses the same version of the support-function modules. The support-function modules are also developed and unit-tested in it’s own repository.

This means that I in total have a project structure like this :

• The MainProject consists for example of three submodules (SubmoduleA, SubmoduleB, SubmoduleC)
• SubmoduleA uses the support-function module “Logging-Tool” with version 4.0
• SubmoduleB and SubmoduleC are using the support-function module “Logging-Tool” with version 5.0

In the past I would have created one main-project-repository and copied all header and source-files and testing-source-files of all submodules and of the support-functions module into this repo and compile it all together. If I would have wanted to support the different versions of the Logging-Tool I maybe would have renamed it to be able to compile both versions.

Now my question is : How do I do this with the state of the art-integration techniques of 2019? Do I have to compile each sub-module and support-function-tool to a library and do a binary-integration. Or can I do a source-code integration which allows me to easily debug the project with all it’s sub-modules. But if I do a source-code integration how can I handle the duplicate support-functions modules with different versions?

Are there some cool techniques / best-practices or tools to use? I already know of the great possibilities of the “google repo” command. This would maybe be a nice help for the Main-Project repository.

I hope someone can help me, or can maybe give me a hint where to continue reading?

Best Regards, anon1234

P.S. : To show a very simple code-example : There is a Logger-class:

which looks in version 4.0 like this

``#ifndef LOGGER_H #define LOGGER_H  #include <iostream>  using namespace std;  class Logger {     public:         Logger() {}         void log(string val_) {             cout << "DEBUG: " << val_ << endl;         } };  #endif // LOGGER_H ``

and in version 5.0 like this

``#ifndef LOGGER_H #define LOGGER_H  #include <iostream>  using namespace std;  class Logger {     public:         Logger() {}         void log(string val_) {             cout << val_ << endl;         } };  #endif // LOGGER_H ``

A SubmoduleA could look like :

``#ifndef ModuleA_H #define ModuleA_H  #include "Logger.h"  class ModuleA {     public:         ModuleA() {}         void doSmth() {             Logger l;             l.log("ModuleA is doing smth");         } };  #endif // ModuleA_H ``

A SubmoduleB could look like:

``#ifndef ModuleB_H #define ModuleB_H  #include "Logger.h"  class ModuleB {     public:         ModuleB() {}         void doSmth() {             Logger l;             l.log("ModuleB is doing smth");         } };  #endif // ModuleB_H ``

A SubmoduleC could look like

``#ifndef MODULEC_H #define MODULEC_H  #include "Logger.h"  class ModuleC {     public:         ModuleC() {}         void doSmth(){             Logger l;             l.log("ModuleC is doing smth");         } };  #endif // MODULEC_H  ``

Is the complexity of this topological sort algorithm O(P+D) where P is projects and D is dependencies?

I have written a topological sorting algorithm in c++ but i am not sure if the complexity is as good as it should be. I know theres a topological sort algorithm that works in O(P+D) time where p is projects and D is number of dependencies, but I am unsure if i wrote it correctly. Can you take a look? Code is below. Any other suggestions on improvement is welcome too, I feel like having 2 lists for adjacency is inefficient and I think there should be a better way to do it.

``#include <iostream> #include <string> #include <unordered_map> #include <unordered_set> #include <queue> using namespace std;  class Graph{ public:     Graph(vector<string> projects, vector<pair<string,string>> dependencies)     {            int counter=0;         for(int i=0;i< projects.size();i++)         {             strToInt[projects[i]]=counter++;             }         adjList.resize(projects.size());         for(int i=0;i<dependencies.size();i++)         {             adjList[strToInt[dependencies[i].second]].first.insert(strToInt[dependencies[i].first]);             adjList[strToInt[dependencies[i].first]].second.push_back(strToInt[dependencies[i].second]);         }     }     vector<pair<unordered_set<int>,vector<int>>> adjList;     unordered_map<string,int> strToInt;     bool BuildOrder(){         vector<int> visited(adjList.size(),0);         queue<int> q;         int count =0;         for(int i=0;i<adjList.size();i++)         {             if(adjList[i].first.size()==0)             {                 count++;                 q.push(i);             }         }         while(!q.empty())         {             count++;             int temp=q.front();             q.pop();             visited[temp]=1;             for(int i=0;i<adjList[temp].second.size();i++)             {                 adjList[i].first.erase(temp);                 if(adjList[i].first.size()==0&&visited[i]==0)                 {                     q.push(i);                 }             }         }         if(count==visited.size())         {             return true;         }         return false;     }   };  int main() {     vector<string> projects;     projects.push_back("a");     projects.push_back("b");     projects.push_back("c");     projects.push_back("d");     projects.push_back("e");     projects.push_back("f");     vector<pair<string,string>> dependencies;     dependencies.push_back(make_pair("a","d"));     dependencies.push_back(make_pair("f","b"));     dependencies.push_back(make_pair("b","d"));     dependencies.push_back(make_pair("f","a"));     dependencies.push_back(make_pair("d","c"));     Graph g(projects,dependencies);     bool temp=g.BuildOrder();     return 0; } $$```$$ ``

Problems with unmet dependencies

I have tried lots of things I found on this website and others and i just can’t get this to go away. This is what happens when I try to install anything:

``rw@rw:~\$   sudo apt install macchanger Reading package lists... Done Building dependency tree        Reading state information... Done You might want to run 'apt --fix-broken install' to correct these. The following packages have unmet dependencies:  libgl1 : Depends: libglvnd0 (= 1.0.0-2ubuntu2.2) but 1.0.0-2ubuntu2.3 is to be installed           Depends: libglx0 (= 1.0.0-2ubuntu2.2) but 1.0.0-2ubuntu2.3 is to be installed  libgl1-mesa-glx:i386 : Depends: libgl1:i386 but it is not going to be installed E: Unmet dependencies. Try 'apt --fix-broken install' with no packages (or specify a solution). ``