You actually had a doubt?
Assassin2684 - Sat May 20, 2006 9:15 am
Post subject:
Thanks guys, you helped me alot. I guess im going to go with C++ then. Im going to break out my old book this summer and start reading agin.
SamHughes - Sat May 20, 2006 9:23 am
Post subject:
Okay okay! In these languages, you have to write the same things over and over again. How many times have you had to write "for (i = 0; i < n; ++i)"? And why can't you make a shortcut for that? Java does have a shortcut for that, in fact, but not C++. You're limited to the shortcuts that are built in to the language.
And I'm not talking down to anybody.
In some languages, like Scheme, or Lisp, you can make shortcuts for that. Since every program in Scheme is just a list of lists, it is straightforward to add these things. It's part of the language, and it's a way of doing things. (It's completely better than C's preprocessor.) For example, you could add the keyword 'for' to the language so that "(for i (range 0 5) ...do stuff...)" becomes valid syntax. (And "(for x (in some-vector) ...do stuff...)" would work too.) But Scheme has many of its own problems (in that it sucks, and everybody does everything differently).
So ok, there are some issues like having to write things out, but that's not so bad. But there are other things C++ and Java lack. Like the ability to make procedures, pass them between functions, and return them, catching all the variables in lexical scope. E.g. in Javascript:
Code: Show/Hide function greeter(greeting) {
return function (name) { print(greeting + ", " + name + "!\n") } } var x = greeter("Greetings") var y = greeter("Hello") x("Earthlings") y("world") |
Each procedure captures the variables defined in its lexical scope, so x's "greeting" is different than y's "greeting". C procedures, with static variables, are like singleton versions of what's here.
In C++, they call these 'objects', which are less flexible but good in many ways.
Code: Show/Hide struct greeter {
std::string greeting; greeter(const std::string& s) : greeting(s) {} void operator() (const std::string& greetee) { std::cout << greeting << ", " << greetee << "!\n"; } }; |
Code: Show/Hide greeter x("Hello");
x("world"); |
Okay, just imagine C++'s <algorithm>, only without the headaches. For example, what would be in C++,
Code: Show/Hide vector<int> foo;
... vector<int> bar; transform(foo.begin(), foo.end(), back_inserter(bar), some_function); |
would look more like this if C++ borrowed from other languages:
Code: Show/Hide // the type of foo is figured out implicitly
... let bar = map(some_function, foo); |
Using a few of these things, especially map and for-each procedures, makes the code much more readable than nested for/while loops filled with declarations and assignments, and caters much more towards human thinking. C++ and Java are designed more around making it simple to compile. Which is useful and is why C++'s existence makes sense, since many times, well-organized low-level programming is needed. But Java doesn't make sense; it's basically (C++) + garbage collection + libraries + marketing - operator overloading, and still, all the code you write is tailored to the compiler, not to the way humans think. Java as in the language isn't very good; Java as in the JVM is good.
Right now, I'd say that Haskell is one of the best languages. It's a pretty weird language (the weirdest relatively well known language meant for practical use?). So I wouldn't be surprised if people disagreed with me. But, for example, it took about 35 minutes to write a program that finds all solutions of the n queens problem in C++, only 5 in Haskell.
If I wanted to write a program that printed the first 10000 prime numbers in Haskell, first I'd write a function, 'primes', that returns an infinite list of all the prime numbers (using the sieve of Eratosthenes). Then the main function takes the first 10000, converts them to strings, appends newlines, and prints them out:
Code: Show/Hide primes = filterComposites [2..]
where filterComposites (n:ns) = n : filterComposites (filter (indivisible n) ns) indivisible n x = (0 /= x `mod` n) main = mapM (putStr . (++ "\n") . show) (take 10000 primes) |
An infinite list is possible because Haskell uses lazy evaluation, meaning that expressions are only evaluated when their value is needed. Then, (putStr . (++ "\n") . show) returns a function that takes a number, and converts it into the outputting of that number (with a newline). (That's one way to think about it.) Then mapM combines those all into one IO () object.
Yes, this seems like a crazy way to think. (Because, well, it is a crazy way to think.) But it works and is surprisingly productive. More and more people are coming to this conclusion, and so the language has had an explosion of growth. (When you start near zero, everything is an explosion!)
What's above doesn't look very readable to somebody just looking at it, since, well, I didn't design it with that in mind. But it is readable to anybody who uses the language. (And it's as readable to you as std::cout << "Hello, world!" << std::endl; was the first time you saw that.) But this is because in the code above, there's no extra syntax, no variable declarations. Every single character there is either whitespace, an equals sign, a parenthesis, or part of the name of a function or datastructure. Just for another example, here's one other example, of how to define a factorial function, and then that greeter from before:
Code: Show/Hide factorial 0 = 1
factorial n = n * factorial (n - 1) greeter g gee = putStr (g ++ ", " ++ gee ++ "!\n") programmerGreeter = greeter "Hello" alienGreeter = greeter "Greetings" |
It doesn't get simpler than that.
Cyan~Fire - Sat May 20, 2006 12:17 pm
Post subject:
What makes those preprocessors you were talking about so much better than C's? What's wrong with
Code: Show/Hide #define MYFOR(max) for(i = 0; i < max; i++) |
or some variant?
SpecShip - Sat May 20, 2006 3:17 pm
Post subject:
So basically, his complaint being that upper ring program languages aren't user friendly enough like the lower rings to simplify things for him, like having macros?
Just create your own compiler or something then... :rolleyes:
Anonymous - Sat May 20, 2006 6:08 pm
Post subject:
He's just a whiney lazy bitch.
Mr Ekted - Sat May 20, 2006 8:45 pm
Post subject:
The reason low-level languages like C don't have dynamic types is because of run-time speed. That is why they are so damn fast. There's no checking going on for every line of code, every expression. Yes, that's more dangerous when you have inferior coders, but it's a trade-off.
The reason for (i = 0; i < max; i++) is not hard-coded into C is because that is only one of the many ways to write it. The for statement can be used in any generic way you want:
Code: Show/Hide for (;; i++) |
Code: Show/Hide for (i = 7;;) |
Code: Show/Hide for (; i < 22;) |
Code: Show/Hide for (a=3,b=12;c < 14 && d > 9; calc(), build(), e += 3) |
(Deactived B l a h e r) - Sat May 20, 2006 8:51 pm
Post subject:
