Unsure if I understand TransactionAwarePersistenceManagerFactoryProxy

http://stackoverflow.com/questions/14636178/unsure-if-i-understand-transactionawarepersistencemanagerfactoryproxy/14636231#14636231

by ericdc • 13 years ago

78 79 13 years ago

stackoverflow.com

mmariani• 13 years ago

And people still complain about ObjC long method names...

ericdc• 13 years ago

lol

mindcrime3• 13 years ago

Long names are a Good Thing as far as I'm concerned. Having spent FAR more time than I care to admit working with IBM crap that uses name like QXMGRTBL and QWRKQITM, I'll take TransactionAwarePersistanceManagerFactoryProxy any day... and twice on Sunday.

The only bit about this that even strikes me as a little bit unreasonable is the "Proxy" bit at the end. Not sure why you need another level of Proxy on top of TransactionAwarePersistenceManagerFactory, but it's not like you type that name particularly often. Most likely it's referenced once in a Spring config file somewhere, and given a bean name of "persistenceManagerFactory" which is what would be referenced in code once at most. Hell, probably not even that... that's probably wired into another bean that just gives you the PersistenceManager... which you might not actually ever reference in code either, since Spring can auto generate JPA implementation classes that use JPQL queries, etc., and eliminate the need for most hand coding of anything JPA related.

OK, sure, just to look at it, at first blush, the name looks long and silly, but when you actually think about what it is and how it's used, it's not exactly a big deal.

jlgreco7• 13 years ago

Long names are a Good Thing as far as I'm concerned. Having spent FAR more time than I care to admit working with IBM crap that uses name like QXMGRTBL and QWRKQITM, I'll take TransactionAwarePersistanceManagerFactoryProxy any day... and twice on Sunday.

Seems like a bit of a false dichotomy. It is reasonable to expect clear and descriptive names that do not reach the level of verbosity that seems to be idiomatic in Java.

michaelerule• 13 years ago

idiomatic? ( I am unfamiliar with the meaning of "idiomatic" in this context, I suspect this is programming language jargon? )

mindcrime3• 13 years ago

Maybe... personally I find most of the carping about Java class names to be hyperbole. This is one of the more extreme examples you'll find (especially in common use) and, again, if you look at what it actually does, the name is descriptive and reasonable.

As to whether or not the whole persistence mechanism is "over-engineered", well... that's a separate question. I can see some of the arguments for it, but when I look at how much easier my life is with JPQL and Spring Data and the auto-generated JPA classes, versus hand-coding raw JDBC calls and raw SQL, I'll take the former every time. And I, for one, like transactions, and the way Spring lets me annotate my Service Facade classes to manage transactions for me.

rbehrends• 13 years ago

The problem is not the name, but the ridiculous overdesign of which it is a symptom.

At which point I bring you the story of the king's toaster [1] (which is a cautionary tale, not an aspirational story, just in case that should be unclear to anybody).

------------------------------------------------

Once upon a time, in a kingdom not far from here, a king summoned two of his advisors for a test. He showed them both a shiny metal box with two slots in the top, a control knob and a lever. "What do you think this is?"

One advisor, an engineer, answered first. "It is a toaster," he said.

The king asked, "How would you design an embedded computer for it?"

The engineer replied, "Using a four-bit microcontroller, I would write a simple program that reads the darkness knob and quantizes its position to one of 16 shades of darkness, from snow white to coal black. The program would use that darkness level as the index to a 16-element table of initial timer values. Then it would turn on the heating elements and start the timer with the initial value selected from the table. At the end of the time delay, it would turn off the heat and pop up the toast. Come back next week, and I'll show you a working prototype."

The second advisor, a computer scientist, immediately recognized the danger of such short-sighted thinking. He said, "Toasters don't just turn bread into toast, they are also used to warm frozen waffles. What you see before you is really a breakfast food cooker. As the subjects of your kingdom become more sophisticated, they will demand more capabilities. They will need a breakfast food cooker that can also cook sausage, fry bacon, and make scrambled eggs. A toaster that only makes toast will soon be obsolete. If we don't look to the future, we will have to completely redesign the toaster in just a few years.

With this in mind, we can formulate a more intelligent solution to the problem. First, create a class of breakfast foods. Specialize this class into subclasses: grains, pork and poultry. The specialization process should be repeated with grains divided into toast, muffins, pancakes and waffles; pork divided into sausage, links and bacon; and poultry divided into scrambled eggs, hard-boiled eggs, poached eggs, fried eggs, and various omelet classes.

