How do we make "Qt on Mer" the solution of choice for device vendors?
This is a modal window.
Das Video konnte nicht geladen werden, da entweder ein Server- oder Netzwerkfehler auftrat oder das Format nicht unterstützt wird.
Formale Metadaten
| Titel |
| |
| Serientitel | ||
| Anzahl der Teile | 90 | |
| Autor | ||
| Lizenz | CC-Namensnennung 2.0 Belgien: Sie dürfen das Werk bzw. den Inhalt zu jedem legalen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen. | |
| Identifikatoren | 10.5446/40293 (DOI) | |
| Herausgeber | ||
| Erscheinungsjahr | ||
| Sprache |
Inhaltliche Metadaten
| Fachgebiet | ||
| Genre | ||
| Abstract |
|
FOSDEM 201348 / 90
2
5
8
10
12
13
14
15
17
19
21
24
25
28
29
31
32
34
36
39
40
43
44
46
50
51
52
54
55
57
58
62
65
66
67
78
79
87
88
00:00
AuswahlaxiomMultiplikationsoperatorOpen SourceProjektive EbeneKollaboration <Informatik>ComputeranimationVorlesung/Konferenz
00:58
AuswahlaxiomMobiles InternetKontrollstrukturTablet PCSpeicherabzugMobiles InternetTablet PCSmartphoneSoftwareProgrammierumgebungOpen SourceFeuchteleitungComputerspielProdukt <Mathematik>Minkowski-MetrikSet-Top-BoxMultimediaSelbst organisierendes SystemFreewareProduktraumZellularer AutomatGüte der AnpassungLineare OptimierungTopologischer VektorraumPunkt
02:40
FokalpunktBitMinkowski-MetrikProgrammierumgebungTablet PCMomentenproblemOpen SourceProjektive EbeneAussage <Mathematik>Selbst organisierendes SystemImplementierungVorlesung/KonferenzComputeranimation
04:09
SpeicherabzugMobiles InternetDistributionenraumPhysikalismusDemoszene <Programmierung>DruckspannungPhysikalisches SystemOffene MengeEigentliche AbbildungBildschirmfensterTVD-VerfahrenDifferenteMereologiePersonal Area NetworkMinkowski-MetrikRichtungProgrammierumgebungMAPFokalpunktTypentheorieProzess <Informatik>Keller <Informatik>Vorlesung/Konferenz
05:59
Treiber <Programm>Kernel <Informatik>ARM <Computerarchitektur>Set-Top-BoxMobiles InternetGraphiktablettMereologieFlächeninhaltServerDifferenteAussage <Mathematik>Zentrische StreckungVarietät <Mathematik>BitSet-Top-BoxTablet PCMobiles InternetWidgetVorlesung/KonferenzComputeranimation
07:28
CodeFokalpunktTypentheorieDifferenteVarietät <Mathematik>HardwareSet-Top-BoxComputerarchitekturHackerBootenSoftware EngineeringIntegralDokumentenserverMereologieFokalpunktCASE <Informatik>Gebäude <Mathematik>RechenschieberElektronisches ForumVorlesung/KonferenzComputeranimation
09:18
CodeFlächeninhaltProjektive EbeneFundamentalsatz der AlgebraFormation <Mathematik>Open SourceSelbst organisierendes SystemFörderverein International Co-Operative StudiesCodeMereologieBefehl <Informatik>Vorlesung/Konferenz
10:20
CodeKollaboration <Informatik>SystemprogrammierungCodePhysikalisches SystemRobotikProgrammfehlerTypentheorieProzess <Informatik>Ideal <Mathematik>MereologieVorlesung/KonferenzComputeranimation
11:08
Software Development KitSampler <Musikinstrument>Gebäude <Mathematik>SpezialrechnerSystemplattformCodePatch <Software>SystemprogrammierungBenutzerschnittstellenverwaltungssystemProzess <Informatik>DifferenteVirtuelle MaschineTopologieSoftwarewartungGebäude <Mathematik>ResultanteBitPhysikalisches SystemProgrammierumgebungCodeNamensraumFokalpunktSoftwareZahlenbereichFundamentalsatz der AlgebraBenutzeroberflächeTaskLastWiderspruchsfreiheitAussage <Mathematik>IntegralSoftwareentwicklerMultiplikationRahmenproblemStochastische MatrixComputeranimation
13:25
ZahlenbereichSampler <Musikinstrument>DämpfungBenutzerschnittstellenverwaltungssystemQuaderLineare OptimierungPhysikalisches SystemComputerarchitekturFront-End <Software>TVD-VerfahrenTermARM <Computerarchitektur>Vorlesung/Konferenz
14:07
SystemprogrammierungBenutzerschnittstellenverwaltungssystemProzess <Informatik>Patch <Software>Physikalisches SystemProzess <Informatik>MereologieGebäude <Mathematik>ProzessautomationVersionsverwaltungDatenverwaltungSoftwaretestGüte der AnpassungEigentliche AbbildungDämpfungVorlesung/Konferenz
15:25
Patch <Software>SystemprogrammierungBenutzerschnittstellenverwaltungssystemProzess <Informatik>Bildgebendes VerfahrenTypentheorieRohdatenWurzel <Mathematik>DateiverwaltungTaskBootenVarietät <Mathematik>ZahlenbereichVirtuelle MaschineMereologiePhysikalisches SystemRobotikProzess <Informatik>SoftwaretestMathematikVorlesung/Konferenz
16:51
MiddlewareSpeicherabzugSoftwaretestFlächeninhaltPhysikalisches SystemProgrammierumgebungSpeicherabzugSchlussregelProjektive EbeneIntegralKlasse <Mathematik>Softwareentwickler
17:55
Kernel <Informatik>Patch <Software>BinärcodeBitHardwareBrennen <Datenverarbeitung>Anpassung <Mathematik>KonfigurationsraumFlächeninhaltServerVerschlingungWeb-SeiteMobiles InternetSpeicherabzugVersionsverwaltungSystemplattformGebäude <Mathematik>SmartphoneMereologieVirtuelle MaschineCodeProjektive EbeneQuaderKonfiguration <Informatik>Tablet PCVirtualisierungWiderspruchsfreiheitPhysikalisches SystemTreiber <Programm>Open SourceProgrammierumgebungVorlesung/Konferenz
20:42
MiddlewareSpeicherabzugSoftware Development KitEmulatorSystemplattformSystemplattformMereologieApp <Programm>Graphische BenutzeroberflächeVirtuelle MaschineComputersicherheitKartesische KoordinatenProgrammierumgebungPlug inOpen Source
21:54
ProgrammierumgebungSoftwarewartungEmulatorBildschirmfensterVirtuelle MaschineÜbersetzer <Informatik>Physikalisches SystemGamecontrollerQuaderDienst <Informatik>Vorlesung/Konferenz
22:48
Software Development KitEmulatorPlug inSystemplattformMaskierung <Informatik>BeamerVirtuelle MaschineMenütechnikRichtungTouchscreenMinimumAuflösung <Mathematik>EmulatorComputeranimation
23:53
RechenschieberOrtsoperatorPunktSelbst organisierendes SystemSoftware Development Kit
24:34
AuswahlaxiomNotebook-ComputerLeistung <Physik>Web-SeiteRechenschieberVisualisierungE-MailBitDateiverwaltungMechanismus-Design-TheorieCodeOrdnung <Mathematik>VollständigkeitElektronische PublikationVorlesung/KonferenzComputeranimation
25:41
CompilerTermBenutzerbeteiligungRechenschieberMultiplikationsoperatorServerKette <Mathematik>Lineare OptimierungWurzel <Mathematik>AdditionE-MailSoftware Development KitDateiverwaltungPhysikalisches SystemDifferenteBenutzerfreundlichkeitSoftwareentwicklerFilesharing-SystemElektronische PublikationVorlesung/KonferenzComputeranimationFlussdiagramm
26:59
WarteschlangeFilesharing-SystemVirtuelle MaschineQuellcodeObjekt <Kategorie>SystemplattformBitHalbleiterspeicherCachingPatch <Software>Web-SeiteE-MailMinkowski-MetrikMini-DiscVirtuelle AdresseComputeranimationVorlesung/Konferenz
27:42
Software Development KitSystemplattformSystemplattformProzess <Informatik>BootenHardwareAnpassung <Mathematik>Elektronischer ProgrammführerGraphikprozessorPunktPhysikalisches SystemComputeranimation
28:29
PhasenumwandlungSpezialrechnerBitCodeSoftwareBildgebendes VerfahrenGebäude <Mathematik>DokumentenserverSichtenkonzeptPunktVorlesung/KonferenzComputeranimation
29:18
StandardabweichungPhasenumwandlungVerschlingungProgrammfehlerPunktMathematikValiditätProgrammierumgebungSinusfunktionVorlesung/Konferenz
30:24
ObjektverfolgungPhasenumwandlungVektorpotenzialProzess <Informatik>Projektive EbeneSpeicherabzugWeg <Topologie>MathematikMultiplikationsoperatorComputeranimation
31:08
ComputerspielDreiecksfreier GraphATMProdukt <Mathematik>OrtsoperatorTypentheorieRückkopplungVorlesung/Konferenz
31:58
ProgrammverifikationSpeicherabzugSystemprogrammierungMaßstabPunktObjekt <Kategorie>RichtungSpeicherabzugTermSI-EinheitenProdukt <Mathematik>Zentrische StreckungHumanoider RoboterSystemplattformComputeranimationVorlesung/Konferenz
32:48
DatenmodellRechter WinkelTermNummernsystemHecke-OperatorProdukt <Mathematik>HilfesystemWort <Informatik>GradientARM <Computerarchitektur>OrtsoperatorMessage-PassingSystemaufrufDifferenteProjektive EbeneMechanismus-Design-TheorieMereologieMinkowski-MetrikInteraktives FernsehenTypentheorieMustererkennungLastQuellcodeMAPOpen SourceSelbst organisierendes SystemPhysikalisches SystemCodeWeb SiteProgramm/Quellcode
35:18
QuellcodePhysikalischer EffektSchreib-Lese-KopfOffene MengeBitVersionsverwaltungAusnahmebehandlungVorlesung/KonferenzComputeranimation
36:29
Software Development KitIntelMathematikSichtenkonzeptVirtuelle MaschineGüte der AnpassungOpen SourceEmulatorSoftwareWertevorratAnpassung <Mathematik>DifferenteProgramm/Quellcode
37:13
Software Development KitAtomarität <Informatik>URLKette <Mathematik>VersionsverwaltungTypentheorieServerSoftwareentwicklerFokalpunktElektronische PublikationRechter WinkelSoftware Development KitBitComputeranimationVorlesung/KonferenzProgramm/Quellcode
37:59
ComputerarchitekturDifferenteVersionsverwaltungSoftware Development KitSampler <Musikinstrument>SoftwareentwicklerKette <Mathematik>Installation <Informatik>SchnittmengeComputeranimation
38:51
Humanoider RoboterGeradeSystemplattformBitWeg <Topologie>Wrapper <Programmierung>NamensraumVirtuelle MaschineOpen SourceBefehl <Informatik>Message-PassingSoftwareentwicklerObjekt <Kategorie>Verzweigendes ProgrammMereologieStellenringTrennschärfe <Statistik>VersionsverwaltungSurjektivitätMechanismus-Design-TheorieApp <Programm>Projektive EbeneProgrammbibliothekComputervirusAuswahlverfahrenProgrammierumgebungHardwareLokales MinimumStabilitätstheorie <Logik>Gebäude <Mathematik>Service providerVorlesung/Konferenz
44:13
VersionsverwaltungGemeinsamer SpeicherBildschirmfensterGlobale OptimierungFlächeninhaltNP-hartes ProblemSystemplattformQuaderVarianzGebäude <Mathematik>SoftwareentwicklerVollständigkeitHardwareÄußere Algebra eines ModulsPaarvergleichVarietät <Mathematik>Minkowski-MetrikBenchmarkRechter WinkelLokales MinimumPhysikalisches SystemSupersymmetrieProgrammierumgebungCASE <Informatik>RahmenproblemVorlesung/Konferenz
49:35
BootenMultiplikationsoperatorPhysikalisches SystemTermSet-Top-BoxSymboltabelleUmsetzung <Informatik>Figurierte ZahlFlash-SpeicherE-MailFokalpunktMailing-ListeCASE <Informatik>HalbleiterspeicherQuaderVorlesung/Konferenz
Transkript: Englisch(automatisch erzeugt)
00:00
Ah, OK. So are we OK to begin? I think so. Sorry about the time it took to get that working. I'm David Greaves, LBT on IRC and generally around the place. I actually work for a company called Yolla, who
00:21
are working on mobile phones. And they actually pay me to work on some open source projects like Mare Project, Nemo, and things like that. That's cool. You all good? So I'm here to talk about Mare and Qt.
00:42
And we're in the cross distro room. That's because there's a lot of talk been going on about tools and collaboration. And a lot of what Mare does is about tools and collaboration. So this is actually quite similar to that kind of stuff in concept. We're really looking to make life easy for vendors
01:01
So this is about making life easy for people who want to build products. So we actually act as both an upstream and a downstream. So we've got Yolla, who have been working. And we've had a stand out there. And we're doing a mobile phone, smartphone stuff. And we've got the Sailfish work.
01:22
And they're producing a full mobile smartphone device that's going out to the market based on our work. So this is really good stuff. We've got Vivaldi, who are working on their tablet. So Aaron's around. And that's still in the works. And he's working on that.
01:40
Chinese organizations making TVs, set-top boxes using Mare. They're on MIPS, if I'm not mistaken. We've got people in the health care environment who've decided that what they need to do is actually produce a product that's got multimedia capability for bedside. And they're using Mare as the core of that. So yeah, we are actually quite proud of what's
02:01
been achieved so far. And we want more people to do it. And we're talking about lots of things. We're talking about TVs, cars. It's basically phones, yes, we all know about that. But there's an awful lot of other stuff about that around the environment that we can work on as well.
02:20
And when you've got things like the Raspberry Pi at that kind of price point, we've got an incredible opportunity for innovation in the product space. And what we want to do is make sure that barrier to entry for organizations, businesses, is really small. And that they're using free software, open-source software inside of it. So we are beginning to encroach down onto the embedded space.
02:42
The embedded space is beginning to grow up into a full-blown Linux kind of environment. Little bit about where we came from. Mare actually started back in about 2009 with the MIMO environment. And we launched that. Carsten launched a project to reconstruct MIMO.
03:01
And we got somewhere, we were looking at Moblin. We looked at stuff around some tablets that we got. But then Migo came along and we kind of thought, okay, this stuff makes sense. Let's get involved with what they're doing. Anyway, that didn't work out too well. But it doesn't matter,
03:20
because a lot of what they did was open-source. They contributed it and they put a huge amount of money and effort into making this stuff work. So thanks, we'll take that, we'll now continue with it. And this is one of the things that we want to put across to organizations, businesses that look at this kind of stuff. The risk is actually lower than you think.
03:40
Migo went away. Yeah, we barely noticed. You know, we can carry on using this stuff. What we did notice was that the implementation, the way they did this stuff didn't really fit with the way community would like that to be done. So we're basically saying, okay, we'll do this ourselves. Yeah, so we looked at the Migo proposition
04:05
and it really wasn't quite what we thought you would want to have if you were looking to build a device, if you were looking to build something physical that you wanted to sell. It was great if you're a really big multinational company that could afford, but that wasn't necessarily the only place
04:21
that we saw this going. So we kind of started pushing internally to Migo before it went away that we should perhaps do this. Didn't really get much traction, kind of isn't surprising because we think they were kind of talking to Samsung behind the scenes and then Tizen came up and we decided, you know, well, it's not that, we're going to do this anyway. So we continued with Mayor and Mayor was reborn
04:42
and we kept the same logo and everything because we liked it. So we've had reasonable success attracting interest for this. The Migo concept, the connected devices stuff was really very good. The whole approach of saying let's make a proper Linux stack, let's go into competition against like Android, iOS, Windows
05:02
and provide the only kind of open environment around here that you can actually contribute to that works at this level in the Linux space and has this particular vendor focus. And it's about being able to influence the direction of what we do. Quality is kind of an important part of what we do in Mir as well.
05:21
It's about saying we care about making stuff ready for putting it into a kind of commercial device. So we've got a lot of stuff about automation and processes and the intention is to be efficient. So we can say a small business can take the work that we're doing and pick it up and actually use it to go into business.
05:44
So yeah, this whole base thing is about where we're coming from. The fact that we're going to sit down and say, okay, build on this, fork it, work with it. This is about working with multiple people who've got variations on what we're doing. And we're going to be working with different types of systems that they have in the background.
06:01
They've got, they'll have Debian servers, Ubuntu servers. They'll have, you know, OpenSUSE we use quite a lot. So there's quite a lot of work that we have to do with different parts of what we do that work on different areas. But it's not. Other things, Mir isn't a, doesn't have a user experience. So we don't sit down and provide, you know,
06:23
widgets and a kind of a look and feel. What we do actually, it kind of is a little tiny thing that just says GLS is working and that's about it. So you get the benefit then of being able to pull down from I think 1,500 or so packages
06:42
that we had in MeeGo down to about 330. And you know, you compare this to something like Debian where I'm not even sure you can fit that into 16 bits anymore. So it's kind of a completely different scale and it's a lot more manageable. And that actually comes back to some of the kind of risk proposition we would put to people out there
07:02
who want to look at taking this into their business. It becomes a manageable problem. And actually don't worry, Mayor Tools is where Emacs lives because I'm not doing without it. So we're basically focusing on delivering into these areas. And that means that there are a variety of UXs.
07:22
We've got mobile UXs, we've got the UXs that are required to go into a tablet. They're different. IVI, there are people developing those. The set-top box UXs, all different types of things. Different architectures, hardware architectures and we as hackers can also work on a variety of different devices that we can get to boot up
07:41
and play with and start our own experiments and such like. And kind of, it's an important thing to look at that you in this slide is the CEOs really. It's the people who are kind of looking at the commercial aspects of what we're trying to get done.
08:01
But we care about this. We really ought to as kind of software engineering professionals, we want them to select this technology and that means we need to understand the business cases behind it. We need to understand why they would want to pay our salaries to work on this stuff. And that to me is an important part of what we're trying to address.
08:20
And also a lot of what we're trying to do is make this more efficient, take out the tedious stuff and allow us to focus on working on the stuff that's actually interesting. And this is kind of, yes okay, so we are gonna focus. We have as a distro a specific focus. We don't have particularly end users.
08:42
We don't have forums. We're not that kind of a distro. We're very much focused on people who want to come and use this and actually go away and build things on top of it. We're very pragmatic about what we do. We're not really, we just have to solve problems. Sometimes we can't solve them perfectly. You want to see our Git repository where we've got
09:01
tarballs in Git, it'll get fixed. And the other half of this is about how going forward we intend to retain the integrity to be able to say this is how we will keep behaving in this manner. In this area we've got Jolla who've been working on this
09:22
have formed something called Sailfish which is Sailfish OS and they're building up a kind of an ecosystem around this project. And they're planning a commercial ecosystem around it. And they're in the tools around this are an important part of what they're doing.
09:42
And it's kind of key to remember that they're doing this in a commercial manner, they're gonna go off and they're gonna try and license it and sell it. But it's a lot like the kind of set up where you've got with the Qt project where you've got a fundamental open source project underlying this with the governance that we've kind of got out there. And you've got commercial organizations
10:00
looking to be able to monetize it and pay salaries. We like that. And this, yes, kind of comparable to things like ICS and Digia and KDAB and these kinds of peoples. Anyway, I mentioned tools in this before and I've got a kind of a statement that says that code is really not enough. When we deliver, it's great to throw
10:22
a chunk of code over to people, but you need to have a lot more than that. You do need the code, but there's also the systems that you need to build stuff. There are QA and reporting type systems, the bug systems. And when you've got these systems, how do you use them, what are the best practices,
10:40
how do you actually use them efficiently, and a lot of that for me is automation. It's about process automation and it's about having robots do tedious jobs. And documentation support, trying to ensure that people are able to pick up what they've been given and work with it. And that documentation is an important part of that.
11:02
Automatically produced documentation, ideally. So what you get with Mer? You get a whole load of software, and yes, we've got Qt as a kind of a primary focus for where our user interface goes.
11:21
It's, you know, the main API is Qt QML and then above that, we don't mind. But it's not just Qt, we have actually had people looking at putting other systems on top and they've gone straight to the frame buffer, things like that. So if you're going to be writing code, you need an SDK, so we've also put some effort
11:43
into the SDK environment. And this is something that we started with a number of developers who had different machines and different environments and we needed consistency in tooling, blah, blah, blah. So we started off with a plain and simple chroot, nothing fancy, and it essentially lets us do
12:00
our maintainer tasks on any other distro so that we can keep the majority of our tools out there. And that should hopefully have a significant improvement, thank you, Oleg, for that, when we start using namespace support and such like. But essentially, we've got a nice chroot for our SDK. And it lets us do what we need to do,
12:21
the basic maintainer tasks. It also lets us talk to some of our systems and the systems that we work with are really important, I think, in making this a valuable proposition for people that wanna get into business making this work. And that's, as I say, our fundamental target.
12:44
OpenSUSE's build system. I was talking to the guys earlier, and I said, I don't understand why there aren't like two or three talks in the cross-distro environments about this particular capability, although they have been at FOSDEM most of the years banging on about it, so that's good.
13:01
We love it, we've done quite a bit of work on it, and it basically allows us to build, if you don't know it, it allows us to build code against multiple different distros at the same time. And we're working on things like Git integration with it so that we can pull in from a Git tree and have packaging for different distros and basically say, okay, build against them all and validate the results of that.
13:23
We're also working a lot on using, on integrating cross-compilation into the build systems so that we've now got the build farm running at the back end, and it's able to build, I mentioned earlier about the number of architectures, so we build for three variations of ARM, we build for Atom-enabled x86 and plain x86,
13:42
and we also build for MIPS. So that's all done using the Scratchbox 2 capability, which is completely different to Scratchbox 1 and actually is really quite good. And that gives us a kind of a path-based cross-compilation system, which if you want more details, I've come and talked to us about it.
14:02
Other things, BOSS. BOSS is something that we put together, previously worked at Nokia, as part of the MeeGo build systems team. And this was something that we developed back then as something that was intended to go out into the MeeGo community for very much this kind of reason and it's a process automation system
14:22
built on something called Ruate, which is a Ruby workflow engine. And again, to my mind, this is a really important part of what we offer. It uses AMQP to reach out distributed workers, participants we call them, because they participate in your process. They do something useful like build an image
14:43
or run a QA test or update Bugzilla. So we're able to put these things together in a proper business process, and there's a lot of good stuff about how that process is A, defined and B, executed insofar as you can change the process
15:00
and existing processes will finish in a sane and sensible manner. So there's a lot of really important stuff in there. I worked at BT for many years and I don't think we ever had an automated process management system that actually handled version control of inflight processes. So it was really interesting.
15:21
Yeah, so I was kind of going through what we can do with that. Scratchworks 2 just mentioned about what we're doing with that. We've got more. We have, as I say, to build an image, we use the, I think it was the Moblin image creator,
15:41
and then it was the MeeGo image creator, and now there's something called the TIC, which is the Tizen image creator, but we're gonna use the Mer image creator. Basically, it's a great tool that sits down and builds an image for us, and given the types of devices we want to do, that's quite a frequent task. It'll either build a root file system or it'll build raw images
16:01
or a variety of other things, live CDs, et cetera. And that's a great way of validating that when somebody makes a change, you go and build an image and you ensure that you're capable, at least, of building all your post commands run, everything works. Then we can boot that up either onto a virtual machine or something, or if we've got the resources,
16:21
you go and boot it up onto real hardware, and if you've got the resources again, you go and buy a robot that will actually do automated tests. So, being able to build an image is an important part of beginning those steps. Bugzilla, Gerrit, there are a number of other systems that we use
16:40
that we have integrated into our processes, and we can talk people through being able to enable them. So, Mer itself is structured into, there's kind of three core projects,
17:01
well, there's the core project, which has got the primary stack in it, and that's where we've got the 330 packages, and that is typically what we would expect to go onto a device, and that's the kind of rule about what goes into Mer core. And it's generally expected to go into most Mer devices, so we wouldn't put stuff in there
17:22
that was specific to a particular device class. The tools area is where we start to explore the, well, stuff that you want to put onto the device or into your development environment, so things like Valgrind and that kind of tooling will go into there, EMX goes in there, but so do a lot of the things to do with QA testing as well.
17:41
So, we've got our QA tools and such like, but this is all stuff that runs within the Mer OS itself, so this is all Mer packaging. Mint is our integration area, and that is where we put systems that we expect to run on infrastructure, so things like the OBS, we will have our own version of the OBS
18:02
that we have our additional patches to that we try and push upstream as soon as we can, that we have the IMG server and lots of other odds and sods of infrastructure, plus packages of things like Python bits and pieces or Ruby bits and pieces that we need to support that.
18:20
And then around Mer as well, we also have something which is the NEMO mobile project, and that's a really important part of what we kind of do as a community, and that's essentially a fully open-source smartphone that runs on N9, N950, and tablets, so the Exo PC, other devices,
18:40
Marco, when he's finished fiddling with his camera, could tell us more if there were any, but Marco maintains the NEMO environment, and that's important because they do a lot of work in there that's actually used by other platforms. I said earlier, I'm sure I said earlier, that Mer does not have a kernel.
19:01
There is no kernel at all in the Mer project. We simply provide a tool that checks the configuration of the kernel that you want to build on. You provide your own hardware adaptation, and we simply say, okay, right, well, and we give documented links as to why we need various kernel options, so we say, right, okay, you need this kernel option, and that's to support systemd.
19:21
Go see this page over here, which is where it tells you why you need that. This one for something to do with the XT4, blah, blah, blah, and we kind of go through and say, these are the configs we need to work, and that's how we generally work through providing the links to the kernel, and there are other adaptation bits and pieces you need for binary blobs for certain binary drivers, et cetera,
19:42
and the NEMO project has also become an area where we have begun to collect some of the community-contributed adaptations, so there's a big adaptation area there. We've got the virtual machine adaptation for things like VirtualBox, et cetera. Okay.
20:02
Yeah, these things also use different ways of managing the code. I kind of laughed. The core from there has the git tarballs in, sorry, the tarballs in git. We talked about being pragmatic. We've gone and fixed that, and we started to experiment in the tools area about using something which is a lot like
20:22
the git build package stuff, and we're working through on trying to make sure that that's consistent with the way packaging is done, best practice for packaging, so we'll probably experiment with that in tools, get that stable, push it into NEMO, and then push that through to Merkor as well.
20:42
We need to work on things like how we handle security updates, so we need to get involved in understanding how to be aware of when security updates to packages and upstream are needed, and how we can get those applied and verified. Yes, okay, so I mentioned the SDK before,
21:01
and that was the platform SDK, as we call it, but we also have QT and GUI apps, and so we have another SDK, which is more kind of your app SDK, and this is something that has been significantly sponsored by YOLA as part of the whole Selfish OS work that they're doing.
21:24
It's all open source, and essentially what we've done is we've taken Qt Creator, which is a really great IDE for developing Qt applications and QML and the like, so we've got that, we've put some plugins into it,
21:41
and we've been working with those guys to get those plugins working, and we've put that together with this virtual machine with the platform SDK inside it, and of course, that platform SDK has got all the cross-compilation tools in it, and because we put that stuff inside a virtual machine, we can put that in VirtualBox, and all of a sudden,
22:02
I can now distribute this to anywhere that Qt Creator and VirtualBox are buildable, like Windows desktops and Mac desktops, and a whole host of Linux environments, and they're all using exactly the same build systems in the virtual machine. My cost of maintenance and all that,
22:20
same as it always was, because this is the same stuff I use in my build service, so we're trying to be very careful about how we develop these things. It's probably not the most ultra-efficient way of doing things, but it pays back in the long run, we think, and of course, because we're doing this, we've got the virtual machine control, so now we can throw another VM in there with a mayor running on it, and that's your emulator,
22:42
so we've now got emulation capabilities as well, and overall, that's what we've kind of got as the SDK. I will now attempt to switch to this one that you saw earlier, if it will let me. I might have to scroll through everything again, but nobody really minds. So this is like a virtual machine that we've got running with that,
23:01
and, oh yes, I have to. Sadly, this projector resolution isn't quite big enough
23:20
to show the bottom of the screen. And where is my mouse? But now what we've got here is this is actually, this is the sailfish variant of the emulator, so that's their peak, let's see if I can pull it down 100 whilst looking in the wrong direction. Peak, go on, there we go,
23:44
and it's got their pulley menu thingy at the top, and you notice that this, if I press the escape button, this thing over here, this is branded as the sailfish SDK, not the Mayor SDK, and they've been nice and mentioned us, and that's cool, but that's the point of Mayor, we're actually there for people
24:01
to be able to go out into the market and position themselves and put commercial offerings together where they own the branding. That's what we're about, we're about letting people do this kind of stuff. And I'm pleased, of course I work there, so they don't mind me showing this and saying they're doing this work. But that's a really important aspect
24:21
of what Mayor is about, it's about providing that capability to organizations. Probably gonna have to sit through all my slides again now, I'm afraid. Slide show. F5. Oh yeah.
24:44
You know, for all the power in this laptop, it's not very good at just paging through slides.
25:05
Okay, see, oops, that was the one I was gonna stop on. So yeah, that's just a visual kind of, this is how we basically get it to work, and what we're also doing is we're using shared folders, which are the VirtualBox mechanism to allow the host
25:22
to share the file system with the guest. And that's important because Qt takes, Qt is looking into the header files and other bits and pieces in order to support things like auto-completion of code and things like that. It also interrogates that a little bit, I believe,
25:41
to find out what's going on in terms of the compiler capabilities. But we've done a lot of work, trying to show you the Qt thing last time I was at it. I'm not gonna go there with the slides again. We've done a lot of work to integrate. There's a web server, at the end of the slides I'll show you, there's a web server running in there which actually offers access to capabilities
26:02
like install a new tool chain. I wanna start, for some reason, I'm gonna be developing in MIPS or just upgrade my overall system, pull in the latest packages. Import a new root file system, where a root file system is essentially a target for me to compile against.
26:20
So you need a root file system for an x86-based device. You'll need a different root file system for an ARM-based device. Your root file system might need upgrading. You might need to, if you're not targeting just the plain Qt API, you might need to pull in some additional development headers. So that kind of capability is the stuff
26:40
that we offer just as ease of use inside the web UI, which is again embedded using WebKit inside Qt Creator. So it fits together quite nicely. And yeah, so what really happens with the file sharing is that you press go in Qt, it issues the make command and the qmake command
27:01
inside the virtual machine. That reads the source over the file share, compiles it and writes the object out, uses the headers again, which are shared between the two. So the shared folders is a little bit slow at the minute. It's got problems with page cache and memory mapping, but we've got somebody working on that.
27:21
And hopefully when we get that done, we'll be patches available, which will fix that. Alternatively, we have other approaches which are a bit less elegant, but which will provide the same capability, just using a bit more disk space. So again, we've got platform SDK. We've gone through and provided a graphical SDK.
27:44
And that really is about saying, okay, we want people to be able to get started working on this. And it's about saying, what do people need to do? How do you start with all this? And we really want to target, say, okay, you just need one or two people, or two engineers to follow this basic guide.
28:02
You get your platform SDK going. You get a hardware adaptation going. You get the graphics adaptation going, and you get to boot to your device. You can do all that with a downloaded platform SDK. It's a fairly simple process. We've got quite a lot of documentation on what to do.
28:21
We've got a lot of support on how to get that working. And at that point, you've now got a running system, which you can now deploy bits of your own code to. If you want, you can download the graphical SDK and use that and write some QML and deploy that to the device.
28:42
But we also want people to take it a step further and say, okay, we want to now start looking at this as a serious piece of investment. And we want to say, let's look at what we want to do from a prototyping point of view. We might now be expecting them to set up internal Git repositories.
29:02
They may want to set up their own internal build farms to build and validate that they can build their perhaps closed solution, probably closed solution, on top of this. They may want to download and use the image building software. They may, at this point, already have a bug tracker.
29:21
They may want one. And really, we've got as much documentation as we can to help people get through those steps as well. And then we can talk to them about doing some preliminary automation. We would like to have a downloadable standard. We had something that we called, I think it was a standard business workflow,
29:41
which was essentially something that went through the workflow that we use in the community environment to accept commits in after they've been through a build and validation phase and used OBS's capability to ensure that when you make a change to one package, any package that has a dependency on that is rebuilt. And if that fails, or the original fails, that's rejected.
30:03
So we do that automatically at this point. And you can go onto IRC and watch it come back and say, you've been rejected, build failure, here's the link. Goes through, shows you the build failure. And it's not even in a package that you've touched. It's another package that's pulled in something that your package has changed and had an assumption perhaps.
30:23
So yeah, the prototyping phase is what we think of as getting next. We expect that by the time people have gotten through that, they'll know us quite well. And we'll be looking at basically collaborating on how to work with the project. And we're seeing actually a lot of this
30:41
is coming to pass with Jolla. We are seeing contributions from Jolla where they're explaining problems that they're finding and we're making changes to the core infrastructure, the processes that we use, that make that easier. We work on release processes.
31:00
We're working on stuff to give early visibility of potential breakage. So that when we put a package into the core, if they're in the active tracking phase, they want early feedback. If they're in the know it's all frozen, we're not even paying attention to you anymore, we're polishing it and about to ship it phase, it's a different position in where they are in their life cycle.
31:24
What we want to start also doing is saying, right, here are your day in the life cycle, day in the life of a vendor type things and say this is what you should be aiming to be setting up going forward into full production mode. Here's how you scale up the infrastructure.
31:42
I still run MeeGo.com for another few weeks until it all gets turned off. But there's some fairly serious infrastructure there and we did a lot of learning about getting the infrastructure set up. So that would also be stuff that we can share. And of course then we hope at that point
32:00
they're all scaled up and in production. They've got all the internal systems, we want to link to their external QA, we want to do automatic updates for them, we want to make sure that they get notifications of when things change, all that kind of stuff. And of course by then we're expecting they will also be contributing back in terms of saying actually no,
32:21
we need to get this into core because we think that you should be changing the direction like this. And actually at that point is when we'll come to the point where they're realizing the objectives of influencing the direction of the platform and being able to affect where things go.
32:40
And that is what we find we want to be able to offer against platforms like Android, et cetera. There's also a message that we give to people who have a more commercial background. And that's to kind of position where they fit
33:00
within the community. And it's really to try and not use that word actually. I like to use the word cooperative when I'm talking to people who have a more kind of commercial hat on. Because frankly it makes them feel like they have got an obligation to put work in an effort into the project. And that's something I find is actually a good way
33:21
of telling them this is a cooperative. You are actually expected to contribute. This is part of the deal. And actually guys, the contribution mechanism is your political push. This is how you change things. So this is the story and this is the messaging that I'm kind of pushing out when I try and talk to people at that level.
33:44
Very much from the community side though, this is, we are a small distro. We are still, we've got a lot of stuff. MeeGo dumped an incredibly valuable load of code systems and knowledge.
34:00
And kind of we decided to pick it up and took a heck of a risk doing that. And there are only a few of us working on it in the grand scheme of things. We've got a lot to learn, but we also came at this from a kind of an interesting place in terms of looking at scaling this right up to production grade stuff inside of Nokia
34:21
where they were looking at making devices like the N9. And that's the kind of stuff that we want to enable people to do. So we've got knowledge from that space that we want to share. That quote from Forbes is like, this is quite interesting. This is the stuff that was being published recently
34:41
that gets recognition of the type of work that we're doing that the Firefox guys and the Ubuntu guys are doing in this space that is being seen now. And really that's about what we are trying to do is make a difference. So that's the call to arms for what Meru's doing is to say, come and join us
35:01
and kind of help us to make a difference, help us to get the open source stuff into the product stuff and begin to influence yet another kind of pronged attack on changing the way that the organizations use this type of source and interact with us as an open source community.
35:20
So that's kind of pretty much the end of this. And what I was gonna do is cause I forgot is just show you the Qt, the creator as well because, please be running, it might not be.
36:03
Yeah, so it's basically Qt Creator as you've never seen it before. Well, except it's a lot like you've seen it before. We just say this is the kind of the branded version with a little bit of branding for Selfish but essentially it's the same as the Mer open version
36:22
where what we've done is we've added this extra capability here which is probably gonna go embarrassingly slowly for me. But what this is doing is it's giving us a view into the virtual machine with the ability to manage and update tool change and targets and such like.
36:41
Good, that's using live network so if it wasn't there, it wouldn't work. And what this does is it lets us have different target sets which, so I can build and I can ask Qt now to build against a Selfish emulator which is the one I showed you. That's gonna be released in a few weeks.
37:02
Nemo N9, that's the kind of open source community adaptation against that. And I don't know what that is. That's me playing around trying to make that one work probably. We've got, this is interesting for me. We wanna make life easy for these developers who wanna focus on the QML side of things. What that does is it goes off to your server
37:21
and says, okay, what's the latest version of the tool chains that I've got available to me? So we give it a URL and it goes off, gets a JSON file and it just installs the right, you type in the URL of a tarball here and it pulls it down and you pick a tool chain for it. You give it a name and all of a sudden you've got a new target that you can build against
37:41
like a Raspberry Pi, you know? So that's the kind of simple but really quite useful capability we can have in there. And then we've got the usual bits and pieces and we've extended, we've worked with them on extending the build and run kits.
38:06
So we're making use of, this is very leading edge Qt Creator stuff but basically we've extended the kits so it's providing this, yeah, this one's only got the 486 stuff in but basically different Qt versions. So of course the Qt version lives inside the tool chain.
38:23
So I can actually have a Qt 5 and a Qt 4 in the tool chain for different architectures. It's really quite flexible. It recognizes the compilers that we've got available, the Nemo, Selfish and Dev and i486 compilers. Yeah, we keep this very clean.
38:41
There's a lot of isolation of packages so you don't accidentally find yourself building against a set of development packages that you had installed but had forgotten you'd installed. So that i486 i486 is actually cross-compiling 486. So we cross-compile our 486 because actually it's so efficient we might as well
39:02
and it gives us the isolation. You don't install your development headers into your development environment, you install them into your root and build them there which means that you can really easily keep track of the versions that you've got and you can work against, you can build against this week's stable-ish release or you can build against your local development branch.
39:24
Right, so, yes, that's a completely different message to what I finished up with. So the other one was come and help us. And this one is more of what we can do. Okay, so that's it. Thank you very much everybody. I'll leave it like that, okay.
39:41
And hopefully some questions if, yeah. That's a statement from them earlier on this, about two or three days ago, yeah.
40:16
It's good to know we have fans.
40:29
I don't know of any mechanisms, any kind of open-source mechanisms for running Android on Linux. But if there are open-source ways of running Android on Linux, we can use them.
40:41
Yeah, I have this embarrassing lack of knowledge about Android. So other people might be able to answer the question but I honestly don't know. What I will say is we're Linux. If you can run your Android app on Linux, you can put the same mechanism onto Mare and do it there.
41:04
We do know and YOLO announced what they've done and they've got, but I'm pretty sure that what they do is a commercial thing that lets you run Android on Linux. So I don't know whether that's relevant. There's probably the, I'm sure there are things out there.
41:20
Any other questions? That's a really interesting one. I've not really covered it in this talk, but there is a project that we've got underway called libhybris.
41:40
And what that does is essentially it, I think I have to phrase this. You take the binary blobs that are provided as part of Android, which have essentially been linked against the Android libc, the bionic. And what we've been able to do, we, Carsten, has been able to do
42:00
is essentially put a wrapper around them which allows us to translate those into libc. So we end up with the ability, at the end of the day, to wrap the blobs and bring them in and run them against X and give us hardware-accelerated X on an Android device with Mayor running on it.
42:22
And we've done that. I'm not good at remembering devices that have had that done to them. But if you come along to the Mayor IRC channel or check out Carsten's Google kind of announcements, look up libhybris. That's exactly what that project does. And yeah, that's gonna be important for us being able to put this onto other devices.
42:42
It's not trivial. We should be able to make it more scriptable, shall we say, but it's currently, I find it a bit of a challenge. And I think there's a step three, compile bionic or something. And it's weird stuff like that that you kind of get caught out by.
43:01
So the answer is yes. Talk to us about it. Any other questions?
43:25
Right, so yeah, my objective with the whole GUI SDK thing is to provide maximum reach early on. So to do that, selection of VirtualBox, that runs on Windows, Linux, and Mac straight away.
43:45
I wouldn't use it on my machine because it's just daft. What I'd like to do is have something like LXC or the stuff that systemd was talking about with nspawn, I could go play with that. We've had some great stuff. Oleg's done some work on just enhancing
44:01
the way that the platform SDK works with namespace isolation. And that gives us enough, I think, probably, to be able to just use a chroot. We could probably then run an SSH inside that chroot that talks to the SDK and kind of containerizes that. Or you could do it in KVM.
44:21
So yeah, there are a whole host of alternatives. What you're essentially looking at is a containerized space to do the build. And of course, all of those things mean we would have, you know, we have performance issues with shared folders. So all of those things slam the performance issues, just completely bypass them, on Linux platforms.
44:44
But I kind of have to be aware that, you know, Mayor is about reaching out to these areas where they are gonna have developers on Windows boxes. And they're gonna have developers on Mac boxes. And we have to make sure that they are first-class citizens.
45:01
It's kind of hard for me. I haven't got a Windows or a Mac box. But you know, we kind of work with people to do the QA with us on these things. Any others?
46:58
Well, a chroot is one way to provide the isolation
47:02
and to ensure that we've got, I would like anybody who comes to me with a support problem not to be saying, oh, I'm using the Debian package version of OSC and the Debian package version of RPM build. Or the SUSE RPM, which doesn't support TILDE yet or does and the Red Hat one, which doesn't,
47:23
and the Fedora one, which does. So when you do package version comparisons in our build system, so this kind of stuff bites you. So the chroot stuff fixes that. It gives us, no.
47:43
On the other hand, doing this now gives me practically a complete MARE environment, minimal one, which opens up other opportunities. So you can find ways to optimize and shrink this down. But we're not that big. And then it's a case, yeah.
48:11
But that's a special, that's now a special build. So that's another build variance that we have to do. So you can do these things.
48:21
What we've tried to do is to find the most, we've tried to find the most efficient solution. And there are optimizations to be had. We've had one of them recently. There are plenty more to get. And we'll certainly look at them. But we'd want to kind of sit down and go, yeah, but what about this, what about that? But open to listening.
48:55
Yep, yes.
49:03
Ah, right. Well, one of the things that we, one of the things I can tell you is that there's a company called Nomavoc who were looking at using MARE in IVI space. One of the things about IVI is they were insistent on having a 60 frames per second out of the particular hardware that they had.
49:22
And they did a benchmark across a variety of platforms to try and find an OS that would allow them to achieve this. And MARE was the only one that they were able to get running that delivered above 60 frames per second. It had all other benefits with the systemd-based boot-up time as well.
49:41
So the other one that we can talk about is the Chinese set-top box people. They basically came to us and said, how small can you get this? Now, my memory is such that I can't give you a figure and promise you that it's correct. But I believe they were talking around 128 meg in terms of flash. And we were able to get them in there.
50:02
We were pushing up against it and we were having to make sure they didn't put any debug symbols in. And I think we had a couple of builds of things that went small, but it was small. If you come and ask me on IRC or on the mailing list, I'll dig up the old email. Cause this was, they were doing this back in January last year. Yeah.
50:21
And I remember the conversations and it was kind of useful for us to say, how small can you get? Don't think we've gone to busy. We haven't got busy box in there yet. Busy box is something that will be coming. Definitely. And when we get that, that is going to help us again, in terms of trying to provide this, keep it down.
50:43
A lot of our focus is on probably slightly more capable systems. But we do want to be performant on stuff which is, you know, at the lower end. We want to make sure that we get the most out of it. So yeah.
51:01
Anything else? No, cool. In that case, thank you very much. And come and join us and use Mir.