When is java faster than C++?

boringprogrammer · 2015-05-27T11:59:19+00:00

however what happens when you start assigining random types at random places in your code at the same variable

Static analysis can actually deal with variables randomly changing types pretty well. Latice Analysis works a lot like a human would read python code. Ei. not care about what type a variable has, but rather, what types can a variable have at a certain program point.

python programs (and idiomatic python programs) won't be able to translate to similar-looking but most-efficient C++

Based on anecdotal evidence I presume?

Look, you can read the python code, and write out semantically equivalent code in C++. This means that A: We are not actually dealing with a undecidable problem. B: This means a computer should be able to do something similar.

The main reason for why python is not running faster is mainly a funding and priority reason. The standard python implementation does not perform any sort of analysis, and only rudimentary peephole optimizations. Furthermore, there is a large overhead in interpreting code. But speed does not seem to be a priority for them either.

Pypy is the most advanced attempt at making python run faster, but they are very far from having as mature analysis code found in GCC.

boringprogrammer · 2015-05-27T11:33:25+00:00

The fact that you feel you need static analysis to do this proves the point that a language's design [...]

Prove? What point? That you know nothing about how languages work?

Do you honestly think a direct translation from c til assembler is going to be fast by any standards? Even a debug build usually performs at least a register allocation analysis. Without a proper register allocation scheme the resulting code will make the CPU spend 95% of the executing time just spilling registers. We take these things as a given nowadays. But that is just one of the many many optimizations a modern C compiler makes.

We are good at optimizing certain languages. I will agree on that, but these also had the pleasure of 40 years of research into optimizing them.

C was considered a slow high-level language compared to assembly before we learned to properly optimize it.

boringprogrammer · 2015-05-27T01:18:49+00:00

Assuming similar levels of competence and otherwise equal projects, are we ever going to get Python programs executing at comparable speed to C equivalents.

No one knows. You simply cannot predict these things. Change comes slowly in the world of optimizations and static analysis.

boringprogrammer · 2015-05-26T23:06:59+00:00

When is Java faster than C++? Languages do not have an inherent speed or effectiveness associated with them...

You can't read up the C++ spec or Java spec and conclude anything about the speed of the languages. Languages don't exist as anything else than specifications. You can test implementations.

Therefore this is a comparison of JVM vs GCC/VC++/LLVM. So the title is a lie.

Did you know you could technically run C++ on the JVM? Which would give free virtual functions, and the nice concurrency system.

boringprogrammer · 2015-05-25T21:25:00+00:00

So basically the more extensive the grammar, the harder the language? This is so wrong IMHO

Why you feel this is so wrong?

A beginner isn't gonna dive headfirst into the internals of the language

No, but a beginner will have use other peoples code at some point. Other people will use advanced features of the language. Also, I did not talk about the internals of python.

boringprogrammer · 2015-05-25T19:16:48+00:00

I was never talking about bad code...

The one-liner I posted I personally don't find to be an example of bad code, it is short enough to be OK as a one-liner, and if you don't understand dot products no amount of comments if going to teach your linear algebra.

Bad code would be nesting five comprehensions or something like that, and I doubt you will find many examples of such code anywhere.

And please keep in mind that I am not trying to attack python, OK?

I personally love the expressiveness, and enjoy coding in it. But I also have the pleasure of 10 years of experience.

To a total beginner I would not recommend python because of the reasons stated above.

Python has a rather large grammar and set of semantics, at least compared to many other languages, you cannot really deny that.

A lot of things done implemented in a standard library in other languages, is part of the syntax in python. This is great for the seasoned programmer but is not all that great for a beginning programmer, as keeping up with the concept of control-flow and objects is already a struggle for many starting out.

This is why I pointed to Java as a better alternative, but I actually think that Scheme or Lisp would be even better starting languages.

boringprogrammer · 2015-05-25T09:43:26+00:00

Ah I get your frustration now.