The ham and cheese omelet class is worth special attention because it must inherit characteristics from the pork, dairy and poultry classes. Thus, we see that the problem cannot be properly solved without multiple inheritance. At run time, the program must create the proper object and send a message to the object that says, 'Cook yourself'. The semantics of this message depend, of course, on the kind of object, so they have a different meaning to a piece of toast than to scrambled eggs.

Reviewing the process so far, we see that the analysis phase has revealed that the primary requirement is to cook any kind of breakfast food. In the design phase, we have discovered some derived requirements. Specifically, we need an object-oriented language with multiple inheritance. Of course, users don't want the eggs to get cold while the bacon is frying, so concurrent processing is required, too.

We must not forget the user interface. The lever that lowers the food lacks versatility and the darkness knob is confusing. Users won't buy the product unless it has a user-friendly, graphical interface.

When the breakfast cooker is plugged in, users should see a cowboy boot on the screen. Users click on it and the message 'Booting UNIX v. 8.3' appears on the screen. (UNIX 8.3 should be out by the time the product gets to the market.) Users can pull down a menu and click on the foods they want to cook.

Having made the wise decision of specifying the software first in the design phase, all that remains is to pick an adequate hardware platform for the implementation phase. An Intel 80386 with 8MB of memory, a 30MB hard disk and a VGA monitor should be sufficient. If you select a multitasking, object oriented language that supports multiple inheritance and has a built-in GUI, writing the program will be a snap. (Imagine the difficulty we would have had if we had foolishly allowed a hardware-first design strategy to lock us into a four-bit microcontroller!)."

The king had the computer scientist thrown in the moat, and they all lived happily ever after.

[1] http://www.ee.ryerson.ca/~elf/hack/ktoast.html

mindcrime3• 13 years ago

It's an amusing story and a good cautionary tale, no doubt. But not all complex designs are over-engineering. Some problems are complex and require complex solutions. And sometimes complexity in one place is just a way of moving it from somewhere else, because somebody thought that tradeoff made their life better.

See what I said below about how much I prefer JPQL and Spring Data... Personally, I really do not have a problem with this.

VladRussian2• 13 years ago

At run time, the program must create the proper object and send a message to the object that says, 'Cook yourself'.

the perceived elegance of this approach makes junior CS college student eyes glow when s/he first hears about it, and that glow continues for, in the best case, at least a decade after college.

famousactress2• 13 years ago

Nothing should exist anywhere in any discipline, medium, or realm that requires that many words to name.

Also, we all have this conversation periodically about the sadness of Spring complexity. They always go the same way - https://news.ycombinator.com/item?id=4550374

humbledrone2• 13 years ago

I went to Jameco and just grabbed the name of a part at random, "Phototransistor IR Chip Silicon NPN Transistor 2-Pin T-1".

I'm curious, how do you propose that part be named? I mean, sure, you can call it part #112176. That's a name with fewer words. The part number is preferable for, say, ordering from a catalog. But when actually designing a device that uses that part? Well, at some point, I need to know what it is. And what it is is a "Phototransistor IR Chip Silicon NPN Transistor 2-Pin T-1".

Sometimes in engineering you just need some really specific thing, and it makes perfect sense for a really specific thing to have a really specific name.

I'm genuinely curious: what is the argument behind your conjecture that nothing should exist that takes so many words to name? Should that phototransistor not exist?

MetaCosm• 13 years ago

mindcrime has been a victim of a ... Stockholm syndrome.

sliverstorm• 13 years ago

Personally, my ability to understand a line of code drops off quickly when it word wraps, and if it wraps twice I have to stop and massage my eyes.

That's the main problem with obscene verbosity in variable naming, at least to me.

finnw• 13 years ago

Reminds me of one of mine: http://stackoverflow.com/q/137060/12048

shmerl3• 13 years ago

Camel notation looks awful with so many words. C++ style with underscores is way more readable.

schrodinger• 13 years ago

It's just what you're used to. I'd say the opposite.

jlgreco7• 13 years ago

Spaces between words got added to Latin over a thousand years ago. I figure there must be a reason that change occurred.

veesahni• 13 years ago

