What went so right?

>>58788623
Java is good.
Scala is better IMO

HACK is better, my friends. Deal, or feel.

>>58788623
Java immensely slowed down the progress of programming language evolution because it propagated its shitty OOP model.
It's a horrible and verbose language that only became somewhat usable after Java 7.

>>58789996
Java 8 has lambdas though.
If you want something purely functional use closure.

Personally I am in love with Scala.

>>58790009
Sorry I meant Java 8 when I said 7.

Compatibility with a wide range of devices and architectures, the acceptance of a lot of boilerplate binaries, and iterative improvements to the language without sacrifice of backward compatability. This, and a huge community support, which provides a large number of libraries for practical applications.

>>58788623
Pretty much everything, except from metaprogramming facilities, the OOP hype and some convenience issues.

>>58788623
it just werks

>>58788623
CLR is better than JVM. Mostly because CLR team saw what few design errors the JVM team had made and then corrected them.

>>58788623

CIA niggers code monkey breeding farm

>>58791554
Actually, they repeated a handful of them. String support, just to name one.

And there are faster JVM implementations on the market.

>import in.techexpert.curry.pajeet

>>58791684
Enjoy no value types, tailcall optimization or proper generics.

Write once run everywhere (if the system running it supports the functionality you are trying to perform).

No pointers. Not needed.

And ofc OOP > functional

>>58791831
>Enjoy no value types, tailcall optimization or proper generics.
Doesn't matter. The only thing that really bothers me - generics - can be easily circumvented with better JVM languages.

>>58788623
Beautiful and easy to learn syntax. No pass by reference vs. value confusion like in C++; everything is pass by value. OOP enforced. Good standard library. Powerful Collections. Strong-, strict-typed and compiled so unlike meme languages the performance is actually decent.

Java is probably the greatest non-functional language in the world.

>>58792119
>everything is pass by value
>a good thing
lmao

>>58792119
>>58792128
wtf are you guys talking about. Only primitive values get passed by value in Java.

>>58792143
I know that, but I just implied that always passing by value isn't a good thing.
Imagine if objects were passed by value.

>>58792143
>hurr durr objects are passed by reference
No, the objects themselves are references and you're passing those references by value.
You can't modify the contents of the variable you pass to the function.

>>58792163
Yes so objects are passed by reference.

>>58792143
>Only primitive values get passed by value in Java.

Not sure if troll or just really stupid.

One of the most popular features of Java is that everything is pass by value. When you declare an object, the variable that is assigned the object is actually a pointer. So when you "pass an object" as a parameter, you're actually passing the pointer by value.

>But anon isn't that pass by reference?

No it's not. Learn C++ to know the difference between passing pointers and passing references.

Git gud.

>>58792179

String str = "foo";
String old = str;

somefunction(str);

if (str != old) {
    System.out.print("This is guaranteed to never be printed.")
}

You cannot create somefunction(String s) that changes the value of str.

File: Java.jpg (23KB, 722x217px) Image search: [Google]

23KB, 722x217px

>>58788623
Nothing. lava™ is the best OOP lang.

>>58792233
Everything*
Fuck, I'm too used to seeing "what went wrong" threads.

File: 1480366367647.jpg (334KB, 1161x869px) Image search: [Google]

334KB, 1161x869px

>>58792207
>being this retarded

>>58792307
He's right, though, by reference means keeping it a reference until dereferencing.

Performance is shit though. From Sandra benchmarks I did, Java performs about 60% slower then native code. I don't understand where this "java is fast" meme comes from.

>>58792245
>gets proven wrong

"H-he's the retard for knowing the right thing."

Why is it popular to hate on Java? It's almost like X language is 10<X years old ergo it's shit

>>58792560
It's 3x-10x faster than other popular meme languages like JS, Python, Ruby. Obviously it's not as fast as C/C++ but that's the price you pay for not having to deal with an insane language.

Also 60% slower than C++ is really fucking fast. Python/JS/Ruby are probably 500% slower than native code.