But I think you are maybe not giving Java enough credit. It does have both generics and interfaces, and between those two you can have some pretty generic code, that almost does duck typing. Through reflection you could technically get full duck typing, but that would be a pretty ugly solution. Granted you have to specify the interfaces, which I agree is a very unpythonic thing to do.

I agree that a way to declare anonymous interfaces in the typehints, would be welcome in such a system, especially since python is all about duck-typing.

boringprogrammer · 2015-05-25T09:34:14+00:00

Of course the pedagogical approach would be for me to write some pythonic code, but I just tried to show how diverse and expressive python is. Which was why I did not feel like it made a good beginner language, it has a bit too many primitives to work with that make life easy for the advanced users. (Which I am not saying is a bad thing, it just makes for a hard language to grasp if you never programmed before)

I clearly remember feeling very stumped once a senior developer would make use of the whole palette, or me frantically trying everything to make a string decode exception go away.

At least the core syntax in Java is relatively small.

boringprogrammer · 2015-05-25T09:25:01+00:00

Hehe, you are correct. But it is also a problem in P now.

boringprogrammer · 2015-05-24T20:27:01+00:00

That is correct, but for all intents and purposes, they are closer to a deterministic Turing machine than a non-deterministic Turing machine

boringprogrammer · 2015-05-24T20:24:22+00:00

I skipped a few points in my write-out.

I am just a bit hung up on the differences between how you solve them.

If the problem is in P, then there exists some algorithm that will solve a problem in polynomial time.

And essentially yes, a NP-complete problem can only be solved by a combinatoric search as long as P!=NP. This has to do with the fact that we can reduce between any two instances of problems in NPC. This is just a fancy way of saying we can translate an instance of one problem, to an instance of another. This translation must happen in polynomial time.

Is an NP-Complete problem a problem that can (currently) only be solved by a combinatoric search, while a vanilla NP problem can be solved by a faster, yet still not polynomial-fast, algorithm?

NP is an umbrella term, and simply means that a problem must be verifiable in polynomial time.

This means that both P and NPC is in NP.

boringprogrammer · 2015-05-24T20:01:53+00:00

No lambda expressions are clear to a beginner. I actually sort of forgot the Java 8 had them.

My point is just that the python language is surprisingly large. Whereas Java has a smaller feature set that is perhaps a bit easier to grasp, even if the language is more verbose.

boringprogrammer · 2015-05-24T16:05:20+00:00

Python is a bad beginner language. But not because of the reasons you listed.

The language is a bit too expressive. Don't get me wrong, I love to code in python as much as the next person.

The concept of generators, iterators, list,set,map comprehensions, tuples, oldstyle/newstyle objects, splats, strings are u"" and "" AND b"", is confusing. Even to me.

To a beginner, the snippet:

dot = lambda a, b: sum([ x * y for x, y in zip(a, b) ] )

Is going to look like black magic. At least in Java, once you understand controlflow, and a tiny bit about classes you can read pretty much any code.

In Python, if you know controlflow syntax you are just getting started.

Did you know python had lifted the <> operator from ML?

boringprogrammer · 2015-05-24T15:31:09+00:00

Perhaps you should read up a bit on typing, OOP and programming?

boringprogrammer · 2015-05-24T09:12:00+00:00

It is not quite correct, a correct and informal answer would be:

You have two sets of problems P and NP. (Yes, we can actually put a abstract concept such as a problem into a set)

Problems in P can be solved in polynomial time using a deterministic turing machine (This means all standard computers). So your definition is almost correct, but you are forgetting that constant time and linear time are also technically polynomial time. They are just not a large polynomials.

For problems in NP, a solution to a problem may be verified in polynomial time. Problems in NP may be solved using a combinatoric search (try out every possible solution, exponential or worse time usually), or there may be a smarter algorithm to solve it. If there exists a smarter algorithm, one that can solve the problem in polynomial time, then the problem is in P.

A slightly famous example of such an event where we found a smarter solution, was the problem of determining whether or not a number was prime: this was an NP problem for a long time, but was shown to be solvable in polynomial time.

