3 ms·

how many times did you have to build a java or javascript project where you are counting kilobytes, or are pre-generating data tables for maximum efficiency whi

how many times did you have to build a java or javascript project where you are counting kilobytes, or are pre-generating data tables for maximum efficiency which you want to be configurable as a build option because you're going to need different tables for different hardware/target ? people with this sort of problem just aren't even considering using java or javascript so of course in C++ we end up with a hairier solution. A lot could be solved if there was good compile-time reflection for sure but still. An example: the main software I work on, along with a few other software I know, has to generate a SDK as part of its build so that people can build plug-ins for it. How often do you have to do this in java or JS ? almost never. But this requirement implies having a build system powerful enough to do that. Another example: another software I work on must produce a Max/MSP package ; this implies: - working with multiple versions of the Max SDK which changed their structure on disk - setting different build options such as file naming depending on the target architecture: .dll on win32, .dll64 on win64 - generating a relatively complex tree structure which combines a Windows and a macOS build together because people don't want the hassle of having two different download options - generating some stub C file that will declare a function to be exported - generating some .json file with various build information, build date, etc - generating a symbols.txt file which contains all the symbols that are known to be explicitly exported to minimize binary size ; the build system has to: list the symbols (one per plug-in we build), write them to a symbols.txt file, pass that file to Apple's dyld like this: set_property(TARGET ossia-max APPEND PROPERTY LINK_FLAGS "-s -exported_symbols_list '${CMAKE_CURRENT_BINARY_DIR}/symbols.txt'" ) etc etc. these are the requirements we have. can you solve these requirements with just Java's XML ?

cogman10 4y ago
> these are the requirements we have. can you solve these requirements with just Java's XML Yes, actually. They don’t come up very often, but maven in particular has the ability to do everything you’ve mentioned. Most of them built right into the standard plugin set, like setting various compiler options, adding build information, or even platform specific build shenanigans (usually when dealing with javafx). Maven also has a rarely used escape hatch plugin (ant run) which allows you to run custom scripts if you really need to.
- jcelerier 4y ago
  can you show an example of how you'd parse, say, a .java.in file from Maven (say match some lines with regexes), and generate a .java file from it, that you'd add as part of the build? And could you really say that this would be cleaner than the same thing done with cmake?
  - cogman10 4y ago
    > can you show an example of how you'd parse, say, a .java.in The canonical way to do such a thing is through the java annotation processing api [1] and using a tool like java poet [2]. Before you did that, you'd probably decide if you wanted to instead use bytecode generation with a library like bytebuddy [3] But, assuming for some reason, you wanted to torture yourself and actually consume a java.in file and apply a regex, then you'd probably pull out the "maven-replacer-plugin" [4] and configure that for the task at hand. (or use your favorite templating language plugin. There's a million of them). Though, to be fair, this really isn't something that comes up in regular java programming due to the nature of the ecosystem. Anything you'd want to codegen likely already has a library and anything you didn't would receive (legitimate) push back. > And could you really say that this would be cleaner than the same thing done with cmake? Probably not. But not really the main point. cmake becomes a problem when you want to do anything more complex than string replacement. Imagine, for example, if you did want to use a code generation library within a project. The strength of maven is a new team dev only needs maven. Further, if they need to update that library they only need to change that maven file. What happens with cmake if you wanted to update a minimum dependency? [1] https://www.baeldung.com/java-annotation-processing-builder https://www.baeldung.com/java-annotation-processing-builder [2] https://github.com/square/javapoet https://github.com/square/javapoet [3] https://bytebuddy.net/ https://bytebuddy.net/ [4] https://github.com/beiliubei/maven-replacer-plugin https://github.com/beiliubei/maven-replacer-plugin
    - jcelerier 4y ago
      I just don't understand in which universe having to look for X plug-ins which may or may not be maintained (the first I looked at had its last update in 2015) is better than cmake ; cmakelang could be literally a befunge variant of INTERCAL than it'd still be a better choice than this for me

cogman10 4y ago

> these are the requirements we have. can you solve these requirements with just Java's XML Yes, actually. They don’t come up very often, but maven in particular has the ability to do everything you’ve mentioned. Most of them built right into the standard plugin set, like setting various compiler options, adding build information, or even platform specific build shenanigans (usually when dealing with javafx). Maven also has a rarely used escape hatch plugin (ant run) which allows you to run custom scripts if you really need to.

jcelerier 4y ago
can you show an example of how you'd parse, say, a .java.in file from Maven (say match some lines with regexes), and generate a .java file from it, that you'd add as part of the build? And could you really say that this would be cleaner than the same thing done with cmake?
- cogman10 4y ago
  > can you show an example of how you'd parse, say, a .java.in The canonical way to do such a thing is through the java annotation processing api [1] and using a tool like java poet [2]. Before you did that, you'd probably decide if you wanted to instead use bytecode generation with a library like bytebuddy [3] But, assuming for some reason, you wanted to torture yourself and actually consume a java.in file and apply a regex, then you'd probably pull out the "maven-replacer-plugin" [4] and configure that for the task at hand. (or use your favorite templating language plugin. There's a million of them). Though, to be fair, this really isn't something that comes up in regular java programming due to the nature of the ecosystem. Anything you'd want to codegen likely already has a library and anything you didn't would receive (legitimate) push back. > And could you really say that this would be cleaner than the same thing done with cmake? Probably not. But not really the main point. cmake becomes a problem when you want to do anything more complex than string replacement. Imagine, for example, if you did want to use a code generation library within a project. The strength of maven is a new team dev only needs maven. Further, if they need to update that library they only need to change that maven file. What happens with cmake if you wanted to update a minimum dependency? [1] https://www.baeldung.com/java-annotation-processing-builder https://www.baeldung.com/java-annotation-processing-builder [2] https://github.com/square/javapoet https://github.com/square/javapoet [3] https://bytebuddy.net/ https://bytebuddy.net/ [4] https://github.com/beiliubei/maven-replacer-plugin https://github.com/beiliubei/maven-replacer-plugin
  - jcelerier 4y ago
    I just don't understand in which universe having to look for X plug-ins which may or may not be maintained (the first I looked at had its last update in 2015) is better than cmake ; cmakelang could be literally a befunge variant of INTERCAL than it'd still be a better choice than this for me