[yocto] Need clarification on some terms

[Trevor Woerner]

On Wed, Jun 12, 2013 at 3:51 PM, Paul D. DeRocco <pderocco at ix.netcom.com> wrote:
> For now, I really just need to know if I'm interested in the SDK, since I
> have no intention of ever running compilations on my target system.

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


[1] When I say "compiler" here (in quotes) I really mean the
cross-compiler, the necessary header files, the cross-linker, etc,
etc...