Well, I’m working on a rather large swing application and its starting to tax my brain. I’ve been looking at managing the complexity through structural, refactoring and testing lenses to try and see if there is anything wildly useful. Sadly, there doesn’t appear to be.
Primarily, I am disappointed by the lack of tool support for “code comprehension”. Yes, IDEA (and Eclipse for that matter) both have refactoring support built in, but that doesn’t help me get a grasp on the overall application without tracing quite a few things through. And apparently my buffer is not large enough to retain enough of the application to get all of the big picture.
Refactorings are great, but only really address smaller things that add up to bigger things. Nothing seems to address software at the more macro level. UML diagrams don’t really cut it, particularly if you’re generating them from the codebase. If you have some good tool support here, let me know.
Software is basically a set of encoded requirements. How to translate those to and from english? XP/agile says - encode it a number of times, once in test. Tell stories about it. Too often in the wild the only tangible version of the requirements is the software itself.
I’ve thought, and read “java is dead” stuff for a while now. I’m not sure why I cling on, although I guess it just feels sad to go back to C++ or just terminally embrace M$. In any case, there are a bunch of new languages like groovy and scala (jython, etc..) that use the JVM that also get me excited, but fail to get me going - first of all, they seem to all lack semicolons, which is fine, except for me since I seem to be hard wired with semicolons at this point. But more importantly, I have yet to see something really compelling that’ll get me off my rump to learn them - essentially, they all seem terse and scripty, but what I’ve always dreamed of is a new programming language with some really nifty features. Maybe something more along the lines of “what” rather than “how”, and maybe not through encapsulation/hiding as much as by hinting.. Besides this, another thing that would be nice in a new higher level language is some sort of cognizance of the kinds of things that are efficient at a lower level, and figuring out how to model the more common stuff you’d want to do. So, multilevel metapatterns.
-what do optimal assembly program structures (tend to) translate into at a higher level, and not just because of compiler tendencies?
-what kinds of things are nicer at a higher level that dont/translate well at a lower level
-what are all the real tradeoffs between higher and lower? is there a high level language that can get further out on this continuum?
-could libraries be optimized with the application?
-how could libraries/frameworks provide some hintable aspects for users to be able to control tradeoffs?
the kinds of optimizations I’d like, particularly from something like Spring: a compile time configuration in addition to the run time configuration. Or, I’d like to tell the library to come to some optimal balance on its own based on my usage pattern.
In terms of reverse engineered object orientation from the ground up:
-data/class normalizer that takes all the data and all the methods and moves things around to their apropriate (most close?) places..
the star graph ast stuff, is good - however, haven’t got it working with modern tools yet.. it seems like the aspect people had all the good stuff.. where are they now?!
-when is inheritance to be used? Encapsulation? simple rules would be nice.
-what about time based stuff? There are some async type things, like waiting for a user, or db for that matter..
-how much does modeling time (or threads) mattter? A lot of the business process/rules stuff seems to take this into account.
-optimizing from various perspectives, for instance speed, memory footprint, elimination of duplication (for instance, not redrawing screen, so only looking from perspective of pixels drawn..), code understandability and conformance to common patterns..
-where is the sweet spot for method size?
-how much does app x or y differ from good encapsulation?
-should model cpu usage or other tradeoff axes..