>>58792601
>but that's the price you pay for not having to deal with an insane language.
Actually, that's rather the price you pay for unnecessary pointer hopping
>I did
and doing benchmarks wrong, as to be expected of a ne/g/gbeard.

>>58792217
You can't have a meaningful discussion about pass-by-value vs pass-by-reference with someone who doesn't know C/C++. Everything is just magic to them. But yes for the record Java is always pass by value. If you get asked that question in an interview like I have and you answer with "only primitives are pass-by-value" then it's over for you.

>>58792630
60% slower means that if C++ code takes 1 second then 60% slower code would take 1.6 seconds and 500% slower code would take 6 seconds.

I think 500% is a reasonable assumption for JS desu. I just finished porting something computationally heavy from JS to C++ and I really do see a 5x difference.

>>58788623
massive shilling and deals

>>58792691
>60% slower means that if C++ code takes 1 second then 60% slower code would take 1.6 seconds and 500% slower code would take 6 seconds.
Not my point. My point was that you hopefully picked a good Java AOT compiler for the benchmark or at least waited quite some time for the warmup phase of the JIT compiler in which you run all the code paths at least 5 times or so.
Also, you could have a sane language that is faster than C/C++.

>>58792207
How can you be so fucking stupid.

>>58792601
>It's 3x-10x faster than other popular meme languages like JS, Python, Ruby.
Oh come on you could do better. I don't know about Python and Ruby but JS has some pretty fast just-in-time compilers like V8 and Mozilla's JIT is pretty good too. That's how node.js got popular.

>>58792735
I used Sandra™ written by elite pajeets from Sis-Software. It uses default oracle java.

>>58792735
>you could have a sane language that is faster than C/C++
inb4 Rust

>JS has some pretty fast just-in-time compilers like V8 and Mozilla's JIT is pretty good too

Tbf JS runs fast enough for whatever purposes people use JS for anyways. But it's really fucking slow for purposes that require heavy computation. Node.js got popular because it's Fisher-Price async for people who know nothing about writing async. You write regular procedural code and it just werks. No good company uses Node.js, because good companies hire good developers who know a thing or two about writing non-blocking code in other languages.

>>58792761
>>58792307
Stop samefagging and start learning what "pass by reference" means. It doesn't mean "pass the reference".

>>58792871
Probably fair enough, since most people/corporations/rocks will use that.

>>58792764
>but JS has some pretty fast just-in-time compilers like V8 and Mozilla's JIT is pretty good too.
It's good in cherry-picked scenarios, anon. Like simple arithmetics and calling browser APIs.
>That's how node.js got popular.
Actually Node got popular by spewing the event loop meme to PHPajeets who wanted concurrency but not the real thing.

>>58788623
Java is like living with your mom, extremely comfy but deep down you feel like a worthless piece of shit.

>>58792942
>Rust
Among others, but unless you mean 'safer', I don't count it as much better because there is still too much usability cancer in there.
Perhaps Zig is an actual better C/C++lite, but I doubt it will ever be ready.

>>58793034
How is RUST?

>>58792207
you are full of shit

>>58792637
>Passing object references is pass-by-value because the value of the reference is passed
Not sure if trolling or fucking retarded.

>>58788623
The majority if not all of /g/, just agrees to this because it is the only language they learned in Uni

Prove me wrong

>>58788623
I really like java but there are some things that really are tedious. most severe:
>no low level control. need to use hacky solution to access unsafe and to get any control
>official api is generally just annoying
>jni slow as fuck because it needs to hold hands for you

>>58793214
>>58792761
>>58792637
>>58792307
Samefag pls go. I can't imagine encountering more than 1 person in a day who doesn't know that Java is always pass-by-value. That's literally chapter 1, page 1 of any decent Java book/tutorial.

>not knowing the difference between pointers and references

Anyways all it takes is one Google search to discover that you aren't as smart as you think you are.

