How we changed openSUSE developement
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 84 | |
| Author | ||
| License | CC Attribution 3.0 Unported: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/32427 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
FrOSCon 201657 / 84
2
4
5
7
11
16
25
26
27
28
29
30
31
32
34
36
37
40
41
43
46
47
48
49
50
52
55
56
58
59
62
63
64
65
66
67
68
69
70
71
72
73
75
76
77
79
82
83
84
00:00
Multiplication signMathematicsDirection (geometry)Set theoryCoefficient of determinationWhiteboardProjective planeXMLUMLLecture/ConferenceComputer animation
00:47
Distribution (mathematics)Execution unitPhysical systemRevision controlComputer animationProgram flowchart
01:26
Distribution (mathematics)Projective planeMereologyElectronic mailing listMultiplication signDivision (mathematics)Flynn's taxonomyTerm (mathematics)BitOpen sourceComputer animation
02:09
Forcing (mathematics)Distribution (mathematics)1 (number)Instance (computer science)CASE <Informatik>Computer animationLecture/Conference
02:51
SoftwareWater vaporStandard deviationComputer animation
03:24
Control flowSpectrum (functional analysis)Lecture/Conference
04:10
Product (business)StatuteMathematicsRight anglePhysical systemMereologyTouch typingSoftware bugComputer animation
05:06
Distribution (mathematics)PlanningAddress spaceNeuroinformatikBus (computing)Type theoryLocal ring
06:05
Distribution (mathematics)Software bugCodeCuboidBitDifferent (Kate Ryan album)Factory (trading post)MathematicsSoftware developerMultiplication signStability theorySoftware repositoryRevision controlEndliche ModelltheorieMetropolitan area networkComputer animation
07:40
Game theoryEndliche ModelltheorieSoftware developerWebsiteService (economics)Open setLecture/ConferenceProgram flowchart
08:22
BuildingOpen sourceServer (computing)Repository (publishing)Control flowDistribution (mathematics)Web pageService (economics)RootMereologyFile systemLecture/ConferenceComputer animation
10:19
Web 2.0BuildingLink (knot theory)Common Language InfrastructureUser interfaceLattice (order)Staff (military)NetbookRepository (publishing)Web pageEstimatorFactory (trading post)Presentation of a group10 (number)Video gameDirection (geometry)MultiplicationMathematicsLecture/ConferenceComputer animationJSON
11:36
Server (computing)TouchscreenProcess (computing)outputVideo game consoleUser interfaceMereologyPhysical systemSoftware testingPattern languageGeneric programmingData managementNatural languageOpen setSpacetimeMathematicsFunction (mathematics)Computer animation
12:47
GodUser interfacePairwise comparisonRight angleProof theorySoftware testingRepository (publishing)Division (mathematics)Process (computing)Distribution (mathematics)SoftwareBuildingConfiguration spaceAndroid (robot)Lecture/Conference
14:14
Projective planeMathematicsFactory (trading post)Block (periodic table)Distribution (mathematics)Repository (publishing)Level (video gaming)Software maintenanceSoftware bugComputer animationDiagram
15:29
Software bugProcess (computing)BitDistribution (mathematics)Food energySoftware developerLevel (video gaming)BuildingFactory (trading post)Projective planeSoftware testingPoint (geometry)Web pageView (database)Roundness (object)Lecture/ConferenceComputer animation
17:04
Multiplication signFactory (trading post)State of matterProjective planeLevel (video gaming)NeuroinformatikTerm (mathematics)BitInheritance (object-oriented programming)MathematicsMultiplicationProcess (computing)Software testingInformation securityLecture/Conference
18:44
Distribution (mathematics)Kernel (computing)Factory (trading post)Numerical analysisDivision (mathematics)Multiplication signCASE <Informatik>Control flowSoftware testingDiagram
19:50
Video gameKernel (computing)Local ringWeb pageMereologyComputer animation
20:26
Product (business)Physical systemWeb pageSampling (statistics)Goodness of fitSoftware maintenanceCycle (graph theory)Stability theoryLecture/ConferenceXMLComputer animation
21:08
Source codeEnterprise architecturePatch (Unix)Information securityDistribution (mathematics)Computer animation
22:06
DatabaseData storage deviceEnterprise architectureLecture/ConferenceComputer animation
22:52
Latent heatCore dumpEnterprise architectureWeb page
23:35
Stability theoryMathematicsDistribution (mathematics)Multiplication signShared memoryMereologyCore dumpComputer animationLecture/Conference
24:22
Distribution (mathematics)Configuration spaceNumerical analysisWordConservation lawPoint (geometry)Marginal distributionComputer animation
25:23
Revision controlCASE <Informatik>System of linear equationsCore dumpMachine visionDivision (mathematics)Point (geometry)Shape (magazine)Slide ruleGodSet theoryLecture/Conference
26:27
Core dumpMathematicsStability theoryServer (computing)Kernel (computing)Service PackCycle (graph theory)Text editorSoftware bugBookmark (World Wide Web)Computer animation
27:46
Service (economics)Group actionStability theoryText editorPoint (geometry)Distribution (mathematics)Meta elementMatching (graph theory)Web pagePhysical systemStandard deviationService PackPhase transitionLecture/Conference
29:05
MathematicsBitVideo gameCollisionInteractive televisionTranslation (relic)Distribution (mathematics)Web applicationLogic gateEuler anglesDiagramComputer animation
30:17
Gaussian eliminationVapor barrierSlide ruleUnit testingCellular automatonMathematicsSoftware testingStaff (military)Graphical user interfaceUser interfaceWebsiteDomain nameService (economics)Office suiteDistribution (mathematics)System administratorClient (computing)Execution unitInstallation artVirtual machineConfiguration spaceLecture/Conference
33:52
ResultantTouchscreenLine (geometry)Web pageRectangleMessage passingSoftware testingSeries (mathematics)Right angleDifferent (Kate Ryan album)Standard deviationFitness functionCASE <Informatik>
35:22
System callSoftware testingElectronic visual displayMereologyProcess (computing)Sound effectVideoconferencingSeries (mathematics)Arithmetic progressionComputer animationJSON
36:16
MathematicsFormal languageProjective planeVideo gameSoftware developerWeb pageData managementMaschinelle ÜbersetzungLogic gateUser interfaceTranslation (relic)Control systemRevision controlPrisoner's dilemmaFactory (trading post)Level (video gaming)Open setNetwork topologyOverhead (computing)Source code
38:20
ExistenceDrop (liquid)Network topologyFocus (optics)String (computer science)Translation (relic)Repository (publishing)MereologyCASE <Informatik>MathematicsCausalityDataflowRow (database)Lattice (order)Source codeLink (knot theory)Data structurePhysical systemMultiplication signUtility softwareBit rateStaff (military)Rule of inferenceAuthorizationCoefficient of determinationState of matterLecture/Conference
43:45
Computer animation
Transcript: English(auto-generated)
00:07
Okay, so hi everybody, thank you for coming, thank you for being interested in OpenSUSE. I'm here to tell you how OpenSUSE evolved mainly last year but we were working on it
00:24
for quite some time. For quite some time we were getting into this direction and now quite some stuff changed. My name is Michal Hushetsky, I'm an OpenSUSE contributor and I'm also a member of the OpenSUSE board.
00:46
I would like to start with what actually is OpenSUSE as a project. Just a reminder that we are not just a Linux distribution, we do a Linux distribution.
01:01
Sorry, I should have turned my Wi-Fi off, damn it, nobody will bother us again.
01:29
Our main goal as an OpenSUSE project is to promote the use of Linux everywhere and we are doing distribution as I said but we are also doing quite some tools around the distribution,
01:42
not just the distribution. Here is a list of some of the projects that are part of OpenSUSE project in general times. You might have heard of some of them, might not, quite some of them are interesting
02:01
and we will be talking about some of them a little bit more in details later on. So every Linux distribution out there is facing similar forces that are trying to rip it apart and those forces are mainly two main ones.
02:27
There is people that would like to have more really new stuff that are looking for newest and greatest and there are people that are looking for stable distribution
02:43
and these two forces are actually going against each other in most cases. We have somebody like some bleeding edge crazies. These guys don't like software that was released months ago because it's too old
03:03
and boring and everybody has it but they want the stuff that was released yesterday because they want to be the first to run it and discover what's new and they care about new features and if it doesn't work it doesn't bother them that much because tomorrow there is a new release
03:25
so it might work better tomorrow and it might break something else but never mind there is still tomorrow. They are really excited about every update that is out there and for them the only viable solution is rolling release
03:43
because everything else is too old and boring and for my grandpa and stuff like that. So they don't care about small issues as long as they are able to update to the newer stuff
04:02
and get some fixes. That's one side of the spectrum. On the other hand we have these boring grandpas that really hate new stuff. They want the stuff the way it used to be when they were young
04:21
and don't like any changes and want to install a system and don't touch it and just get some small bug fixes but no new features, no change in behavior really something that I can depend on for years and don't have to learn anything new
04:44
and everything will work always the same. And yeah. Well some people call it production, some people run rolling releases in production. It's called agile nowadays.
05:05
You deploy as soon as you have something that builds and it's more than way of thinking. So yeah we have these two guys that well two types of guys that want completely opposite things and distribution for everybody has to address both of them.
05:25
One of them wants to recycle basically every other day ideally two releases every day or something like that and the other guys want to release once in a few years at the top.
05:43
So how to deal with it? We dealt with it by creating two different distributions. We let them rip us apart and we have two distributions that work together and that address both issues.
06:06
One of them is called OpenSUSE Tumbleweed. It's our rolling distribution. Always changing, always fun, always new features, always new bugs and always fixing bugs that was there yesterday by adding different bugs.
06:31
So a little bit of history. It was started a long time ago by Greg Hartman. It was meant to be a rolling distribution that was kind of stable
06:45
and initially it was just add-on repo on the stable distribution. So we had a stable distribution and then we had an add-on repo where Greg picked changes from our development version
07:02
which he's kind of expected to be stable. He put them there and we got something that was kind of stable but every time we released a new distribution there was kind of a big leap in the stuff that wasn't traffic yet.
07:25
Later on we introduced some changes to our development model of OpenSUSE Factory which is the development version that made it quite stable and actually made it more stable than the old Tumbleweed.
07:44
And in November 4, 2014, old Tumbleweed was replaced by this new model of development. So how did it become more stable?
08:02
We extensively use some of the tools that I mentioned in the beginning. It can work only thanks to OpenBuild Service and OpenQA. What are those? Just a side question.
08:20
Who is here OpenSUSE user? Okay, not many. So the rest of you probably don't know these tools so let me briefly introduce them. OBS or OpenBuild Service is open source build server.
08:43
It's focused mainly on packaging so it can basically build packages but it tracks all the dependencies. When you change, for example, OpenSSL it will trigger rebuilds of everything that depends on OpenSSL
09:03
to make sure that API and ABI work together and it publishes only some coherent repositories. It understands what repositories are, how to publish them
09:22
and although it is part of OpenSUSE ecosystem it doesn't work only with RPMs. It can also create Debian packages. It can create packages for Arch Linux. It can create ISOS, TARBOS of root file systems
09:44
and some other stuff that I don't even know about and it's quite extensible. So if you are running some weird Linux distribution that we don't have support for yet it's quite easy to add support for new distribution.
10:03
You just need to implement how to write recipes for your packaging and how to export some dependencies so it can work with it. It supports, basically you have a server that directs everything
10:21
and then you have a bunch of build nodes that actually build stuff. It has a web interface, it has a CLI tool and if you want to know more there is a link that you can use and learn more.
10:40
I can try to... Yep, I turned off Wi-Fi. I wanted to show it but then this is my Android netbook so there will be plenty of notifications popping up. Maybe at the end of the presentation I will turn on the Wi-Fi
11:01
and show you how it looks in real life. So OBS is one thing. It constantly builds our packages, allows us to create plenty of repositories and publishes packages for us and makes it really easy to handle thousands and tens of thousands of packages
11:22
constantly building, rebuilding, flowing in multiple directions. Everything constantly rebuilding and changing. Great for factory or tumblery. Then we have OpenQA. That's some kind of generic testing tool
11:42
but it's mostly focused on testing of operating systems. Typical usage, how we use it is it starts VM and it pushes some input into the VM, it tracks the output, looks at the screens,
12:02
takes the screenshots and tries to find some patterns in the screenshots and then decides whether it works or not. You can use server console to push in some commands and it can compare just parts of the screen
12:23
so it can look for something. If you don't know where the window will pop up in your window manager, you can try to search for it. And we have, for example, whole installation process of OpenSUSE scripted in this tool.
12:42
So whenever we change anything, this tool will run installation process for every possible configuration of the installation and we are making sure that installation works whether you select KD, GNOME,
13:03
software 8, encrypted hard drive or whatever. And you can also make some fuzzy comparisons so if you want, it doesn't matter that much if font changes
13:20
but if you like, it can be pretty strict. And it's actually nowadays not used only by us but our colleagues at Fedora are using it nowadays as well and it can test not only OpenSUSE but I know that there was some proof of concept
13:43
of testing, for example, Android and I think somebody even tried running Windows in there. So these two tools are really great. We have something to test the distribution and make sure that it works
14:01
and we have something that can build plenty of packages and make repositories and basically create distribution. So let's put it together and we get a great tambourine. So how was factory developed?
14:24
Basically, as I was saying that we have all these repositories that can be done in OBS pretty easily. We had OpenSUSE factory and we had some package and that package always had some develop project
14:42
where changes get submitted. When maintainers of develop project or the package agrees to the changes, you can imagine it like pull request on GitHub. So they accepted the changes and pushed them to factory.
15:02
Then it got through some levels of review and ended up in factory and then it broke something completely unrelated and we had to fix it. So that was the way how factory used to be broken quite often.
15:22
If you are looking for rolling distribution, you don't mind if there are some small bugs if you get updates quite often and bugs get fixed. But if we push, for example, new GCC and it breaks half of the distribution and we cannot release anything in a month,
15:45
then you are not that happy. So we changed this process to something a little bit more complicated. Yeah.
16:01
From a contributor's point of view, it's still mostly the same. You still have your package that you branched and you still submit it to the develop project. But when developer from develop project submits it to factory, it doesn't go directly to the developer to the factory.
16:22
It ends up in some staging project before where we try to build this package and packages that depends on it from factory also so we can discover the potential building issues. Well, we found out whether it builds
16:44
but building it is not enough. So when it builds, we submit it to OpenQA for some testing to see whether it actually also runs and works. And only when it passes, then we merge it to factory.
17:04
If it doesn't pass, you have to fix, somebody has to fix what's broken there and only after that it gets merged. So, for example, if there is a new GCC, it ends up in staging project for quite a long time
17:21
until everything is prepared for release. And in the meantime, we get some fixes. How security updates work?
17:43
Question was how do we update packages of unrelated projects? There is not only one staging project. There is multiple staging projects. So you can still send updates for packages that are not this package that broke everything.
18:03
And when this change gets merged into factory, then factory gets rebuilt, published, but before it goes to the users, just to make sure we run it through OpenQA again,
18:21
do more testing to make sure that everything works and then we release it. So it's a pretty complicated process, but luckily for us, most of the stuff is done by computers. So it's just some electricity going on somewhere.
18:45
So some numbers. When we started with Tumbleweed, it was quite popular. Then its popularity kind of decreased. Then we changed the factory. It got stable and people started to like it
19:02
and migrate to new factory because we got a growing distribution that is really fast, rolling, but still quite stable thanks to our tooling that we have. So we don't break stuff that often and even if we do, we don't break it.
19:23
We don't break the major stuff because for major stuff, we have test cases in OpenQA. Some quiet week for our rolling distributions. We released three times a week.
19:41
We changed the kernel and 146 packages. That's quite a boring week. Normal week is something like this. Five releases, two kernels, and 300 packages.
20:03
Yeah, if you want to see a busy week, take a look when we update KDE or GNOME or Tech Live. Then there is thousands of packages updated and changed.
20:23
So yeah, this solves part of the problem. We got a tumbleweed to cover all these bleeding edge crazies, but what about people who want the old production systems,
20:42
old boring production systems? So what do these guys actually want? They want long recycle, long support, good maintenance. They are not after the newest and the greatest. They are after stability
21:00
and they still want quite some packages. So luckily for us, we have SUSE that helped us in that regard because they actually do distribution for these boring kind of guys. They have SUSE Linux Enterprise that is for people that don't want to update
21:24
and are conservative and stuff like that. So they released the sources of SUSE Linux Enterprise, including all patches and including all security updates. And we could do some kind of slant OS
21:41
or something like that with that, but we decided to do something completely different, something better, we hope. And because we want more packages than SLE, SLE is focused really on companies.
22:01
So set of packages is limited to what they require and because the support is really long, it's not feasible to support everything and these enterprise customers don't care about KDE, Plasma,
22:20
but they care about storage and databases and this stuff that is not that visible. So we can help each other. They can provide us with some stable code base. We are going to build on top of it some new packages.
22:42
We are going to take stuff from upstream and improve it and we can both win. So we have Tumbleweed, which has plenty of packages rolling.
23:01
Then we have OpenSUSE Leap that has some thousands of packages as well. But it has a shared core with SUSE Linux Enterprise and this shared core is shared between Leap and SUSE Linux Enterprise. And SUSE Linux Enterprise has some specific packages
23:24
on top of it that are really targeting enterprise customers like SAP and whatever. So we have this OpenSUSE Tumbleweed that is rolling
23:40
and we are taking changes from OpenSUSE Tumbleweed into our stable distributions. For example, KDE, sometimes GNOME, this stuff ends up in OpenSUSE Tumbleweed as soon as they are released.
24:02
From time to time, we want to pick something and put it into our stable distribution. And then it becomes part of the shared core that we share with SLE. Sometimes if it is something that SLE doesn't care, it just lives in Leap. And we go on and on and on and on.
24:23
We started with this, with Leap 42.1, which was our first new release. We had OpenSUSE 13.2 and then we started doing new distribution
24:43
and we call it OpenSUSE Leap and we started with the number 42.1 because we like 42. Anybody knows what 42 is? Yeah, the answer to all questions.
25:03
And actually we have quite history with this number because first SUSE distribution that was actually on distribution done by SUSE was 4.2 and first the last version, which is our graphical configuration too,
25:21
was 0.42. So we have quite a habit of starting with 42. And it actually makes sense in this case because we were basing it on the same shared core that has SLE 12. So it nicely corresponds
25:41
because Leap version is SLE version plus 30. So we can figure out which SLE we are based on. So what will happen when there will be SLE 13?
26:00
Well, at that point we will create new shared core that will be based on OpenSUSE Tambovid and on this shared core we will develop both SLE 13 and Leap 43.0. And from then on we will be still getting,
26:22
shape picking some updates from Tambovid and rolling forward as suggested here, updating the core slightly, but just little by little, no big changes, nothing that will scare people off,
26:44
keeping things stable and boring for everybody. So what we ended up with? We have a recycle based on Slivan, which is pretty conservative.
27:02
It's about one year to the service pack. So you have one year where there are just bug fixes and then there is just small changes. So nothing really scary.
27:20
You have long support over three years. We have a well-maintained and stable core, which is kernel, glibc and stuff like that. So if you are running server, then your core packages are stable and we can still do crazy stuff with the Leap packages,
27:45
like your favorite minority text editor. We can update it in OpenSUSE Leap every service pack without actually breaking stability of the whole system.
28:02
So you get newer and better packages for the stuff that is not that important, but the important stuff stays stable. First release was last year in November 2015
28:22
and currently we are I think in beta, right? We are about to enter beta phase for 42.2, which is just a little incremental update on top of 42.1.
28:44
So instead of making one distribution for everybody, we split it into two distributions that match our two groups in target audience much better.
29:05
Well, we did also some other changes. We found out that nobody is using 32 bits and pretty much nobody was using live CDs. So with the introduction of Leap, we basically dropped support for 32 bits and live CDs
29:23
as long as nobody picks it up. And since we were shaking things up, we did also something else. We deployed some translation tool.
29:41
This is a generic translation tool. It's called WebLite. It's a web-based translation, but it's running on top of Git and you can use just Git. You don't have to use web, but it's nice and easy because end users can submit suggestions for translations
30:02
and translators can just pick them up. So hopefully we will get better translated distribution and everything goes back directly to the Git. So again, another tool that helps us, well, eliminate barriers of entry
30:23
and makes it easier for people to contribute to OpenSUSE. So that's all I have on slides. I can ask you for your questions and I will turn on Wi-Fi and show you the websites that I was talking on.
30:43
So we can start by questions if you have any. No questions? Okay, let's turn on Wi-Fi and see what pops up. Where? Sorry?
31:00
Okay. So OpenQA sounds... No, I've never seen OpenQA for the SUSE stuff, but I'm also kind of working a lot on client-automated deploys or public configuration that is kind of employed and continuous clients. So OpenQA also looks like a nice way to integrate
31:21
in a setup like that where you test your deployed configuration with clients. Have you ever seen something like that in use? Okay, so question is... question is that there are...
31:41
if you have... if you are deploying quite some changes using stuff like Puppet, Chef and Ansible and whatnot, whether we saw somebody using OpenQA to test those changes? I haven't seen personally.
32:02
It might be possible to use it, but the main idea behind the OpenQA is that you get to test the user interface the user is facing. And mostly the stuff that you are talking about,
32:21
this system management stuff, you are configuring stuff that is not that user visible. Mostly it's much easier to test it without graphical user interface and to test it by doing some unit testing.
32:40
The main issue we were trying to address with OpenQA is that you cannot unit test that user interface for LibreOffice is working. Or you can, but not that easily. Or it's really hard to test that you can install distribution and Grap works
33:03
after installer ended up. So, yeah, probably it can be used, but I think you can do it easier with tests tailored to your services because mostly you are deploying some service
33:25
that has some API or something. Oh, you are deploying desktop machines. Okay, then this too might help you.
33:42
So, let's start by OpenQA. Okay, so this is how the page looks like. We have results of some tests, some are failing, some are soft failing, some are passing.
34:06
And if we take a look at, I don't know what. Let's take a look here. We can see that test results are not just one thing,
34:21
but there is multiple stuff that was tested. We can see what was working, what was not working. And, yeah, if we take a detailed look, we can see the series of screenshots documenting what was going on
34:41
and what was, the green one were passing and orange one was soft passing. We can take a closer look and here is, that doesn't work on touch screen. But in general, there is this yellow line
35:02
that you can direct to the left or to the right and you can see what's the difference between the real result and the wrong result. In this case, there is a blue rectangle. That blue rectangle is something that we were looking for and in this case, didn't really match it up.
35:24
This is a serial, but yeah. Oh, this one? Yep. We were looking whether Grap works,
35:40
whether it displays OpenQL logo somewhere and whether we have progress bar in there. So OpenQL is taking a series of screenshots and looking for stuff in those screenshots and the interesting part, it documents.
36:01
There is also a video of whole installation process. So you can take a look at how installation is done as a side effect of doing tests for the installation.
36:24
Now, this is how OBS looks like. It's quite busy, as you can see. And we have plenty of projects. All packages are divided into projects.
36:42
There are submit requests that can go between those projects. One of those projects is open SUSE factory. You can see some staging projects.
37:01
There is a nice web interface for managing all these packages, but mostly if you are a developer, you can get really fast accustomed to the CLI stuff. It works basically like SVN or Git.
37:21
It has its own version control system where you just commit changes to the packages it builds. It gets published, you test it, you submit it somewhere. And WebLite, I will show you the upstream one.
37:42
And yeah, it's basically website translation tool where you can see languages makes a suggestion and changes goes directly into the Git that is in the backend.
38:01
So developers don't have any overhead with managing translations somewhere in some tool. It runs directly on top of their Git tree. Okay, so some more questions now that you see some pictures.
38:26
Anything? Nothing? Okay, what were we using for translation before WebLite?
38:42
Yeah, we had some SVN tree where we had to export our strings to then our translators did whatever they wanted with those strings. Some of them downloaded it and mailed it back. And some of them committed it directly.
39:04
But it still required somebody to export the strings to the tool. Well, in our case, SVN repository and merge changes back. So nowadays, we are just running tool that can work on top of our Git tree
39:22
that kind of simplifies the stuff and eliminates the need for somebody to merge it there and back and makes just translators responsible for that.
39:48
Yeah, well, we were looking at some other systems as well. I think that KD has some... I don't know what. There is also Poodle, I think you said.
40:03
Yeah, we found out that this one works the best for our use case. There are a few translation tools out there. We like this one the most.
40:20
Okay. So, how much German is SUSE and OpenSUSE?
40:56
Well, we still have a bigger German community.
41:03
Sorry? Whether SUSE GmbH exists? I believe so. I think it's still... Is it still GmbH? Yeah. So, yeah. No.
41:23
Okay, I have a mic. So, I know that Doug can explain it, but he doesn't have the mic, so for the recording, I will try to explain. SUSE GmbH is a company that still exists and never stopped existing.
41:42
It was bought by Novell. Novell was then bought by Attachmate company. These were both American and then Attachmate company was bought by Micro Focus, which is a Britain company.
42:03
And in Novell days, Novell was trying to merge with SUSE. Then Micro Focus decided that it would be better to run SUSE quite separately from other businesses because they had multiple businesses.
42:21
And I think Micro Focus is still the same. SUSE runs pretty much independently from the other parts of the company. So, yeah. SUSE is still there, better than ever. And, yeah, I think headquarters of SUSE is back to Nuremberg.
42:47
So, yeah. We still have plenty of Germans in SUSE. We have also plenty of other people, other nationalities. And we have, as OpenSUSE,
43:01
we have a broad community around the world. So, yeah, we have, hopefully, everybody can join. So, we are a friendly community. Okay. So, any other questions?
43:24
No? Then thank you for your attention. If I got you interested, try OpenSUSE. We have a booth down there. Doug is running it. We have plenty of goodies. So, drop by and ask more. Thank you.