Comparison And Critique Of Object-Oriented Programming And Aspect-Oriented Programming Essay.

Your Assessment of this Paper's Contribution” your own interpretation of the findings and key issues the paper raises and “The Review” your own critical summary of the research carried out and presented in the paper.

Explain and appropriately use key programming constructs

Critique and compare different software development approaches

Discussion

Software development is a process which is adopted for the development of a software project. This is mainly done by implementing the programming languages for the development of software and implementing it in the company standards. The use of object oriented programming is mostly done because of its aid in the process of software engineering process. This is mainly because the object oriented model suits the domain related problems. However, the use of object oriented programming cannot capture the processes effectively and this is the reason for adopting the use of aspect of oriented programming language. This report includes a comparison among both the programming languages. In addition, the results from this analysis are also discussed in this report. Lastly, the literature review of the languages is also mentioned in this report.

This section discusses about the main concepts related to the topic.

The design of software process is done by breaking it into smaller components which are then addressed to individually. Using these processes, a programmer can apply coding techniques to each of the subsystems and then combine them by applying the process of abstraction. When abstraction and composition techniques are used, then the programming techniques are greatly combined (Aspect-Oriented Programming, 1997). For this reason, the use of procedural languages, structured languages and the object oriented languages are being used for the process as the software development as all of the languages have the basics of abstractions and compositions in their features.

Object oriented programming

The use of the OOP language goes back to the early centuries where the Simula language was famous for program simulations. In the modern times, the use of C++ and Java is the most adopted languages for programming. In case of the object oriented programming languages, objects are made which communicates among each other in the domain (Jackson 2016). The encapsulation is a feature of the OOP which converts the whole codes into small modules which can then be re-used. Using of classes and applying for inheritance is another feature of the object oriented programming languages.  

However, the mapping of objects to the relational database is a great technical problem that is considered in the use of OOP language (Smith 2015). The use of application servers are a wise choice for addressing to the transactional details of a database server. In addition, the use of business logic software must be used for adopting business details. Similarly, object oriented development is usually accompanied by object oriented modeling which considers the conceptual designs at high level to implementations at lower levels. The modeling of these concepts both in the high level and the low level terms are done by using UML languages (Corral et al. 2014). The major advantages of OOP are that it allows extensive reuse of codes and better abstraction and encapsulation.

Literature Review

Aspect oriented programming

The use of traditional approaches cannot be used for constructing complex systems. This is because the exact codes are cut across due to execution processes. This means that the modules of the program become intangible with each other which lead to failure (Cardoso et al. 2016). For this reason, the use of aspect oriented programming is emphasized as it is always involved with the aspects rather than codes. The main purpose of the aspect oriented programming includes removal of the tangible nature of the aspects and then combining those aspects and with codes by using automated tools.

Additionally, the use of abstraction is mainly done to break down the complex problems by using the method of aspect decomposition. This means that the software codes are present in the whole class as aspects which are usually spread out across the whole program (Pasquier, Bacon and Shand 2014). This greatly enables decoupling of the aspects. Thus, it can be said that modifications can be done without causing changes in the code.

The use of aspect orientation is also done in the place of software development programming. It makes it necessary for considering the architecture of the software by following the aspect angle (Ghareb and Allen 2015). However, the software architecture and the aspect orientation are two different subjects which cause various problems. The main reason for such outcome is that it is very difficult to handle different aspects and it takes different treatments for referencing them.

Aspect oriented programming assists in providing solution to the previous issue. It deals with aspects and behavior that cuts through several objects.   One of the main limitations to object oriented programming includes specific things that can crosscut specific objects as well as methods.  One of the examples is logging or monitoring (Uysal 2016). In OOP, it is required to login in to each of the classes. AOP avoids the process through treating the process cross cutting behavior that is opposed to the object.  A single block of code helps to deal with specific aspect.

On the other hand, a class is considered as blueprint for doing something such as engine, employee and publication. An object is considered as an example of the class. A class can inherit specific methods as well as variables from different class. It is considered as inheritance. It is possible to develop a particular program with fairly complicated hierarchy of the classes (Nanakorn, Petprakob and Naga 2014).  However, there is a limitation where it is important to protect data as well as variables within the particular class. The log files are required radio access to engine. However, the term is defined is the type of data hiding or data protection that is named as encapsulation.

Object oriented programming