http://stackoverflow.com/questions/40480/is-java-pass-by-reference-or-pass-by-value

If you still don't believe me, see >>58792217

Also try printing an object instance that doesn't have a toString method. You'll literally see the memory address. That's because it's printing the pointer value. You're passing around pointers. A pointer is not a reference. "Pass-by-reference" means passing the reference, not the pointer. Passing the reference basically means extending the scope of the object. That's not the same thing as passing the pointer but if you would know if you weren't a retarded codemonkey who watched a few Udacity videos and started calling himself a "programmer".

>>58793257
Easy to learn easy to read language. Great for learning to program
Anon is right

>>58793390
That would be C, C++ and python. Java is the most difficult language and has a terrible design. You have to be an idiot to think it's good.

>>58793536
You must be legit retarded if you think Java is hard

One reason, ONE reason this shit language is a success:
LINES
OF
CODE.

That shit metric of "work" is the reason Java still exists.
CEOs thinking MORE LINES means more work and is better.
Java is one of the most fucking verbose, line-heavy pieces of shit around.

The whole "b-b-but muh universal code!" excuse is the worst.
You can cross-compile EASILY and run much faster than Java can. (especially if it uses any even remotely advanced graphics)
This always makes me laugh when people say that about Minecraft. Minecraft is fucking trash at running. Compare Minetest and Minecraft and you can see how laughable Java is.

Fuck Java. Fuck it in its face.
Fuck C++ too. It's an even bigger mess.
C plus your own OOP is literally better than anything C++ can offer you. C++ is committee run amok.
There's entire sections of C++ banned in some companies because it is problematic at best and downright destructive and incompatible WITH ITSELF.
These aren't even my words. They are the words of a person that has used C++ its entire life and hates it. (only does it because money)

File: 1470577022310.jpg (190KB, 2048x1536px) Image search: [Google]

190KB, 2048x1536px

>>58793639
>I can fizzbuzz in c

>>58793667
fuck you on about spergfence

>>58792207
>>58792761
>>58793194

Relax, that's some obvious pajeet grammar.

Just for clarification, that pajeet is full of shit. Java passes objects by reference, not by value. In fact it's one of the major downsides of OOP, that you throw around references to objects, non of which are private, and what kind of defeats the mantra that "objects communicate through messages".

>>58793633
It's harder than C languages

>>58793874
Tbqhwu Anon
They all are the same to me

>>58793332
I like how you don't realize that you're talking "java definition" while everyone else is talking "common sense".

>>58788623

Scala and Clojure

>>58790009

I'm drinking the scala koolaid myself. Starting to get used to fs2, shit's fucking mindbending at times

>>58793639
>Fuck C++ too. It's an even bigger mess.
>C plus your own OOP is literally better than anything C++ can offer you. C++ is committee run amok.

It is pretty ironic that you complain about LOC and then go on and say that implementing OOP in C is a good idea.

I've done OOP in C before and 3/4 of the LOC was just dedicated to bullshit that is already built into C++

>>58793332
Could you please explain the difference between a pointer and a reference then?

>>58794276
I like how you don't realize that you're an idiot. By the Java definition it's actually passing a reference. What the Pajeets at Sun call references are actually pointers. You're passing around pointers as values. If you call passing pointers "pass-by-reference" then you should off yourself.

>>58795007
what else do you think pass by reference is?
you do realize that on a hardware level, there is no pass by reference? only pass by value
so what you do is pass a reference by value(of that reference)

and that's what everyone calls pass by reference in C/C++

>>58795007

In the burning heap of garbage that is C++ you have both references and pointers. I decided to not bother with the language after finding out, but I assume that's where much of the confusion stems from

>>58795007
I agree that java is pass by value. But in java, you don't really get to do too much with the "references" that are passed. Pretty much everything that you do with that value that's passed in is modifying the object it's referring to.

>>58793639
Meanwhile big data and big processing is strongly Java again. Must be the force of bosses counting lines of code, huh.

