 Newsgroups: net.micro.mac ' Subject: LighspeedC -- A Review (long!)  Message-ID: <848@harvard.UUCP> Date: 9 Apr 86 03:24:09 GMT  Article-I.D.: harvard.848   Posted: Tue Apr  8 22:24:09 1986$ Date-Received: 9 Apr 86 10:19:00 GMT% Organization: Aiken Comp Lab, Harvard 
 Lines: 173    > There have been a couple of postings about the new LightspeedCF compiler, and since I recently ported a large (2200 line) program fromH Aztec to that environment, I figured that the net might be interested inI my reaction.  I had been using Aztec for about a year, and my familiarity E with Unix-style utilities and the speed of the Aztec compiler made me G very satisfied.  One week of Lightspeed has convinced me to switch: the G environment is superior, both in design and execution, and the compiler I brings new meaning to the word "fast."  I have some benchmarks below, but E they only tell part of the story.  The best part of Lightspeed is its K "feel" -- a whole range of features make it effortless to use and seemingly , even faster than the numbers would indicate.   Environment  =========== > Lightspeed is one big application, about 170k on the disk, andF requires 512k to run.  The compiler deals with programming tasks usingL a data structure called the project.  Projects are basically lists of sourceE files and libraries included in the program.  A window with the names E of these files is always on the screen.  The visual representation of @ the project makes some tasks more natural, as well as fast.  TheF segmentation, if any, of the program is represented by the grouping ofF the names in the window: to change it you just drag them around.  ThisD is much nicer than long linker commands.  To edit a source file you H just double-click on a name -- avoiding both the typing of Aztec and theH SFGetFile dialog of other systems.  The project also contains the objectI code produced by compiles (so no .o files) and other information to speed K development.  Make dependencies are generated automatically, i.e. it checks I source files for #includes and keeps track of when you change what.  This G isn't as powerful as Unix make, but it's good enough for most tasks and E best of all, it's totally transparent.  One cost of using the project F format is disk space: the project file for my 76k program totaled overG 200k; by contrast, the .o files produced by Aztec for the same program   totaled 86k.B The editor is included in the single application: it is comparableF to MDS Edit, with the one significant plus of multi-file search.  ThisG eliminates much, though not all, of the need for grep.  The integration G between the compiler and editor is very close.  When the compiler finds D an error, you are popped into the editor at the line of the error.  D Compiling open files takes into account changes since your last saveD and the Make utility marks the file as not compiled if you then quitE without saving changes.  The editor is quick with scrolling, does not E mess up with large cuts and pastes, and handles at least a dozen open G files.  The one drawback to the close integration of the system is that H you could not easily use another editor if you wanted.  Fortunately, the8 included editor is good enough to diminish that problem.= Programs under development can be run from within Lightspeed, F through some sort of executive.  The program run is real machine code,G and runs as fast as a stand-alone version, but when you quit you return C to Lightspeed with your project still open.  To build a stand-alone E application file takes a little while (for my program, 1 minute), and " yields a standard Mac application.   Speed  ===== > Think is really pushing the speed of the compiler, and rightlyH so:  while not quite as impressive as those advertised by Think (reasonsG below), my benchmark figures essentially confirm the hype.  Here's what A I got compiling a 2200 line program, broken into 16 source files:   E Configuration: 1Mbyte Mac Plus, with one 800k disk drive and one 300k F Ram disk.  In both cases, all system files, source, and libraries wereC on the floppy, include files and the compiler/editor/linker were on 
 the ram disk.   K Times are in seconds, turnaround refers to the time necessary to recompile, A link, and run the program after changing one typical source file.    Aztec ver. 1.06gLighspeedC Beta    compile all files:1320550  link/run:12726 turnaround:25876 code size in bytes:7079276860   < This benchmark may or may not be typical.  I believe that onI a hard disk system, or if the source and project files were on ram-disks, F Lightspeed's edge in compile speed would be even greater.  Most of theF time cited above was spent reading source and writing output to a slowE floppy: the actual compilation is over 250 lines/second (as displayed J by their line counter).  Think claims that it takes 2 minutes to recompileE Lightspeed in itself (1 Mbyte source) on ram disks, and I believe it. G On the other hand, using faster io devices would help Aztec in the link L comparison, since Lightspeed links in ram (for my program, in 1.5 seconds!).N As for code size, I think that the difference may be due to Lightspeed linkingJ in more stdio code than I need: I'll look into that when I get the release" version with source for libraries.D So how does Lightspeed do it?  There are a number of reasons.  SinceH it's one program, it doesn't have to repeatedly load the compiler.  MostK of the linking is taken care of at compile time (the project document makes J a global symbol table possible) and libraries are linked only when you addK them to the project, not at every make (which makes sense, as they probably I didn't change).  The compiler does everything in ram, with no temp files, L and I'm sure that helps a lot.  Also, there is no cascading error recovery--K the first error sends you back to the editor -- although I don't think that H won them a lot of speed.  On the other hand, the compiler checks for theI number of arguments to toolbox calls, does all the pre-linking, and still I beats Aztec hands down.  So it's very fast, but they seem to have made it 5 fast the old-fashioned way: painstaking optimization. B The best thing about Lightspeed's speed is the way it changes yourG work habits.  With Aztec I was loath to recompile the program with just D a single change, and having to alter a global include file (and thusE trigger re-compilation of every source file) was a prospect to be met H with dread.  Lightspeed makes it easy to make small changes and then seeI what happens.  There's even a "Check Syntax" option that rivals the speed I of an interpreter (since it doesn't write output) making it easy to check ( your work during a long type-in session.   Bugs ====> Alas, there are always bugs.  One that I found is particularlyC insidious for programs using floating-point, and apparently was not B fixed before shipping.  An error in the way casted expressions are# processed results in the following:    #define CONSTANT any-integer   int foo;  * if ((double)foo == (double)(foo-CONSTANT)) printf("Bug!");   E printing out a message.  The bug manifests itself with implicit casts D also -- x/foo evaluates to the same thing as x/(foo-CONSTANT), whereF x is a double.  This bug is serious, and Think was very attentive whenC I called it in.  A week later, however, I called back and it hadn't F been fixed; meanwhile the compiler is shipping.  Anyone contemplating D using Lightspeed for floating point should be aware of the problem, D and perhaps wait for an update.  The work-around is to cast the int C to a double before the arithmetic, a small loss in performance and  : a large loss in programmer convenience.  I'm still looking7 for the last occurances of such expressions in my code.    Portability  =========== B Lightspeed handles standard K&R C, with the following differences/ features of note:    Structure passing by values $ Argument # checking on toolbox calls> No inline assembly -- must link in assembler output separately< "pascal" keyword for pascal-style routines (just like Aztec)@ Explicit string conversion with CtoPstr and PtoCstr (like Aztec)@ 16 bit ints, 32 bit longs and floats, 80 bit doubles (uses SANE)  > I ported my program in two evenings with occasional glances atK the documentation, all the while learning how to use the Lightspeed system. H The biggest hassles were renaming include files and dealing with points.H Aztec provides a macro to pass points to LineTo and MoveTo (for example)H by casting them to a long.  Since Lightspeed checks number of arguments,C it had to be replaced with a macro that separates a point into its  G structure elements.  The documentation is written toward users of other F Mac C compilers (Consulair, Megamax, and Aztec) and points out many ofJ the differences.  All in all, the manual looks good although I didn't need to look at it much.   B All in all, I think that Lightspeed is simultaneously the cheapestG and best Mac C compiler available.  Think has to fix the floating point H bug, and it would be nice if they provided a means of converting projectI files to other formats (there is an MDS => Lightspeed conversion utility) L but otherwise it looks great.  If the advertised Quicksilver Pascal compilerI uses the same technology, Apple's Workshop could have serious competition  before it's even released.   Jim Matthews matthews@harvard  I The above views are mine, and may or may not reflect those of my employer  and Harvard University.   O I'm sure that LightspeedC and Quicksilver are trademarks of Think Technologies, G that Aztec is a trademark of Manx Software, and that MDS is a trademark  of Apple Computer Corporation.  (  6-Apr-86 10:42:33-PST,8755;000000000001 Return-Path: <INTMET@A.BBN.COM> N Received: from A.BBN.COM by SUMEX-AIM.ARPA with TCP; Sun 6 Apr 86 10:42:24-PST Date: Sun 6 Apr 86 13:02:53-EST  From: INTMET@A.BBN.COM Subject: LightspeedC, a rview  To: info-mac@SUMEX-AIM.ARPA   F LightspeedC, a new C compiling system for the MacIntosh, is a delight.  E The product is an integrated application building environment.  I see ? the product as broken into these pieces (show here with a quick 
 synopsis):=    -> A compilerFastest, Bestest of the current Mac products. >    -> A project managerA wonderful idea, beautifully executed.    -> An editorNothing special@    -> A set of librariesVery complete, and very well documented.$    -> A converter for MDS .rel files! I haven't used it (a trap door?). 3    -> A manualvery good, very complete, hype/chatty .    -> A set of standard Mac Developer's tools:)          - ResEdit, RMaker, MacBugs, etc. +    -> Mac Interface           Very standard   B I'll leave benchmarks to people who take them seriously, I for oneE despise them.  The entire system is without question the fastest most J usable way to develop applications for the Mac, that I have used.  It is aH much faster way to build stuff than the other Mac C environments.  It is5 not as fast a Vax11/780 with 4.2 Unix on the weekend.   C The most innovative aspect of the system is the project management, F auto-make, linking aspects.  First, let me talk about some of the more
 simple stuff.   B Compilers for micros aren't generally very good.  This one is muchD better than most.  It sure is fast.  They must of bit-diddled it for quiet a few late nights.  F The compiler supports a number of things to ease living with the Mac'sB pascal heritage:  pascal strings ( "\PPascal String" ),  functionsC who's parameters are will follow to be pascal conventions, and line F Tool box traps.  You seem to be unable to add new traps to the system.  @ Struct's maybe passed by value.  They are unique among the Mac CF compiler's in choosing to pass Points by value.  This makes converting to Lightspeed quite a chore.  E The editor is a disappointment.  It is simple and Mac like.  It lacks  undo.  Unlike a lot of o8`%5A1h < *%Q=IM1JQ:MU%1Q:%Q!"!@care it takes to get a fast/large file editor on the Mac.  For example G text inserted into the middle of a huge file goes in smoothly.  You may   set the window font as you like.  F There is magnificent support for searching.  Egrep style patterns (andF replacements) are supported.  This is very nice.  It isn't awk/sed but it will do.L  E Since the editor is integrated into the single application your stuckp with it.  G The libraries are very complete with about 200 functions.  They supporteD the entire range of string functions, printv, stdio, etc.  These are/ well documented in a classic unix manual style.o  C It is possible to write assembler code using the MDS assembler, and D then convert the MDS libraries into their project manager's formats.B MDS isn't included so you'll have to spend extra if you want to do that.f  E The system can produce most all the various flavors of code resourcespF that are common on the Mac.  I was unable to figure out how to produce< a package without having MDS, but who makes packages anyway?  G The manual really shines in some places.  The documentation for MacBugs D is wonderful.  The discussion of the subtle issues in desk accessoryC writting is, having had to figure this out myself once, delightful. D The manual starts with a lot of hype, which is forgivable since they@ are obvious very proud of their product.  There is an epilogue, ? it was written by a recent cash paying attendee of some Sciencee Fiction Fairie.n  : The manual contains a very detailed specification of theirG implementation of C, something that is lacking from most all C compiler D documentation.  A detailed set of library documentation is makes theC buyer feel confident that they are careful craftsmen.  Against thath< background I feel I can complain: there needs to be detailed= (reference manual style) documentation of the project/commando structure of the application.o  F The Mac Interface is very standard, which is good.  The dialogue boxesA lack the care of a good graphic designer.  Undo is not supported,aB except in desk toys.  The about LightspeedC...  command is a rush.= The down side of their very standard Mac interface is, if youp@ use Excel a lot you get very enamored of Microsoft's extensions.  = I have had a good deal of trouble using the application on myiF HFS/HD20/Fat-Mac.  They have been very helpful.  They assure me it wasF extensively tested on many configurations so they are are confident itG must be a problem unique to my situation.  I hope this is what Consumer G Reports might refer to as a correctable cosmetic flaw.  I have owned myg copy for three days.  G Think Technologies is the company that build MacPascal.  LightspeedC iseD not copy protected, each sale apparently has a unique serial number.: (Note that MacPascal isn't copy protected anymore either).  F The product was built with one goal, get the feel of an interpreter inC a linking/compiling environment.  They succeeded via these devices:n(    -> Link on the fly using jump tables.    -> Have a very fast linker.C    -> maintain a currently linked application with associated data:c         call this a "project."C    -> Have a rarely used "build step" that removes project info andg! removes extra jump table entries. @ And of course about a dozen other ideas to hold it all together.  A Project provide a way to expose the large scale structure of youre@ application.  In C the largest construct is the file (include or  source).  A project consists of:&    a set of input parts consisting of:      a set of source files,a%      a implicit set of include files,t      a set of libraries,K    a target kind of code:  ( application, device driver, code resource... )a    a set of options:<      searching options: ( case sensitive, wrap around, ... )*      confirm options: ( confirm save, ...)2      compile options: ( MacBugs symbols, profile )%    a dependency graph between sources ,      - a model of uptodateness in that graph)    a symbol table of all external symbolsd'    a set of loaded/compiled object codei  aF The dependency graph allow them to automaticly batch compile everybodyD effected by an edit to any file.  This isn't as complex a concept asF the unix Makefile.  Each object has only a single flag associated withD it, and only a single, wired in, operation is known that will remove> that flag.  Only the include file dependency graph is known to understood by the program.  D The user may turn the flag on or off by hand.  The major use of thisE feature is to amaze you friends with how fast it compiles your entire A system, but it is also used to inform Lightspeed that you changed  something behind it's back.   G Upon request, in a manner analogous to unix make's use of file dates to D infer uptodateness, the flags may also be brought into sync with theH filesystem's file dates.  The purpose of this is to inform it of changesG you make to files outside the Lightspeed system, or via other projects.   > Apparently the only thing to do at "link time" is to check forG unresolved symbols.  If you edit a file, recompile, link, and launch it ? only takes a few seconds.  This is usually done with the single G key stroke cmd-R or "Run" command.  When you quit from your application D you will fall back into LightspeedC, i.e. it install's itself as theG shell when you are in the debug loop.  The slowest step of that loop is  returning to Lightspeed (narc).   . Libraries come in two types and three flavors:   Project libraries:     - other projects,    Real libraries: 9     - projects that have been converted to libraries, and 2     - libraries converted from MDS .rel libraries.G Objects in real libraries are loaded only upon request.  Apparently you H can only convert MDS .rel files to Lightspeed libraries, not visa-versa.  B The unix power user will be frustrated, since this isn't make, and- there is no way to add additional operations.   G What is wonderful about the Mac is that about every few months somebody G brings out a product that is delightfully innovative.  This is one such F product.  The importance of a fast compiler and linking on the fly hasB always been under-rated.  If you write in C for the Mac it is wellE worth the $175.00, list price.  If you are patient then  you can wait F for the discounters to move in.  You might do well to wait a month for! the first wave of cosmetic fixes.   
   LightspeedC    Think Technologies, Inc.   420 Bedford St. >   Lexington, MA 02173         Customer Service: (617) 863-1099  !      - ben hyde, cambridge mass.   [ From Delphi - Jeff ]  ! Name: LIGHTSPEEDC CONVERSION SAGA  Date: 8-APR-1986 14:09 by PEABO    M This is the story of my experience with converting a medium sized application H program from the MANX Aztec C development environment to the LightspeedC5 development environment from THINK Technologies, Inc.   I ------------------------------------------------------------------------- H This is a report on the conversion of a medium sized application programE from the MANX Aztec C programming environment to LightspeedC(tm) from  Think Technologies.   H I'm not going to go into detail about LightspeedC since you can find outK about that from other sources.  However, to summarize, it is an interactive J development environment for C on the Mac which emphasizes quick turnaroundI time.  It collects the files used in building a program into a 'project', G which is a data structure analogous to a UNIX-like makefile and all the I object code and libraries used in the compile/link.  The source files are J still maintained as standard text files.  A built-in editor accesses filesK and can be used in conjunction with multiple file searches, with or without F regular expression matching.  Time between closing the edit window andH launching the rebuilt application can typically be in the range of 10 toJ 30 seconds depending on how many modules need to be recompiled.  After theK program is debugged, an additional step is performed to produce a clickable . application module from the project workspace.  > --------------------------------------------------------------   The nitty-gritty:   K I received my copy of LightspeedC on Friday, April 4, and like any cautious N developer would do, I first read the manual to find out what kind of surprisesJ I might be in store for.  Finding none, I proceeded to install LightspeedCF on my system.  (I am using a MacPlus with an Apple HD-20.)  The manualJ mentions that LightspeedC works with HFS, but doesn't go into detail aboutK how to install it.  They refer repeatedly to 'put this and that on the sameeH volume', and that does translate accurately to an HFS environment if youH reword it as 'in the same folder'.  My working configuration (after some! experimentation) looks like this:2   DesktopsF  AA Light            <----- folder for Lightspeed stuff, easy to click6                             from Standard File dialogsI   Compiler           <----- 96 files:  compiler, includes, and libraries,uH                             including library sources for my convenience=   Demo               <----- I haven't looked closely at theseiC   LCRelease          <----- other misc files from the release disksk@   #include catalog.c <----- a C file which includes all the .h'sA   StdInclude         <----- a project file for #include catalog.cn  H I put the LightspeedC application in my Waystation menu, so I never haveH to open the AA Light and Compiler folders when launching the development environment.  K Elsewhere in the HFS hierarchy, I created a folder with all my MANX projecte$ stuff.  This folder looks like this:   DesktopeK  Project             <----- named the same as my program, with a P appendednI   Source             <----- .c's, .h's, .r and .rsrc, LightspeedC projectoK                             workspace, and clickable application, totallingp     about 21 filesI   MANX Obj           <----- the MANX make file, .o's, and comparison copyaH                             of the application, also .lnk and .sym, so I3     have something to refer back to (discard after) G   Misc               <----- some other related files I didn't feel like =                             leaving out in the Project folderkD   a couple files     <----- that I want to be able to get at quickly  J I might at some point decide to bring the contents of Source up to the topH level of the Project folder, since it would make the treewalking easier.  K At this point I got rid of about 90 files used by the MANX compiler which I K had to leave on the Desktop of my HD-20.  Halleluiah, a clean desk at last!yJ (The version of MANX I am running is 1.06F and it does not function unlessK the shell, compiler, linker, assembler, all utility programs, all includes,nG and all source files are on the desktop in a pseudo-MFS configuration.)   K So I started up LightspeedC and told it to run the project, which causes it G to ascertain that everything needs recompiling.  Kaboom!  "Include file G not found".  So this is surprise number one:  most of the include filescK for the Mac managers are named differently in LightspeedC from the way theylK are named in MANX.  OK, I can dig it.  It is good practice using the editoroH to rewrite the includes.  Most of the names are obvious variations (suchH as menu.h => MenuMgr.h), but a few require some investigation (like pb.h => FileMgr.h).  M Then I told it to rebuild, and got surprise number two.  Syntax error.  Sure.!N There doesn't appear to be anything wrong with the statement it is complainingL about.  I should mention that the compiler does not produce a list of errorsG as output.  When it hits the first error it zips back to the editor andiG leaves the cursor at the left margin of the line it doesn't like and aneM alert box at the top of the screen saying what is wrong.  Cute bug icon.  YoufN click the alert out of existence, make the fix, close the window, and rebuild.  K Well this works great when you are making small changes, but in the case oflL a conversion, it can be a bit tedious.  (Think Technologies admits this is aL potential hassle.)  The real problem in this case though, was that the errorH message 'syntax error' was not real helpful.  However, most of the otherA error messages are not as obscure, so I won't complain very much.r  J It turned out to be a conflict between a symbol I #defined to fix a bug inL the MANX toolbox.h file.  The symbol was defined properly in the LightspeedC3 include, so I took the patchwork out of my .c file.C  J I think the alert box ought to display the C code *after* preprocessing ofN macro invocations, and with the point of the error highlighted.  This would beJ a feature not found in other C compilers, and a very appropriate method of improving ease of use.  K Now we get into the interesting case:  syntax error on "struct Rect rect;".t Turns out that MANX does this:       struct Recte     {l         short top;         short left;r         short bottom;r         short right;
         };     typedef struct Rect Rect;   H but I had been in the habit of saying "struct Rect" anyway.  LightspeedC does this instead:       typedef struct	         {n#         int top,left,bottom,right ;h         } Rect ;  F so the only valid way to use this is to say "Rect rect;".  OK, so I doG another multi-file search and destroy.  The multi-file stuff works veryaH well, by the way, and will probably encourage me to split up my programs into smaller source files.  G (I'm not real enthusiastic about the use of "int" in these .h files.  IrK always use "short" or "long".  MANX and LightspeedC both use "int = short",PK but I also develop programs for the VAX, which uses "int = long", and there 7 are other Macintosh C compilers that use "int = long".)   J Next I ran into some very minor differences in the spelling of field namesL in structures, and a major difference in the way the ParamBlock is declared.B In MANX, the fixed part of the PB is declared and there is a giantG union of the variants for file, volume, etc.  LightspeedC cuts out some C of the excess structure, so the intermediate field names need to be: changed.  K Also, since LightspeedC supports passing of structures, I don't have to use0N the pass() macro to convert Points to longs in calling sequences.  Rather thanL edit out the pass()'s, I using a #define to make pass() do nothing.  I'm notM dumb -- it is a LOT harder to put the pass()'s back in than to take them out!a  I Somewhere along the way I needed to do a multifile search of the standardeH .h files.  No go, they aren't listed in the project, so you can't searchK them.  (Later I did see some of them listed in the project box, so there istJ more to this that I understand just at the moment.  It probably depends onJ the state of the project, such as whether a given .c file is open or not.)  I It was at this point that I followed the advice of the manual and created J the StdInclude project referencing "#include catalog.c".  Now if I have toH search the system .h's, I close the project I'm working on, walk the HFSJ tree over to my compiler folder ("Aha!" you exclaim, "that's why he calledF it 'AA Light' on the Desktop.")  Well, this is dandy, but it takes tooI damn long to get from the context of the error to the StdInclude project,hI and I find I lose my train of thought seriously, even though it's only 10sG or 15 seconds.  Too many mouseclicks in the process.  There should be asJ way of opening a second project read-only for the purpose of searching, or: of opening a folder of files as if it were a Project list.  I Let me also mention at this point that the editor is very good, but has atK few peculiarities.  For one thing, if you do a search and replace and clickeM Replace Again too many times, it winds up pasting extra copies of the replacecK string into the text right after the last legitimate one.  This sounds like L a bug to me.  The other will affect only users familiar with MDS Edit -- theH trick of selecting a bit of text and invoking the Find dialog to get theK search string pasted from the selection does not work.  Instead you have to K Copy and Paste into the Find dialog.  Tabs and return characters are easily K incorporated into find/replace strings though.  Just hold down Option while  typing tab or return.1  L OK, back to the saga.  After a bit of work, I got clean compiles all around,M and of course the link failed.  I should mention that I had already segmentedlN the code to match the way I had done it with MANX.  This is very easy, becauseH the project list window shows the the segments of the program by drawingM horizontal rules between segments and you simply drag the source module namese0 around to associate them with specific segments.  E So I inserted a few libraries into the project.  I had to do a little K experimenting to find out which libraries contain which modules, but it waseN easier (and FASTER) to just plug libraries in by trial and error and see whichM symbols got resolved than to open up the book and look up the library calling L sequence descriptions to see which module each of the unresolved symbols was in!i  H Kaboom!  Code segment 1 overflowed the 32768 barrier.  It seems that theJ LightspeedC library is not very granular, and one of my favorite routines,M sprintf() was responsible for dragging in about 16K of code.  (Actually it is?M not just sprintf() that is doing this, but you get the picture -- big runtimesJ library.)  So I dragged the standard I/O package off into a segment of its own and that fixed the problem.t  N When the linker diagnoses errors, it leaves a list of errors in a small windowK on the screen.  I suppose you can Copy the contents of this window into theeM Clipboard if you need to keep the list around in a file while you fix things,aI but I didn't try it.  Note the difference in philosophy:  an error duringmK compile is diagnosed in isolation and you are sent to the editor to fix it,tI whereas the link shows you all the errors it can find.  Except for duringiL massive infusions of code, I think this works very well.  When you are firstL developing a large chunk of code, you can easily compile repeatedly to checkL syntax (it takes about as long as Saving the file does).  So by getting intoJ proper habits, you should never be faced with repeated and annoying cyclesJ between the editor and the compiler.  On the other hand, having a completeH list of linker errors was essential for the rapid determination of which+ libraries were needed to complete the link.   I Note that all these compile and link cycles were managed by the automaticuI build procedures triggered when I try to RUN the application.  It is alsolK possible to compile a specific module or check the link without running theeK application.  When you edit inside the LightspeedC development environment,sJ it notes when you update something and computes the make list quickly.  IfK you edit outside LightspeedC, you have to tell it to check the modificationh@ timestamps explicitly (a little slower) when computing the make.  M The first time the link was OK, the program launched.  It also ran just fine.e  J Then I tested the turnaround performance by making some trivial changes toL the program.  All worked very nicely and speedily.  I tried out MacsBug, andO was very pleased with the results.  (LightspeedC allows you a choice of getting M procedure names inserted into the code or not.  MANX does not.  Until now, itaL has not been as easy to work with MacsBug as it should have been, because ofF the lack of symbols in the disassembly.  I'm looking forward to a moreb enjoyable low level debugging as well as drastically improved turnaround time.)  The big deal froma my point of view is that with this fast turnaround, source level debugging should be a peach.  No [ longer will there be any point to worrying about how many print statements to put in to getpG information, since it does not take 5 minutes to get another make done.o  I The last step was to build the application.  This ran pretty fast, and itnJ produced a clickable application module which worked just fine outside theM LightspeedC environment.  The only problem is that it is 17K bigger, and thisiK I attribute mainly to the problem with the library routines.  Aztec C seemsiN to be pretty good about avoiding unnecessary runtime overhead, and in additionM I have been suppressing the floating point library, since I don't need it formJ the program I am writing.  LightspeedC has a way to go in this regard, butJ I don't regard that as a fundamental defect, but rather an opportunity for  improvement in the next release.  M It's also not clear what the deal is if library routines are called from moredJ than one segment.  You can include the library in the root, but in MANX itL was possible (and required) to list the libraries in each segment that mightH have symbols not yet resolved.  MANX is not too clear about what they doO either, since a symbol called from segment 7 and segment 13 might more properly ; go into segment 1 than segment 7 or both segments 7 and 13.n  I That brings up one last point:  the licensing agreement has the followingm language in it:h  B         You have the right to include object code derived from theE         libraries in programs that you develop using the software and C         you also have the right to use, distribute and license suchoH         programs to third parties without payment of any further licenseE         fees providing you include the following copyright notice (nonG         less prominently than your own copyright notice) in the graphiceI         display of your software, in the documentation for it, and on the J         labels affixed to the media on which your software is distributed:E         "Copyright 1986 THINK Technologies, Inc.  Certain portions of B         this software are copyrighted by Think Technologies, Inc."  H Well, I regard that as an advertisement, and I'm not interested in beingI compelled to advertise another company's product in my own, EVEN THOUGH IoJ THINK IT'S A GREAT PRODUCT.  What this means is that I should write my ownI library routines (I might want to do that anyway, given the problems withrK the size of the library code).  Or, I maintain some compatibility with MANX H so that when I finish developing, I can go run the code through the MANXH compiler to get the final executable product for shipping.  What a pain.  H My point is that I bought a DEVELOPMENT SYSTEM from THINK, *not* a niftyM C library.  Come on guys, you have a great product, don't get into the nickeleK and dime business with this silly copyright notice.  If I like your product J (I do) I'll tell several thousand of my closest friends about it, and thatL will be a much better exposure than forcing your name into my product image.  > --------------------------------------------------------------   Peter Olson * DELPHI ICONtact Mac User Group SIG Manager   PEABO @ DELPHI PEABO @ Unison PEABO @ MCI Mail
 PEABO @ GEniex [76174,1670] @ CIS   :-)          