Don't publish YA API reference; Library documentation should be embedded within the software.
If I an author comes up with this great book idea,
that teaches porgrammers *what* functions/classes/messages/structures/macros
are available in a particular platform/library/tool kit/OS/compiler,
then just say NO.
Every morning I hate the scene of 30lbs or printed
MFC documentations (six books in total.) MS ODBC (15lbs.)
Win32 API (huge book, I can't even take to the toilet, about 5 lbs.)
Do I ever use those? Nope, help is an F1 keypress
away, and when I am home, I use the beautiful, self
documenting Lisp (sometimes Java and Perl, which
are also well documented.)
If you write a book, teach me "how to use" some
libarary, and give me an overview of what services it provides.
Sometimes, I buy sequel editions of old books I liked.
I have a curses book from the 80s, which didn't
have documentation for the Panels/Menus library
additions from GNU ncurses, so I went out and bought it.
Also, Don't jump on the band wagon, if I want a new
technology, I will buy books from Addison Wesley, Prentice Hall, or the vendor's publisher.
I am not gonna ask an startup publisher about C#,
I am going straight to MS press; similarly, I will
not buy a Java intro anyone, If I can lay my hands
on one from SunPress.
C#'s advanced features like better encapsulation (you don't need to call set() and get() methods, you can map them to the = operator, for example).
You, my friend, have it the nail on the head. Java's lack of operator overloading is really annoying,
but it is not a good reason to declare C# the winner
of the two.
In an ideal world, you have a competent designer,
who makes new data types as conceret as possible,
but in the real world, there is no messiah to save
you from abused language facilities, and assingment
operators that have ill side effects.
There is a point in your life when you realize that you have
written enough destructors, and have spent enough time tracking
down a memory leak, and you have spend enough time tracking down
memory corruption, and you have spent enough time using low-level
insecure functions, and you have implemented way too many linked
lists [1]
Last time I felt that way, I dicovered Lisp. Java also fits the bill (and so does C++ with STL, BOOST and ACE.
> #include
> #include
> #include
> #include
> printf("Welcome to linux 2.5.4")
Hey, you can only call a function from within
other functions, and you don't have a "main"
function, which is a must, in order to compile
an executable (otherwise the linker with cry from
unresolved calls.)
Also, you need a semi-colon to terminate the statement
> run_unix()
As above.
Besides, why do you need four header files, when
you only use two foreign symbols (prinf() and run_unix() ) ?
And finally, why clutter your standard header file
directories, with project dependant header files?
Put these files in a directory local to the project,
and include them with ""s
I know this might sound like a troll, but you can't
expect a sane developer to ship a GUI on time, with
nothing but list boxes, dialogs, text fields, menues and labels.
Some might say that is all you will ever need, or that
you can assemble any other widgets from those basic
ones as needed, but why bother do that when other
toolkits give me property sheets, combo boxes, tabbed views, rich toolbars (dragable, detachable, with animated bitmaps, and even with support for other control embedding.)
rich text support, and entire grids for spread sheet
and database applications. Document/View architectures (aka. MVC)
and rich OO class hierchies.
Guys, the days of hand coding everything are over.
MFC gives me all I need on Win32, and Qt on Unix;
someone else might appreciate Motif, but thank you
very much, not me.
This offcourse goes against the longs standing
trend of clapping for everything new. As always,
O'Reilly gets my respect (I knew about the books
for two months, and I was one of the first volunteers to convert them to PDF from the troff
sources.)
My father was a big follower of Nicholas Wirth's
(actually, many CS professors in europe.) teachings.
During the Vietnam war, he returned from europe
to the US, and he was required to join the armed
forces and fight.
The man was an emaciated grad student, and failed
every physical exam they threw at him. During the
2nd day of try-outs, he developed asthma and a long
list of other illnesses and complexes.
USMC knew they will support this man to the grave
if they ever enlist him, so they decided to save
the public money from an evidant premature medicare.
As soon as they certified him "unfit", he returned
healthy and kicking -- back to terminal radiation,
and eliminating left recursion.
I pasted the text twice; the input form is too short to type in, so I used a text editor.
Emacs actually:-D
Ignore the sig, it is an artifact from my days of
VI zealotery, and is now dried in the concrete.
I hate it, the same way I hate the disco tatoos from my yout;-)
This is absolutely off topic, but it might be of help to those wanting to pursue
the most interesting piece of software I have ever seen.
First of all, Scheme and Common Lisp are not the same; don't let the parenthesis
fool you, they are different beasts.
I learn scheme first, from the online version of SICP [http://mitpress.mit.edu/sicp/full-text/book/book. html]
and played with scsh (a unix scheme shell.) which is a very practical environment to
program on.
After that, I decided to try the mover language, Common Lisp, so I bought the excellent
"Lisp 3rd edition" by Winston and Horn.
I tried to find the most standard compliant, free implementation of CL, and found
CLISP and CMUCL. Only the first, runs on win32.
Usually when I am learning to program a new language, I write a template file, that
contains an empty "main" file, or atleast the shebang, then copy it whenever I am
starting a new project.
What shocked me was, Lisp does not have a main file. You only define functions, and you call
those functions from other functions, and so on.
The name "function" has a technical meaning, implying a returned result after evaluation,
otherwise it could have been a procedure.
The funny thing is, Lisp does not require a returned value. A function can return
multiple values, or change some unshielded global variable.
The later is dangerous, because Lisp doesn't "type" its variables, and you can use a variable
without declaring it.
So, if you change a non paremeter variable, from within a function, and assign it a different
type, it will go un-notice. THAT my friend, is the worst side effect you can have.
This might be cheap shot, because Perl allows the excat same thing. Both languages have a
remedy for this, which is a compiler directive. But there is not inherent enforcement.
Secondly, Lisp has the richest set of data stuctures I have ever seen in a programming language,
EVER!
And they all have a uniform declaration/initialization/access way (even down to the naming convention.)
I was able to use the structures without even reading their chapter on the book; just by learning
how to use arrays.
The string formating thingies in lisp are a bit cryptic. Unlike all the languages out there
that use printf like formatting, lisp has its own way of doing things -- it predates C ofcourse,
it could have been cute if they used C style, just like they adopted POSIX style regexes.
Lisp's way of calling library functions is "Implementation dependant. Actually, I own "Common
Lisp the Language, 2nd edition" and "Implementation dependant" is the most recuring clause in
the whole book. I wish the clause never existed.
There are some open sources packages, most noticably CLOCC, but it could have been cute if there
was an standard linking method.
Common Lisp doesn't have a parent authority, and this shows in the diverse implementations. The
standard is too abstract to enforce a uniform environment (is that why Lisp is out surviving
metal jackets like ADA? dunno.)
And things Like net/database connection, host system interface, etc. are lacking.
If the Foreign Function Interface (lisp's way of language binding.) was frozen Lisp could have
been a much richer language, in terms of 3rd party libraries. But unfortunately, it is not.
The Make of Lisp "defsystem" is not standard either; and the C/C++ file inclussion recursive
loops are copied en-masse.
Emacs is the greatest thing ever happened to Lisp (Actually, I like Hemlock better.) It does
everything you could ever imagine; indenting is done as I type, I never have to type the parenthesis
myself (that is right folks I just press C-( type the body of the expression then C-) the beauty
is, that ALSO takes care of indenting, so 2 birds with one stone.)
I can evaluate expressions immediately, and correct them on the spot if they are buggy (edit-compile-run-debug is
now compressed to one step.. edit!)
Just make sure you are not sucked in to the Elisp (it is very practical, and you will be tempted
to use it, but don't, as it is not CL and is very limited.)
The commercial Lisp implementations are nothing short of the Visual Studio suit, in terms of
RAD.
Actually, I think Franz is as easy as VB, and has its own dialog editors, which has more controls
than Visual C++ 6 Enterprise edition!
Lisp's bit manipulation operators (actually functions.) are not easily reachable. I was shocked
when I couldn't test a value by ORing it to its COMPLEMENT (an old habit from assembler.)
Lisp *requires* you to define the number bits in your byte!!
Lisp is the language of compiler contstruction. One of my very first test apps was a BASIC
interpreter. Gone are the days of low level charcter manipulation, buffer overruns, pointer
increments, and prematures free()s;
my whole parser was a 20 line COND form!
Lisp is an interesting thing, I don't know if I like it or not, but I am always tempted to drop
whatever I have, to see how differently it does some standard programming idiom, and most of the
time, I am left in an awe.First of all, Scheme and Common Lisp are not the same; don't let the parenthesis
fool you, they are different beasts.
I learn scheme first, from the online version of SICP [http://mitpress.mit.edu/sicp/full-text/book/book. html]
and played with scsh (a unix scheme shell.) which is a very practical environment to
program on.
After that, I decided to try the mover language, Common Lisp, so I bought the excellent
"Lisp 3rd edition" by Winston and Horn.
I tried to find the most standard compliant, free implementation of CL, and found
CLISP and CMUCL. Only the first, runs on win32.
Usually when I am learning to program a new language, I write a template file, that
contains an empty "main" file, or atleast the shebang, then copy it whenever I am
starting a new project.
What shocked me was, Lisp does not have a main file. You only define functions, and you call
those functions from other functions, and so on.
The name "function" has a technical meaning, implying a returned result after evaluation,
otherwise it could have been a procedure.
The funny thing is, Lisp does not require a returned value. A function can return
multiple values, or change some unshielded global variable.
The later is dangerous, because Lisp doesn't "type" its variables, and you can use a variable
without declaring it.
So, if you change a non paremeter variable, from within a function, and assign it a different
type, it will go un-notice. THAT my friend, is the worst side effect you can have.
This might be cheap shot, because Perl allows the excat same thing. Both languages have a
remedy for this, which is a compiler directive. But there is not inherent enforcement.
Secondly, Lisp has the richest set of data stuctures I have ever seen in a programming language,
EVER!
And they all have a uniform declaration/initialization/access way (even down to the naming convention.)
I was able to use the structures without even reading their chapter on the book; just by learning
how to use arrays.
The string formating thingies in lisp are a bit cryptic. Unlike all the languages out there
that use printf like formatting, lisp has its own way of doing things -- it predates C ofcourse,
it could have been cute if they used C style, just like they adopted POSIX style regexes.
Lisp's way of calling library functions is "Implementation dependant. Actually, I own "Common
Lisp the Language, 2nd edition" and "Implementation dependant" is the most recuring clause in
the whole book. I wish the clause never existed.
There are some open sources packages, most noticably CLOCC, but it could have been cute if there
was an standard linking method.
Common Lisp doesn't have a parent authority, and this shows in the diverse implementations. The
standard is too abstract to enforce a uniform environment (is that why Lisp is out surviving
metal jackets like ADA? dunno.)
And things Like net/database connection, host system interface, etc. are lacking.
If the Foreign Function Interface (lisp's way of language binding.) was frozen Lisp could have
been a much richer language, in terms of 3rd party libraries. But unfortunately, it is not.
The Make of Lisp "defsystem" is not standard either; and the C/C++ file inclussion recursive
loops are copied en-masse.
Emacs is the greatest thing ever happened to Lisp (Actually, I like Hemlock better.) It does
everything you could ever imagine; indenting is done as I type, I never have to type the parenthesis
myself (that is right folks I just press C-( type the body of the expression then C-) the beauty
is, that ALSO takes care of indenting, so 2 birds with one stone.)
I can evaluate expressions immediately, and correct them on the spot if they are buggy (edit-compile-run-debug is
now compressed to one step.. edit!)
Just make sure you are not sucked in to the Elisp (it is very practical, and you will be tempted
to use it, but don't, as it is not CL and is very limited.)
The commercial Lisp implementations are nothing short of the Visual Studio suit, in terms of
RAD.
Actually, I think Franz is as easy as VB, and has its own dialog editors, which has more controls
than Visual C++ 6 Enterprise edition!
Lisp's bit manipulation operators (actually functions.) are not easily reachable. I was shocked
when I couldn't test a value by ORing it to its COMPLEMENT (an old habit from assembler.)
Lisp *requires* you to define the number bits in your byte!!
Lisp is the language of compiler contstruction. One of my very first test apps was a BASIC
interpreter. Gone are the days of low level charcter manipulation, buffer overruns, pointer
increments, and prematures free()s;
my whole parser was a 20 line COND form!
Lisp is an interesting thing, I don't know if I like it or not, but I am always tempted to drop
whatever I have, to see how differently it does some standard programming idiom, and most of the
time, I am left in an awe.
Debugging is part of testing, and is an iterative
process.
Tester feeback is the best way to debug a system,
when QA is an issue. But for a ship-and-let-lusers-pay-for-beta
company like microsoft, they need to *listen* to
user feedback.
Here is the catch: Even if microsoft devotes all its
time, throughout the month for debugging, users will
not be doing that!
So, if they are not soliciting user feedback, how
are they doing it? heauristics?
My first guess is, they have heaps of bug reports
that they need to go over and fix.
But halting all development is not the way to do it,
they childishly jumped the gun this time, simply
because ALL developers don not debug.
Similarly, there is no "wipe your ass day",
wiping your ass should happen every time you take
a shit.
So, it is either an stupid decision, or YAPR move.
My girlfriend (a high school senior) is running
debian+ximian on her desktop.
She knows nothing about 'puting (she is an artist.)
and doesn't mind it at all.
Infact, she doesn't even recognize it as a different
OS, she thinks it is all the same.
My first two programming languages were both assembly,
so you know I am a performance freak by nature.
When I first tried java, the only two things that came
between me and it were run time and compile time
speed.
The later has been solved by native compilers, and GHz
speeds.
The first is yet to be solved.
For an edit-compile-run-debug programming language like
java, I need the least time between edit and debug.
The "one public class per file" policy forces some
code modularity, and with an incremental compiler,
speeds things up.
But the java compiler itself is SLOOW. My energy
is exhausted waiting to test the effect of a one line change. Turbo C did thrice that work, on my
286, under an operating system that didn't see more
than 640K bytes, thank you very much.
I am much more productive, evaluating my expressions
immediately in an emacs buffer, and running CLISP
as an inferrior:-D
Until FOX takes over it: Then it will change to a
reality-TV/dating/contraversial/engineering beast.
If I know the FOX producers well, this will be their format:
A group of hunky and petite boys and girls will be
sent to the wilderness, equiped with an entire
garage of tools, and bathing suits.
The group ("tribe" from now onwards) will contain
people of conflicting personalities and culture:
There will be Kevin the KKK wannabe, Debbie the dyke,
a token black man, and a dozen or so undecided suburban
kids who just walk around semi naked.. in winter!
Slashdot Mirror
Don't publish YA API reference; Library documentation should be embedded within the software.
If I an author comes up with this great book idea,
that teaches porgrammers *what* functions/classes/messages/structures/macros
are available in a particular platform/library/tool kit/OS/compiler,
then just say NO.
Every morning I hate the scene of 30lbs or printed
MFC documentations (six books in total.) MS ODBC (15lbs.)
Win32 API (huge book, I can't even take to the toilet, about 5 lbs.)
Do I ever use those? Nope, help is an F1 keypress
away, and when I am home, I use the beautiful, self
documenting Lisp (sometimes Java and Perl, which
are also well documented.)
If you write a book, teach me "how to use" some
libarary, and give me an overview of what services it provides.
Sometimes, I buy sequel editions of old books I liked.
I have a curses book from the 80s, which didn't
have documentation for the Panels/Menus library
additions from GNU ncurses, so I went out and bought it.
Also, Don't jump on the band wagon, if I want a new
technology, I will buy books from Addison Wesley, Prentice Hall, or the vendor's publisher.
I am not gonna ask an startup publisher about C#,
I am going straight to MS press; similarly, I will
not buy a Java intro anyone, If I can lay my hands
on one from SunPress.
C#'s advanced features like better encapsulation (you don't need to call set() and get() methods, you can map them to the = operator, for example).
You, my friend, have it the nail on the head. Java's lack of operator overloading is really annoying,
but it is not a good reason to declare C# the winner
of the two.
In an ideal world, you have a competent designer,
who makes new data types as conceret as possible,
but in the real world, there is no messiah to save
you from abused language facilities, and assingment
operators that have ill side effects.
So, If I decided to stand beside Miguel and code for
GNOME in C#, where should I start?
The C# literature out there is too "in 21 days" for
an experienced programmer. What solid books are there
for the platform?
don't be WHERE so paranoid DO YOU, there is nothing WANT
subliminal or brain TO GO washing about TODAY the article.
There is a point in your life when you realize that you have written enough destructors, and have spent enough time tracking down a memory leak, and you have spend enough time tracking down memory corruption, and you have spent enough time using low-level insecure functions, and you have implemented way too many linked lists [1]
Last time I felt that way, I dicovered Lisp. Java also fits the bill (and so does C++ with STL, BOOST and ACE.
The past generation knew how to tinker because it was the entertainment... now the spirit's being lossed.
Lemme guess, the old generation didn't play with grammar books?
so beautifully writen troll :-)
there goes son, 2 points on you.
That little flippy was quick to land ;-)
This is disrespectful to all the hard working
volunteers, how have spent years awake at night
refining the Linux desktops.
Bob "Traitor" Young has discredit them so easily,
after he has made a fortune selling their efforts.
Shame on him.
> #include
> #include
> #include
> #include
> printf("Welcome to linux 2.5.4")
Hey, you can only call a function from within
other functions, and you don't have a "main"
function, which is a must, in order to compile
an executable (otherwise the linker with cry from
unresolved calls.)
Also, you need a semi-colon to terminate the statement
> run_unix()
As above.
Besides, why do you need four header files, when
you only use two foreign symbols (prinf() and run_unix() ) ?
And finally, why clutter your standard header file
directories, with project dependant header files?
Put these files in a directory local to the project,
and include them with ""s
the original texts are here http://www.oreilly.com/openbook/
along with other goodies.
Motif is poor!
I know this might sound like a troll, but you can't
expect a sane developer to ship a GUI on time, with
nothing but list boxes, dialogs, text fields, menues and labels.
Some might say that is all you will ever need, or that
you can assemble any other widgets from those basic
ones as needed, but why bother do that when other
toolkits give me property sheets, combo boxes, tabbed views, rich toolbars (dragable, detachable, with animated bitmaps, and even with support for other control embedding.)
rich text support, and entire grids for spread sheet
and database applications. Document/View architectures (aka. MVC)
and rich OO class hierchies.
Guys, the days of hand coding everything are over.
MFC gives me all I need on Win32, and Qt on Unix;
someone else might appreciate Motif, but thank you
very much, not me.
This offcourse goes against the longs standing
trend of clapping for everything new. As always,
O'Reilly gets my respect (I knew about the books
for two months, and I was one of the first volunteers to convert them to PDF from the troff
sources.)
This is the greatest thing to set afoot on /. since
the penis bird.
Thanks a million, applepie.cx will be up soon.
My father was a big follower of Nicholas Wirth's
(actually, many CS professors in europe.) teachings.
During the Vietnam war, he returned from europe
to the US, and he was required to join the armed
forces and fight.
The man was an emaciated grad student, and failed
every physical exam they threw at him. During the
2nd day of try-outs, he developed asthma and a long
list of other illnesses and complexes.
USMC knew they will support this man to the grave
if they ever enlist him, so they decided to save
the public money from an evidant premature medicare.
As soon as they certified him "unfit", he returned
healthy and kicking -- back to terminal radiation,
and eliminating left recursion.
I pasted the text twice; the input form is too short to type in, so I used a text editor.
:-D
;-)
Emacs actually
Ignore the sig, it is an artifact from my days of
VI zealotery, and is now dried in the concrete.
I hate it, the same way I hate the disco tatoos from my yout
This is absolutely off topic, but it might be of help to those wanting to pursue
. html]
.. edit!)
. html]
.. edit!)
the most interesting piece of software I have ever seen.
First of all, Scheme and Common Lisp are not the same; don't let the parenthesis
fool you, they are different beasts.
I learn scheme first, from the online version of SICP [http://mitpress.mit.edu/sicp/full-text/book/book
and played with scsh (a unix scheme shell.) which is a very practical environment to
program on.
After that, I decided to try the mover language, Common Lisp, so I bought the excellent
"Lisp 3rd edition" by Winston and Horn.
I tried to find the most standard compliant, free implementation of CL, and found
CLISP and CMUCL. Only the first, runs on win32.
Usually when I am learning to program a new language, I write a template file, that
contains an empty "main" file, or atleast the shebang, then copy it whenever I am
starting a new project.
What shocked me was, Lisp does not have a main file. You only define functions, and you call
those functions from other functions, and so on.
The name "function" has a technical meaning, implying a returned result after evaluation,
otherwise it could have been a procedure.
The funny thing is, Lisp does not require a returned value. A function can return
multiple values, or change some unshielded global variable.
The later is dangerous, because Lisp doesn't "type" its variables, and you can use a variable
without declaring it.
So, if you change a non paremeter variable, from within a function, and assign it a different
type, it will go un-notice. THAT my friend, is the worst side effect you can have.
This might be cheap shot, because Perl allows the excat same thing. Both languages have a
remedy for this, which is a compiler directive. But there is not inherent enforcement.
Secondly, Lisp has the richest set of data stuctures I have ever seen in a programming language,
EVER!
And they all have a uniform declaration/initialization/access way (even down to the naming convention.)
I was able to use the structures without even reading their chapter on the book; just by learning
how to use arrays.
The string formating thingies in lisp are a bit cryptic. Unlike all the languages out there
that use printf like formatting, lisp has its own way of doing things -- it predates C ofcourse,
it could have been cute if they used C style, just like they adopted POSIX style regexes.
Lisp's way of calling library functions is "Implementation dependant. Actually, I own "Common
Lisp the Language, 2nd edition" and "Implementation dependant" is the most recuring clause in
the whole book. I wish the clause never existed.
There are some open sources packages, most noticably CLOCC, but it could have been cute if there
was an standard linking method.
Common Lisp doesn't have a parent authority, and this shows in the diverse implementations. The
standard is too abstract to enforce a uniform environment (is that why Lisp is out surviving
metal jackets like ADA? dunno.)
And things Like net/database connection, host system interface, etc. are lacking.
If the Foreign Function Interface (lisp's way of language binding.) was frozen Lisp could have
been a much richer language, in terms of 3rd party libraries. But unfortunately, it is not.
The Make of Lisp "defsystem" is not standard either; and the C/C++ file inclussion recursive
loops are copied en-masse.
Emacs is the greatest thing ever happened to Lisp (Actually, I like Hemlock better.) It does
everything you could ever imagine; indenting is done as I type, I never have to type the parenthesis
myself (that is right folks I just press C-( type the body of the expression then C-) the beauty
is, that ALSO takes care of indenting, so 2 birds with one stone.)
I can evaluate expressions immediately, and correct them on the spot if they are buggy (edit-compile-run-debug is
now compressed to one step
Just make sure you are not sucked in to the Elisp (it is very practical, and you will be tempted
to use it, but don't, as it is not CL and is very limited.)
The commercial Lisp implementations are nothing short of the Visual Studio suit, in terms of
RAD.
Actually, I think Franz is as easy as VB, and has its own dialog editors, which has more controls
than Visual C++ 6 Enterprise edition!
Lisp's bit manipulation operators (actually functions.) are not easily reachable. I was shocked
when I couldn't test a value by ORing it to its COMPLEMENT (an old habit from assembler.)
Lisp *requires* you to define the number bits in your byte!!
Lisp is the language of compiler contstruction. One of my very first test apps was a BASIC
interpreter. Gone are the days of low level charcter manipulation, buffer overruns, pointer
increments, and prematures free()s;
my whole parser was a 20 line COND form!
Lisp is an interesting thing, I don't know if I like it or not, but I am always tempted to drop
whatever I have, to see how differently it does some standard programming idiom, and most of the
time, I am left in an awe.First of all, Scheme and Common Lisp are not the same; don't let the parenthesis
fool you, they are different beasts.
I learn scheme first, from the online version of SICP [http://mitpress.mit.edu/sicp/full-text/book/book
and played with scsh (a unix scheme shell.) which is a very practical environment to
program on.
After that, I decided to try the mover language, Common Lisp, so I bought the excellent
"Lisp 3rd edition" by Winston and Horn.
I tried to find the most standard compliant, free implementation of CL, and found
CLISP and CMUCL. Only the first, runs on win32.
Usually when I am learning to program a new language, I write a template file, that
contains an empty "main" file, or atleast the shebang, then copy it whenever I am
starting a new project.
What shocked me was, Lisp does not have a main file. You only define functions, and you call
those functions from other functions, and so on.
The name "function" has a technical meaning, implying a returned result after evaluation,
otherwise it could have been a procedure.
The funny thing is, Lisp does not require a returned value. A function can return
multiple values, or change some unshielded global variable.
The later is dangerous, because Lisp doesn't "type" its variables, and you can use a variable
without declaring it.
So, if you change a non paremeter variable, from within a function, and assign it a different
type, it will go un-notice. THAT my friend, is the worst side effect you can have.
This might be cheap shot, because Perl allows the excat same thing. Both languages have a
remedy for this, which is a compiler directive. But there is not inherent enforcement.
Secondly, Lisp has the richest set of data stuctures I have ever seen in a programming language,
EVER!
And they all have a uniform declaration/initialization/access way (even down to the naming convention.)
I was able to use the structures without even reading their chapter on the book; just by learning
how to use arrays.
The string formating thingies in lisp are a bit cryptic. Unlike all the languages out there
that use printf like formatting, lisp has its own way of doing things -- it predates C ofcourse,
it could have been cute if they used C style, just like they adopted POSIX style regexes.
Lisp's way of calling library functions is "Implementation dependant. Actually, I own "Common
Lisp the Language, 2nd edition" and "Implementation dependant" is the most recuring clause in
the whole book. I wish the clause never existed.
There are some open sources packages, most noticably CLOCC, but it could have been cute if there
was an standard linking method.
Common Lisp doesn't have a parent authority, and this shows in the diverse implementations. The
standard is too abstract to enforce a uniform environment (is that why Lisp is out surviving
metal jackets like ADA? dunno.)
And things Like net/database connection, host system interface, etc. are lacking.
If the Foreign Function Interface (lisp's way of language binding.) was frozen Lisp could have
been a much richer language, in terms of 3rd party libraries. But unfortunately, it is not.
The Make of Lisp "defsystem" is not standard either; and the C/C++ file inclussion recursive
loops are copied en-masse.
Emacs is the greatest thing ever happened to Lisp (Actually, I like Hemlock better.) It does
everything you could ever imagine; indenting is done as I type, I never have to type the parenthesis
myself (that is right folks I just press C-( type the body of the expression then C-) the beauty
is, that ALSO takes care of indenting, so 2 birds with one stone.)
I can evaluate expressions immediately, and correct them on the spot if they are buggy (edit-compile-run-debug is
now compressed to one step
Just make sure you are not sucked in to the Elisp (it is very practical, and you will be tempted
to use it, but don't, as it is not CL and is very limited.)
The commercial Lisp implementations are nothing short of the Visual Studio suit, in terms of
RAD.
Actually, I think Franz is as easy as VB, and has its own dialog editors, which has more controls
than Visual C++ 6 Enterprise edition!
Lisp's bit manipulation operators (actually functions.) are not easily reachable. I was shocked
when I couldn't test a value by ORing it to its COMPLEMENT (an old habit from assembler.)
Lisp *requires* you to define the number bits in your byte!!
Lisp is the language of compiler contstruction. One of my very first test apps was a BASIC
interpreter. Gone are the days of low level charcter manipulation, buffer overruns, pointer
increments, and prematures free()s;
my whole parser was a 20 line COND form!
Lisp is an interesting thing, I don't know if I like it or not, but I am always tempted to drop
whatever I have, to see how differently it does some standard programming idiom, and most of the
time, I am left in an awe.
Debugging is part of testing, and is an iterative
process.
Tester feeback is the best way to debug a system,
when QA is an issue. But for a ship-and-let-lusers-pay-for-beta
company like microsoft, they need to *listen* to
user feedback.
Here is the catch: Even if microsoft devotes all its
time, throughout the month for debugging, users will
not be doing that!
So, if they are not soliciting user feedback, how
are they doing it? heauristics?
My first guess is, they have heaps of bug reports
that they need to go over and fix.
But halting all development is not the way to do it,
they childishly jumped the gun this time, simply
because ALL developers don not debug.
Similarly, there is no "wipe your ass day",
wiping your ass should happen every time you take
a shit.
So, it is either an stupid decision, or YAPR move.
My girlfriend (a high school senior) is running
debian+ximian on her desktop.
She knows nothing about 'puting (she is an artist.)
and doesn't mind it at all.
Infact, she doesn't even recognize it as a different
OS, she thinks it is all the same.
My first two programming languages were both assembly,
:-D
so you know I am a performance freak by nature.
When I first tried java, the only two things that came
between me and it were run time and compile time
speed.
The later has been solved by native compilers, and GHz
speeds.
The first is yet to be solved.
For an edit-compile-run-debug programming language like
java, I need the least time between edit and debug.
The "one public class per file" policy forces some
code modularity, and with an incremental compiler,
speeds things up.
But the java compiler itself is SLOOW. My energy
is exhausted waiting to test the effect of a one line change. Turbo C did thrice that work, on my
286, under an operating system that didn't see more
than 640K bytes, thank you very much.
I am much more productive, evaluating my expressions
immediately in an emacs buffer, and running CLISP
as an inferrior
Until FOX takes over it: Then it will change to a
.. in winter!
reality-TV/dating/contraversial/engineering beast.
If I know the FOX producers well, this will be their format:
A group of hunky and petite boys and girls will be
sent to the wilderness, equiped with an entire
garage of tools, and bathing suits.
The group ("tribe" from now onwards) will contain
people of conflicting personalities and culture:
There will be Kevin the KKK wannabe, Debbie the dyke,
a token black man, and a dozen or so undecided suburban
kids who just walk around semi naked
I used to work for the MOD (the equivalent of the US DARPA). We used to have SGI onyx's for our simulations, and life was good.
Who knew tax money supported machines would have *that* much uptime running "life".
I hope Conway gets overclocked in his grave
[00:11] thanks for organizing this
...
[00:11] talk to y'all later!
[00:11] * _jkh waves
[00:11] *** _jkh (jkh@apple.com) has left #freebsd
a minute later
[00:13] *** rootkid (jkh@apple.com) has joined #freebsd
[00:13] whaz000p bitches; I am back for idling.
don't worry, that man has been dying on slashdot
for a VERY long time. two years now.
He was a taliban ;-)
* beer for homiez ... $30
... $275
... priceless
* fake police car
* knowing that will be your last penny