>>58795078
references in C++ are similiar to pointers, with some key differences:
from wikipedia:
It is not possible to refer directly to a reference object after it is defined; any occurrence of its name refers directly to the object it references[i. e. you can't access the reference itself. You can print the value of a pointer, but not that of a reference.].
Once a reference is created, it cannot be later made to reference another object; it cannot be reseated. This is often done with pointers.
References cannot be null, whereas pointers can; every reference refers to some object, although it may or may not be valid. Note that for this reason, containers of references are not allowed.
References cannot be uninitialized. Because it is impossible to reinitialize a reference, they must be initialized as soon as they are created. In particular, local and global variables must be initialized where they are defined, and references which are data members of class instances must be initialized in the initializer list of the class's constructor.

>>58795003
Not him but I'm gonna use Microsoft's explanation:

https://msdn.microsoft.com/en-us/library/14akc2c7.aspx
> Do not confuse the concept of passing by reference with the concept of reference types. The two concepts are not the same. A method parameter can be modified by ref regardless of whether it is a value type or a reference type.

From what I'm understanding from this discussion, this is something you can't do in Java. Everything is always passed around by value, even reference types, it's just that reference types' value is a memory address, you're still passing around it's value though.

>>58793332
>>58792974
as you can tell from the volume of replies, there is no samefagging going on, the majority simply disagrees with you.

>>58795078
References are just pointers that can't be changed essentially.
They don't really exist like pointers do, they're more of a language construct that gets compiled away.

>>58790015
This post was brought to you by Oracle Corporation.

Nobody care what languages defines what as a reference or not you fucking turboautists.

Pass-by-reference: Whatever is passed to the called function can be modified in the context of the calling function
Pass-by-value: Whatever is passed to the called function can not be modified in the context of the calling function

File: pajeet_tier_fibonacci.png (21KB, 606x354px) Image search: [Google]

21KB, 606x354px

>>58788623
not the design patterns or language syntax, that's for sure.

JVM meant write-once run-anywhere, which made is massively popular for most developers until better cross-compiling came around.

>>58792217
You're right because string operations always return a pointer to a new string in a special string memory pool.

Now try passing in a stringbuilder and come back to me faggot.

>>58792560
Java is compiled into native code dipshit what are you on about?
Do they not teach you kids the difference between AOT and JIT compilation?

>>58795201
but that's what everyone does ever, as i already explained in >>58795071
references are just pointers, and call by reference simply passes the value of a pointer. it might not look like a pointer in your code(it might be a reference or something else) but in the resulting assembly it certainly is.

>>58792119
>No pass by reference vs. value confusion like in C++; everything is pass by value
It's not even that confusing though
>OOP enforced
That's not a good thing, I'd rather my language be multiparadigm

>>58795367

StringBuilder sb = new StringBuilder();
StringBuilder old = sb;

somefunction(sb);

if (sb != old) {
System.out.print("This is guaranteed to never be printed.");
}

You cannot create somefunction(StringBuilder s) that changes the value of sb.

You're a bit dim aren't you?

>>58795293
Cross compiling hasn't changed anything really. Java only gained ground (on mobile personal computers, in the cloud / big data and big processing, on complex websites). And more and more languages do JIT on something intermediate.

>>58792764
https://benchmarksgame.alioth.debian.org/u64q/javascript.html

>>58795325
>>58795386
Fucking hell.

>>58795386
I believe you are. While the reference is the same, the state of the passed StringBuilder can be different. Which is called "call-by-reference".

>Not using Ceylon
I'm enjoying my union types desu

>>58793269
You do know Java has reflection and shit. You shouldn't be using sun.misc.unsafe anymore.

>>58795414
Changing the value of the variable outside of the function is what pass-by-reference allows you to do.
Java can't do that. Java doesn't have pass-by-reference.

Further reading material:
>>58795201
>>58793332

>>58795464
>Changing the value of the variable outside of the function is what pass-by-reference allows you to do.
No, that is not what call-by-reference is. You should probably go educate yourself.

>>58795490
Why don't you tell me what it is then.

>>58792586
Lisp is literally older than humanity and /g/ loves it though.

>>58795496
Serialize the StringBuilder before the call of "somefunction" and after the call. If the result can be in any way different then it's call-by-reference.

>>58795386
The fuck are you even doing?

.eqauls() dipshit

>>58795071
>>58795078
>>58795214
>>58795258
>>58795003


There are some pretty important differences with how pointers and references can be used in a language. To say that they're the same thing indicates that there are huge gaps in your programming knowledge and I'd rather hire a Pajeet straight outta IIT than you folks.

You can think of a reference as an extension of the scope of an object. When you pass the reference of object A, the receiving function can manipulate object A as if it was originally declared within its own scope. You can't do that at all in Java for obvious safety reasons, but you can in C++.

Educate yourself cucks, before you start shitposting about Trump sending back Pajeets:
>>58792217
>>58792377
Stackoverflow link at >>58793332
>>58795190
>>58795201

>>58795464
Are you mentally ill?

StringBuilder is the only mutable string and can very easily be mutated by a function.

>>58795441
I dont see how reflection let you do all the low level stuff that unsafe let you do. unsafe is as fast as it gets and I will keep using it until it gets removed or replaced.

>>58788623
java is ass and 100% not needed for anything but old farts and pajeets job security

>>58795536
>tfw you share a board with this retard

>>58795549
Equals can be any arbitrary comparison. == compares values, which are in this case object references

>>58795574
You can mutate the contents of the object pointed to by sb, you can't change the object sb points to.

>>58795513
/g/ likes primarily languages that were almost not successfully used or mainly on projects you don't need or want to do again.

>>58795570

I'd accept references in C++ if it wasn't for the fact that regular old pointers still sometimes leak through. It's not that we cannot understand how they work..

>>58795570
You're wrong anyhow since unsafe allows you to mutate the reference from a function.

>>58795612

The only worthwhile text editor out there is written in lisp :^)

