Application efficiency?
-
Sorry to say this but you don't seem to be very educated. You never heard of stateless architecture?
CsTreval wrote:
You never heard of stateless architecture?
I have. I have used it. It however is limited to very specific applications and your original post did not make it clear what you are doing. Additionally stateless architecture has little to do with object creation and much more to do with how data is used within objects. I can create a stateless architecture in C (which has no objects) using global variables (which exist for the lifetime of the application.) And MORE importantly efficiency has nothing to to with correct implementation. I can create very efficient stateful code which is incorrect because it is supposed to be stateless.
-
Where in the code do I best put object creation (stateful objects) and where not? In what layers? For example, I once put an object reference inside a Hibernate DAO class and I was told that this was incorrect because DAO classes are not supposed to have state. State should be inside the 'service layer'. I have been told that I should not create new objects on recurring method calls such as UpdateCart(). Creation of objects is costly and should not be sitting in your code everywhere. It should be sitting in initialization type methods only. For example, if an e-commerce application needs a cart, put it in the session. If it needs some general main object, put it in the initialization code. Create it once there and let the rest of the application access its instance later. Do not create this instance upon every call. I'm confused about this whole design principle. The strangest thing I heard is 'an app is not supposed to have state. State should be kept in the data layer where the database is'. Really? I'm quite new to these design concepts and I don't know where to look in order to get more educated on it. GoF? Design Patterns books? The goal is to create qualitative code (i.e. to be used in the business). Thanks
I am hopeful that your question is confused rather than you and or whoever is providing this information to you. Retrieving data from a database is a relatively expensive operation. Period. Doesn't matter why you do it. That however doesn't mean that you can retrieve it once only. The business needs drive in what way it can be retrieved. You put database code in a database layer because that has multiple benefits. You don't put database code outside the database layer because doing that completely violates the point of having the database layer in the first place. And notice that nothing in the above has anything to do with stateful or stateless.
CsTreval wrote:
For example, I once put an object reference inside a Hibernate DAO class and I was told that this was incorrect because DAO classes are not supposed to have state. State should be inside the 'service layer'.
As a general statement that is nonsense. Implementing code for real businesses is not clean. You attempt to create well crafted code but only to the extent that it makes sense to meet the needs of the business. Other than that I can only suppose that you did something really wrong in terms of service separation and database layer separation and that point was being emphasized. The database layer should to database stuff. The service layer should do service layer stuff. Again normally, not exclusively. And note that none of this has anything to to with the general topic of object creation. Nor with performance.
CsTreval wrote:
Create it once there and let the rest of the application access its instance later. Do not create this instance upon every call.
As stated generally nonsense. It depends on what the object does. I don't need to retrieve the database connection string on every call. There is however no point in not creating a StringBuilder on every call.
-
Could you let us know where this university is and what, exactly, the course is that you are doing?
*pre-emptive celebratory nipple tassle jiggle* - Sean Ewington
"Mind bleach! Send me mind bleach!" - Nagy Vilmos
CodeStash - Online Snippet Management | My blog | MoXAML PowerToys | Mole 2010 - debugging made easier
-
Sorry to say this but you don't seem to be very educated. You never heard of stateless architecture?
Sorry to say this, but the OP wasn't asking about stateless architecture.
-
CsTreval wrote:
Sorry to say this but you don't seem to be very educated
I did not have any official schooling. Does it show? :-D
CsTreval wrote:
You never heard of stateless architecture?
Heard of it, never worked on it, and I'm doin' this for a few years now. Applications usually have a state, since the components in there have a state. A connection-object is either opened or closed. What you implied is that this information (whether the database-connection is opened or closed) should only be stored in the database. Being my usual self (the sig was a warning), please educate me, show me where I'd need it. Until you can explain what it's good for, I'll judge it by it's appearance, and it appears to be an abstraction too far for the architecture.
Bastard Programmer from Hell :suss: if you can't read my code, try converting it here[^]
Eddy Vluggen wrote:
What you implied is that this information (whether the database-connection is opened or closed) should only be stored in the database.
That's not really what's meant by stateless design. :) I'd happily agree with you that any information stored anywhere IS "state" but going by this definition we'd be talking about information-free information systems, and I suspect they'd be useless. What people actually mean when they speak of stateless is that the object instances themselves are stateless. There are no instance members. But there are method parameters and local variables, and they live on the stack. (If they are references to other objects, the objects themselves of course live on the heap. But every reference to them will be on the stack.) This leads to two properties which are sometimes desireable: You can't corrupt the heap in such a way that it affects more than one thread. A service for instance may fail under some condition, but this can't leave the server itself corrupted and subsequent requests still have a chance of succeeding. Secondly, it means the same "objects" can be shared among many threads, because they use the stack of each thread to store all the state they manipulate. Lest you now become a fan, let me just add this: Stateless design also means throwing OOP out the window! Some will argue on this point, but here's my take. What really defines OOP is 3 things: Encapsulation. Inheritance. Polymorphism. But stateless implies you are creating "objects" that really are nothing more than a bunch of routines. And although you still have inheritance and polymorphism to play with, you can't put them to really good use, because you no longer have any objects, just mini-libraries of routines and subroutines! Personally, I consider encapsulation the far most powerful - and least understood - aspect of object-oriented programming. It is what makes it object-oriented! You cannot model stuff as an object if you can't encapsulate. You could still do it without inheritance or polymorphism, though they are both *very* useful and powerful concepts. The most I would ever consider using stateless architecture for would be a small part of a server. This would ensure this part couldn't get corrupted. Then I'd make everything else properly object-oriented and build capability to "reset" the state into it. Hence the service could sort of "reboot" in case of trouble, and I could still program the vast majority of the system pro
-
Take my advice: Don't make yourself look worse than you already have.
-
Eddy Vluggen wrote:
What you implied is that this information (whether the database-connection is opened or closed) should only be stored in the database.
That's not really what's meant by stateless design. :) I'd happily agree with you that any information stored anywhere IS "state" but going by this definition we'd be talking about information-free information systems, and I suspect they'd be useless. What people actually mean when they speak of stateless is that the object instances themselves are stateless. There are no instance members. But there are method parameters and local variables, and they live on the stack. (If they are references to other objects, the objects themselves of course live on the heap. But every reference to them will be on the stack.) This leads to two properties which are sometimes desireable: You can't corrupt the heap in such a way that it affects more than one thread. A service for instance may fail under some condition, but this can't leave the server itself corrupted and subsequent requests still have a chance of succeeding. Secondly, it means the same "objects" can be shared among many threads, because they use the stack of each thread to store all the state they manipulate. Lest you now become a fan, let me just add this: Stateless design also means throwing OOP out the window! Some will argue on this point, but here's my take. What really defines OOP is 3 things: Encapsulation. Inheritance. Polymorphism. But stateless implies you are creating "objects" that really are nothing more than a bunch of routines. And although you still have inheritance and polymorphism to play with, you can't put them to really good use, because you no longer have any objects, just mini-libraries of routines and subroutines! Personally, I consider encapsulation the far most powerful - and least understood - aspect of object-oriented programming. It is what makes it object-oriented! You cannot model stuff as an object if you can't encapsulate. You could still do it without inheritance or polymorphism, though they are both *very* useful and powerful concepts. The most I would ever consider using stateless architecture for would be a small part of a server. This would ensure this part couldn't get corrupted. Then I'd make everything else properly object-oriented and build capability to "reset" the state into it. Hence the service could sort of "reboot" in case of trouble, and I could still program the vast majority of the system pro
dojohansen wrote:
What people actually mean when they speak of stateless is that the object instances themselves are stateless. There are no instance members.
This must be theoretical; I don't see this work with static (shared) members. It's a nice explanation, but at this point, there's not much I can actually do with it :^)
Bastard Programmer from Hell :suss: if you can't read my code, try converting it here[^]
-
dojohansen wrote:
What people actually mean when they speak of stateless is that the object instances themselves are stateless. There are no instance members.
This must be theoretical; I don't see this work with static (shared) members. It's a nice explanation, but at this point, there's not much I can actually do with it :^)
Bastard Programmer from Hell :suss: if you can't read my code, try converting it here[^]
Actually I made a mistake; correct would be no instance *state*, i.e. no instance fields, only local variables and method parameters. But it sure can work also with only static methods, though in that case you of course *also* lose the ability to use polymorphy. Note that this doesn't imply there should be any static fields. They too would live on the heap and represent shared state. Come to think of it, "isolated state" or "local state" would actually be better names for this type of architecture than "stateless". And again, personally I'm no fan of the beast.
-
Actually I made a mistake; correct would be no instance *state*, i.e. no instance fields, only local variables and method parameters. But it sure can work also with only static methods, though in that case you of course *also* lose the ability to use polymorphy. Note that this doesn't imply there should be any static fields. They too would live on the heap and represent shared state. Come to think of it, "isolated state" or "local state" would actually be better names for this type of architecture than "stateless". And again, personally I'm no fan of the beast.
-
Now you're just teasing me...? It is nothing like a functional language. It's plain old procedural code. And you can of course write procedural code in C#, in methods in classes. But that doesn't make it OOP. :)
-
Now you're just teasing me...? It is nothing like a functional language. It's plain old procedural code. And you can of course write procedural code in C#, in methods in classes. But that doesn't make it OOP. :)
dojohansen wrote:
Now you're just teasing me...?
Partly; F# is a functional language, seemed to map to having everything in a function.
dojohansen wrote:
It's plain old procedural code.
In that case, I wrote a lot of those applications, in AMOS Basic. Somehow, that one seems to fit the previous description less than F#. It became a mess quite quickly when your app grows larger. The best thing since sliced bread was the idea to group 'em. The idea that the local variables could be shared among that group was brilliant; took a lot of repeating parameters out of the procedures. Lots of people still program in a procedural way in the new OO-environment, simply because it's easier to understand. And given recursion, you could still kill the stack.
Bastard Programmer from Hell :suss: if you can't read my code, try converting it here[^]