[Tfug] windows to linux

[Liz_Ravenwood at beaerospace.com]

Thanks  Don,

I've begun copyng and pasting your replys for my own little reference 
manual. They're dang good!

>Is arduino a prebuilt binary?  I.e., something that you just
>have to *install*?  Or, is it something that you have to *build*
>(from sources) first?

install files

Respectfully,
Liz, Data Base Architect/Developer,
Methods Engineering





Bexley Hall <bexley401 at yahoo.com> 
Sent by: <tfug-bounces at tfug.org>
09/25/2009 05:10 PM
Please respond to
Tucson Free Unix Group <tfug at tfug.org>


To
Tucson Free Unix Group <tfug at tfug.org>
cc

Subject
Re: [Tfug] windows to linux






Hi Liz,

> aha.  This is good stuff.

... said Cheech to his buddy, Chong. 
 
> I just did a "man make" and am trying to understand the syntax 
> of the make command.
> 
> make -f arduino?

<frown>  Silly Rabbit...

make is a utility common to most Eunices (or some variant
of make:  nmake, gmake, odemake, etc.).  It is used when 
building (compiling) software "from scratch" -- though
it *can* be used to automate damn near anything (not
necessarily in the most intuitive manner :< )

When building software, make examines a "makefile" that
contains (cryptic) instructions on the various dependancies
that the "source files" have on each other.  It then looks
at the times each file was most recently modified.  From this,
and the dependancies information in the makefile, it can see
if something that "A" depends on has been updated *since*
"A" was "built".  If so, that suggests that "A" is out of
date (i.e., soomething that it uses is *newer* than *it* is so
it must be "updated" -- rebuilt).

The makefile tells make how to rebuild "A" when it sees a
change in one of its dependancies.

This process continues for all "components" referenced by
the makefile.

So, if A depends on B and B depends on C...
And, if *C* has been updatred more recently than B;
Then B is rebuilt to reflect the more up-to-date changes in C;
which now means B has been updated more recently than *A*
So A is rebuilt to reflect the most recent changes made to B...

(get the picture?)

I.e., you could write a makefile that updates your "Financial
Statement" by telling it how changes in your checking account
are reflected in your Financial Statement, etc.  So, whenever
it sees that your checking account is "more current" than
the Financial Statement, it updates the Financial Statement
(using instructions in a makefile that you have created)
to reflect those changes.

In the example I cited -- "make fetch-list" -- the "fetch-list"
is something particular to the *BSD packages collection.  Just
like "make FinancialStatement" would be something particular
to *you*.  So, it only makes sense in the context of the
*BSD packages collection (if you just typed this randomly,
chances are very high that you'll just get an error from make
(since there probably won't be a "makefile" nearby and, even if
there is, chances are very high that it won't have a
"fetch-list" target specified within!

Is arduino a prebuilt binary?  I.e., something that you just
have to *install*?  Or, is it something that you have to *build*
(from sources) first?


 

_______________________________________________
Tucson Free Unix Group - tfug at tfug.org
Subscription Options:
http://www.tfug.org/mailman/listinfo/tfug_tfug.org



--------------------------------------------------------------------------------------------------------- 

This email (and all attachments) is for the sole use of the intended 
recipient(s) and may contain privileged and/or proprietary information. 
Any unauthorized review, use, disclosure or distribution is prohibited. If 
you are not the intended recipient, please contact the sender by reply 
e-mail and destroy all copies of the original message.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://tfug.org/pipermail/tfug_tfug.org/attachments/20090929/b7fa929e/attachment-0002.html>