On Mon, Mar 29, 2010 at 9:23 AM, Space Ship T. <
[email protected]> wrote:
P.S. I don’t want to cause any grief
Is the general syntax simple and concise?
I wouldn’t consider C’s syntax to be simple and concise. It’s type
leads to weird contortions and obnoxious typecasting that just add
lines to code. To do anything polymorphic you have to use void pointers
function pointers. You have to use esoteric naming conventions because
doesn’t support namespaces. Compiling multiple source files requires
knowledge of makefiles (I’ve switched to rake) which have their own
syntax (and god help you if you use spaces instead of tab on some line
somewhere). If there is a single comprehensive source of documentation
ruby-doc.org), I don’t know what it is, and I’ve looked and asked and
using C off and on for about 2 years. Prototypes duplicate your
signatures across files that you then have to remember to change if you
alter your code, you have to include them to make your code visible to
files, and because code in your own file can’t see code that comes after
so you either deal with dependencies depending on where you wrote the
in the file in relation to other code, or you use a header. But even
can have dependency issues when included in some other file in the wrong
order. You can’t just include the file your header is dependent on
your header, because C can only include files a couple files deep. Their
type equality forces you to use typedefs because structures use some
equality measurement that the type system won’t realize is the same.
Is it generally easy to write new code?
I also disagree with C for this category. C does not support many
abstractions like interfaces, namespaces, OO, closures, etc. So you end
with a lot of code duplicated, and bound to eachother. I’m not saying
is inevitable, just that it’s really easy to for that to happen. This
that if you want to write new code, you end up being concerned you’re
to break something you’ve already done. It also has very poor support
testing, because it is so static and brittle, which makes it dangerous
refactor existing code. You also have to always be aware of where things
came from, and really let people know where they are going, because you
to manage all of your own memory, so if you don’t free that ‘object’ or
user you return your result to doesn’t free it, it’s going to turn into
Does the language have a type system conducive education?
I think Java should be green here. It’s static typing only gets in the
when you use things like containers. Otherwise, I think it is helpful
education to be able to look at the signature of the method, and see it
takes a String and an int, or just a String, and it returns an array of
strings. I always found that helpful when learning OO. And explicitly
declaring that your variable is of type whatever is helpful when you are
very strong with understanding types. It also allows the compiler to
incompatibilities, and (ideally, at least) give you more useful errors.
In this regard, I think Ruby should be yellow here. Ruby relies much
naming conventions, because you can’t display types in signatures. You
have code that will break because you passed the wrong type of variable,
it won’t break, because you don’t execute that particular piece of code.
Then much later when you do, you get an unexpected error! That is fine
you understand how types work, you don’t need all that extra code
this type or that type or casting between types. But if you are just
learning, then having the compiler hold your hand would probably be
Is it easy to reuse existing code?
I think C should be red. If you want to do anything non trivial,
code pretty much means function pointers and void pointers, which means
obnoxious typecasting and code/namespace pollution. You also have the
that the library you are including has some function named the same as
function you are using, or in some other library you want to use,
there is only the global namespace. To get around that, you have to have
really obnoxious names, usually preceeded by several characters to
artificially namespace it, but it all just makes the code more cryptic.
Also, I don’t know where you would go to get existing code other people
written, is there any standard documentation like rdoc or javadoc? I
not since I’ve read several books on C without any such mention. You
have to know how to build the code you are using, and know how to link
Does the language provide a useful and consistent set of object oriented
Maybe I’m misunderstanding the question, but C is not OO. To get OO like
behaviour, you have to declare a struct with all types in it, go write
own create and destroy functions to malloc and free the code. Write all
functions with prefixes appended to their names to make it clear that
are related to eachother, accept the object itself as your first
(something oo does explicitly for you), and then pass everything in
functionally, instead of calling methods. Ie let the prefix pr_ indicate
are defining a “method” for a person (which is just a typedefed struct).
Then ruby’s person.has_birthday; would look like
Now imagine if you wanted to chain methods.
Are people in education already familiar with the language and
At my school (Wichita State), C would be green, C++ would be yellow, and
Java would be green. Everything else on that list would be red.
Are there good learning resources available for use in education?
I think Java should be green, it’s api is very very helpful. I don’t
why C is green, for me it was just google and books (and now stack
Anyway, thats my opinion. Anyone is welcome to disagree, but as a
pre-emptive rebuttal, if there is a resource that resolves the issue,
not widely accepted or adopted, then I don’t think it is relevant,
it is not the kind of thing a new programmer will know about or is
understand well enough to use.