For an image processing system, the main concept involves passing of various images through a point. For this reason, the memory addressing and the storage requirements must be taken into considerations (Aspect-Oriented Programming, 1997). The basic functionality of the system involves the passage of various images as input and the production of an output image. The basic filters used in this system can be defined by using various primitive procedures which provides logical and pixel-wise outputs. This will be done by starting loops in the process. This is the main comparison among the two languages. In case of the OOP, the loops and the processes are done differently giving the concept of object orientation.

The next comparison lies in the process of logical operations. The use of the operator ‘!’ is done for recognizing the symbols in the program while in case of the object oriented programming languages, it defines the not operation in execution (Greifenberg et al. 2015). Another comparison among the two approaches is the use of syntax functions like “defun”.

However, the simple implementation of the AOP cannot define the memory optimization problems. For each procedure, the number of loops covered identifies each of the inputs and creates an output significantly. The output images that have been produced exist for a small amount of time. After that they are customized by another executable loop (Aspect-Oriented Programming, 1997). This results in reference memory exhaustion and in turn leads to cache memory miss and performance reduction. The solution for this is to consider global perspectives of the program codes and mapping of the intermediate results so that memory allocations are not done for them. This mainly utilizes the fusion of the loops which is responsible for the creation of the output.

(defun horizontal-edge! (a)

(let ((result (new-image))

(a-up (up! a))

(a-down (down! a)))

(loop for i from 1 to width do

(loop for j from 1 to height do

(set-pixel result i j

(or (and (get-pixel a i j)

(not (get-pixel a-up i j)))

(and (get-pixel a i j)

(not (get-pixel a-down i j)))))))

Similarly, the memory allocation processes of object oriented programming is also similar but with a different perspective included in processing. In case of object oriented programming languages like Java, the use of default constructors are in place for memory addressing. The constructors are in place for repeated usages (Barnes, Kölling and Gosling 2017). This means a particular code used for constant memory requirements will be used each and every time a class is executable. This reduces the memory usages and in turn leads to effective memory allocations.

Aspect oriented programming

class Programming {

  Programming() {

    System.out.println("Constructor method called.");

  } 

  public static void main(String[] args) {

    Programming object = new Programming();

In case of the object oriented programming, the major features include encapsulation, abstraction, inheritance and polymorphism (Welborn et al. 2014). However, in case of aspect oriented programming, the use of join points, advice, pointcut and introduction is present. For a program code listed below, the aspect orientation will be discussed.

public class TestClass {

public void sayHello () {

System.out.println ("Hello, AOP");

}

public void sayAnyThing (String s) {

System.out.println (s);

}

public static void main (String[] args) {

sayHello ();

sayAnyThing ("ok");

For this code, the aspect orientation will change the listings of the codes.

public aspect MyAspect {

public pointcut sayMethodCall (): call (public void

                                             TestClass.say*() );

public pointcut sayMethodCallArg (String str): call

                     (public void TestClass.sayAnyThing (String))

                     && args(str);

before(): sayMethodCall() {

System.out.println("n TestClass." + thisJoinPointStaticPart.getSignature().getName() +   "start..." );

after(): sayMethodCall() {

System.out.println("n TestClass." + thisJoinPointStaticPart.getSignature().getName() + " end...");

before(String str): sayMethodCallArg(str) {

if (str .length() < 3) {

The first line of the code defines the aspect in a similar way of defining codes in object oriented languages like Java. The aspect oriented languages consists of methods and member variables. Additionally, it also includes advices, pointcuts and introductions. In the second and third line, the modification will be considered. This line represents the pointcuts. The join points in an aspect program are used to define points considered in case of execution of a program code (Mammar, Nguyen and Laleau 2017). This is done by calling out the TestClass.sayAnyThing and TestClass.sayHello methods. The join points include method calling, execution, field get and set, exception handling and static/dynamic initialization. The pointcut is considered as a language construct that selects join points according to set criteria which can be function names or wildcards.

The pointcuts are used for defining an advice. The uses of an advice involve defining additional codes for execution. In the above program, the lines from 4 to 6 and 7 to 9 is used to define two advices which will be executed after the first occurrence of the pointcut. The dynamic execution of an aspect is done by utilizing pointcuts and advice (Tanter, Figueroa and Tabareau 2014). However, the use of introduction in an aspect is adopted for customizing the static stature of a code. New methods and variables can be added to a class by an aspect utilizing the introduction. Moreover, implementing of an interface and handling of exceptions can also be done by utilizing the introduction.

Comparison among OOSD and AOP

Conclusion

Thus, it can be stated that the use of aspect oriented programming is greatly used to enhance the program codes. For an object oriented programming language, the breaking of the codes into objects are a fundamental difference. However, in case of the aspect oriented programming structure, the aspects are used for denoting the program in an organized way. This also helps in reducing the complexity of the codes. However, the main disadvantage of the aspect oriented programming language is that the memory allocation that is required far exceeds the actual memory referenced. In addition, the aspects consist of properties where the implementation of the codes cannot be totally encapsulated generally. However, in case of the object oriented language, encapsulation is a general feature. This report includes the general discussion of both the aspect oriented and the object oriented language. Moreover, this report has also included the discussion of the comparison among both the languages.

The main considerations that are to be addressed by the use of aspect oriented programming is that proper use of codes must be done to minimize the number of memory wastages that occur. This will lead to effective utilization of a program.

References

Aspect-Oriented Programming. (1997). 1st ed. [ebook] Gregor Kiczales, John Lamping, Anurag Mendhekar, Chris Maeda, Cristina Videira Lopes, Jean-Marc Loingtier, John Irwin. Available at: https://1934644_1181110973_javaresearchpaper%20(1).pdf [Accessed 9 Jan. 2018].

Barnes, D.J., Kölling, M. and Gosling, J., 2017. Objects first with Java: A practical introduction using Bluej. Pearson.

Cardoso, J.M., Coutinho, J.G., Carvalho, T., Diniz, P.C., Petrov, Z., Luk, W. and Gonçalves, F., 2016. Performance?driven instrumentation and mapping strategies using the LARA aspect?oriented programming approach. Software: Practice and Experience, 46(2), pp.251-287.

Corral, J.M.R., Balcells, A.C., Estévez, A.M., Moreno, G.J. and Ramos, M.J.F., 2014. A game-based approach to the teaching of object-oriented programming languages. Computers & Education, 73, pp.83-92.

Ghareb, M. and Allen, G., 2015. Improving the Design and Implementation of Software Systems uses Aspect Oriented Programming.

Greifenberg, T., Hölldobler, K., Kolassa, C., Look, M., Nazari, P.M.S., Müller, K., Perez, A.N., Plotnikov, D., Reiss, D., Roth, A. and Rumpe, B., 2015, February. Integration of handwritten and generated object-oriented code. In International Conference on Model-Driven Engineering and Software Development (pp. 112-132). Springer, Cham.

Jackson, W., 2016. Objects and Object-Oriented Programming: OOP Primer. In JSON Quick Syntax Reference(pp. 31-50). Apress.

Mammar, A., Nguyen, T.M. and Laleau, R., 2017. A formal approach to derive an aspect oriented programming-based implementation of a secure access control filter. Information and Software Technology, 92, pp.158-178.

Nanakorn, P., Petprakob, W. and Naga, V.C., 2014. Object-oriented programming for topology optimization of steel truss structures by multipopulation particle swarm optimization.

Pasquier, T.F.M., Bacon, J. and Shand, B., 2014, April. FlowR: aspect oriented programming for information flow control in ruby. In Proceedings of the 13th international conference on Modularity (pp. 37-48). ACM.

Smith, B., 2015. Object-oriented programming. In Advanced ActionScript 3 (pp. 1-23). Apress.

Tanter, É., Figueroa, I. and Tabareau, N., 2014. Execution levels for aspect-oriented programming: Design, semantics, implementations and applications. Science of Computer Programming, 80, pp.311-342.

Thüm, T., Kästner, C., Benduhn, F., Meinicke, J., Saake, G. and Leich, T., 2014. FeatureIDE: An extensible framework for feature-oriented software development. Science of Computer Programming, 79, pp.70-85.

Uysal, M.P., 2016. Evaluation of learning environments for object-oriented programming: measuring cognitive load with a novel measurement technique. Interactive Learning Environments, 24(7), pp.1590-1609.

Welborn, C.R., Peterson, T., Sanchez, C. and Hawkins, B., 2014. Teaching advanced object-oriented programming techniques via a DBMS project. Journal of Computing Sciences in Colleges, 30(2), pp.132-138.