7 ms·
How Many Type Parameters Can a Java Method Have?
- cobbzilla 7y agoA fun short article, but if you’re too lazy to read, the summary answer is “way more than you will ever need.”
- RobertDeNiro 7y agoOr if you need that much, your design is severely broken
- blattimwind 7y agohttps://github.com/groovy/groovy-core/blob/master/src/main/org/codehaus/groovy/runtime/ArrayUtil.java https://github.com/groovy/groovy-core/blob/master/src/main/o...
- cobbzilla 7y agoWow -- that is some ugly code. Why couldn't they use a single varargs method declaration? Does this code need to support older Java versions that lack varargs support?
- lokedhs 7y agoIt may be a performance hack. Varargs results in an array being allocated. I've seen this trick in the past, but they usually stopped at a handful of arguments and let the rest be handled by varargs.
- usrusr 7y agoGroovy is chock-full of absurd little microoptimizations that will forever fail to make even the tiniest dent in the general overhead relative to java. For several years there was even an "assume equality of hashes match" shortcut hidden in certain set operation code paths.
- zmmmmm 7y agoWhen compiled statically groovy has almost zero overhead relative to Java. I appreciate how much effort they have made to keep the overhead low and reduce the bloat as much as they can.
- Someone 7y agoRead the code comments. ”The purpose is the reduction of the size of the bytecode.”
- kccqzy 7y agoYou can quite clearly see, though, how many arguments GitHub's code highlighter thinks a Java method should have.
- Rebelgecko 7y agoAn auspicious and possibly immature number
- mattcoles 7y ago70?
- vorg 7y agoThe Java methods with up to 70 arguments are highlighted. This code defines methods with up to 250 arguments. I wonder why the Apache Groovy people didn't choose a number like 256, which is more compatible with other magic numbers in the JVM.
- g105b 7y agoThe article will make Uncle Bob shudder.
- michaelcampbell 7y agoHe can assuage himself with more tests.
- chii 7y agoi wonder if it's possible to generate type parameters such that computation is done with it at compile time?
- ygra 7y agohttps://arxiv.org/abs/1605.05274 https://arxiv.org/abs/1605.05274 perhaps?
- OskarS 7y agoTheoretically, sure: https://arxiv.org/pdf/1605.05274.pdf https://arxiv.org/pdf/1605.05274.pdf
- JadeNB 7y agoI think it's a good idea to link to abstracts https://arxiv.org/abs/1605.05274 https://arxiv.org/abs/1605.05274 (as ygra does (https://news.ycombinator.com/item?id=19777896 https://news.ycombinator.com/item?id=19777896 )) rather than directly to PDFs.
- saagarjha 7y agoJava’s generics are Turing complete, though I don’t think anyone has written a useful program in them yet: https://arxiv.org/pdf/1605.05274.pdf https://arxiv.org/pdf/1605.05274.pdf
- erdeszt 7y agoThere's a Prolog in your Scala: https://www.youtube.com/watch?v=iYCR2wzfdUs https://www.youtube.com/watch?v=iYCR2wzfdUs It does compile time computations using generics + implicits
- deathwarmedover 7y agoI wonder if it would be feasible to scan, say, GitHub or Apache projects to find the highest parameter count in the wild?
- saagarjha 7y agoFrom the other news on the front page, scanning the former should now give you the latter as well :)
- aiCeivi9 7y agoI can bet it will be Spring. It was always in Top 3 for thing like: - longest method name - longest class name - deepest inheritance tree
- peeters 7y agoDoubtful. I'd guess it's a general utility library like Guava, where they're doing something with heterogeneous type "vararg" methods. Often they'll have a number of overloads to give the most type help, before reverting to less helpful vararg types. Anything that's heterogeneous, with dynamic arity to the library but known static types to the caller would be a good candidate. Like NTuple type implementations.
- erdeszt 7y agoDo you mean type parameters or regular parameters? If it's the former(and Scala is allowed) then I think Rho's Result type is a pretty good bet with it's ~60 type arguments: https://github.com/http4s/rho/blob/989db04e6dd828518770a42fdbb17f4d4d7d3643/core/src/main/scala/org/http4s/rho/Result.scala#L9 https://github.com/http4s/rho/blob/989db04e6dd828518770a42fd...
- leibnitz27 7y agoOne little thing - the string that's running out of space here is the signature of the interface, not the signature of the method. You could use that fact together with method scoped type parameters to get a few more, if it weren't for the fact the descriptor would blow up too soon already. Since it's not mentioned in the article - the signature of a method is the description containing generic information. The descriptor is the erased signature, which, because A strips to Ljava/lang/Object; will likely be a fair bit longer. An aside - you can (mostly) still get away with corrupting signatures, if you want to obfuscate code. (eg https://github.com/ItzSomebody/StopDecompilingMyJava/blob/master/decompiler-tool-bugs/Entry-005/Entry.md https://github.com/ItzSomebody/StopDecompilingMyJava/blob/ma... ) (yes, I used to blow up on one of these in https://www.benf.org/other/cfr https://www.benf.org/other/cfr - (my java decompiler), but it's all good now).
- hyperpape 7y agoThanks for that. I confess I got a bit lazy about checking which string was at issue--I'll try to do an update when I get home, if I can make time.
- jnty 7y agoI wonder how many other articles could do with a conclusion entitled "None of This Matters"?!
- jmkni 7y agoTempted to make that my email signature.
- LoSboccacc 7y agothis reminds me of that one table with more than 255 columns which hibernate converted into a class that could not be compiled since the constructor had too many parameters. we split it up using the component mapping to realize some of these column as if they were composition. the early '00 were a lawless wasteland.
- LanceH 7y agoIf you were using Hibernate in 2000 and not caught up in the EJB hype, you were ahead of the game.
- LoSboccacc 7y agomaybe because I was fresh out of academia then but neither xml defined behavior nor the ejb looked like something that really removed work, moreover I've always been biased against things I can't put a break-point and debug in the event of having issues (which is also why I skipped on angular, for example).
- maaaats 7y agoAh, reminds me of something I had to do only two years ago. Business side would send an excel file with thousands of lines and some columns with some definitions. These we would export to csv and turn into a huge enum using some generator. One definition per line in the excel document, on the form Rule67_Oslo(245, 167, NO_TRANSFER). One day it failed, as the byte count was too big. Managed to strip down the definitions some, but a few weeks later it was impossible to add new rules again. No idea why someone would make that design in the first place, old legacy system. But it was hard to refactor as well, as those constants were littered everywhere in the code as well. I switched teams before it was solved, but I think the fix was mainly that business had to find one rule to remove every time they wanted to add a new one..
- smcl 7y agoI tried this with the F# mono REPL - it eventually failed after creating a let binding with 1328 params: http://blog.mclemon.io/f-number-polymorphic-parameter-overflow http://blog.mclemon.io/f-number-polymorphic-parameter-overfl...
- sebazzz 7y agoI imagine that the limit on the .NET CLR is even lower because there needs to be runtime support for type parameters all the way down to the JIT.
- reifiedgent 7y agoI modified the python script to generate C# and it compiled with 131072 type parameters. It did take 9 minutes though so I didn't continue after that.
- int_19h 7y agoIn theory, the maximum encodable compressed unsigned integer, as used by GenParamCount in MSIL, is 0x1FFFFFFF.
- tauwauwau 7y agoGoing to leave it here Inside the Java Virtual Machine by Bill Venners https://www.artima.com/insidejvm/ed2/ https://www.artima.com/insidejvm/ed2/
- s_k_ 7y agoIs it still relevant? If you've read it, what's your review in one sentence (or not just in one if you wish :D)?
- tauwauwau 7y agoI read it a few years ago, when I wanted to know how many methods can there be in a Java class. (count: 2 bytes, but compiler fails to compile such a class a long before that). Many of the concepts such as structure of class files should still be relevant (fact that all classes start with hex code CAFEBABE etc). Garbage collection, security should be more or less relevant.
- Aweorih 7y ago> Nonetheless, if I was king, I'd consider explicitly banning any class or method from having more than 255 type parameters. As he says there is probably no use case where you need so many and the additional overhead of time to implement this is (in my eyes) a bit wasted. But he can be actually the king by contributing to the openJDK project.
- twoodfin 7y agoI think it's pretty cool that the result emerges, as the author points out, not from the implementation details of any particular JVM, but from well-defined parts of the Java specs intersecting in a fully determined way.