>>58795570

void somefunction(SomeObject o)
{
   o.AddOneToNumber();
}
// ...
SomeObject a = new SomeObject(5);
somefunction(a);
if (a.GetNumber() == 5) {
    System.out.print("This is guaranteed to never be printed.")
}

Oh look, a changed! I thought that was not possible in Java for "obvious safety reasons"?
Or maybe you're a fucking retard who doesn't understand the concept of "call-by-reference".

>>58795691
Try calling a.toString() before and after that function call and then tell me if it changed.
Don't override toString() with your own implementation.

>>58795691
a is still the same object, you didn't change the value of a.
What you did change is the value of a.someFieldThatIsHoldingTheNumber

>>58795741
>>58795774
Of course the reference to the object is still the same. This has absolutely nothing to do with call-by-reference though so I am not sure why you bother to mention it.

>>58795570
OK fair enough.

Yes you can't share and mutate call stack variables, but given that +95% of the JVMs memory is dedicated to heap space, the strict adherence to the definition of "pass by value" is retarded.

>>58795691
Not him but in that example, what you're passing to someFunction() is "a"'s value, which is the memory address of an object since "a" is a pointer. There is no way to pass a reference like you can in C, C++, C#, etc.

>>58795837
When you pass a pointer in C/C++/C# you're also just passing the value of the pointer.

>>58795804

#include <iostream>

int somefunction(int &a) {
    a = 3;
}

int main()
{
  int n = 5;
  std::cout << n << std::endl; // prints 5
  if (n == 5) {
      std::cout << "n is indeed 5" << std::endl; // this is executed
  }
  
  somefunction(n);
  
  std::cout << n << std::endl; // prints 3
  if (n == 3) {
      std::cout << "n is indeed 3" << std::endl; // this is also executed
  }
}

Come back to me when you write an equivalent program in Java.

