4 ms·
Byte Buddy is a code generation and manipulation library for Java
- morkalork 1y agoReminds me of a side project I did when first starting CS! The Java byte code specification is absolutely approachable and if you've never looked at it before I recommend it (although this project says you can still use it without that knowledge)
- pjmlp 1y agoNote that Java now has its own API for this purpose. https://openjdk.org/jeps/484 https://openjdk.org/jeps/484
- atomicnumber3 1y agofor those who might be clicking through thinking "since when??", the emphasis is on "now" - this was released in JDK 24. bytebuddy predates it by at least a decade.
- pjmlp 1y agoHence the now on my comment. :)
- brabel 1y agoHow does that compare in terms of usability and completeness?
- cogman10 1y agoIt's complete but low level compared to Byte Buddy. A better comparison is the to ASM (which is what it was meant to replace). https://asm.ow2.io/ https://asm.ow2.io/
- pjmlp 1y agoI have not yet used it, only raising awareness. This came to be, because Oracle noticed everyone, including themselves, were depending on ASM, so the JEP was born.
- cogman10 1y agoYup, the ASM dependency is one that would constantly cause us headaches. A load of frameworks have a path to ASM for one reason or another and it requires an update every time you move up JVM runtimes. It's usually not painful to update (just bump the version) but it's an annoyance. In fact, Byte buddy has a dep on ASM.
- aardvark179 1y agoIt is complete, and I’ve found it extremely usable when writing code to trawl over a large number of class files. Looks like it should be good for code generation as well but I haven’t used that yet.
- zappb 1y agoIdeally, tools like ByteBuddy will adopt that API as it's for low level concerns.
- lbalazscs 1y agoWe are already living in an (almost) ideal world: https://github.com/raphw/byte-buddy/discussions/1798 https://github.com/raphw/byte-buddy/discussions/1798
- kiicia 1y agoWasn’t there already like instrumentation api that was run via premain?
- zappb 1y agoThat is an even lower level API that lets you manipulate the bytecode as a byte array. You still need to parse it to do anything useful, hence libraries like ASM. And if you want to compile more code at runtime (or generate bytecode), you'll need some way to do that.
- cogman10 1y agoIf you are into code generation, another project of interest is Java Poet https://github.com/square/javapoet https://github.com/square/javapoet I've used it to do a mass refactoring of an annotation-based library. Worked pretty great.
- layer8 1y agoShould probably link to https://github.com/palantir/javapoet https://github.com/palantir/javapoet instead, as the Square version has been deprecated since 2020.
- pandemic_region 1y agoPalantir does Java? Jikes !
- deleted 1y ago[deleted]
- ActorNightly 1y agoThe better question is why use Java for anything these days. If you really need to run something with JVM, use Kotlin.
- ackfoobar 1y agoAs a Kotlin enjoyer, I find these comments counterproductive. Maybe they like the lack of extension functions?
- kachapopopow 1y agoKotlin is fatter, compiler is slower, code completion is slow as hell on large projects, but other than building small applications - there's really no reason to not use kotlin except for the fact that you need to actually learn the language or else you're going to end up with very very slow codebase where opening a file and waiting for syntax highlighting takes 2-3 seconds and typing autocomplete is just painfully slow.
- switchbak 1y ago"fatter, compiler is slower, code completion is slow as hell" - if that's all you want out of your programming language, then Java is probably a good choice for you. For others that value the things that Kotlin brings over Java (even modern Java), and for the ways in which it delivers a simpler experience than Scala - I think it's a pragmatic and sensible decision.
- vips7L 1y agoI do like the lack of extension functions. I find them confusing, especially when you can use them on things that are null.
- simon_void 1y agoI wonder if that confusion is due to the fact that you haven't yet wrapped your head around the fact that extension functions are "just" syntactic sugar for static functions. The implicit "this" becomes the the first parameter of the static function and function parameters can be null. Now you might ask "why not use static (/first class) functions then? Because those "feel" like less ideomatic to use then extension functions or methods that are defined on the object (hirachy) itself. But understanding why the extension type can be nullable is not the same is using it on nullable types. I restrict my extension functions to non-nullable types most of the time as well. The best exception to this preference -just to see where it makes sense- is the build-in function [toString](https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/to-string.html https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/to-stri...), since you want it to return "null" if you invoke it on null.
- selimco 1y agoIt seems like micronaut has been able to avoid runtime bytecode generation by doing everything at compile-time. I wonder if there’s things that you can’t do the micronaut way.
- hansvm 1y agoSure: - There are how many computer architectures? A compile-once-run-anywhere binary looks closer to shipping a fancy interpreter with your code than shipping a compiled project. Runtime bytecode generation is one technique for making that fast. - More generally, anything you don't know till runtime generates a huge amount of bloat if you handle it at compile-time. Imagine, e.g., a UI for dragging and dropping ML components to create an architecture. For as much compute as you're about to pour into training, even for very simple problems, it's worth something that looks like a compilation pass to appropriately fuse everything together. You could probably get away with literally shipping a compiler, but bytecode generation is a reasonable solution too. - Some things are literally impossible at compile-time without boxing and other overhead. E.g., once upon a time I made a zero-cost-abstraction library allowing you to specify an ML computational graph using the type system (most useful for problems where you're not just doing giant matmuls all day). It was in a language where mutually recursive generics are lazily generated, so you're able to express arbitrary nth derivatives still in the type system, still with zero overhead. What you can't do though is create a runtime program capable of creating arbitrary derivatives; there must be an upper bound for any finite-sized binary (for sufficiently complex starting functions) -- you could cap it at 2nd derivatives or 10th or whatever, but there would have to be a cap. If you move that to runtime though then you can have your cake and eat it too, less the cost of compiling (i.e., bytecode generation) at runtime. Etc. It's a tradeoff between binary size (which might have to be infinite in the compiled case) and runtime overhead (having to "compile" for each new kind of input you find).
- exabrial 1y agoI think that's noteworthy, but just not necessary. Still really cool if memory usage and startup times are your constraints.
- looperhacks 1y agoI haven't used micronaut specifically, but I remember using Quarkus when it was rather new. It also does a lot at compile-time compared to, say, spring. The one big disadvantage I noticed that it's had to eject if you need to defer something to runtime for some reason. Don't know if it's still an issue, but that's really the only disadvantage I remember