snake_case is 20% easier to read ( reference: http://bit.ly/11T1FWY )

shmerl3• 13 years ago

I always thought it's rather self explanatory. Reading a text without distance between the words requires more effort. Capital letters don't help much for that. Underscore gives a space between the words, which allows more fluent reading.

philh• 13 years ago

Glancing at the first page of that study, it looks like

* People trained mostly in camelCase (also, nonprogrammers) read camelCase more accurately, but snake_case faster. (Previous study which I didn't follow up.)

* People trained mostly in snake_case read both of them equally accurately, but snake_case faster. (But, grand total of fifteen participants.)

(I find this mildly surprising: I seem to read snake_case slightly slower than normal text, and camelCase slightly faster, just based on the pauses between words. But camelCase would be easier to lose myself in. I find hyphenated-words easiest to read, but not many languages permit them...)

angersock• 13 years ago

ThisIsMyClassType

thisIsAnInstanceOfMyClass

this_is_some_ruby_or_kernel_c_i_copied_from_stack_exchange

_thisIsAFunctionParameterHavingBeenPassedIn

THISISACONSTANTDONOTCHANGE

THIS_IS_A_FRIENDLIER_ENUM

_____how_many_spaces__in_this_var

EDIT: Aaaand then there is the JS approach:

http://mathiasbynens.be/notes/javascript-identifiers

ante_annum• 13 years ago

Remember that Sun led by example.

com.sun.java.swing.plaf.nimbus.InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonPainter, anyone?

http://javadoc.bugaco.com/com/sun/java/swing/plaf/nimbus/Int...

jfb4• 13 years ago

That has to have been automatically generated, no?

sluukkonen• 13 years ago

It's an internal, automatically generated class. No programmer is ever going to use it.

sukuriant• 13 years ago

in an internal, unfinished, maybe even experimental (see com.sun.java.* rather than java.*) bit of code that other people in the thread are saying was auto-generated.

I don't really see that class as a problem.

soup10• 13 years ago

I've always maintained that java itself is not so bad. It's the things people have done with it that make angels cry. People are the problem, not java. Leave java alone.

icambron• 13 years ago

Languages aren't just syntax rules; they're ecosystems. And unless you want to build everything from scratch, you're going to need to use libraries and frameworks from that ecosystem, and you'll have to play by their rules. Further, you'll probably end up impedance-matching your code to those frameworks, just to make your architecture cleaner. Later, you'll seek help on some aspect of your project and most of the respondents' advice will follow the basic patterns of How Java is Written. Then you're going to hire additional programmers with lots of Java experience to help you build it, and they'll come with a bunch of notions on what the best practices are. So I'm not sure there's a practical distinction between "Java itself" and "things people have done with it". Java is people.

nostromo• 13 years ago

I've come back to Java recently via Play Framework. To my surprise, Java can be a joy to use, so long as you avoid old-school frameworks, like Spring, entirely.

jebblue• 13 years ago

I'm starting to look more at play on the side, except for the SCala stuff I keep seeing, as long as I can use it from Java and not have to deal with Scala's weird syntax then I think Play could be the new best hope (since it's not clear what Google plans to do with GWT - which rocked).

jhare• 13 years ago

Not necessarily a "Java" problem so much as it is a Spring problem.

speeder• 13 years ago

I don't understood the question either...

I mean, it has so much jargon on it, that what I felt is what I think my mom feels when I am talking with my dad...

I read, and re-read, and read again... And the only thing that I would think was: "omgwhy? wtf? WHY THIS EXISTS IN FIRST PLACE???"

strlen• 13 years ago

Alternatively, this is why Java needs a real namespace mechanism. "package" doesn't cut it. See: namespaces in C# or C++, or alternately modules in ML.

One thing I like about DI implemented in a language itself is that is that it negates the need to make factories in all cases. So, essentially, imagine if Java had C# style namespace and this was done using Guice-style DI.

  bind(Persistance::Manager.class).toProvider( 
    new Provider<>() {    
      public Persistance::Manager get() {
        new Persistence::Manager::TransactionAware();
      }
  });

jamesbritt• 13 years ago

Wow. Naming really is importantant.

https://news.ycombinator.com/item?id=5944101

smegel2• 13 years ago

And I thought C++ led to complex abstractions.

It makes me wonder if it was just accident that Java developed this way, or if it could have been an xml free, simple interface language.

Fauntleroy• 13 years ago

That's not so bad. If you haven't seen the Windows 8 API documentation yet, you should go ahead and have a laugh: http://msdn.microsoft.com/en-us/library/windows/apps/br21137...

When most of your method/class names overflow your table of contents' width, you've got a serious problem.

keithnoizu• 13 years ago

The problem here isn't their class names. It's that everyone at the empire decided to go metro a few years back and made a bunch of sites like msdn a pain to use but with a nicer font and color pallet.

My guess is no one bothered to include UX in their annual commitments when they got the memo for the design change.

cocoflunchy• 13 years ago

Java does not own the monopole on this one...

Ever heard of kBluetoothAMPManagerCreatePhysicalLinkResponseAMPDisconnectedPhysicalLinkRequestReceived

__AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_5

cairo_atsui_font_face_create_for_atsu_font_id_REPLACED_BY_cairo_quartz_font_face_create_for_atsu_font_id

eridius2• 13 years ago

I'm not familiar with the first or the third, but the second example you cited is working as intended. No 3rd-party developer ever types this (and I don't know if anyone at all ever types this or if it's machine-generated), and the long name is meant as a form of documentation for anyone reading the header file.

krapp• 13 years ago

knowing absolutely nothing about language design (and not many languages) other than occasional experiments in notepad... is there no language which attempts to allow spaces, maybe with quotes, for better legibility?

like instead of

    org.springframework.orm.jdo.TransactionAwarePersistenceManagerFactoryProxy

something like

    org.'spring framework'.orm.jdo.'transaction aware persistence manager factory proxy'

or is that just a terrible idea?

dxm• 13 years ago

I personally think that's worse. The original declaration is easier to read and immediately recognisable as to what it is, I can see clearly that it's a namespace and a class. The second version would require me to think.

dugmartin• 13 years ago

In PHP you can have non-alphanumeric variables like so:

    $org->{'spring framework'}->orm->jdo->{'transaction aware persistence manager factory proxy'}

I'm not sure if you can do that with PHP namespaces though (and I'm too lazy to test this):

    use org\{'spring framework'}\orm\jdo\{'transaction aware persistence manager factory proxy'};

jcheng• 13 years ago

This is obviously trolling but I'll take a stab at actually answering the question, based on the javadoc[0]. (I have never used Spring or JDO and haven't done Java server-side programming since 2002.)

The JDO framework has an interface called PersistenceManagerFactory that is used to... well, create objects that manage persistence. Spring has its own thread-bound PersistenceManager abstraction that you need to fiddle with when you're doing transactions. This class lets you use the former's interface but decorated with the latter's behavior, so code that is designed for JDO doesn't need to be modified to call the Spring APIs explicitly.

(Am I close??)

[0] http://static.springsource.org/spring/docs/2.0.7/api/org/spr...

ovoxo• 13 years ago

How did this post's title not get auto-modified?

bengoodger• 13 years ago

It's not limited to Java. We have a rule in Chromium where if your class name contains the same word twice you have to do a shot.

ojiikun• 13 years ago

For my money, "ObjectFactoryCreatingFactoryBean" is the most mind-blowing class name ever authored, especially when you realize it is actually useful on occasion!

ww520• 13 years ago

People are so easily trolled. This looks like a generated class name in Spring.

EzGraphs• 13 years ago

I kind of preferred the original title on HN that quoted a comment:

"And this, dear children, is why Java should stop taking drugs."

smegel2• 13 years ago

Who keeps changing the title, it was "And this, dear children, is why Java should stop taking drugs"?

Quoting part of an article as the title is not necessarily editorialization, and when the link is not actually an article, but a SO question, the original "title" may not be particularly interesting or informative.

Obviously inventing provocative titles simply to spark a flame-war is not on, but in this case the title was humorous (and interesting). The new title which is literally someones question on SO seems out of place on the front page, and not really the point of discussion.

Interesting titles can form part of the culture of a site like this, and over-zealous editing of titles damages the sense of community. It's probably the thing I dislike most about HN right now.

eridius2• 13 years ago

The original title was garbage. The only thing at all it told me was that the article was somehow related to Java. I did click on it when it was the original title, and was very disappointed to see it was just a bad answer (which has at this point been deleted by the SO mods) to a stupid question.

The new title, on the other hand, tells me this is going to be about absurdly long factory classes, almost certainly using Java, and that I should probably be expecting humor rather than, say, a long article about an obscure interaction in Java that produces amusing results (which is what I had hoped I was getting with the original title).

It also happens to be the title of the linked "article" as well, which I believe is what HN says you should be using rather than editorialized titles.

contingencies• 13 years ago

The problem with object-oriented languages is they've got all this implicit environment that they carry around with them. You wanted a banana but what you got was a gorilla holding the banana and the entire jungle. - Joe Armstrong, inventor of Erlang.

Unsure if I understand TransactionAwarePersistenceManagerFactoryProxy

Related Stories