Re: Need clarification on some terms


Paul D. DeRocco
 

From: Trevor Woerner

Imagine a company which produces embedded devices running Linux. There
are hardware engineers, and software people. Within the software group
there will always be that person (or group) which is responsible for
creating the Linux filesystem which runs on the device, i.e. the
"base" system, and there is the person or group responsible for
writing the "special sauce", the program which (or programs that) make
the device do the special thing that sets this device apart (i.e. the
application developer group).

Sometimes these people are the one and the same person, other times
they are separate people/groups.

Only the person/group responsible for the base filesystem need to know
about Yocto/OE. The "special sauce" people don't need to know anything
about packages, kernels, udev, /etc, or any of that other stuff. But
what they do need is a "compiler"[1] so they can build the software
for their target device.

The "compiler" they need has to be tied to the base filesystem. They
shouldn't be using a "compiler" that isn't aware of what libraries
(and therefore also be using the correct header files) that are going
to be available on the target, and they shouldn't be using a compiler
that isn't aware of the version of the kernel that will be available
on the target.

In order to help get the Yocto/OE group and the application group in
sync, Yocto/OE has this neat target which allows the platform team to
generate an "compiler" (i.e. the SDK) that the application group can
use which is, through the magic of the Yocto system, perfectly tuned
for the image the platform team is creating. In other words, the
application team doesn't need to perform Yocto builds in order to
write their software, they just need the Yocto people to generate an
SDK for them and produce a new SDK anytime anything on the target
image changes. The Yocto people can generate this SDK using a very
simple one-liner.

For a little more information, please have a look at item 19 of
https://github.com/twoerner/meta-trevor/blob/master/misc/notes
Okay, so I'm wrong about the SDK being a toolchain that runs on the target.
It does indeed run on the host, right? So why is the toolchain that builds
the target application on the host different from the toolchain that builds
the target OS image on the host?

--

Ciao, Paul D. DeRocco
Paul mailto:pderocco@ix.netcom.com

Join yocto@lists.yoctoproject.org to automatically receive all group messages.