Java™

also,
so again, the language is trying to hard to control programmer behaviour rather than giving the programmer the tools necessary to solve problems.

enjoy your side effects faggot

Still shouldn't be forty fucking megabytes

So what exactly is so bad about extreme programming?

Its a meme, really.

Just do it right the first time, holy shit

Nothing.wrong.with.it.extends.at.all

Or something like that. Its probably more verbose that .NET without the nice IDE, but NetBeans seemed like it could be good. I used Eclipse, it was alright.

Perhaps because if you include all the libraries needed for everything gui in the program it grows.

Never understood the OO hate as I would think all programming is fundamentally OO.

All variables are essentially nouns which are essentially objects (albeit of different "classes" - int, char, double, etc).
All nouns relate to each other through the use of verbs (functions).
"OO" takes this to the next logical step by allowing these variable/function clusters to be formed into larger objects/containers for easier handling.

Can someone explain to me what the alternative might be? I'm not defending particular implementations of OO, just the concept. For example, C can essentially do OO, it's just coded differently.

Java is mostly gluecode. Configuring servers and B2B interfaces. Because big business requires compatibility, most libraries are now outdated. If I nowadays want to hack some crap together I use javascript. If it is serious I use C/C++.

youtube.com/watch?v=QM1iUe6IofM
youtube.com/watch?v=IRTfhkiAqPw
youtube.com/watch?v=V6VP-2aIcSc
harmful.cat-v.org/software/OO_programming/_pdf/Pitfalls_of_Object_Oriented_Programming_GCAP_09.pdf

quellish.tumblr.com/post/126712999812/how-on-earth-the-facebook-ios-application-is-so

It's just boring man. And terribly verbose. It's like the new COBOL.

It's like communism. In theory it works. In practice it's a gigantic clusterfuck of broken shit.

And when you point out its failures the proponents say you're just not doing it right.

Most people around here seem to have trouble understanding inheritance trees and polymorphism. They say it's an aberration and composition would probably be better (except when you have to access an object inside an object inside an object inside an object and then System.out.println() starts looking short and concise), but if the language implements inheritance correctly, it should be essentially the same or very close from a performance standpoint.

The proposed alternative is whatever C provides, because C is perfect. This of course means prepending the name of the library to every function because namespaces are bloat, making a different function with the same code inside for each data type that could use a similar operation because polymorphism is bloat but copypasting isn't and making up a different name for each function depending on the input parameters because overloading is bloat and C89 a best.

Namespaces are okay.
Polymorphism is the most intersting feature void*, m8
Overloading is spaghetti shit.

The problem isn't OO, it's that in Javajoke, EVERYTHING is OO; even when it's not needed/desirable.

Personally, I think C still has the best syntax, even if it's lacking problem genericity. The real problem is the standard lib that's stuck in the past (not UTF-8 per default, not using stdint, retarded things like malloc/calloc args differences, etc...).

java runs like ass on sparc. we got a big performance boost after migrating it to linux

not true. big enterprises use java apps almost exclusively

Works until your shit gets disaligned. You must keep the order of variables the same for all structs if you don't want the program to get kill, by hand. Shit's not really practical except for some light use.
I'd rather have a single function identifier than having to memorize different ones just to throw in default parameters or having to transform data before passing it. If anything, it makes code cleaner, easier to read and faster to write, which is the antonym of spaghetti.

People aren't complaining about Java, tho. People here are complaining about OOP in general, because C has no OOP and C is the most perfect language ever made. All its quirks and oddities or even limitations and bugs are features that actually improve the language by making it more "elitist" or something like that (despite C having its fair deal of spaghetti coders as well). Torvalds said it, therefore it must be true.

The people sucking C's virtual dick around here are all professional low level programmers who seem to know C is the best tool for everything despite hating on other jobs such as webdev. I assume because deep down they know C may not be the best tool for string manipulation, so that field may as well not exist, but coincidentially enough, only one or two anons in the board really seem to know their shit about low level programming. Chances are the other low level programmers have actually just made a Fizzbuzz and used some xor swap macro and then thought they were important.

This is actually good. UTF-8 is bloat, Uriel cat-v said it.

...

Cat-v will praise literally anything made by Rob Pike or Ken Thompson, and UTF-8 was made BY BOTH. They probably have a shrine just for that.

everything runs like ass on sparc

true

...

I suggest you look at Linux's code. Shit or not, most data structures uses void*, and everything's fine.
Only faster to write.
Structures with function pointers technically are OO.

Most critics of C (including yours) are about the stdlib, not C itself. We'd really need a language that's just a fixed C/fixed lib. The thing is that the inconvenient of C don't warrant a totally new language with the associated tools. Especially when you can use your-favourite-subset-of-sepples.

You're doing it wrong. You need to read code where it's done correctly.

By light use, I meant "don't expect anything too complex out of this". If Linux does use void* for crazy polymorphism of fairly different structs, like polymorphism allows then they should kill themselves, and said struct isn't being used as a parameter in which the function reads some specific field of the struct (hopefully the first one) then chooses how to interpret the struct according to said field (still spaghetti tier), then they should kill themselves.

No, it is cleaner. I'd rather have one calculate_module() function than calculate_module_coords_3d(float x, float y, float z), calculate_module_coords_2d(float x, float y), calculate_module_vector_3d(vector3 v) and calculate_module_vector_2d(vector2 v).

