Object Oriented Programming suck

Post Reply New Topic

Understood.

I don't rewrite things either, I write code to do something once, as a modular function, and cut & paste it into anyplace I need it. I've reused some functions dozens of times. If I were lazy, I could even just put them into <my_junk.h> . Works for me.

On the other hand, I pretty regularly need to port my applications, I never know when someone's going to need them running on AIX, HP-UX, z/OS, or what have you, immediately. And on many of the platforms that do have C# support, BSD for example, you're basically dealing with a beta-level product that is occasionally tinkered with by 2 guys. That sort of thing makes owners of production networks nervous.

Or maybe I just don't use languages which were invented by Microsoft, take your pick.

Anyway, to each their own.

Total agreement there. I glanced at, then completely ignored C# when in came out. SharpDevelop came along, and that got me interested. Now Mono. MS have completely lost it.

Sadly I think I will have to adjust to C# at some point . I would much rather do C++, but the unit I have to do is based of C#.

Stupid Microsoft rip off everything. Open Source community made PHP, Microsoft made ASP .

I recall that as being the C# story, too... Sun came out with Java, MS wanted to add extensions to it and have their own, incompatible version. Sun successfully sued them over it, MS decided that if they couldn't have an incompatible Java that they wouldn't support Java at all, and came out with C# as a substitute.

Of course Java wasn't open source at the time, and won't be for another few weeks (?), but the general principle is the same.

There is the fact that Java's mistakes were recognized, and many of them are not in C#; so, it's not really a copy, so much as an improvement on the ideas. There are some fundemental problems with this whole style of language though.

Lau -

When I said well written native code, I was intentionally trying to avoid the points that you brought up. I'm sure that in general assembly code is too likely to be poorly written - which is why there tend to be libraries for important stuff.

As far as I see what you're saying about Forth (and it's a language I never knew well, and is long gone from my mind), it sounds a lot like the ideas which go into the scripting languages. Given that Python can be used to run C modules, and many of the key things that one would want to do are already encoded as such, and the fact that it is eminantly more popular now, I think I'll stick with it. Might take another peek at Forth though - just for historical interest. I actually thought it was a dead language.

While C doesn't enforce OO design, it can be used for it. It's just an incredibly ugly thing to do. But long before C+classes existed, people were finding that they needed OO design principles, and used them in their C code. I'm not particularly demanding that my language force me to use OO. I like the flexibility (though I can't remember when I last wrote a C++ program without them - probably just before I figured out how to use operator new) of being able to choose.

I like using 'new' way more than 'malloc(pointer,sizeof(datatype))'

Yeah. But sometimes you need to actually carve out space in shared memory, which is why you need to redefine operator new - and it ain't pretty.

calandale, as an example of Forth, I amused myself, when ahayes put out a "little" C++ program on the KBABZ awards thread, by responding with much the same program in Forth.

Forth is a dead language? I suppose so, to a large extent. Another case of "too many standards", maybe. Offhand though, a language that come part and parcel with its own compiler, which you can replace/extend/mess with any way you like. Where you can change everything about it, from adding the odd "function" down to changing the lexical analysis. Assembler built in. (E.g. If you want to use the machine's built in multibyte "MOV"/"MOVEM"/whatever, you can probably do so within a single line of 64 characters. Then you can instantly use it.). All that without leaving "the command line". Where else do you find anything quite as powerful? (And the whole thing in 3 Kbytes of Z80 machine code).

Things against Forth:

• Portable? Not if you do use the assembler, but that's hardly surprising.
• Fast? Not as fast as assembler. In practice, maybe only a factor of ten, though. I know of no other general purpose "interpreter" (for that is, ultimately, what it is) that comes remotely close. Compiled C, in my experience, is typically a factor of two down on assembler, even on and exceptionally good day.
• Intelligible? Not really. Particularly not if RPN gives you headaches.
• Verbose? Hardly. Don't take a contract writing in Forth where you are paid by lines of code written. (Mind you, it's all in WORDS, so maybe by definition it is verbose?)
• Bloated? Not at all. You'll have trouble filling one megabyte of program space, let alone a Gig. That project where you were hoping to get the boss to buy in some 8x8x8 array of quad core processors... you'll have to be content with getting it all to run on a single 8086

Ah, I forgot it was interpreted. Actually this is where Python shines: it has some of the advantages of both worlds. Other languages have moved in this direction as well.

I did put "interpreter" in quotes (see, I've done it again), because there's not a better way to say it. The inner loop of Forth goes like:

Code at label NEXT:

1. Fetch CFA (Code Field Address) held in the cell pointed to by the FORTH IP (Instruction Pointer).
2. Increment the FORTH IP to the following cell.
3. Branch to the fetched CFA.

If the processor could do it, that might all boil down to a single instruction: "JUMP *(IP)+".
A "NOP" would be code that merely jumped back to NEXT.
The "+" word, would just do "ADD (SP)+,(SP)" (if that made sense in the machine in question) before jumping to NEXT.
A literal value would do something like "MOVE (IP)+,-(SP)" before jumping to NEXT. In fact, this is what makes for that "factor of ten" speed. To stack a literal in Forth takes hardly any more time than doing it in machine code anyway, and it takes no more code space. Ditto for lots of stuff. In fact, my "factor of ten" is probably pessimistic, depending on the processor concerned.

And yet I do. Javascript just isn't a productive language for applications. The only real functionality it offers is manipulation of the browser DOMs, some basic math routines, and a primitive array class. Thanks to the free typing, no precompilation error warnings are possible.

Debugging is a pain, as well. If something's wrong in your Javascript, the whole document simply stops processing

The despising comes more from professional irritation at having to write Javascript, and with web apps in general. The whole GET/POST paradigm of structuring applications just doesn't jibe with anything more interactive than a form. Xmlhttprequest is the only way to emulate a traditional application, and it isn't very robust. Application state has to be faked by server sessions or endless baton passing, because a page refresh destroys everything.

It's just silly to me that I spend half of my time trying to fix constantly changing browser issues and tediously debugging in Venkman, the only useful debugger I've seen for JS, and that this is the future of software.

Maybe in another few years I'll be more productive with CSS/XHTML/Javascript development, but for the last year it's been an aching pain.

Google has an API that where you to develop a Java program and instead of compiling to byte code it gets turned into an AJAX app.

But he's talking javascript, something completely different.

Haskell, anyone?

Yeah, I just saw that today. I'll have to give it a whirl. The google page for it makes the exact same complaints I did about web development. Makes me feel better.

dammit they came so close to the perfect computer language but then they had to go and spoil it all by doing something stupid like the .net framework! i hate it oop and basic need to come together but not like that why can't they use vb for the gui and syntax and c++ for the components and as for counting from zero thats just stupid why can't c++ just count from 1 dammit!