>>58795883
Not possible, because it's impossible to pass primitive types by-reference in Java. Try doing the same in C++ with any type that doesn't happen to be convered by that bullshit rule Java made up.

File: 1485391526701.jpg (6KB, 229x220px) Image search: [Google]

6KB, 229x220px

>it's c# but shittier

>>58795883
see >>58795258
This has nothing to do with the call-by-reference concept. Both >>58795883 and >>58795691 are call-by-reference.

>>58795883
Let me get this straight: You're saying that this:

void f(int *i) { *i = 7; }

int i = 2;
f(&i);
// By the way, i is still the same memory address here.

is not call-by-reference?

>>58795872
You usually do, but if you want to you can pass a reference to the pointer. From my previous link:

>You can also use the ref keyword to pass reference types. Passing a reference type by reference enables the called method to replace the object in the calling method to which the reference parameter refers. The storage location of the object is passed to the method as the value of the reference parameter. If you change the value in the storage location of the parameter (to point to a new object), you also change the storage location to which the caller refers. The following example passes an instance of a reference type as a ref parameter.

I can't post the example because the post would be too long but it's here:
https://msdn.microsoft.com/en-us/library/14akc2c7.aspx
It's the "RefExample2".

Can't do that in Java since everything is always passed by value. Interesting discussion by the way.

>>58795991
not him, but what you posted is call by reference
but
int* p = &i
f(p)
is not
although i think that, while technically correct, it's pedantic and misleading

>>58788623
Is Codeacademy a viable way of learning a language such as Java? I want to get into programming, but I don't know where to start. I was thinking Codeacademy and maybe even buying a premium membership if it isn't too expensive if it's worth the money.

>>58795991
Correct. You're passing the the value of the pointer.

>>58795953
>This has nothing to do with the call-by-reference concept
This is exactly what call-by-reference means. Did you even fucking try to look it up? Multiple people posted links explaining what it is.

>>58796086
So what is happening here? >>58795691

>>58796086
>This is exactly what call-by-reference means.
All textbooks since the 70s disagree with you then.

>>58796098
He's passing the value of the "pointer" to object a. He can use that pointer to mutate the object.
However, he can't mutate the pointer.

If that was C++ you could add & in front of the name of the argument and 'a' would assume whatever value you assign to 'o', i.e. you could mutate the pointer.

>>58796113
There are links in this thread that agree with me. Can you link me to a textbook that doesn't?

>>58796134
>However, he can't mutate the pointer.
You can't mutate the pointer in the C code either.

File: 1457808800448.png (28KB, 470x241px) Image search: [Google]

28KB, 470x241px

>>58795937

>>58796145

int firstnumber = 1;
int secondnumber = 2;
int *firstpointer = &firstnumber;
int *secondpointer = &secondnumber;

void somefunction(int *&a) {
    a = secondpointer;
}

int main()
{
    int *mypointer = firstpointer;

    printf("%d\n", *mypointer); // prints 1

    somefunction(mypointer);

    printf("%d\n", *mypointer); // prints 2
}

Then why doesn't this print 1 both times?

>>58796343
Because you didn't write this in C.

>>58796156
>implying c# is inferior to J*va

>>58796060
>>58796086
>>58796098
>>58796113
>>58796134
>>58796145
>>58796343
>>58796365
You are NOT fucking getting it, why do I have to keep explaining this to you idiots?
SIXTY WORDS
SIXTY PING-PONG BALLS

>>58796398
Thanks for correcting the record, Micros**t

and so another java thread entirely derailed because someone wanted to advertise the fact that they read http://javadude.com/articles/passbyvalue.htm but disguise it as if the pedantic distinction they are making is common knowledge rather than just knowledge shared between everyone who has read the article

File: average java fanboi.jpg (6KB, 219x230px) Image search: [Google]

6KB, 219x230px

>>58796538
>javacucks

>>58792119
>Java is probably the greatest dysfunctional language in the world.

>>58788623
India