Not exactly. Had they had a : operator like Lua, I would agree, but right now it's just a function pointer inside a struct.

Sepples is actually good. Maybe too overarching, but it solves many of C's limitations. Honestly, if you don't have a good reason to use C, you may as well use C++, specially if your project is somewhat complex and could need to be extended in the future.

Void* is for genericity, not polymorphism.
Cleaner != more lines
homer's_car.tga
Seriously, C++ has evolved into a monster comparable to Java; I don't want that. I really like the simplicity of C, even if it forces me to reinvent the wheel sometimes.

Who cares, we don't need that overcomplicated shit. HolyC is the way to go.

Fuck you.

How do people this new speak so confidently and incorrectly? Thank you, random CS student, for pointing out how thousands of the best of the best have been doing it wrong for decades.
Polymorphic functions are discouraged in C++ as they encourage code duplication and are difficult to write bindings for. A "coordinate" struct using C-style inheritance is the better way to implement your example. This will make you mad because your (((professor))) told you otherwise and of course they are always correct like Tanenbaum, or you will naively insist that saving three cycles was worth the damage done.
... that's what they are; what do you think lua is doing with tables? It's the same shit plus a hash to pay the dynamic language toll.

Faggot.

Yeah, this mostly.

At least the new bleedin' edge framework of the month isn't as bad as it used to be.

Not that there's anything wrong with it.

Java hate is a meme from kids and neckbeards who couldn't land an actual programming job if they tried.

Sure, it's bloated verbose shit, but it's also where the jobs are.

There are a lot of jobs sucking dicks too but I'd rather not. Java is to get value out of Pajeet and should be below you.

At least those Pajeets can do more than struggle to write fizzbuzz in Python and rice a tiling WM on Arch Linux.

Have you ever seen Pajeet code? It takes a hundred of them to implement fizzbuzz and the result is radioactive.
This is only viable because they can pay each of them less than 1/100th of your salary and Java safely isolates it from the rest of the software.

Mad Pajeet detected.

Why didn't this meme die when dynarec started to take off big in the early '90s?

The only difference between a compiled binary, and bitcode, is that the former runs better on anything other than its native platform, while the latter runs even worse on EVERY platform.

OO sounds like a good simple idea at first but once you get into the weeds and start programming it becomes a huge giant clusterfuck. It's like what said.

...

Like what? Let me guess, some shit-tier meme RMS spit out when chowing down on the 15th quadruple cheeseburger that hour?

Do you have a single fact to back that up or is this just another Holla Forums thing where you don't understand shit and can't do anything but like to virtue signal about your l33t loonux machine RMS himself would make out with?

Okay, so what would be a reasonable amount of memory for that program?

...

lmfao that's just terrible.

t-thanks

Uriel will smite you for this heresy.

>quellish.tumblr.com/post/126712999812/how-on-earth-the-facebook-ios-application-is-so
Jesus Christ.

Well, you were obviously trained in an OO language and never have used anything else. Just because you cannot understand it doesn't mean it doesn't make sense, or isn't in fact better. Not understanding why others are saying what they are saying isn't a logical argument for doubling down on your ignorance. Instead it should be motivation for learning a procedural or functional language and trying to solve coding problems you have previously solved with OO, but now with new tools.

Java is good because it is brown like my poo.

But OO is not the culprit. It's facebook stuffing that much bloat in there. Writing bloat another way would still make it bloat.

You just said a whole lot of nothing..

Right, that's one data point.

Now try beating it with about:blank in any browser and tell us Java is the worst thing out there.

What does the language have anything to do with this? Try about:blank in Dillo/Netsurf.

The lawnmower that's Oracle for you fuckwit -- it doesn't care about security and has incompetent people in charge of it.

And no, not all the security issues are or were only in the browser plugin. Websites running Java server side have been hacked -- repeatedly.

Netsurf 3.5 consumes almost the same as Java, but something this broken doesn't even count as a UI layout engine.

Dillo isn't worthy of consideration until they get rid of their special snowflake HTML-but-fuck-standards parser.

Yeah, it needs at least 16MB RAM, and really needs at least 48.

Compare that to older browsers like iCab 2.x, which could run on less than 1MB.

The problem is you don't get OOP user.

In functional programming you also have objects, but your application is not object ORIENTED.

Let me explain in with an example, let's build and application consisting of two objects A and B, let both of them have a parameter value "what the other thinks of me" and let both have a method "set what I think about the other one".

How would you implement this?

In OOP you would have a class for A and a class for B, maybe a primitive class with the elements that both share, it doesn't matter. You could put a reference to the other one in each so that when you call "set what I think about the other one" it would update that other one. A nice OOP implementation.

Now I tell you that you have a million different objects, that require a million different classes. Or better yet you have an undetermined number of different objects.

Then you panic, you will try to implement some sort of logic in side of each, it will be slow, then you will try to implement a event emitter object and event listener supraclasses, and it will somehow work.

In functional programming this "undetermined number of different objects" it's very simple and straight forward, you just implement an onchange function that updates everything on the state machine. No event listeners, no event emitters.

That's the way I see it, OPP makes sense when you have a few things that can do a lot things,and functional approaches make more sense when you a bunch of things making a few things. That's why big complex programs benefit from having a bit of both.