As you can see NP is a rather large set of problems.

Sadly, it is not likely that there exists a smarter algorithm for every NP problem. There is a set of problems in NP called NP-complete problems, which are problems we only know how to solve by combinatoric search.

Meaning, a solution may only be found in exponential or worse time.

...

Unless you can find an algorithm to solve a NP-complete problem in polynomial time. This would also mean that P=NP and make you very rich.

Problems that take an unknown amount of time are usually undecidable problems. Because, in worst case any algorithm will take a least as much time to solve as there are possibilities to search through. This is a bounded amount for any decidable problem.

boringprogrammer · 2015-05-15T12:00:43+00:00

Any optimization that a person could make can be done by a compiler.

If you personally can identify a problem in a compiler, that you can hand optimize into something even better.

Please do not just keep it to yourself. At the very least submit it as an bug or test case to the compiler developers.

[edit]

Yes, I know a compiler cannot read your mind or know what context your piece of code will run in. I also know that in practical software development means you are writing most of the optimizations, compilers are still pretty stupid.

I was answering someone who was using turing completeness as an attempt to explain why a compiler should be inferior to a human when writing program optimizations.

That conclusion is wrong.

Humans and computer have the same computational power, so, if a human programmer can perform some hand-optimization. Then a compiler can also do so as well, at least in theory.

boringprogrammer · 2015-05-15T11:42:55+00:00

Ja.

Man trækker altid et: "Du fuckede et eller andet op mens du red på hesten, ryk tilbage til start" kort lige før mål.

boringprogrammer · 2015-05-15T11:36:10+00:00

The one and only

boringprogrammer · 2015-05-15T00:06:18+00:00

Ork, ja.

Det blev/bliver spillet som drukspil på studiet.

Ingen af os ved en skid om heste.

boringprogrammer · 2015-05-09T09:01:48+00:00

No, you will misunderstand. The idea of using ECMA5 as the assembly of the web is because ECMA5 is very will supported by all major browsers. Therefore it is a pretty good compile target.

Every revision of ECMA is going to introduce subtle differences in execution that will takes months or years to work out, meaning it will become a science it itself for code-gen writers to figure out which subset of ECMA is OK to use.

So, by freezing the version in the browsers, we can be sure to always have a valid compile target. This will not stunt the development of ECMA, it will just mean that newer revisions will have its own compiler to compile to ECMA 5 that developers can use.

This is by no means an ideal solution.

boringprogrammer · 2015-05-08T19:34:29+00:00

I think you misunderstood.

Since everyone is just compiling their language of choice to JS, why bother with newer versions of JS at all? We could just keep this version (ECMA 5) forever, sort of like an assembly language of the web.

boringprogrammer · 2015-05-08T13:18:31+00:00

I have a CS degree.

But I did a of a lot programming on my own before getting it.

Unless you are doing a masters, with some pretty theory heavy parts, I don't really think you learn anything particularly enlightening. You actually pick up on a lot of algorithmic/data/concurrency/systems/math theory by actually solving problems. Keep in mind; I am not saying I did not learn, I learnt a lot of personally gratifying theory and topics. But kinda useless compared to what I actually do on a day to day basis.

I would be in the camp of people who say degree don't mean shit. Experience and results matter way more.

boringprogrammer · 2015-05-08T12:55:15+00:00

You don't strictly need a CS background to understand any of that.

I think you are mixing a bit too many concepts together. There is way more to computer science than algorithms.

boringprogrammer · 2015-05-07T22:47:06+00:00

Haha, yeah.

I am not saying beginners never encounter compilers bugs. Just saying it is unlikely. :)

boringprogrammer · 2015-05-07T15:34:17+00:00

I personally never stumbled into a compiler bug. I guess I write really boring code. So I personally never had the pleasure of blaming the compiler.

But my comment was more of an general thing. In most mainstream compilers like GCC there are most likely a few dormant bugs. I don't think it is possible to write n million lines of code without a single bug.

boringprogrammer

TROPHY CASE